From fd65230f9abd4dcccfad4ece995904f6c522718b Mon Sep 17 00:00:00 2001 From: YoctoProductions Date: Thu, 26 Dec 2024 07:12:27 +0000 Subject: [PATCH] deploy: 89338180ec8fcd2413367cc85179c264ecb3a038 --- asset-manifest.json | 12 ++++++------ index.html | 2 +- static/css/main.aa8b0086.css.map | 1 - static/css/{main.aa8b0086.css => main.b22b21b4.css} | 4 ++-- static/css/main.b22b21b4.css.map | 1 + static/js/main.6c7d9e3c.js.map | 1 - static/js/{main.6c7d9e3c.js => main.de62bb46.js} | 6 +++--- ...c.js.LICENSE.txt => main.de62bb46.js.LICENSE.txt} | 0 static/js/main.de62bb46.js.map | 1 + 9 files changed, 14 insertions(+), 14 deletions(-) delete mode 100644 static/css/main.aa8b0086.css.map rename static/css/{main.aa8b0086.css => main.b22b21b4.css} (97%) create mode 100644 static/css/main.b22b21b4.css.map delete mode 100644 static/js/main.6c7d9e3c.js.map rename static/js/{main.6c7d9e3c.js => main.de62bb46.js} (52%) rename static/js/{main.6c7d9e3c.js.LICENSE.txt => main.de62bb46.js.LICENSE.txt} (100%) create mode 100644 static/js/main.de62bb46.js.map diff --git a/asset-manifest.json b/asset-manifest.json index 2f13db8f..e2279830 100644 --- a/asset-manifest.json +++ b/asset-manifest.json @@ -1,7 +1,7 @@ { "files": { - "main.css": "./static/css/main.aa8b0086.css", - "main.js": "./static/js/main.6c7d9e3c.js", + "main.css": "./static/css/main.b22b21b4.css", + "main.js": "./static/js/main.de62bb46.js", "static/media/final.png": "./static/media/final.67c8267a4b9ff73d40cd.png", "static/media/play-again.png": "./static/media/play-again.38923238033620c8ab00.png", "static/media/home.png": "./static/media/home.cbf4d9badcc4e56f2636.png", @@ -11,11 +11,11 @@ "static/media/gem.png": "./static/media/gem.b19d06f98a5cf6c31cbd.png", "static/media/cursor.cur": "./static/media/cursor.138cb2f1fcf8183aaa1b.cur", "index.html": "./index.html", - "main.aa8b0086.css.map": "./static/css/main.aa8b0086.css.map", - "main.6c7d9e3c.js.map": "./static/js/main.6c7d9e3c.js.map" + "main.b22b21b4.css.map": "./static/css/main.b22b21b4.css.map", + "main.de62bb46.js.map": "./static/js/main.de62bb46.js.map" }, "entrypoints": [ - "static/css/main.aa8b0086.css", - "static/js/main.6c7d9e3c.js" + "static/css/main.b22b21b4.css", + "static/js/main.de62bb46.js" ] } \ No newline at end of file diff --git a/index.html b/index.html index 39cea815..9254a97d 100644 --- a/index.html +++ b/index.html @@ -1 +1 @@ -Swordbattle.ioSwordbattle.io
\ No newline at end of file +Swordbattle.ioSwordbattle.io
\ No newline at end of file diff --git a/static/css/main.aa8b0086.css.map b/static/css/main.aa8b0086.css.map deleted file mode 100644 index 33c7e448..00000000 --- a/static/css/main.aa8b0086.css.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"static/css/main.aa8b0086.css","mappings":"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CAEE,gBAQF,0DACE,UAKF,mKAME,oBF5HI,iBALI,CEmIR,oBAHA,QAGA,CAIF,gEAEE,oBAKF,uCACE,eAGF,gCAGE,iBAGA,yCACE,UAOJ,mKACE,uBAQF,oJAIE,0BAGE,gNACE,eAON,4CAEE,kBADA,SACA,CAKF,kCACE,gBAUF,kCAIE,QAAO,CADP,SAFA,YACA,SAEA,CAQF,gCACE,WF9MM,gCEoNN,oBAHA,mBCmN4B,CDpN5B,UADA,UAKA,CFhXE,yBEyWJ,gCFtMQ,kBE+MN,kCACE,WAOJ,8ZAOE,UAGF,qDACE,YASF,uCACE,6BACA,oBAmBF,qDACE,wBAKF,wDACE,UAOF,sDAEE,0BADA,YACA,CAFF,gDAEE,0BADA,YACA,CAKF,gCACE,qBAKF,gCACE,SAOF,iCAEE,eADA,iBACA,CAQF,kCACE,uBAQF,kCACE,uBGrkBF,+BLmQM,iBALI,CK5PR,eFwoB4B,CEnoB5B,oCLgQM,iCK5PJ,eFynBkB,CExnBlB,eFwmB0B,CHzgB1B,yBKpGF,oCLuQM,gBKvQN,oCLgQM,iCK5PJ,eFynBkB,CExnBlB,eFwmB0B,CHzgB1B,yBKpGF,oCLuQM,kBKvQN,oCLgQM,iCK5PJ,eFynBkB,CExnBlB,eFwmB0B,CHzgB1B,yBKpGF,oCLuQM,gBKvQN,oCLgQM,iCK5PJ,eFynBkB,CExnBlB,eFwmB0B,CHzgB1B,yBKpGF,oCLuQM,kBKvQN,oCLgQM,iCK5PJ,eFynBkB,CExnBlB,eFwmB0B,CHzgB1B,yBKpGF,oCLuQM,gBKvQN,oCLgQM,iCK5PJ,eFynBkB,CExnBlB,eFwmB0B,CHzgB1B,yBKpGF,oCLuQM,kBK1OR,8EC3DE,gBADA,cACA,CD8DF,2CACE,qBAEA,4DACE,kBFsoB0B,CE5nB9B,qCL8MM,gBALI,CKvMR,yBAIF,qCLwMM,kBKvMJ,kBLkMQ,CK/LR,iDACE,gBAIJ,4CAIE,cL2LI,gBALI,CKxLR,kBFuTO,CExTP,gBFnFS,CEwFT,mDACE,aEhGJ,oCCOE,YAHA,cAGA,CDDF,wCAEE,kCJ6jDkC,CI5jDlC,2DHGE,sCILF,YAHA,eDGA,cCAA,CDcF,iCAEE,qBAGF,qCAEE,aAA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wCACA,+CACA,CAHA,gCAGA,uSANA,yCAEA,+HAIA,0CAEA,iDDyFA,CC5FA,kCACA,CD2FA,sCCtGA,CAWA,mBAVA,uCACA,mBACA,oBACA,8BACA,oDACA,oCACA,qCAEA,sDACA,sCACA,uDAEA,0DDyFA,uCCrGA,yCACA,mBACA,oBACA,8BACA,0BACA,8DACA,sCAEA,sDACA,qCACA,wDAEA,0DDyFA,uCCrGA,uCACA,mBACA,oBACA,8BACA,0BACA,8DAEA,qCACA,2BACA,gEACA,wDAEA,8BDmHA,mECvGA,CACA,mCACA,uCACA,8BACA,0BACA,2BACA,mCACA,qCACA,2BACA,gEACA,wDAEA,8BACA,4BD0FA,uCCvGA,uCACA,mBACA,qBACA,6BACA,oDACA,oCACA,oCACA,CACA,qDACA,6FAEA,6BACA,6BACA,uCD0FA,sCCvGA,mBACA,oBACA,8BACA,0BACA,0BACA,wEAEA,2BACA,4BACA,4FAEA,6BACA,oED2FA,qCCvGA,mBACA,kDACA,0BACA,0BACA,oCACA,sCACA,2BACA,2BACA,qCACA,wDACA,6BACA,6BACA,uCACA,oCD0FA,mBCvGA,oBACA,8BACA,0BACA,0BACA,oCACA,mCACA,2BACA,2BACA,qCACA,wDACA,0DACA,uCACA,+CD2FA,uBCvGA,6BACA,0BACA,0BACA,oCACA,qCACA,2BACA,2BACA,qCACA,wDACA,gCACA,2BACA,uCACA,oED2FA,sBCvGA,8BACA,0BACA,0BACA,oCACA,sCACA,2BACA,2BACA,qCACA,wDACA,gCACA,2BACA,uCACA,mBACA,+CD0FA,sBCvGA,8BACA,0BACA,0BACA,oCACA,oCACA,2BACA,2BACA,qCACA,wDACA,gCACA,2BACA,uCACA,mBACA,4CDsGF,sBACE,8BACA,0BACA,0BACA,oCACA,qCACA,sDACA,qCACA,wDACA,gCACA,2BACA,uCACA,mBAEA,+CAUA,sBACE,8BAGF,oDACE,oCAWJ,+DCxIE,2BACA,qCAEA,wDDyIF,2DC5IE,uCACA,mB5B8NI,8C4B5NJ,oDCnEF,0BVgBM,0BAIA,oCUpBN,oCAGE,sDAOA,q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sCDhBN,4BCiBQ,iBDGN,uCACE,gBAEA,sEACE,eAKJ,kCAEE,kCfg2BoC,Ce/1BpC,oBf82BoC,Cex2BlC,kCARF,0Bfs2BoC,Cen2BpC,SfuhBoB,Ce9gBtB,yDAYE,aAKA,QAAO,CAXP,cAWA,CAKF,mDACE,cACA,UAIF,yCACE,+Bf40BoC,Ce10BpC,UAQF,qCAEE,uCf8yBoC,Ce3yBpC,UAIF,wDE1FA,sCjBqiCgC,Cel8B9B,eAFA,qBAGA,8CfgsB0B,Ce/rB1B,gBAPA,0BfsyBoC,CexyBpC,wBACA,wBforB0B,CetrB1B,uBAKA,oBCpFE,mQD0FF,CAZF,kDE1FA,sCjBqiCgC,Cel8B9B,eAFA,qBAGA,8CfgsB0B,Ce/rB1B,gBAPA,0BfsyBoC,CexyBpC,wBACA,wBforB0B,CetrB1B,uBAKA,oBCpFE,6HD0FF,CCtFE,sCD0EJ,wDCzEM,wCDyEN,kDCzEM,iBDwFN,6FACE,uCf47B8B,Ce77BhC,uFACE,uCf47B8B,Cen7BlC,sCAOE,uBACA,mBACA,sCAHA,0Bf2xBsC,CehyBtC,cAIA,efwf4B,Cezf5B,gBADA,kBADA,UAOA,CAEA,4CACE,UAGF,4GAGE,cAAa,CADb,eACA,CAWJ,+BdjII,yCJ4QE,iBALI,CkBrIR,yDf4wBsC,Ce3wBtC,oBdnIE,CcuIF,2DAEE,sBACA,wBAFA,oBfsoB0B,CevoB5B,qDAEE,sBACA,wBAFA,oBfsoB0B,CehoB9B,+Bd9II,yCJ4QE,iBALI,CkBxHR,wDfgwBsC,Ce/vBtC,kBdhJE,CcoJF,2DAEE,oBACA,uBAFA,kBf6nB0B,Ce9nB5B,qDAEE,oBACA,uBAFA,kBf6nB0B,CennB5B,oCACE,0Df6uBoC,Ce1uBtC,uCACE,yDf0uBoC,CevuBtC,uCACE,wDfuuBoC,CeluBxC,kCAEE,sDf8tBsC,Ce7tBtC,gBAFA,UfmlB4B,Ce/kB5B,iEACE,eAGF,qDACE,mBdvLA,sCc2LF,wDACE,mBd5LA,sCcgMF,uGf8sBsC,Ce7sBtC,sGf8sBsC,CkB75BxC,2BACE,qQAYA,CACA,uBACA,mDACA,mDACA,iFFNI,wCAIA,CAJA,4BAIA,yBEfN,2DAsBE,s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AEA,iCACA,yCAFA,yBAEA,kCAEA,uCACA,8CAbA,CACA,yCACA,CASA,+BACA,CAZA,SAEA,6CAEA,6CACA,CACA,yCACA,CAFA,SAEA,0KAKA,wCACA,+CAbA,CAWA,gCAXA,gPAQA,yCACA,8FAIA,0CDyFA,CCtGA,gDAEA,CASA,kCAEA,CAXA,sCACA,CAUA,mBAVA,4BACA,mBACA,kDACA,0BACA,0BACA,oCACA,qCACA,sDACA,qCACA,wDD0FA,6BCtGA,CACA,4BACA,uCACA,8BACA,mBACA,kDACA,0BACA,0BACA,oCACA,sCACA,sDACA,qCACA,wDD0FA,6BCrGA,6BACA,uCACA,4BACA,mBACA,oBACA,wDACA,0BACA,oCACA,qCACA,sDACA,qCAEA,wDDmHA,6BCvGA,6BACA,uCAEA,yBACA,uCACA,8BACA,2BACA,6DACA,qCACA,2BACA,4BACA,oCACA,wDD2FA,0DCtGA,uCACA,4BACA,mBACA,kDACA,0BACA,0BACA,oCACA,oCACA,sDACA,qCACA,wDAEA,6BD0FA,6BCvGA,uCACA,2BACA,mBACA,oBACA,8BACA,oDACA,oCACA,oCACA,2BACA,gEACA,wDAEA,6BACA,6BD0FA,uCCtGA,0BACA,uCACA,8BACA,0BACA,2BACA,mCACA,sCACA,2BACA,gEACA,wDAEA,6BACA,6BD0FA,uCCvGA,yBACA,mBACA,qBACA,6BACA,oDACA,oCACA,mCAEA,sDACA,6FAEA,6BACA,6BACA,uCD0FA,oCCtGA,uBACA,6BACA,0BACA,8DACA,qCAEA,2BACA,gEACA,wDACA,gCACA,2BACA,uCD2FA,yDCtGA,sBACA,8BACA,0BACA,8DACA,sCAEA,2BACA,gEACA,wDAEA,gCACA,kED2FA,mBCvGA,oCACA,sBACA,8BACA,0BACA,0BACA,oCACA,oCACA,2BACA,2BACA,6FAEA,gCACA,4BACA,sCDsGF,mBACE,iCACA,sBACA,8BACA,0BACA,8DACA,qCACA,sDACA,qCACA,wDAEA,gCACA,2BAEC,CAAD,sCAUA,uDAIA,sBACE,+BAWJ,uFCvIE,oC5B8NI,2B4B5NJ,2BDyIF,6FC3I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","sources":["ui/game/ChatInput.scss","ui/game/Leaderboard.scss","ui/game/GameResults.scss","ui/game/GameComponent.scss","ui/modals/Modal.scss","ui/modals/SettingsModal.scss","ui/LoadingScreen.scss","ui/modals/ChangelogModal.scss","ui/modals/LoginModal.scss","ui/modals/SignupModal.scss","ui/modals/ConnectionError.scss","ui/App.scss","ui/modals/ShopModal.scss","ui/modals/MigrationModal.scss","ui/AccountCard.scss","ui/GlobalLeaderboard.scss","../node_modules/bootstrap/scss/mixins/_banner.scss","../node_modules/bootstrap/scss/_root.scss","../node_modules/bootstrap/scss/vendor/_rfs.scss","../node_modules/bootstrap/scss/mixins/_color-mode.scss","../node_modules/bootstrap/scss/_reboot.scss","../node_modules/bootstrap/scss/_variables.scss","../node_modules/bootstrap/scss/mixins/_border-radius.scss","../node_modules/bootstrap/scss/_type.scss","../node_modules/bootstrap/scss/mixins/_lists.scss","../node_modules/bootstrap/scss/_images.scss","../node_modules/bootstrap/scss/mixins/_image.scss","../node_modules/bootstrap/scss/_containers.scss","../node_modules/bootstrap/scss/mixins/_container.scss","../node_modules/bootstrap/scss/mixins/_breakpoints.scss","../node_modules/bootstrap/scss/_grid.scss","../node_modules/bootstrap/scss/mixins/_grid.scss","../node_modules/bootstrap/scss/_tables.scss","../node_modules/bootstrap/scss/mixins/_table-variants.scss","../node_modules/bootstrap/scss/forms/_labels.scss","../node_modules/bootstrap/scss/forms/_form-text.scss","../node_modules/bootstrap/scss/forms/_form-control.scss","../node_modules/bootstrap/scss/mixins/_transition.scss","../node_modules/bootstrap/scss/mixins/_gradients.scss","../node_modules/bootstrap/scss/forms/_form-select.scss","../node_modules/bootstrap/scss/forms/_form-check.scss","../node_modules/bootstrap/scss/forms/_form-range.scss","../node_modules/bootstrap/scss/forms/_floating-labels.scss","../node_modules/bootstrap/scss/forms/_input-group.scss","../node_modules/bootstrap/scss/mixins/_forms.scss","../node_modules/bootstrap/scss/_buttons.scss","../node_modules/bootstrap/scss/mixins/_buttons.scss","../node_modules/bootstrap/scss/_transitions.scss","../node_modules/bootstrap/scss/_dropdown.scss","../node_modules/bootstrap/scss/mixins/_caret.scss","../node_modules/bootstrap/scss/_button-group.scss","../node_modules/bootstrap/scss/_nav.scss","../node_modules/bootstrap/scss/_navbar.scss","../node_modules/bootstrap/scss/_card.scss","../node_modules/bootstrap/scss/_accordion.scss","../node_modules/bootstrap/scss/_breadcrumb.scss","../node_modules/bootstrap/scss/_pagination.scss","../node_modules/bootstrap/scss/mixins/_pagination.scss","../node_modules/bootstrap/scss/_badge.scss","../node_modules/bootstrap/scss/_alert.scss","../node_modules/bootstrap/scss/_progress.scss","../node_modules/bootstrap/scss/_list-group.scss","../node_modules/bootstrap/scss/_close.scss","../node_modules/bootstrap/scss/_toasts.scss","../node_modules/bootstrap/scss/_modal.scss","../node_modules/bootstrap/scss/mixins/_backdrop.scss","../node_modules/bootstrap/scss/_tooltip.scss","../node_modules/bootstrap/scss/mixins/_reset-text.scss","../node_modules/bootstrap/scss/_popover.scss","../node_modules/bootstrap/scss/mixins/_clearfix.scss","../node_modules/bootstrap/scss/_carousel.scss","../node_modules/bootstrap/scss/_spinners.scss","../node_modules/bootstrap/scss/_offcanvas.scss","../node_modules/bootstrap/scss/_placeholders.scss","../node_modules/bootstrap/scss/helpers/_color-bg.scss","../node_modules/bootstrap/scss/helpers/_colored-links.scss","../node_modules/bootstrap/scss/helpers/_focus-ring.scss","../node_modules/bootstrap/scss/helpers/_icon-link.scss","../node_modules/bootstrap/scss/helpers/_ratio.scss","../node_modules/bootstrap/scss/helpers/_position.scss","../node_modules/bootstrap/scss/helpers/_stacks.scss","../node_modules/bootstrap/scss/helpers/_visually-hidden.scss","../node_modules/bootstrap/scss/mixins/_visually-hidden.scss","../node_modules/bootstrap/scss/helpers/_stretched-link.scss","../node_modules/bootstrap/scss/mixins/_text-truncate.scss","../node_modules/bootstrap/scss/helpers/_vr.scss","../node_modules/bootstrap/scss/mixins/_utilities.scss","../node_modules/bootstrap/scss/utilities/_api.scss","ui/Profile.scss","../node_modules/bootstrap/scss/helpers/_text-truncation.scss","global.scss"],"sourcesContent":["#chat {\n border: 2px solid #cdcdcd;\n border-color: rgba(0, 0, 0, .14);\n background-color: AliceBlue;\n padding: 3px 6px;\n font-size: max(min(1.5vw, 36px), 24px);\n font-family: 'Franklin Gothic Medium', Arial, sans-serif;\n}\n",".leaderboard {\n position: fixed;\n top: 10px;\n right: 10px;\n width: fit-content;\n padding: 5px;\n color: white;\n font-family: Arial, Helvetica, sans-serif;\n\ttext-shadow: 1px 1px 1px rgb(0, 0, 0);\n transform-origin: top right;\n user-select: none;\n pointer-events: none;\n\n .leaderboard-title {\n margin-bottom: 5px;\n text-align: center;\n font-size: 24px;\n pointer-events: all;\n\n &:hover {\n cursor: pointer;\n }\n }\n\n .leaderboard-content {\n opacity: 1;\n transition: all 0.2s ease-in;\n\n &.hidden {\n opacity: 0;\n }\n }\n}\n\n.leaderboard-line {\n display: block;\n font-size: 22px;\n white-space: nowrap;\n}\n",".results {\n\tposition: fixed;\n\tuser-select: none;\n\tleft: 50%;\n\ttop: 50%;\n\twidth: 600px;\n\ttransform: translate(-50%, -50%);\n\t.results-main {\n background-color: rgb(0, 0, 0, 0.7);\n\ttext-shadow: 1px 1px 1px rgb(0, 0, 0);\n border: 5px solid #111111;\n\tborder-radius: 10px;\n\t}\n\tanimation: fadeIn 1s ease both;\n\n\t.results-title {\n\t\tmargin-top: 10px;\n\t\tmargin-bottom: 5px;\n\t\ttext-align: center;\n\t\tcolor: #ffffff;\n\t\tfont-size: 45px;\n\t\tfont-weight: 700;\n\n\t\t.name {\n\t\t\tmargin-top: 10px;\n\t\t\tfont-size: 30px;\n\t\t\tcolor: #eef6ff;\n\t\t}\n\t}\n\n\t.results-container {\n\t\ttext-align: center;\n\t\tmargin: 0 auto 15px;\n\n\t\t.info {\n\t\t\tmargin: 15px;\n\t\t\tcolor: #cccccc;\n\t\t\tfont-size: 13px;\n\t\t\ttext-align: center;\n\t\t\tdisplay: inline-block;\n\n\t\t\t.title {\n\t\t\t\tmargin-bottom: 5px;\n\t\t\t\tfont-size: 22px;\n\t\t\t\tcolor: #f5f5f5;\n\t\t\t}\n\t\t}\n\t}\n\n\t.results-buttons {\n\t\tdisplay: flex;\n\t\tflex-direction: column;\n\t\talign-items: center;\n\t\tjustify-content: center;\n\t\tpadding: 15px;\n\n\t\t.play-again {\n\t\t\timg {\n\t\t\t\twidth: 150px;\n\t\t\t\theight: 150px;\n\t\t\t\ttransition: 0.2s;\n\n\t\t\t\t&:hover {\n\t\t\t\t\tscale: 1.1;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t.to-home {\n\t\t\tmargin-bottom: 5px;\n\t\t\timg {\n\t\t\t\twidth: auto;\n\t\t\t\theight: 60px;\n\t\t\t\ttransition: 0.2s;\n\n\t\t\t\t&:hover {\n\t\t\t\t\tscale: 1.1;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t@keyframes fadeIn {\n from {\n opacity: 0;\n backdrop-filter: blur(0px);\n }\n to {\n opacity: 1;\n backdrop-filter: blur(8px);\n }\n }\n}\n",".game {\n width: 100%;\n height: 100%;\n overflow: hidden;\n position: absolute;\n cursor: url(/assets/img/cursor.cur) 20 20, crosshair;\n}\n",".modal {\n position: absolute;\n left: 50%;\n top: 50%;\n min-width: 300px;\n transform: translate(-50%, -50%);\n background-color: rgb(20, 20, 20) !important;\n box-shadow: 0 0 0 5px rgba(47, 47, 47, 0.98);\n color: rgb(231, 231, 231);\n border-radius: 10px;\n padding: 15px 30px;\n z-index: 5;\n\n .modal-close {\n position: absolute;\n display: flex;\n align-items: center;\n justify-content: center;\n top: 0px;\n right: 0px;\n width: 30px;\n\n cursor: pointer;\n appearance: none;\n background-color: #000;\n border: 2px solid #fff;\n height: 30px;\n line-height: normal;\n border-radius: 30px;\n transform: rotate(0deg);\n transition: all 0.2s linear;\n\n &::before, &::after {\n content: ' ';\n display: block;\n width: 20px;\n height: 2px;\n background-color: #fff;\n transform: rotate(45deg);\n margin: 0 auto;\n position: absolute;\n }\n &::after {\n transform: rotate(-45deg);\n }\n &:hover {\n transform: rotate(180deg);\n }\n }\n}\n",".settings {\n .settings-title {\n font-size: 30px;\n margin: 0 0 20px;\n letter-spacing: 2px;\n }\n\n .section {\n text-decoration: underline;\n font-size: 22px;\n }\n\n label {\n display: block;\n margin-bottom: 10px;\n }\n\n .settings-line {\n display: flex;\n flex-direction: row;\n justify-content: space-between;\n }\n \n select, input {\n width: 100%;\n margin: 0 0 10px;\n font-size: 18px;\n }\n}\n\n.switch {\n position: relative;\n display: inline-block;\n width: 50px;\n height: 21px;\n\n input {\n opacity: 0;\n width: 0;\n height: 0;\n }\n\n .slider {\n position: absolute;\n cursor: pointer;\n top: 0;\n left: 0;\n right: 0;\n bottom: 0;\n background-color: #ccc;\n -webkit-transition: .4s;\n transition: .4s;\n\n &:before {\n position: absolute;\n content: \"\";\n height: 15px;\n width: 15px;\n left: 6px;\n bottom: 3px;\n background-color: white;\n -webkit-transition: .4s;\n transition: .4s;\n }\n }\n\n input:checked + .slider {\n background-color: #2196F3;\n\n &:before {\n -webkit-transform: translateX(26px);\n -ms-transform: translateX(26px);\n transform: translateX(26px);\n }\n }\n\n input:focus + .slider {\n box-shadow: 0 0 1px #2196F3;\n }\n}\n\n.slider.round {\n border-radius: 34px;\n\n &:before {\n border-radius: 50%;\n }\n}\n",".loading-screen {\n position: absolute;\n display: flex;\n align-items: center;\n justify-content: center;\n left: 50%;\n top: 50%;\n transform: translate(-50%, -50%);\n z-index: 2;\n background-color: #333333;\n width: 100%;\n height: 100%;\n\ttransition: 500ms all ease-in-out;\n\n .loading-container {\n width: 400px;\n text-align: center;\n\n .loading-text {\n color: #ffffff;\n font-size: 45px;\n margin-bottom: 10px\n }\n\n .progress-bar {\n width: 100%;\n height: 20px;\n background-color: #eee;\n\n .progress {\n height: 100%;\n background-color: lime;\n transition: width 0.5s ease-in-out;\n }\n }\n }\n}\n",".changelog {\n text-align: center;\n\n h1 {\n margin-top: 20px;\n font-size: 32px;\n }\n\n h2 {\n font-size: 28px;\n }\n\n h1, h2 {\n margin: 0 0 20px;\n font-family: 'courier new', courier;\n color: #44bafa;\n }\n\n ul, li {\n color: #9dd3ff;\n margin: 0;\n padding: 0;\n line-height: normal;\n font-size: 15px;\n }\n\n li {\n font-weight: bold;\n list-style: none;\n font-size: 20px;\n }\n\n .important {\n font-size: 45px;\n }\n\n .primary-link {\n color: rgb(128, 119, 255);\n text-decoration: underline;\n font-size: 120%;\n font-weight: bold;\n margin: 20px auto;\n font-size: 18px;\n }\n \n}\n",".login-modal {\n display: flex;\n flex-direction: column;\n align-items: center;\n\n input {\n margin: 5px;\n font-size: 20px;\n font-weight: bold;\n }\n\n button {\n width: 120px;\n color: white;\n background-color: #4caf50;\n transition: all 0.2s ease-in;\n border: none;\n border-radius: 10px;\n font-size: 22px;\n padding: 5px;\n margin-top: 10px;\n\n &:hover {\n color: #4caf50;\n background-color: white;\n cursor: pointer;\n }\n }\n}\n",".signup-modal {\n display: flex;\n flex-direction: column;\n align-items: center;\n\n input {\n margin: 5px;\n font-size: 20px;\n font-weight: bold;\n }\n\n button {\n width: 120px;\n color: white;\n background-color: #4caf50;\n transition: all 0.2s ease-in;\n border: none;\n border-radius: 10px;\n font-size: 22px;\n padding: 5px;\n margin-top: 10px;\n\n &:hover {\n color: #4caf50;\n background-color: white;\n cursor: pointer;\n }\n }\n}\n","@import url(\"https://fonts.googleapis.com/css2?family=Poppins:wght@400;600&display=swap\");\n\n.connectionErrorModal {\n animation: fadeIn 1s ease both;\n background: none;\n width: 100%;\n height: 100%;\n display: flex;\n justify-content: center;\n align-items: center;\n z-index: 3;\n\n .content {\n width: 400px;\n padding: 1rem 3rem;\n padding-top: 2rem;\n border-radius: 10px;\n font-family: Poppins, sans-serif;\n\n h2 {\n font-weight: 600;\n font-size: 2rem;\n }\n\n p {\n font-size: 1rem;\n line-height: 1rem;\n padding: 0.5rem 0;\n }\n\n button {\n margin: 5px;\n }\n }\n\n .reload-btn {\n background: green;\n color: black;\n border: 1px solid black;\n padding: 0.5rem 1rem;\n border-radius: 10px;\n font-size: 1rem;\n font-weight: 600;\n cursor: pointer;\n transition: all 0.3s ease;\n\n &:hover {\n background: black;\n color: white;\n }\n }\n\n @keyframes fadeIn {\n from {\n opacity: 0;\n backdrop-filter: blur(0px);\n }\n to {\n opacity: 1;\n backdrop-filter: blur(8px);\n }\n }\n}\n",".panel {\n padding: 15px;\n margin: 8px;\n border-radius: 10px;\n background-color: rgb(34, 34, 34) !important;\n box-shadow: 0 0 0 3px rgba(51, 51, 51, 0.98);\n color: rgb(231, 231, 231);\n box-sizing: border-box;\n}\n\n.shop-btn{\n position: absolute;\n\n\n // left\n left: 0%;\n top: 0%;\n transform-origin: left;\n cursor: pointer;\n\n\n img {\n height: auto;\n display: inline-block;\n margin-left: 10px;\n margin-top: 10px;\n transition: transform 0.3s ease;\n }\n\n img:hover {\n transform: scale(1.1);\n }\n}\n\nfooter {\n position: absolute;\n bottom: 10px;\n width: 100%;\n pointer-events: none;\n height: 50px;\n color: rgb(231, 231, 231);\n text-align: center;\n padding-top: 15px;\n box-sizing: border-box;\n display: flex;\n justify-content: center;\n flex-direction: row;\n gap: 30px;\n\n a {\n font-size: 30px;\n text-decoration: underline;\n pointer-events: auto;\n }\n\n}\n\n.auth-buttons {\n position: absolute;\n top:5px;\n right: 5px;\n display: flex;\n flex-direction: column;\n transform-origin: top right;\n\n .dropdown {\n\n .dropdown-menu {\n background-color: #f9f9f9;\n padding: 12px 16px;\n border-radius: 10px;\n right: 10px;\n user-select: none;\n display: none;\n\n li {\n list-style: none;\n }\n\n .dropdown-item {\n font-size: 18px;\n color: green;\n\n &:active {\n background-color: transparent;\n color: unset;\n }\n }\n }\n }\n .dropdown:hover .dropdown-menu {\n display: block;\n }\n\n .auth-username {\n font-size: 40px;\n margin-top: 20px;\n margin-right: 40px;\n cursor: pointer;\n color: white;\n }\n .auth-btn {\n margin-bottom: 10px;\n height: 70px;\n margin-right: 5px;\n\n transition: all 0.2s ease-in-out;\n\n &:hover {\n cursor: pointer;\n transform: scale(1.05);\n }\n }\n}\n\n*::-webkit-scrollbar, *::-webkit-scrollbar-button, *::-webkit-scrollbar-track, *::-webkit-scrollbar-track-piece, *::-webkit-scrollbar-thumb, *::-webkit-scrollbar-corner, *::-webkit-resizer {\n background: transparent;\n}\n*::-webkit-scrollbar {\n width: 7px;\n border-radius: 5px;\n}\n*::-webkit-scrollbar-track-piece {\n border-radius: 5px;\n}\n*::-webkit-scrollbar-thumb {\n background: #9e9e9e;\n border-radius: 5px;\n}\n*::-webkit-scrollbar-thumb:hover {\n background: #858585;\n}\n*::-webkit-scrollbar-button {\n width: 0;\n height: 0;\n}\n\n.connectionErrorModal {\n z-index: 100;\n}\n\n\ninput[type=text],\ninput[type=email],\ninput[type=password] {\n -webkit-touch-callout: text;\n -webkit-user-select: text;\n user-select: text;\n text-align: center;\n font-size: 26px;\n padding: 6px;\n border: none;\n outline: none;\n box-sizing: border-box;\n color: #4a4a4a;\n background-color: #e5e3e3;\n border-radius: 10px;\n}\ninput[type=text][disabled],\ninput[type=email][disabled],\ninput[type=password][disabled] {\n cursor: not-allowed;\n opacity: 0.7;\n}\n\n.login-modal,\n.signup-modal {\ninput {\n font-size: 20px;\n}\n}\n\na {\n color: #6edcef;\n text-decoration: none;\n}\na:hover {\n color: #29cbe7;\n}\na:active {\n color: #169bc7;\n}\n\n.altLink {\n color: #6ed7ef;\n font-size: 24px;\n text-decoration: none;\n}\n.altLink:hover {\n color: #40c5ea;\n}\n.altLink:active {\n color: #19c1de;\n}\n\n.inline {\n display: inline-block;\n}\n\nspan {\n font-size: inherit;\n}\n\n.material-icons {\n vertical-align: sub;\n}\n\n.ui-icon {\n font-size: 30px;\n vertical-align: middle;\n}\n\n\n\n.mainMenu {\n background-color: rgb(44, 118, 22);\n position: absolute;\n width: 100%;\n height: 100%;\n z-index: 10;\n}\n\n.mainMenu.loaded {\n background-color: rgba(0, 0, 0, 0.507);\n display: block;\n}\n\n#menuContainer {\n width: 100%;\n white-space: nowrap;\n text-align: center;\n position: absolute;\n top: 45%;\n transform: translateY(-50%);\n pointer-events: auto;\n\n}\n\n#contentt {\n transform: translateY(-50%);\n height: 100%;\n width: 100%;\n pointer-events: none;\n}\n\n.menuCard {\n text-align: left;\n white-space: normal;\n word-wrap: break-word;\n padding: 18px;\n overflow: hidden;\n}\n\n.menuHeader {\n font-size: 24px;\n color: #dadada;\n margin-bottom: 5px;\n}\n\n.menuSubheader {\n font-size: 20px;\n color: #dadada;\n margin-bottom: 3px;\n}\n\n.menuText {\n font-size: 18px;\n color: #a8a8a8;\n margin-bottom: 10px;\n}\n\n.menuLink {\n font-size: 20px;\n}\n\n#gameName {\n font-size: 110px;\n text-shadow: #3b2a7b 3px 5px 2px;\n color: #fff;\n}\n\n.menuButton {\n text-align: center;\n font-size: 23px;\n padding: 6px;\n box-sizing: border-box;\n color: #fff;\n background-color: rgb(133, 186, 227);\n width: 100%;\n border-radius: 10px;\n cursor: pointer;\n box-shadow: inset 0 -8px 0 rgba(0, 0, 0, 0.2941176471);\n transition: transform cubic-bezier(0.77, 0, 0.175, 1) 0.2s;\n transform: scale(1);\n}\n.menuButton:hover {\n transform: scale(1.05);\n}\n.menuButton:active {\n transform: scale(0.95);\n}\n\n#topRight1 {\n position: absolute;\n color: white;\n top: 20px;\n right: 20px;\n font-size: 24px;\n text-decoration: none;\n}\n\n#topRight2 {\n position: absolute;\n top: 54px;\n right: 20px;\n cursor: pointer;\n}\n\n#settingsButton {\n position: absolute;\n cursor: pointer;\n font-size: 35px;\n line-height: 20px;\n bottom: 12px;\n left: 12px;\n transition: transform cubic-bezier(0.77, 0, 0.175, 1) 0.1s;\n}\n#settingsButton:hover {\n transform: scale(1.05);\n}\n#settingsButton:active {\n transform: scale(0.95);\n}\n\n.fullWidth {\n width: 100%;\n}\n\n#menuCardHolder #adBelow {\n height: auto !important;\n position: absolute;\n bottom: auto;\n // center the ad\n left: 50%;\n transform: translateX(-50%);\n box-sizing: border-box;\n display: 'inline-block' !important;\n}\n#menuCardHolder .menu {\n display: flex;\n}\n#menuCardHolder .menu * {\n box-sizing: border-box;\n}\n#menuCardHolder .menu a {\n cursor: pointer;\n}\n#menuCardHolder .menu #nameInput {\n transition: transform cubic-bezier(0.77, 0, 0.175, 1) 0.2s;\n transform: scale(1);\n}\n#menuCardHolder .menu #nameInput:focus {\n transform: scale(1.05);\n}\n#menuCardHolder .menu #serverInfo {\n margin-bottom: 8px;\n text-align: center;\n}\n#menuCardHolder .menu .joinCard {\n width: 375px;\n}\n#menuCardHolder .menu .accountCard {\n width: 310px;\n}\n#menuCardHolder .menu .forumCard {\n width: 310px;\n padding: 0;\n}\n\n#linksContainer {\n position: absolute;\n bottom: 12px;\n left: 12px;\n text-align: right;\n font-size: 20px;\n}\n\n#loadingText {\n font-size: 45px;\n color: #fff;\n text-align: center;\n}\n#loadingText a {\n display: block;\n}\n\n.joinCardInput {\n width: 100%;\n}\n.joinCardInput #nameInput,\n.joinCardInput #enterGame {\n height: 44px;\n top: 50%;\n width: 100%;\n margin-bottom: 10px;\n}\n.joinCardInput #enterGame {\n height: 74px;\n font-size: 48px;\n line-height: 50px;\n // background-image: url(\"../img/ui/bg.png\");\n background-position: 0px 0px;\n // background-repeat: repeat;\n // animation: animatedBackground 500s linear infinite;\n}\n@keyframes animatedBackground {\n 0% {\n background-position: 0 0;\n }\n 100% {\n background-position: -10000px 20000px;\n }\n}\n\n.joinCardContent {\n position: relative;\n top: 50%;\n transform: translateY(-50%);\n}\n\n.account-badge {\n height: 1.5em;\n -webkit-user-drag: none;\n margin-right: 4px;\n}\n\n#serverBrowser {\n border: none;\n text-align: center;\n font-size: 16px;\n padding: 6px;\n box-sizing: border-box;\n color: rgb(70, 70, 70);\n background-color: #f7faf6;\n width: 100%;\n border-radius: 10px;\n margin-bottom: 10px;\n cursor: pointer;\n}\n@media only screen and (max-width: 1040px) {\n #menuCardHolder #adBelow {\n display: none;\n }\n .forumCard {\n display: none;\n }\n #menuCardHolder .menu {\n flex-direction: column;\n }\n #menuCardHolder .menu .menuCard {\n width: 85vw !important;\n }\n #menuCardHolder .menu .joinCard {\n order: -1;\n }\n}\n@media only screen and (max-width: 768px) {\n #menuCardHolder #adBelow {\n display: none;\n }\n #loadingText {\n margin-top: 20px;\n }\n #mainMenu {\n overflow: scroll;\n }\n #gameName {\n font-size: 55px;\n line-height: 2;\n }\n #gameName-mobile {\n display: initial !important;\n }\n #setupCard {\n width: 260px;\n margin-top: 4px;\n }\n #topRight1 {\n top: 8px;\n left: 33%;\n right: inherit;\n transform: translateX(-50%);\n }\n #topRight2 {\n top: 8px;\n left: 66%;\n right: inherit;\n transform: translateX(-50%);\n }\n #linksContainer {\n display: none;\n }\n}","/* General Styles */\n*,\n*::before,\n*::after {\n box-sizing: border-box;\n}\n\n/* Modal Styles */\n.shop-modal {\n display: flex;\n flex-direction: column;\n height: calc(100vh - 100px);\n width: calc(100vw - 100px);\n max-width: 1000px;\n margin: 20px auto;\n background: linear-gradient(to top left, #000000 5%, rgb(10, 3, 51) 100%);\n box-shadow: 0 20px 40px -14px rgba(0, 0, 0, 0.25);\n padding: 20px;\n border-radius: 10px;\n color: #ffffff;\n /* White text color for modal */\n\n}\n\n/* Skins Container Styles */\n.skins {\n flex-grow: 1;\n display: flex;\n flex-wrap: wrap;\n justify-content: space-around;\n overflow-y: auto;\n overflow-x: hidden;\n align-content: flex-start;\n}\n\n.shop-title {\n font-size: 30px;\n text-align: center;\n color: #ffffff;\n /* Adjusting header color to fit modal style */\n margin: 0;\n}\n\n.shop-desc {\n font-size: 20px;\n text-align: center;\n color: #ffffff;\n /* Adjusting header color to fit modal style */\n margin: 0;\n margin-bottom: 10px;\n}\n\n.gem {\n transform: translate(0, 25%);\n}\n\n/* Skin Card Styles */\n.skin-card {\n margin: 10px;\n border-radius: 10px;\n background-color: #323ab1;\n /* Dark background for cards */\n display: flex;\n flex-direction: column;\n justify-content: space-between;\n align-items: center;\n padding: 10px;\n box-shadow: 0 10px 20px -10px rgba(0, 0, 0, 0.25);\n width: 200px;\n\n .skin-name {\n font-size: 25px;\n color: white;\n text-align: center;\n font-weight: 700;\n }\n\n .skin-img {\n width: 150px;\n height: 150px;\n background-size: cover;\n background-position: center;\n }\n\n .skin-sword {\n width: 156px;\n height: 168px;\n background-size: cover;\n background-position: center;\n }\n\n .skin-count {\n font-size: 20px;\n color: white;\n text-align: center;\n font-weight: normal;\n margin-top: 10px;\n margin-bottom: 10px;\n }\n\n .buy-button {\n color: #ffffff;\n padding: 0.8rem;\n margin-top: 5px;\n font-size: 14px;\n text-transform: uppercase;\n border-radius: 4px;\n font-weight: 400;\n display: block;\n width: 100%;\n cursor: pointer;\n border: 1px solid rgba(255, 255, 255, 0.2);\n background: transparent;\n\n &:hover {\n background-color: rgba(255, 255, 255, 0.2);\n }\n }\n}\n\n// low height\n@media screen and (max-height: 600px) {\n\n .skin-card {\n margin: 5px;\n\n\n .skin-img {\n width: 50px;\n height: 50px;\n margin: 0;\n }\n\n .skin-sword {\n width: 52px;\n height: 56px;\n margin: 0;\n }\n\n .skin-name {\n font-size: 20px;\n margin: 0;\n }\n\n .skin-count {\n font-size: 15px;\n margin: 0;\n }\n\n .buy-button {\n font-size: 12px;\n margin: 0;\n margin-top: 5px;\n padding: 0.2rem;\n }\n\n .skin-desc {\n font-size: 12px;\n margin: 0;\n }\n\n\n }\n\n .shop-title {\n font-size: 20px;\n }\n\n .shop-desc {\n font-size: 15px;\n }\n}\n\n/* General Styling Adjustments */\nh1 {\n font-size: 24px;\n font-weight: 400;\n text-align: center;\n color: #ffffff;\n /* Adjusting header color to fit modal style */\n}\n\n.highlight {\n background-color: yellow;\n}\n\n.search-bar {\n display: flex;\n justify-content: center;\n margin-bottom: 10px;\n}\n\n.search-bar input {\n width: 50%;\n padding: 5px;\n border: none;\n border-radius: 20px;\n box-shadow: 0 0 15px 4px rgba(0, 0, 0, 0.06);\n font-size: 15px;\n}\n\n.search-bar input:focus {\n outline: none;\n box-shadow: 0 0 15px 4px rgba(0, 0, 0, 0.1);\n}\n\n.search-bar input::placeholder {\n color: #aaa;\n}\n\n.badges {\n display: flex;\n justify-content: center;\n margin-bottom: 5px;\n}\n\n.badges button {\n margin: 0 10px;\n padding: 5px 10px;\n border: none;\n border-radius: 20px;\n background-color: #ddd;\n cursor: pointer;\n transition: background-color 0.3s ease;\n}\n\n.badges button.active {\n background-color: gray;\n border: 3px solid #000;\n}\n\n.badges button[data-selected-badge=\"og\"]:not(.active) {\n background-color: #ff0000;\n}\n\n.badges button[data-selected-badge=\"event\"]:not(.active) {\n background-color: #00ffff;\n}\n\n.badges button[data-selected-badge=\"own\"]:not(.active) {\n background-color: #00ff00;\n}\n\n\n.badges button[data-selected-badge=\"sale\"]:not(.active) {\n background-color: #ffff00;\n}",".reward-container {\n display: flex;\n justify-content: space-around;\n align-items: center;\n flex-wrap: wrap;\n gap: 20px;\n margin-top:\n20px;\n}\n\n\n.reward-box {\n display: flex;\n align-items: center;\n justify-content: start;\n flex: 0 1 auto;\n border: 2px solid transparent;\n border-radius: 10px;\n padding: 10px;\n text-align: left; // Align text to the left\n gap: 10px; // Space between icon and text\n transition: border-color 0.3s ease-in-out, transform 0.3s ease-in-out;\n\n &:hover {\n border-color: #fff;\n transform: scale(1.05);\n }\n\n .icon {\n // Icon styles, adjust as needed\n display: flex;\n align-items: center;\n justify-content: center;\n }\n\n .text {\n // Text styles, adjust as needed\n font-size: 16px;\n font-weight: bold;\n }\n}\n\n\n// Different colors for each type of reward\n.gems {\nbackground-color: #04390f;\n}\n\n.skinsbox {\nbackground-color: #b52555;\n}\n\n.xp {\nbackground-color: #1d9fe1;\n}","#logged-in {\n .stats {\n display: flex;\n flex-direction: row;\n align-items: center;\n justify-content: center;\n margin: 0 0 0 1rem;\n padding: 0.5rem 0.5rem 0.5rem 0;\n border-left: 1px solid var(--color-border);\n gap: 1rem;\n }\n\n h1 {\n margin-top: 0;\n margin-bottom: 0;\n }\n\n .profilebutton {\n display: flex;\n flex-direction: row;\n align-items: center;\n justify-content: center;\n gap: 0.5rem;\n padding: 0.5rem;\n border-radius: 0.5rem;\n background-color: rgb(22, 143, 22);\n color: white;\n cursor: pointer;\n transition: transform 0.3s ease;\n\n &:hover {\n transform: scale(1.1);\n }\n }\n\n}","@import url(\"https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap\");\n\n.global-leaderboard-body {\n\t@import '~bootstrap/scss/bootstrap';\n\n\t--bs-table-bg: transparent;\n\t--bs-body-bg: transparent;\n\n\t.btn {\n\t\t--bs-btn-border-radius: 0.25rem;\n\n\t\t&:focus {\n\t\t\tbox-shadow: 0 0 0 0.25rem rgba(130,138,145,0.5);\n\t\t}\n\t}\n\n\t.dropdown {\n\t\tmargin-right: 5px;\n\n\t\t.dropdown-menu {\n\t\t\tborder-radius: 0.25rem;\n\t\t\tbackground: #ffffff;\n\t\t\tborder: 1px solid rgba(0,0,0,0.15);\n\n\t\t\tli {\n\t\t\t\tcursor: pointer;\n\t\t\t}\n\t\t}\n\t}\n\n\tbackground: #f9f9f9;\n\tfont-family: \"Roboto\", sans-serif;\n\n\t.main-content {\n\t\tpadding-top: 100px;\n\t\tpadding-bottom: 100px;\n\n\t\t.leaderboard-card {\n\t\t\tbackground: #fff;\n\t\t\tmargin-bottom: 30px;\n\t\t\tborder-radius: 5px;\n\t\t\toverflow: hidden;\n\t\t\tbox-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);\n\n\t\t\t&__top {\n\t\t\t\tbackground: #f9f6ff;\n\t\t\t\tpadding: 20px 0 10px 0;\n\t\t\t}\n\n\t\t\t&__body {\n\t\t\t\tpadding: 15px;\n\t\t\t\tmargin-top: -20px;\n\t\t\t}\n\n\t\t\t&--first {\n\t\t\t\ttransform: scale(1.05);\n\n\t\t\t\t.leaderboard-card__top {\n\t\t\t\t\tbackground: linear-gradient(45deg, #7e57c2, #ab47bc);\n\t\t\t\t\tcolor: #fff;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t.table {\n\t\t\tborder-spacing: 0 15px;\n\t\t\tborder-collapse: separate;\n\n\t\t\tthead tr th,\n\t\t\tthead tr td,\n\t\t\ttbody tr th,\n\t\t\ttbody tr td {\n\t\t\t\tvertical-align: middle;\n\t\t\t\tborder: none;\n\n\t\t\t\t&:nth-last-child(1) {\n\t\t\t\t\ttext-align: center;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\ttbody tr {\n\t\t\t\tbox-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);\n\t\t\t\tborder-radius: 5px;\n\n\t\t\t\ttd {\n\t\t\t\t\tbackground: #fff;\n\n\t\t\t\t\t&:nth-child(1) {\n\t\t\t\t\t\tborder-radius: 5px 0 0 5px;\n\t\t\t\t\t}\n\n\t\t\t\t\t&:nth-last-child(1) {\n\t\t\t\t\t\tborder-radius: 0 5px 5px 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n","@mixin bsBanner($file) {\n /*!\n * Bootstrap #{$file} v5.3.2 (https://getbootstrap.com/)\n * Copyright 2011-2023 The Bootstrap Authors\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n */\n}\n",":root,\n[data-bs-theme=\"light\"] {\n // Note: Custom variable values only support SassScript inside `#{}`.\n\n // Colors\n //\n // Generate palettes for full colors, grays, and theme colors.\n\n @each $color, $value in $colors {\n --#{$prefix}#{$color}: #{$value};\n }\n\n @each $color, $value in $grays {\n --#{$prefix}gray-#{$color}: #{$value};\n }\n\n @each $color, $value in $theme-colors {\n --#{$prefix}#{$color}: #{$value};\n }\n\n @each $color, $value in $theme-colors-rgb {\n --#{$prefix}#{$color}-rgb: #{$value};\n }\n\n @each $color, $value in $theme-colors-text {\n --#{$prefix}#{$color}-text-emphasis: #{$value};\n }\n\n @each $color, $value in $theme-colors-bg-subtle {\n --#{$prefix}#{$color}-bg-subtle: #{$value};\n }\n\n @each $color, $value in $theme-colors-border-subtle {\n --#{$prefix}#{$color}-border-subtle: #{$value};\n }\n\n --#{$prefix}white-rgb: #{to-rgb($white)};\n --#{$prefix}black-rgb: #{to-rgb($black)};\n\n // Fonts\n\n // Note: Use `inspect` for lists so that quoted items keep the quotes.\n // See https://github.com/sass/sass/issues/2383#issuecomment-336349172\n --#{$prefix}font-sans-serif: #{inspect($font-family-sans-serif)};\n --#{$prefix}font-monospace: #{inspect($font-family-monospace)};\n --#{$prefix}gradient: #{$gradient};\n\n // Root and body\n // scss-docs-start root-body-variables\n @if $font-size-root != null {\n --#{$prefix}root-font-size: #{$font-size-root};\n }\n --#{$prefix}body-font-family: #{inspect($font-family-base)};\n @include rfs($font-size-base, --#{$prefix}body-font-size);\n --#{$prefix}body-font-weight: #{$font-weight-base};\n --#{$prefix}body-line-height: #{$line-height-base};\n @if $body-text-align != null {\n --#{$prefix}body-text-align: #{$body-text-align};\n }\n\n --#{$prefix}body-color: #{$body-color};\n --#{$prefix}body-color-rgb: #{to-rgb($body-color)};\n --#{$prefix}body-bg: #{$body-bg};\n --#{$prefix}body-bg-rgb: #{to-rgb($body-bg)};\n\n --#{$prefix}emphasis-color: #{$body-emphasis-color};\n --#{$prefix}emphasis-color-rgb: #{to-rgb($body-emphasis-color)};\n\n --#{$prefix}secondary-color: #{$body-secondary-color};\n --#{$prefix}secondary-color-rgb: #{to-rgb($body-secondary-color)};\n --#{$prefix}secondary-bg: #{$body-secondary-bg};\n --#{$prefix}secondary-bg-rgb: #{to-rgb($body-secondary-bg)};\n\n --#{$prefix}tertiary-color: #{$body-tertiary-color};\n --#{$prefix}tertiary-color-rgb: #{to-rgb($body-tertiary-color)};\n --#{$prefix}tertiary-bg: #{$body-tertiary-bg};\n --#{$prefix}tertiary-bg-rgb: #{to-rgb($body-tertiary-bg)};\n // scss-docs-end root-body-variables\n\n --#{$prefix}heading-color: #{$headings-color};\n\n --#{$prefix}link-color: #{$link-color};\n --#{$prefix}link-color-rgb: #{to-rgb($link-color)};\n --#{$prefix}link-decoration: #{$link-decoration};\n\n --#{$prefix}link-hover-color: #{$link-hover-color};\n --#{$prefix}link-hover-color-rgb: #{to-rgb($link-hover-color)};\n\n @if $link-hover-decoration != null {\n --#{$prefix}link-hover-decoration: #{$link-hover-decoration};\n }\n\n --#{$prefix}code-color: #{$code-color};\n --#{$prefix}highlight-color: #{$mark-color};\n --#{$prefix}highlight-bg: #{$mark-bg};\n\n // scss-docs-start root-border-var\n --#{$prefix}border-width: #{$border-width};\n --#{$prefix}border-style: #{$border-style};\n --#{$prefix}border-color: #{$border-color};\n --#{$prefix}border-color-translucent: #{$border-color-translucent};\n\n --#{$prefix}border-radius: #{$border-radius};\n --#{$prefix}border-radius-sm: #{$border-radius-sm};\n --#{$prefix}border-radius-lg: #{$border-radius-lg};\n --#{$prefix}border-radius-xl: #{$border-radius-xl};\n --#{$prefix}border-radius-xxl: #{$border-radius-xxl};\n --#{$prefix}border-radius-2xl: var(--#{$prefix}border-radius-xxl); // Deprecated in v5.3.0 for consistency\n --#{$prefix}border-radius-pill: #{$border-radius-pill};\n // scss-docs-end root-border-var\n\n --#{$prefix}box-shadow: #{$box-shadow};\n --#{$prefix}box-shadow-sm: #{$box-shadow-sm};\n --#{$prefix}box-shadow-lg: #{$box-shadow-lg};\n --#{$prefix}box-shadow-inset: #{$box-shadow-inset};\n\n // Focus styles\n // scss-docs-start root-focus-variables\n --#{$prefix}focus-ring-width: #{$focus-ring-width};\n --#{$prefix}focus-ring-opacity: #{$focus-ring-opacity};\n --#{$prefix}focus-ring-color: #{$focus-ring-color};\n // scss-docs-end root-focus-variables\n\n // scss-docs-start root-form-validation-variables\n --#{$prefix}form-valid-color: #{$form-valid-color};\n --#{$prefix}form-valid-border-color: #{$form-valid-border-color};\n --#{$prefix}form-invalid-color: #{$form-invalid-color};\n --#{$prefix}form-invalid-border-color: #{$form-invalid-border-color};\n // scss-docs-end root-form-validation-variables\n}\n\n@if $enable-dark-mode {\n @include color-mode(dark, true) {\n color-scheme: dark;\n\n // scss-docs-start root-dark-mode-vars\n --#{$prefix}body-color: #{$body-color-dark};\n --#{$prefix}body-color-rgb: #{to-rgb($body-color-dark)};\n --#{$prefix}body-bg: #{$body-bg-dark};\n --#{$prefix}body-bg-rgb: #{to-rgb($body-bg-dark)};\n\n --#{$prefix}emphasis-color: #{$body-emphasis-color-dark};\n --#{$prefix}emphasis-color-rgb: #{to-rgb($body-emphasis-color-dark)};\n\n --#{$prefix}secondary-color: #{$body-secondary-color-dark};\n --#{$prefix}secondary-color-rgb: #{to-rgb($body-secondary-color-dark)};\n --#{$prefix}secondary-bg: #{$body-secondary-bg-dark};\n --#{$prefix}secondary-bg-rgb: #{to-rgb($body-secondary-bg-dark)};\n\n --#{$prefix}tertiary-color: #{$body-tertiary-color-dark};\n --#{$prefix}tertiary-color-rgb: #{to-rgb($body-tertiary-color-dark)};\n --#{$prefix}tertiary-bg: #{$body-tertiary-bg-dark};\n --#{$prefix}tertiary-bg-rgb: #{to-rgb($body-tertiary-bg-dark)};\n\n @each $color, $value in $theme-colors-text-dark {\n --#{$prefix}#{$color}-text-emphasis: #{$value};\n }\n\n @each $color, $value in $theme-colors-bg-subtle-dark {\n --#{$prefix}#{$color}-bg-subtle: #{$value};\n }\n\n @each $color, $value in $theme-colors-border-subtle-dark {\n --#{$prefix}#{$color}-border-subtle: #{$value};\n }\n\n --#{$prefix}heading-color: #{$headings-color-dark};\n\n --#{$prefix}link-color: #{$link-color-dark};\n --#{$prefix}link-hover-color: #{$link-hover-color-dark};\n --#{$prefix}link-color-rgb: #{to-rgb($link-color-dark)};\n --#{$prefix}link-hover-color-rgb: #{to-rgb($link-hover-color-dark)};\n\n --#{$prefix}code-color: #{$code-color-dark};\n --#{$prefix}highlight-color: #{$mark-color-dark};\n --#{$prefix}highlight-bg: #{$mark-bg-dark};\n\n --#{$prefix}border-color: #{$border-color-dark};\n --#{$prefix}border-color-translucent: #{$border-color-translucent-dark};\n\n --#{$prefix}form-valid-color: #{$form-valid-color-dark};\n --#{$prefix}form-valid-border-color: #{$form-valid-border-color-dark};\n --#{$prefix}form-invalid-color: #{$form-invalid-color-dark};\n --#{$prefix}form-invalid-border-color: #{$form-invalid-border-color-dark};\n // scss-docs-end root-dark-mode-vars\n }\n}\n","// stylelint-disable scss/dimension-no-non-numeric-values\n\n// SCSS RFS mixin\n//\n// Automated responsive values for font sizes, paddings, margins and much more\n//\n// Licensed under MIT (https://github.com/twbs/rfs/blob/main/LICENSE)\n\n// Configuration\n\n// Base value\n$rfs-base-value: 1.25rem !default;\n$rfs-unit: rem !default;\n\n@if $rfs-unit != rem and $rfs-unit != px {\n @error \"`#{$rfs-unit}` is not a valid unit for $rfs-unit. Use `px` or `rem`.\";\n}\n\n// Breakpoint at where values start decreasing if screen width is smaller\n$rfs-breakpoint: 1200px !default;\n$rfs-breakpoint-unit: px !default;\n\n@if $rfs-breakpoint-unit != px and $rfs-breakpoint-unit != em and $rfs-breakpoint-unit != rem {\n @error \"`#{$rfs-breakpoint-unit}` is not a valid unit for $rfs-breakpoint-unit. Use `px`, `em` or `rem`.\";\n}\n\n// Resize values based on screen height and width\n$rfs-two-dimensional: false !default;\n\n// Factor of decrease\n$rfs-factor: 10 !default;\n\n@if type-of($rfs-factor) != number or $rfs-factor <= 1 {\n @error \"`#{$rfs-factor}` is not a valid $rfs-factor, it must be greater than 1.\";\n}\n\n// Mode. Possibilities: \"min-media-query\", \"max-media-query\"\n$rfs-mode: min-media-query !default;\n\n// Generate enable or disable classes. Possibilities: false, \"enable\" or \"disable\"\n$rfs-class: false !default;\n\n// 1 rem = $rfs-rem-value px\n$rfs-rem-value: 16 !default;\n\n// Safari iframe resize bug: https://github.com/twbs/rfs/issues/14\n$rfs-safari-iframe-resize-bug-fix: false !default;\n\n// Disable RFS by setting $enable-rfs to false\n$enable-rfs: true !default;\n\n// Cache $rfs-base-value unit\n$rfs-base-value-unit: unit($rfs-base-value);\n\n@function divide($dividend, $divisor, $precision: 10) {\n $sign: if($dividend > 0 and $divisor > 0 or $dividend < 0 and $divisor < 0, 1, -1);\n $dividend: abs($dividend);\n $divisor: abs($divisor);\n @if $dividend == 0 {\n @return 0;\n }\n @if $divisor == 0 {\n @error \"Cannot divide by 0\";\n }\n $remainder: $dividend;\n $result: 0;\n $factor: 10;\n @while ($remainder > 0 and $precision >= 0) {\n $quotient: 0;\n @while ($remainder >= $divisor) {\n $remainder: $remainder - $divisor;\n $quotient: $quotient + 1;\n }\n $result: $result * 10 + $quotient;\n $factor: $factor * .1;\n $remainder: $remainder * 10;\n $precision: $precision - 1;\n @if ($precision < 0 and $remainder >= $divisor * 5) {\n $result: $result + 1;\n }\n }\n $result: $result * $factor * $sign;\n $dividend-unit: unit($dividend);\n $divisor-unit: unit($divisor);\n $unit-map: (\n \"px\": 1px,\n \"rem\": 1rem,\n \"em\": 1em,\n \"%\": 1%\n );\n @if ($dividend-unit != $divisor-unit and map-has-key($unit-map, $dividend-unit)) {\n $result: $result * map-get($unit-map, $dividend-unit);\n }\n @return $result;\n}\n\n// Remove px-unit from $rfs-base-value for calculations\n@if $rfs-base-value-unit == px {\n $rfs-base-value: divide($rfs-base-value, $rfs-base-value * 0 + 1);\n}\n@else if $rfs-base-value-unit == rem {\n $rfs-base-value: divide($rfs-base-value, divide($rfs-base-value * 0 + 1, $rfs-rem-value));\n}\n\n// Cache $rfs-breakpoint unit to prevent multiple calls\n$rfs-breakpoint-unit-cache: unit($rfs-breakpoint);\n\n// Remove unit from $rfs-breakpoint for calculations\n@if $rfs-breakpoint-unit-cache == px {\n $rfs-breakpoint: divide($rfs-breakpoint, $rfs-breakpoint * 0 + 1);\n}\n@else if $rfs-breakpoint-unit-cache == rem or $rfs-breakpoint-unit-cache == \"em\" {\n $rfs-breakpoint: divide($rfs-breakpoint, divide($rfs-breakpoint * 0 + 1, $rfs-rem-value));\n}\n\n// Calculate the media query value\n$rfs-mq-value: if($rfs-breakpoint-unit == px, #{$rfs-breakpoint}px, #{divide($rfs-breakpoint, $rfs-rem-value)}#{$rfs-breakpoint-unit});\n$rfs-mq-property-width: if($rfs-mode == max-media-query, max-width, min-width);\n$rfs-mq-property-height: if($rfs-mode == max-media-query, max-height, min-height);\n\n// Internal mixin used to determine which media query needs to be used\n@mixin _rfs-media-query {\n @if $rfs-two-dimensional {\n @if $rfs-mode == max-media-query {\n @media (#{$rfs-mq-property-width}: #{$rfs-mq-value}), (#{$rfs-mq-property-height}: #{$rfs-mq-value}) {\n @content;\n }\n }\n @else {\n @media (#{$rfs-mq-property-width}: #{$rfs-mq-value}) and (#{$rfs-mq-property-height}: #{$rfs-mq-value}) {\n @content;\n }\n }\n }\n @else {\n @media (#{$rfs-mq-property-width}: #{$rfs-mq-value}) {\n @content;\n }\n }\n}\n\n// Internal mixin that adds disable classes to the selector if needed.\n@mixin _rfs-rule {\n @if $rfs-class == disable and $rfs-mode == max-media-query {\n // Adding an extra class increases specificity, which prevents the media query to override the property\n &,\n .disable-rfs &,\n &.disable-rfs {\n @content;\n }\n }\n @else if $rfs-class == enable and $rfs-mode == min-media-query {\n .enable-rfs &,\n &.enable-rfs {\n @content;\n }\n } @else {\n @content;\n }\n}\n\n// Internal mixin that adds enable classes to the selector if needed.\n@mixin _rfs-media-query-rule {\n\n @if $rfs-class == enable {\n @if $rfs-mode == min-media-query {\n @content;\n }\n\n @include _rfs-media-query () {\n .enable-rfs &,\n &.enable-rfs {\n @content;\n }\n }\n }\n @else {\n @if $rfs-class == disable and $rfs-mode == min-media-query {\n .disable-rfs &,\n &.disable-rfs {\n @content;\n }\n }\n @include _rfs-media-query () {\n @content;\n }\n }\n}\n\n// Helper function to get the formatted non-responsive value\n@function rfs-value($values) {\n // Convert to list\n $values: if(type-of($values) != list, ($values,), $values);\n\n $val: \"\";\n\n // Loop over each value and calculate value\n @each $value in $values {\n @if $value == 0 {\n $val: $val + \" 0\";\n }\n @else {\n // Cache $value unit\n $unit: if(type-of($value) == \"number\", unit($value), false);\n\n @if $unit == px {\n // Convert to rem if needed\n $val: $val + \" \" + if($rfs-unit == rem, #{divide($value, $value * 0 + $rfs-rem-value)}rem, $value);\n }\n @else if $unit == rem {\n // Convert to px if needed\n $val: $val + \" \" + if($rfs-unit == px, #{divide($value, $value * 0 + 1) * $rfs-rem-value}px, $value);\n } @else {\n // If $value isn't a number (like inherit) or $value has a unit (not px or rem, like 1.5em) or $ is 0, just print the value\n $val: $val + \" \" + $value;\n }\n }\n }\n\n // Remove first space\n @return unquote(str-slice($val, 2));\n}\n\n// Helper function to get the responsive value calculated by RFS\n@function rfs-fluid-value($values) {\n // Convert to list\n $values: if(type-of($values) != list, ($values,), $values);\n\n $val: \"\";\n\n // Loop over each value and calculate value\n @each $value in $values {\n @if $value == 0 {\n $val: $val + \" 0\";\n } @else {\n // Cache $value unit\n $unit: if(type-of($value) == \"number\", unit($value), false);\n\n // If $value isn't a number (like inherit) or $value has a unit (not px or rem, like 1.5em) or $ is 0, just print the value\n @if not $unit or $unit != px and $unit != rem {\n $val: $val + \" \" + $value;\n } @else {\n // Remove unit from $value for calculations\n $value: divide($value, $value * 0 + if($unit == px, 1, divide(1, $rfs-rem-value)));\n\n // Only add the media query if the value is greater than the minimum value\n @if abs($value) <= $rfs-base-value or not $enable-rfs {\n $val: $val + \" \" + if($rfs-unit == rem, #{divide($value, $rfs-rem-value)}rem, #{$value}px);\n }\n @else {\n // Calculate the minimum value\n $value-min: $rfs-base-value + divide(abs($value) - $rfs-base-value, $rfs-factor);\n\n // Calculate difference between $value and the minimum value\n $value-diff: abs($value) - $value-min;\n\n // Base value formatting\n $min-width: if($rfs-unit == rem, #{divide($value-min, $rfs-rem-value)}rem, #{$value-min}px);\n\n // Use negative value if needed\n $min-width: if($value < 0, -$min-width, $min-width);\n\n // Use `vmin` if two-dimensional is enabled\n $variable-unit: if($rfs-two-dimensional, vmin, vw);\n\n // Calculate the variable width between 0 and $rfs-breakpoint\n $variable-width: #{divide($value-diff * 100, $rfs-breakpoint)}#{$variable-unit};\n\n // Return the calculated value\n $val: $val + \" calc(\" + $min-width + if($value < 0, \" - \", \" + \") + $variable-width + \")\";\n }\n }\n }\n }\n\n // Remove first space\n @return unquote(str-slice($val, 2));\n}\n\n// RFS mixin\n@mixin rfs($values, $property: font-size) {\n @if $values != null {\n $val: rfs-value($values);\n $fluid-val: rfs-fluid-value($values);\n\n // Do not print the media query if responsive & non-responsive values are the same\n @if $val == $fluid-val {\n #{$property}: $val;\n }\n @else {\n @include _rfs-rule () {\n #{$property}: if($rfs-mode == max-media-query, $val, $fluid-val);\n\n // Include safari iframe resize fix if needed\n min-width: if($rfs-safari-iframe-resize-bug-fix, (0 * 1vw), null);\n }\n\n @include _rfs-media-query-rule () {\n #{$property}: if($rfs-mode == max-media-query, $fluid-val, $val);\n }\n }\n }\n}\n\n// Shorthand helper mixins\n@mixin font-size($value) {\n @include rfs($value);\n}\n\n@mixin padding($value) {\n @include rfs($value, padding);\n}\n\n@mixin padding-top($value) {\n @include rfs($value, padding-top);\n}\n\n@mixin padding-right($value) {\n @include rfs($value, padding-right);\n}\n\n@mixin padding-bottom($value) {\n @include rfs($value, padding-bottom);\n}\n\n@mixin padding-left($value) {\n @include rfs($value, padding-left);\n}\n\n@mixin margin($value) {\n @include rfs($value, margin);\n}\n\n@mixin margin-top($value) {\n @include rfs($value, margin-top);\n}\n\n@mixin margin-right($value) {\n @include rfs($value, margin-right);\n}\n\n@mixin margin-bottom($value) {\n @include rfs($value, margin-bottom);\n}\n\n@mixin margin-left($value) {\n @include rfs($value, margin-left);\n}\n","// scss-docs-start color-mode-mixin\n@mixin color-mode($mode: light, $root: false) {\n @if $color-mode-type == \"media-query\" {\n @if $root == true {\n @media (prefers-color-scheme: $mode) {\n :root {\n @content;\n }\n }\n } @else {\n @media (prefers-color-scheme: $mode) {\n @content;\n }\n }\n } @else {\n [data-bs-theme=\"#{$mode}\"] {\n @content;\n }\n }\n}\n// scss-docs-end color-mode-mixin\n","// stylelint-disable declaration-no-important, selector-no-qualifying-type, property-no-vendor-prefix\n\n\n// Reboot\n//\n// Normalization of HTML elements, manually forked from Normalize.css to remove\n// styles targeting irrelevant browsers while applying new styles.\n//\n// Normalize is licensed MIT. https://github.com/necolas/normalize.css\n\n\n// Document\n//\n// Change from `box-sizing: content-box` so that `width` is not affected by `padding` or `border`.\n\n*,\n*::before,\n*::after {\n box-sizing: border-box;\n}\n\n\n// Root\n//\n// Ability to the value of the root font sizes, affecting the value of `rem`.\n// null by default, thus nothing is generated.\n\n:root {\n @if $font-size-root != null {\n @include font-size(var(--#{$prefix}root-font-size));\n }\n\n @if $enable-smooth-scroll {\n @media (prefers-reduced-motion: no-preference) {\n scroll-behavior: smooth;\n }\n }\n}\n\n\n// Body\n//\n// 1. Remove the margin in all browsers.\n// 2. As a best practice, apply a default `background-color`.\n// 3. Prevent adjustments of font size after orientation changes in iOS.\n// 4. Change the default tap highlight to be completely transparent in iOS.\n\n// scss-docs-start reboot-body-rules\nbody {\n margin: 0; // 1\n font-family: var(--#{$prefix}body-font-family);\n @include font-size(var(--#{$prefix}body-font-size));\n font-weight: var(--#{$prefix}body-font-weight);\n line-height: var(--#{$prefix}body-line-height);\n color: var(--#{$prefix}body-color);\n text-align: var(--#{$prefix}body-text-align);\n background-color: var(--#{$prefix}body-bg); // 2\n -webkit-text-size-adjust: 100%; // 3\n -webkit-tap-highlight-color: rgba($black, 0); // 4\n}\n// scss-docs-end reboot-body-rules\n\n\n// Content grouping\n//\n// 1. Reset Firefox's gray color\n\nhr {\n margin: $hr-margin-y 0;\n color: $hr-color; // 1\n border: 0;\n border-top: $hr-border-width solid $hr-border-color;\n opacity: $hr-opacity;\n}\n\n\n// Typography\n//\n// 1. Remove top margins from headings\n// By default, `

`-`

` all receive top and bottom margins. We nuke the top\n// margin for easier control within type scales as it avoids margin collapsing.\n\n%heading {\n margin-top: 0; // 1\n margin-bottom: $headings-margin-bottom;\n font-family: $headings-font-family;\n font-style: $headings-font-style;\n font-weight: $headings-font-weight;\n line-height: $headings-line-height;\n color: var(--#{$prefix}heading-color);\n}\n\nh1 {\n @extend %heading;\n @include font-size($h1-font-size);\n}\n\nh2 {\n @extend %heading;\n @include font-size($h2-font-size);\n}\n\nh3 {\n @extend %heading;\n @include font-size($h3-font-size);\n}\n\nh4 {\n @extend %heading;\n @include font-size($h4-font-size);\n}\n\nh5 {\n @extend %heading;\n @include font-size($h5-font-size);\n}\n\nh6 {\n @extend %heading;\n @include font-size($h6-font-size);\n}\n\n\n// Reset margins on paragraphs\n//\n// Similarly, the top margin on `

`s get reset. However, we also reset the\n// bottom margin to use `rem` units instead of `em`.\n\np {\n margin-top: 0;\n margin-bottom: $paragraph-margin-bottom;\n}\n\n\n// Abbreviations\n//\n// 1. Add the correct text decoration in Chrome, Edge, Opera, and Safari.\n// 2. Add explicit cursor to indicate changed behavior.\n// 3. Prevent the text-decoration to be skipped.\n\nabbr[title] {\n text-decoration: underline dotted; // 1\n cursor: help; // 2\n text-decoration-skip-ink: none; // 3\n}\n\n\n// Address\n\naddress {\n margin-bottom: 1rem;\n font-style: normal;\n line-height: inherit;\n}\n\n\n// Lists\n\nol,\nul {\n padding-left: 2rem;\n}\n\nol,\nul,\ndl {\n margin-top: 0;\n margin-bottom: 1rem;\n}\n\nol ol,\nul ul,\nol ul,\nul ol {\n margin-bottom: 0;\n}\n\ndt {\n font-weight: $dt-font-weight;\n}\n\n// 1. Undo browser default\n\ndd {\n margin-bottom: .5rem;\n margin-left: 0; // 1\n}\n\n\n// Blockquote\n\nblockquote {\n margin: 0 0 1rem;\n}\n\n\n// Strong\n//\n// Add the correct font weight in Chrome, Edge, and Safari\n\nb,\nstrong {\n font-weight: $font-weight-bolder;\n}\n\n\n// Small\n//\n// Add the correct font size in all browsers\n\nsmall {\n @include font-size($small-font-size);\n}\n\n\n// Mark\n\nmark {\n padding: $mark-padding;\n color: var(--#{$prefix}highlight-color);\n background-color: var(--#{$prefix}highlight-bg);\n}\n\n\n// Sub and Sup\n//\n// Prevent `sub` and `sup` elements from affecting the line height in\n// all browsers.\n\nsub,\nsup {\n position: relative;\n @include font-size($sub-sup-font-size);\n line-height: 0;\n vertical-align: baseline;\n}\n\nsub { bottom: -.25em; }\nsup { top: -.5em; }\n\n\n// Links\n\na {\n color: rgba(var(--#{$prefix}link-color-rgb), var(--#{$prefix}link-opacity, 1));\n text-decoration: $link-decoration;\n\n &:hover {\n --#{$prefix}link-color-rgb: var(--#{$prefix}link-hover-color-rgb);\n text-decoration: $link-hover-decoration;\n }\n}\n\n// And undo these styles for placeholder links/named anchors (without href).\n// It would be more straightforward to just use a[href] in previous block, but that\n// causes specificity issues in many other styles that are too complex to fix.\n// See https://github.com/twbs/bootstrap/issues/19402\n\na:not([href]):not([class]) {\n &,\n &:hover {\n color: inherit;\n text-decoration: none;\n }\n}\n\n\n// Code\n\npre,\ncode,\nkbd,\nsamp {\n font-family: $font-family-code;\n @include font-size(1em); // Correct the odd `em` font sizing in all browsers.\n}\n\n// 1. Remove browser default top margin\n// 2. Reset browser default of `1em` to use `rem`s\n// 3. Don't allow content to break outside\n\npre {\n display: block;\n margin-top: 0; // 1\n margin-bottom: 1rem; // 2\n overflow: auto; // 3\n @include font-size($code-font-size);\n color: $pre-color;\n\n // Account for some code outputs that place code tags in pre tags\n code {\n @include font-size(inherit);\n color: inherit;\n word-break: normal;\n }\n}\n\ncode {\n @include font-size($code-font-size);\n color: var(--#{$prefix}code-color);\n word-wrap: break-word;\n\n // Streamline the style when inside anchors to avoid broken underline and more\n a > & {\n color: inherit;\n }\n}\n\nkbd {\n padding: $kbd-padding-y $kbd-padding-x;\n @include font-size($kbd-font-size);\n color: $kbd-color;\n background-color: $kbd-bg;\n @include border-radius($border-radius-sm);\n\n kbd {\n padding: 0;\n @include font-size(1em);\n font-weight: $nested-kbd-font-weight;\n }\n}\n\n\n// Figures\n//\n// Apply a consistent margin strategy (matches our type styles).\n\nfigure {\n margin: 0 0 1rem;\n}\n\n\n// Images and content\n\nimg,\nsvg {\n vertical-align: middle;\n}\n\n\n// Tables\n//\n// Prevent double borders\n\ntable {\n caption-side: bottom;\n border-collapse: collapse;\n}\n\ncaption {\n padding-top: $table-cell-padding-y;\n padding-bottom: $table-cell-padding-y;\n color: $table-caption-color;\n text-align: left;\n}\n\n// 1. Removes font-weight bold by inheriting\n// 2. Matches default `` alignment by inheriting `text-align`.\n// 3. Fix alignment for Safari\n\nth {\n font-weight: $table-th-font-weight; // 1\n text-align: inherit; // 2\n text-align: -webkit-match-parent; // 3\n}\n\nthead,\ntbody,\ntfoot,\ntr,\ntd,\nth {\n border-color: inherit;\n border-style: solid;\n border-width: 0;\n}\n\n\n// Forms\n//\n// 1. Allow labels to use `margin` for spacing.\n\nlabel {\n display: inline-block; // 1\n}\n\n// Remove the default `border-radius` that macOS Chrome adds.\n// See https://github.com/twbs/bootstrap/issues/24093\n\nbutton {\n // stylelint-disable-next-line property-disallowed-list\n border-radius: 0;\n}\n\n// Explicitly remove focus outline in Chromium when it shouldn't be\n// visible (e.g. as result of mouse click or touch tap). It already\n// should be doing this automatically, but seems to currently be\n// confused and applies its very visible two-tone outline anyway.\n\nbutton:focus:not(:focus-visible) {\n outline: 0;\n}\n\n// 1. Remove the margin in Firefox and Safari\n\ninput,\nbutton,\nselect,\noptgroup,\ntextarea {\n margin: 0; // 1\n font-family: inherit;\n @include font-size(inherit);\n line-height: inherit;\n}\n\n// Remove the inheritance of text transform in Firefox\nbutton,\nselect {\n text-transform: none;\n}\n// Set the cursor for non-`\r\n * \r\n * )\r\n * }\r\n */\n\nexport const useDispatch = /*#__PURE__*/createDispatchHook();","////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nexport enum Action {\n /**\n * A POP indicates a change to an arbitrary index in the history stack, such\n * as a back or forward navigation. It does not describe the direction of the\n * navigation, only that the current index changed.\n *\n * Note: This is the default action for newly created history objects.\n */\n Pop = \"POP\",\n\n /**\n * A PUSH indicates a new entry being added to the history stack, such as when\n * a link is clicked and a new page loads. When this happens, all subsequent\n * entries in the stack are lost.\n */\n Push = \"PUSH\",\n\n /**\n * A REPLACE indicates the entry at the current index in the history stack\n * being replaced by a new one.\n */\n Replace = \"REPLACE\",\n}\n\n/**\n * The pathname, search, and hash values of a URL.\n */\nexport interface Path {\n /**\n * A URL pathname, beginning with a /.\n */\n pathname: string;\n\n /**\n * A URL search string, beginning with a ?.\n */\n search: string;\n\n /**\n * A URL fragment identifier, beginning with a #.\n */\n hash: string;\n}\n\n// TODO: (v7) Change the Location generic default from `any` to `unknown` and\n// remove Remix `useLocation` wrapper.\n\n/**\n * An entry in a history stack. A location contains information about the\n * URL path, as well as possibly some arbitrary state and a key.\n */\nexport interface Location extends Path {\n /**\n * A value of arbitrary data associated with this location.\n */\n state: State;\n\n /**\n * A unique string associated with this location. May be used to safely store\n * and retrieve data in some other storage API, like `localStorage`.\n *\n * Note: This value is always \"default\" on the initial location.\n */\n key: string;\n}\n\n/**\n * A change to the current location.\n */\nexport interface Update {\n /**\n * The action that triggered the change.\n */\n action: Action;\n\n /**\n * The new location.\n */\n location: Location;\n\n /**\n * The delta between this location and the former location in the history stack\n */\n delta: number | null;\n}\n\n/**\n * A function that receives notifications about location changes.\n */\nexport interface Listener {\n (update: Update): void;\n}\n\n/**\n * Describes a location that is the destination of some navigation, either via\n * `history.push` or `history.replace`. This may be either a URL or the pieces\n * of a URL path.\n */\nexport type To = string | Partial;\n\n/**\n * A history is an interface to the navigation stack. The history serves as the\n * source of truth for the current location, as well as provides a set of\n * methods that may be used to change it.\n *\n * It is similar to the DOM's `window.history` object, but with a smaller, more\n * focused API.\n */\nexport interface History {\n /**\n * The last action that modified the current location. This will always be\n * Action.Pop when a history instance is first created. This value is mutable.\n */\n readonly action: Action;\n\n /**\n * The current location. This value is mutable.\n */\n readonly location: Location;\n\n /**\n * Returns a valid href for the given `to` value that may be used as\n * the value of an attribute.\n *\n * @param to - The destination URL\n */\n createHref(to: To): string;\n\n /**\n * Returns a URL for the given `to` value\n *\n * @param to - The destination URL\n */\n createURL(to: To): URL;\n\n /**\n * Encode a location the same way window.history would do (no-op for memory\n * history) so we ensure our PUSH/REPLACE navigations for data routers\n * behave the same as POP\n *\n * @param to Unencoded path\n */\n encodeLocation(to: To): Path;\n\n /**\n * Pushes a new location onto the history stack, increasing its length by one.\n * If there were any entries in the stack after the current one, they are\n * lost.\n *\n * @param to - The new URL\n * @param state - Data to associate with the new location\n */\n push(to: To, state?: any): void;\n\n /**\n * Replaces the current location in the history stack with a new one. The\n * location that was replaced will no longer be available.\n *\n * @param to - The new URL\n * @param state - Data to associate with the new location\n */\n replace(to: To, state?: any): void;\n\n /**\n * Navigates `n` entries backward/forward in the history stack relative to the\n * current index. For example, a \"back\" navigation would use go(-1).\n *\n * @param delta - The delta in the stack index\n */\n go(delta: number): void;\n\n /**\n * Sets up a listener that will be called whenever the current location\n * changes.\n *\n * @param listener - A function that will be called when the location changes\n * @returns unlisten - A function that may be used to stop listening\n */\n listen(listener: Listener): () => void;\n}\n\ntype HistoryState = {\n usr: any;\n key?: string;\n idx: number;\n};\n\nconst PopStateEventType = \"popstate\";\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Memory History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A user-supplied object that describes a location. Used when providing\n * entries to `createMemoryHistory` via its `initialEntries` option.\n */\nexport type InitialEntry = string | Partial;\n\nexport type MemoryHistoryOptions = {\n initialEntries?: InitialEntry[];\n initialIndex?: number;\n v5Compat?: boolean;\n};\n\n/**\n * A memory history stores locations in memory. This is useful in stateful\n * environments where there is no web browser, such as node tests or React\n * Native.\n */\nexport interface MemoryHistory extends History {\n /**\n * The current index in the history stack.\n */\n readonly index: number;\n}\n\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nexport function createMemoryHistory(\n options: MemoryHistoryOptions = {}\n): MemoryHistory {\n let { initialEntries = [\"/\"], initialIndex, v5Compat = false } = options;\n let entries: Location[]; // Declare so we can access from createMemoryLocation\n entries = initialEntries.map((entry, index) =>\n createMemoryLocation(\n entry,\n typeof entry === \"string\" ? null : entry.state,\n index === 0 ? \"default\" : undefined\n )\n );\n let index = clampIndex(\n initialIndex == null ? entries.length - 1 : initialIndex\n );\n let action = Action.Pop;\n let listener: Listener | null = null;\n\n function clampIndex(n: number): number {\n return Math.min(Math.max(n, 0), entries.length - 1);\n }\n function getCurrentLocation(): Location {\n return entries[index];\n }\n function createMemoryLocation(\n to: To,\n state: any = null,\n key?: string\n ): Location {\n let location = createLocation(\n entries ? getCurrentLocation().pathname : \"/\",\n to,\n state,\n key\n );\n warning(\n location.pathname.charAt(0) === \"/\",\n `relative pathnames are not supported in memory history: ${JSON.stringify(\n to\n )}`\n );\n return location;\n }\n\n function createHref(to: To) {\n return typeof to === \"string\" ? to : createPath(to);\n }\n\n let history: MemoryHistory = {\n get index() {\n return index;\n },\n get action() {\n return action;\n },\n get location() {\n return getCurrentLocation();\n },\n createHref,\n createURL(to) {\n return new URL(createHref(to), \"http://localhost\");\n },\n encodeLocation(to: To) {\n let path = typeof to === \"string\" ? parsePath(to) : to;\n return {\n pathname: path.pathname || \"\",\n search: path.search || \"\",\n hash: path.hash || \"\",\n };\n },\n push(to, state) {\n action = Action.Push;\n let nextLocation = createMemoryLocation(to, state);\n index += 1;\n entries.splice(index, entries.length, nextLocation);\n if (v5Compat && listener) {\n listener({ action, location: nextLocation, delta: 1 });\n }\n },\n replace(to, state) {\n action = Action.Replace;\n let nextLocation = createMemoryLocation(to, state);\n entries[index] = nextLocation;\n if (v5Compat && listener) {\n listener({ action, location: nextLocation, delta: 0 });\n }\n },\n go(delta) {\n action = Action.Pop;\n let nextIndex = clampIndex(index + delta);\n let nextLocation = entries[nextIndex];\n index = nextIndex;\n if (listener) {\n listener({ action, location: nextLocation, delta });\n }\n },\n listen(fn: Listener) {\n listener = fn;\n return () => {\n listener = null;\n };\n },\n };\n\n return history;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Browser History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A browser history stores the current location in regular URLs in a web\n * browser environment. This is the standard for most web apps and provides the\n * cleanest URLs the browser's address bar.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory\n */\nexport interface BrowserHistory extends UrlHistory {}\n\nexport type BrowserHistoryOptions = UrlHistoryOptions;\n\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nexport function createBrowserHistory(\n options: BrowserHistoryOptions = {}\n): BrowserHistory {\n function createBrowserLocation(\n window: Window,\n globalHistory: Window[\"history\"]\n ) {\n let { pathname, search, hash } = window.location;\n return createLocation(\n \"\",\n { pathname, search, hash },\n // state defaults to `null` because `window.history.state` does\n (globalHistory.state && globalHistory.state.usr) || null,\n (globalHistory.state && globalHistory.state.key) || \"default\"\n );\n }\n\n function createBrowserHref(window: Window, to: To) {\n return typeof to === \"string\" ? to : createPath(to);\n }\n\n return getUrlBasedHistory(\n createBrowserLocation,\n createBrowserHref,\n null,\n options\n );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hash History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A hash history stores the current location in the fragment identifier portion\n * of the URL in a web browser environment.\n *\n * This is ideal for apps that do not control the server for some reason\n * (because the fragment identifier is never sent to the server), including some\n * shared hosting environments that do not provide fine-grained controls over\n * which pages are served at which URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory\n */\nexport interface HashHistory extends UrlHistory {}\n\nexport type HashHistoryOptions = UrlHistoryOptions;\n\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nexport function createHashHistory(\n options: HashHistoryOptions = {}\n): HashHistory {\n function createHashLocation(\n window: Window,\n globalHistory: Window[\"history\"]\n ) {\n let {\n pathname = \"/\",\n search = \"\",\n hash = \"\",\n } = parsePath(window.location.hash.substr(1));\n\n // Hash URL should always have a leading / just like window.location.pathname\n // does, so if an app ends up at a route like /#something then we add a\n // leading slash so all of our path-matching behaves the same as if it would\n // in a browser router. This is particularly important when there exists a\n // root splat route () since that matches internally against\n // \"/*\" and we'd expect /#something to 404 in a hash router app.\n if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n pathname = \"/\" + pathname;\n }\n\n return createLocation(\n \"\",\n { pathname, search, hash },\n // state defaults to `null` because `window.history.state` does\n (globalHistory.state && globalHistory.state.usr) || null,\n (globalHistory.state && globalHistory.state.key) || \"default\"\n );\n }\n\n function createHashHref(window: Window, to: To) {\n let base = window.document.querySelector(\"base\");\n let href = \"\";\n\n if (base && base.getAttribute(\"href\")) {\n let url = window.location.href;\n let hashIndex = url.indexOf(\"#\");\n href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n }\n\n return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n }\n\n function validateHashLocation(location: Location, to: To) {\n warning(\n location.pathname.charAt(0) === \"/\",\n `relative pathnames are not supported in hash history.push(${JSON.stringify(\n to\n )})`\n );\n }\n\n return getUrlBasedHistory(\n createHashLocation,\n createHashHref,\n validateHashLocation,\n options\n );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @private\n */\nexport function invariant(value: boolean, message?: string): asserts value;\nexport function invariant(\n value: T | null | undefined,\n message?: string\n): asserts value is T;\nexport function invariant(value: any, message?: string) {\n if (value === false || value === null || typeof value === \"undefined\") {\n throw new Error(message);\n }\n}\n\nexport function warning(cond: any, message: string) {\n if (!cond) {\n // eslint-disable-next-line no-console\n if (typeof console !== \"undefined\") console.warn(message);\n\n try {\n // Welcome to debugging history!\n //\n // This error is thrown as a convenience, so you can more easily\n // find the source for a warning that appears in the console by\n // enabling \"pause on exceptions\" in your JavaScript debugger.\n throw new Error(message);\n // eslint-disable-next-line no-empty\n } catch (e) {}\n }\n}\n\nfunction createKey() {\n return Math.random().toString(36).substr(2, 8);\n}\n\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location: Location, index: number): HistoryState {\n return {\n usr: location.state,\n key: location.key,\n idx: index,\n };\n}\n\n/**\n * Creates a Location object with a unique key from the given Path\n */\nexport function createLocation(\n current: string | Location,\n to: To,\n state: any = null,\n key?: string\n): Readonly {\n let location: Readonly = {\n pathname: typeof current === \"string\" ? current : current.pathname,\n search: \"\",\n hash: \"\",\n ...(typeof to === \"string\" ? parsePath(to) : to),\n state,\n // TODO: This could be cleaned up. push/replace should probably just take\n // full Locations now and avoid the need to run through this flow at all\n // But that's a pretty big refactor to the current test suite so going to\n // keep as is for the time being and just let any incoming keys take precedence\n key: (to && (to as Location).key) || key || createKey(),\n };\n return location;\n}\n\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nexport function createPath({\n pathname = \"/\",\n search = \"\",\n hash = \"\",\n}: Partial) {\n if (search && search !== \"?\")\n pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n if (hash && hash !== \"#\")\n pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n return pathname;\n}\n\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nexport function parsePath(path: string): Partial {\n let parsedPath: Partial = {};\n\n if (path) {\n let hashIndex = path.indexOf(\"#\");\n if (hashIndex >= 0) {\n parsedPath.hash = path.substr(hashIndex);\n path = path.substr(0, hashIndex);\n }\n\n let searchIndex = path.indexOf(\"?\");\n if (searchIndex >= 0) {\n parsedPath.search = path.substr(searchIndex);\n path = path.substr(0, searchIndex);\n }\n\n if (path) {\n parsedPath.pathname = path;\n }\n }\n\n return parsedPath;\n}\n\nexport interface UrlHistory extends History {}\n\nexport type UrlHistoryOptions = {\n window?: Window;\n v5Compat?: boolean;\n};\n\nfunction getUrlBasedHistory(\n getLocation: (window: Window, globalHistory: Window[\"history\"]) => Location,\n createHref: (window: Window, to: To) => string,\n validateLocation: ((location: Location, to: To) => void) | null,\n options: UrlHistoryOptions = {}\n): UrlHistory {\n let { window = document.defaultView!, v5Compat = false } = options;\n let globalHistory = window.history;\n let action = Action.Pop;\n let listener: Listener | null = null;\n\n let index = getIndex()!;\n // Index should only be null when we initialize. If not, it's because the\n // user called history.pushState or history.replaceState directly, in which\n // case we should log a warning as it will result in bugs.\n if (index == null) {\n index = 0;\n globalHistory.replaceState({ ...globalHistory.state, idx: index }, \"\");\n }\n\n function getIndex(): number {\n let state = globalHistory.state || { idx: null };\n return state.idx;\n }\n\n function handlePop() {\n action = Action.Pop;\n let nextIndex = getIndex();\n let delta = nextIndex == null ? null : nextIndex - index;\n index = nextIndex;\n if (listener) {\n listener({ action, location: history.location, delta });\n }\n }\n\n function push(to: To, state?: any) {\n action = Action.Push;\n let location = createLocation(history.location, to, state);\n if (validateLocation) validateLocation(location, to);\n\n index = getIndex() + 1;\n let historyState = getHistoryState(location, index);\n let url = history.createHref(location);\n\n // try...catch because iOS limits us to 100 pushState calls :/\n try {\n globalHistory.pushState(historyState, \"\", url);\n } catch (error) {\n // If the exception is because `state` can't be serialized, let that throw\n // outwards just like a replace call would so the dev knows the cause\n // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n if (error instanceof DOMException && error.name === \"DataCloneError\") {\n throw error;\n }\n // They are going to lose state here, but there is no real\n // way to warn them about it since the page will refresh...\n window.location.assign(url);\n }\n\n if (v5Compat && listener) {\n listener({ action, location: history.location, delta: 1 });\n }\n }\n\n function replace(to: To, state?: any) {\n action = Action.Replace;\n let location = createLocation(history.location, to, state);\n if (validateLocation) validateLocation(location, to);\n\n index = getIndex();\n let historyState = getHistoryState(location, index);\n let url = history.createHref(location);\n globalHistory.replaceState(historyState, \"\", url);\n\n if (v5Compat && listener) {\n listener({ action, location: history.location, delta: 0 });\n }\n }\n\n function createURL(to: To): URL {\n // window.location.origin is \"null\" (the literal string value) in Firefox\n // under certain conditions, notably when serving from a local HTML file\n // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n let base =\n window.location.origin !== \"null\"\n ? window.location.origin\n : window.location.href;\n\n let href = typeof to === \"string\" ? to : createPath(to);\n invariant(\n base,\n `No window.location.(origin|href) available to create URL for href: ${href}`\n );\n return new URL(href, base);\n }\n\n let history: History = {\n get action() {\n return action;\n },\n get location() {\n return getLocation(window, globalHistory);\n },\n listen(fn: Listener) {\n if (listener) {\n throw new Error(\"A history only accepts one active listener\");\n }\n window.addEventListener(PopStateEventType, handlePop);\n listener = fn;\n\n return () => {\n window.removeEventListener(PopStateEventType, handlePop);\n listener = null;\n };\n },\n createHref(to) {\n return createHref(window, to);\n },\n createURL,\n encodeLocation(to) {\n // Encode a Location the same way window.location would\n let url = createURL(to);\n return {\n pathname: url.pathname,\n search: url.search,\n hash: url.hash,\n };\n },\n push,\n replace,\n go(n) {\n return globalHistory.go(n);\n },\n };\n\n return history;\n}\n\n//#endregion\n","// The primary entry point assumes we're working with standard ReactDOM/RN, but\n// older versions that do not include `useSyncExternalStore` (React 16.9 - 17.x).\n// Because of that, the useSyncExternalStore compat shim is needed.\nimport { useSyncExternalStore } from 'use-sync-external-store/shim';\nimport { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector';\nimport { unstable_batchedUpdates as batch } from './utils/reactBatchedUpdates';\nimport { setBatch } from './utils/batch';\nimport { initializeUseSelector } from './hooks/useSelector';\nimport { initializeConnect } from './components/connect';\ninitializeUseSelector(useSyncExternalStoreWithSelector);\ninitializeConnect(useSyncExternalStore); // Enable batched updates in our subscriptions for use\n// with standard React renderers (ReactDOM, React Native)\n\nsetBatch(batch);\nexport { batch };\nexport * from './exports';","import type { Location, Path, To } from \"./history\";\nimport { invariant, parsePath, warning } from \"./history\";\n\n/**\n * Map of routeId -> data returned from a loader/action/error\n */\nexport interface RouteData {\n [routeId: string]: any;\n}\n\nexport enum ResultType {\n data = \"data\",\n deferred = \"deferred\",\n redirect = \"redirect\",\n error = \"error\",\n}\n\n/**\n * Successful result from a loader or action\n */\nexport interface SuccessResult {\n type: ResultType.data;\n data: any;\n statusCode?: number;\n headers?: Headers;\n}\n\n/**\n * Successful defer() result from a loader or action\n */\nexport interface DeferredResult {\n type: ResultType.deferred;\n deferredData: DeferredData;\n statusCode?: number;\n headers?: Headers;\n}\n\n/**\n * Redirect result from a loader or action\n */\nexport interface RedirectResult {\n type: ResultType.redirect;\n status: number;\n location: string;\n revalidate: boolean;\n reloadDocument?: boolean;\n}\n\n/**\n * Unsuccessful result from a loader or action\n */\nexport interface ErrorResult {\n type: ResultType.error;\n error: any;\n headers?: Headers;\n}\n\n/**\n * Result from a loader or action - potentially successful or unsuccessful\n */\nexport type DataResult =\n | SuccessResult\n | DeferredResult\n | RedirectResult\n | ErrorResult;\n\ntype LowerCaseFormMethod = \"get\" | \"post\" | \"put\" | \"patch\" | \"delete\";\ntype UpperCaseFormMethod = Uppercase;\n\n/**\n * Users can specify either lowercase or uppercase form methods on `

`,\n * useSubmit(), ``, etc.\n */\nexport type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;\n\n/**\n * Active navigation/fetcher form methods are exposed in lowercase on the\n * RouterState\n */\nexport type FormMethod = LowerCaseFormMethod;\nexport type MutationFormMethod = Exclude;\n\n/**\n * In v7, active navigation/fetcher form methods are exposed in uppercase on the\n * RouterState. This is to align with the normalization done via fetch().\n */\nexport type V7_FormMethod = UpperCaseFormMethod;\nexport type V7_MutationFormMethod = Exclude;\n\nexport type FormEncType =\n | \"application/x-www-form-urlencoded\"\n | \"multipart/form-data\"\n | \"application/json\"\n | \"text/plain\";\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\n/**\n * @private\n * Internal interface to pass around for action submissions, not intended for\n * external consumption\n */\nexport type Submission =\n | {\n formMethod: FormMethod | V7_FormMethod;\n formAction: string;\n formEncType: FormEncType;\n formData: FormData;\n json: undefined;\n text: undefined;\n }\n | {\n formMethod: FormMethod | V7_FormMethod;\n formAction: string;\n formEncType: FormEncType;\n formData: undefined;\n json: JsonValue;\n text: undefined;\n }\n | {\n formMethod: FormMethod | V7_FormMethod;\n formAction: string;\n formEncType: FormEncType;\n formData: undefined;\n json: undefined;\n text: string;\n };\n\n/**\n * @private\n * Arguments passed to route loader/action functions. Same for now but we keep\n * this as a private implementation detail in case they diverge in the future.\n */\ninterface DataFunctionArgs {\n request: Request;\n params: Params;\n context?: Context;\n}\n\n// TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:\n// ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs\n// Also, make them a type alias instead of an interface\n\n/**\n * Arguments passed to loader functions\n */\nexport interface LoaderFunctionArgs\n extends DataFunctionArgs {}\n\n/**\n * Arguments passed to action functions\n */\nexport interface ActionFunctionArgs\n extends DataFunctionArgs {}\n\n/**\n * Loaders and actions can return anything except `undefined` (`null` is a\n * valid return value if there is no data to return). Responses are preferred\n * and will ease any future migration to Remix\n */\ntype DataFunctionValue = Response | NonNullable | null;\n\n/**\n * Route loader function signature\n */\nexport interface LoaderFunction {\n (args: LoaderFunctionArgs):\n | Promise\n | DataFunctionValue;\n}\n\n/**\n * Route action function signature\n */\nexport interface ActionFunction {\n (args: ActionFunctionArgs):\n | Promise\n | DataFunctionValue;\n}\n\n/**\n * Arguments passed to shouldRevalidate function\n */\nexport interface ShouldRevalidateFunctionArgs {\n currentUrl: URL;\n currentParams: AgnosticDataRouteMatch[\"params\"];\n nextUrl: URL;\n nextParams: AgnosticDataRouteMatch[\"params\"];\n formMethod?: Submission[\"formMethod\"];\n formAction?: Submission[\"formAction\"];\n formEncType?: Submission[\"formEncType\"];\n text?: Submission[\"text\"];\n formData?: Submission[\"formData\"];\n json?: Submission[\"json\"];\n actionResult?: any;\n defaultShouldRevalidate: boolean;\n}\n\n/**\n * Route shouldRevalidate function signature. This runs after any submission\n * (navigation or fetcher), so we flatten the navigation/fetcher submission\n * onto the arguments. It shouldn't matter whether it came from a navigation\n * or a fetcher, what really matters is the URLs and the formData since loaders\n * have to re-run based on the data models that were potentially mutated.\n */\nexport interface ShouldRevalidateFunction {\n (args: ShouldRevalidateFunctionArgs): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set `hasErrorBoundary`\n * from the framework-aware `errorElement` prop\n *\n * @deprecated Use `mapRouteProperties` instead\n */\nexport interface DetectErrorBoundaryFunction {\n (route: AgnosticRouteObject): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set any framework-specific\n * properties from framework-agnostic properties\n */\nexport interface MapRoutePropertiesFunction {\n (route: AgnosticRouteObject): {\n hasErrorBoundary: boolean;\n } & Record;\n}\n\n/**\n * Keys we cannot change from within a lazy() function. We spread all other keys\n * onto the route. Either they're meaningful to the router, or they'll get\n * ignored.\n */\nexport type ImmutableRouteKey =\n | \"lazy\"\n | \"caseSensitive\"\n | \"path\"\n | \"id\"\n | \"index\"\n | \"children\";\n\nexport const immutableRouteKeys = new Set([\n \"lazy\",\n \"caseSensitive\",\n \"path\",\n \"id\",\n \"index\",\n \"children\",\n]);\n\ntype RequireOne = Exclude<\n {\n [K in keyof T]: K extends Key ? Omit & Required> : never;\n }[keyof T],\n undefined\n>;\n\n/**\n * lazy() function to load a route definition, which can add non-matching\n * related properties to a route\n */\nexport interface LazyRouteFunction {\n (): Promise>>;\n}\n\n/**\n * Base RouteObject with common props shared by all types of routes\n */\ntype AgnosticBaseRouteObject = {\n caseSensitive?: boolean;\n path?: string;\n id?: string;\n loader?: LoaderFunction;\n action?: ActionFunction;\n hasErrorBoundary?: boolean;\n shouldRevalidate?: ShouldRevalidateFunction;\n handle?: any;\n lazy?: LazyRouteFunction;\n};\n\n/**\n * Index routes must not have children\n */\nexport type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {\n children?: undefined;\n index: true;\n};\n\n/**\n * Non-index routes may have children, but cannot have index\n */\nexport type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {\n children?: AgnosticRouteObject[];\n index?: false;\n};\n\n/**\n * A route object represents a logical route, with (optionally) its child\n * routes organized in a tree-like structure.\n */\nexport type AgnosticRouteObject =\n | AgnosticIndexRouteObject\n | AgnosticNonIndexRouteObject;\n\nexport type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {\n id: string;\n};\n\nexport type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {\n children?: AgnosticDataRouteObject[];\n id: string;\n};\n\n/**\n * A data route object, which is just a RouteObject with a required unique ID\n */\nexport type AgnosticDataRouteObject =\n | AgnosticDataIndexRouteObject\n | AgnosticDataNonIndexRouteObject;\n\nexport type RouteManifest = Record;\n\n// Recursive helper for finding path parameters in the absence of wildcards\ntype _PathParam =\n // split path into individual path segments\n Path extends `${infer L}/${infer R}`\n ? _PathParam | _PathParam\n : // find params after `:`\n Path extends `:${infer Param}`\n ? Param extends `${infer Optional}?`\n ? Optional\n : Param\n : // otherwise, there aren't any params present\n never;\n\n/**\n * Examples:\n * \"/a/b/*\" -> \"*\"\n * \":a\" -> \"a\"\n * \"/a/:b\" -> \"b\"\n * \"/a/blahblahblah:b\" -> \"b\"\n * \"/:a/:b\" -> \"a\" | \"b\"\n * \"/:a/b/:c/*\" -> \"a\" | \"c\" | \"*\"\n */\ntype PathParam =\n // check if path is just a wildcard\n Path extends \"*\" | \"/*\"\n ? \"*\"\n : // look for wildcard at the end of the path\n Path extends `${infer Rest}/*`\n ? \"*\" | _PathParam\n : // look for params in the absence of wildcards\n _PathParam;\n\n// Attempt to parse the given string segment. If it fails, then just return the\n// plain string type as a default fallback. Otherwise, return the union of the\n// parsed string literals that were referenced as dynamic segments in the route.\nexport type ParamParseKey =\n // if you could not find path params, fallback to `string`\n [PathParam] extends [never] ? string : PathParam;\n\n/**\n * The parameters that were parsed from the URL path.\n */\nexport type Params = {\n readonly [key in Key]: string | undefined;\n};\n\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\nexport interface AgnosticRouteMatch<\n ParamKey extends string = string,\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n /**\n * The names and values of dynamic parameters in the URL.\n */\n params: Params;\n /**\n * The portion of the URL pathname that was matched.\n */\n pathname: string;\n /**\n * The portion of the URL pathname that was matched before child routes.\n */\n pathnameBase: string;\n /**\n * The route object that was used to match.\n */\n route: RouteObjectType;\n}\n\nexport interface AgnosticDataRouteMatch\n extends AgnosticRouteMatch {}\n\nfunction isIndexRoute(\n route: AgnosticRouteObject\n): route is AgnosticIndexRouteObject {\n return route.index === true;\n}\n\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nexport function convertRoutesToDataRoutes(\n routes: AgnosticRouteObject[],\n mapRouteProperties: MapRoutePropertiesFunction,\n parentPath: number[] = [],\n manifest: RouteManifest = {}\n): AgnosticDataRouteObject[] {\n return routes.map((route, index) => {\n let treePath = [...parentPath, index];\n let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n invariant(\n route.index !== true || !route.children,\n `Cannot specify children on an index route`\n );\n invariant(\n !manifest[id],\n `Found a route id collision on id \"${id}\". Route ` +\n \"id's must be globally unique within Data Router usages\"\n );\n\n if (isIndexRoute(route)) {\n let indexRoute: AgnosticDataIndexRouteObject = {\n ...route,\n ...mapRouteProperties(route),\n id,\n };\n manifest[id] = indexRoute;\n return indexRoute;\n } else {\n let pathOrLayoutRoute: AgnosticDataNonIndexRouteObject = {\n ...route,\n ...mapRouteProperties(route),\n id,\n children: undefined,\n };\n manifest[id] = pathOrLayoutRoute;\n\n if (route.children) {\n pathOrLayoutRoute.children = convertRoutesToDataRoutes(\n route.children,\n mapRouteProperties,\n treePath,\n manifest\n );\n }\n\n return pathOrLayoutRoute;\n }\n });\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/utils/match-routes\n */\nexport function matchRoutes<\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n routes: RouteObjectType[],\n locationArg: Partial | string,\n basename = \"/\"\n): AgnosticRouteMatch[] | null {\n let location =\n typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n let pathname = stripBasename(location.pathname || \"/\", basename);\n\n if (pathname == null) {\n return null;\n }\n\n let branches = flattenRoutes(routes);\n rankRouteBranches(branches);\n\n let matches = null;\n for (let i = 0; matches == null && i < branches.length; ++i) {\n matches = matchRouteBranch(\n branches[i],\n // Incoming pathnames are generally encoded from either window.location\n // or from router.navigate, but we want to match against the unencoded\n // paths in the route definitions. Memory router locations won't be\n // encoded here but there also shouldn't be anything to decode so this\n // should be a safe operation. This avoids needing matchRoutes to be\n // history-aware.\n safelyDecodeURI(pathname)\n );\n }\n\n return matches;\n}\n\nexport interface UIMatch {\n id: string;\n pathname: string;\n params: AgnosticRouteMatch[\"params\"];\n data: Data;\n handle: Handle;\n}\n\nexport function convertRouteMatchToUiMatch(\n match: AgnosticDataRouteMatch,\n loaderData: RouteData\n): UIMatch {\n let { route, pathname, params } = match;\n return {\n id: route.id,\n pathname,\n params,\n data: loaderData[route.id],\n handle: route.handle,\n };\n}\n\ninterface RouteMeta<\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n relativePath: string;\n caseSensitive: boolean;\n childrenIndex: number;\n route: RouteObjectType;\n}\n\ninterface RouteBranch<\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n path: string;\n score: number;\n routesMeta: RouteMeta[];\n}\n\nfunction flattenRoutes<\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n routes: RouteObjectType[],\n branches: RouteBranch[] = [],\n parentsMeta: RouteMeta[] = [],\n parentPath = \"\"\n): RouteBranch[] {\n let flattenRoute = (\n route: RouteObjectType,\n index: number,\n relativePath?: string\n ) => {\n let meta: RouteMeta = {\n relativePath:\n relativePath === undefined ? route.path || \"\" : relativePath,\n caseSensitive: route.caseSensitive === true,\n childrenIndex: index,\n route,\n };\n\n if (meta.relativePath.startsWith(\"/\")) {\n invariant(\n meta.relativePath.startsWith(parentPath),\n `Absolute route path \"${meta.relativePath}\" nested under path ` +\n `\"${parentPath}\" is not valid. An absolute child route path ` +\n `must start with the combined path of all its parent routes.`\n );\n\n meta.relativePath = meta.relativePath.slice(parentPath.length);\n }\n\n let path = joinPaths([parentPath, meta.relativePath]);\n let routesMeta = parentsMeta.concat(meta);\n\n // Add the children before adding this route to the array, so we traverse the\n // route tree depth-first and child routes appear before their parents in\n // the \"flattened\" version.\n if (route.children && route.children.length > 0) {\n invariant(\n // Our types know better, but runtime JS may not!\n // @ts-expect-error\n route.index !== true,\n `Index routes must not have child routes. Please remove ` +\n `all child routes from route path \"${path}\".`\n );\n\n flattenRoutes(route.children, branches, routesMeta, path);\n }\n\n // Routes without a path shouldn't ever match by themselves unless they are\n // index routes, so don't add them to the list of possible branches.\n if (route.path == null && !route.index) {\n return;\n }\n\n branches.push({\n path,\n score: computeScore(path, route.index),\n routesMeta,\n });\n };\n routes.forEach((route, index) => {\n // coarse-grain check for optional params\n if (route.path === \"\" || !route.path?.includes(\"?\")) {\n flattenRoute(route, index);\n } else {\n for (let exploded of explodeOptionalSegments(route.path)) {\n flattenRoute(route, index, exploded);\n }\n }\n });\n\n return branches;\n}\n\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path: string): string[] {\n let segments = path.split(\"/\");\n if (segments.length === 0) return [];\n\n let [first, ...rest] = segments;\n\n // Optional path segments are denoted by a trailing `?`\n let isOptional = first.endsWith(\"?\");\n // Compute the corresponding required segment: `foo?` -> `foo`\n let required = first.replace(/\\?$/, \"\");\n\n if (rest.length === 0) {\n // Intepret empty string as omitting an optional segment\n // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n return isOptional ? [required, \"\"] : [required];\n }\n\n let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n\n let result: string[] = [];\n\n // All child paths with the prefix. Do this for all children before the\n // optional version for all children, so we get consistent ordering where the\n // parent optional aspect is preferred as required. Otherwise, we can get\n // child sections interspersed where deeper optional segments are higher than\n // parent optional segments, where for example, /:two would explode _earlier_\n // then /:one. By always including the parent as required _for all children_\n // first, we avoid this issue\n result.push(\n ...restExploded.map((subpath) =>\n subpath === \"\" ? required : [required, subpath].join(\"/\")\n )\n );\n\n // Then, if this is an optional value, add all child versions without\n if (isOptional) {\n result.push(...restExploded);\n }\n\n // for absolute paths, ensure `/` instead of empty segment\n return result.map((exploded) =>\n path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded\n );\n}\n\nfunction rankRouteBranches(branches: RouteBranch[]): void {\n branches.sort((a, b) =>\n a.score !== b.score\n ? b.score - a.score // Higher score first\n : compareIndexes(\n a.routesMeta.map((meta) => meta.childrenIndex),\n b.routesMeta.map((meta) => meta.childrenIndex)\n )\n );\n}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = (s: string) => s === \"*\";\n\nfunction computeScore(path: string, index: boolean | undefined): number {\n let segments = path.split(\"/\");\n let initialScore = segments.length;\n if (segments.some(isSplat)) {\n initialScore += splatPenalty;\n }\n\n if (index) {\n initialScore += indexRouteValue;\n }\n\n return segments\n .filter((s) => !isSplat(s))\n .reduce(\n (score, segment) =>\n score +\n (paramRe.test(segment)\n ? dynamicSegmentValue\n : segment === \"\"\n ? emptySegmentValue\n : staticSegmentValue),\n initialScore\n );\n}\n\nfunction compareIndexes(a: number[], b: number[]): number {\n let siblings =\n a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n\n return siblings\n ? // If two routes are siblings, we should try to match the earlier sibling\n // first. This allows people to have fine-grained control over the matching\n // behavior by simply putting routes with identical paths in the order they\n // want them tried.\n a[a.length - 1] - b[b.length - 1]\n : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n // so they sort equally.\n 0;\n}\n\nfunction matchRouteBranch<\n ParamKey extends string = string,\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n branch: RouteBranch,\n pathname: string\n): AgnosticRouteMatch[] | null {\n let { routesMeta } = branch;\n\n let matchedParams = {};\n let matchedPathname = \"/\";\n let matches: AgnosticRouteMatch[] = [];\n for (let i = 0; i < routesMeta.length; ++i) {\n let meta = routesMeta[i];\n let end = i === routesMeta.length - 1;\n let remainingPathname =\n matchedPathname === \"/\"\n ? pathname\n : pathname.slice(matchedPathname.length) || \"/\";\n let match = matchPath(\n { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },\n remainingPathname\n );\n\n if (!match) return null;\n\n Object.assign(matchedParams, match.params);\n\n let route = meta.route;\n\n matches.push({\n // TODO: Can this as be avoided?\n params: matchedParams as Params,\n pathname: joinPaths([matchedPathname, match.pathname]),\n pathnameBase: normalizePathname(\n joinPaths([matchedPathname, match.pathnameBase])\n ),\n route,\n });\n\n if (match.pathnameBase !== \"/\") {\n matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n }\n }\n\n return matches;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/utils/generate-path\n */\nexport function generatePath(\n originalPath: Path,\n params: {\n [key in PathParam]: string | null;\n } = {} as any\n): string {\n let path: string = originalPath;\n if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n warning(\n false,\n `Route path \"${path}\" will be treated as if it were ` +\n `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n );\n path = path.replace(/\\*$/, \"/*\") as Path;\n }\n\n // ensure `/` is added at the beginning if the path is absolute\n const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n\n const stringify = (p: any) =>\n p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n\n const segments = path\n .split(/\\/+/)\n .map((segment, index, array) => {\n const isLastSegment = index === array.length - 1;\n\n // only apply the splat if it's the last segment\n if (isLastSegment && segment === \"*\") {\n const star = \"*\" as PathParam;\n // Apply the splat\n return stringify(params[star]);\n }\n\n const keyMatch = segment.match(/^:(\\w+)(\\??)$/);\n if (keyMatch) {\n const [, key, optional] = keyMatch;\n let param = params[key as PathParam];\n invariant(optional === \"?\" || param != null, `Missing \":${key}\" param`);\n return stringify(param);\n }\n\n // Remove any optional markers from optional static segments\n return segment.replace(/\\?$/g, \"\");\n })\n // Remove empty segments\n .filter((segment) => !!segment);\n\n return prefix + segments.join(\"/\");\n}\n\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\nexport interface PathPattern {\n /**\n * A string to match against a URL pathname. May contain `:id`-style segments\n * to indicate placeholders for dynamic parameters. May also end with `/*` to\n * indicate matching the rest of the URL pathname.\n */\n path: Path;\n /**\n * Should be `true` if the static portions of the `path` should be matched in\n * the same case.\n */\n caseSensitive?: boolean;\n /**\n * Should be `true` if this pattern should match the entire URL pathname.\n */\n end?: boolean;\n}\n\n/**\n * A PathMatch contains info about how a PathPattern matched on a URL pathname.\n */\nexport interface PathMatch {\n /**\n * The names and values of dynamic parameters in the URL.\n */\n params: Params;\n /**\n * The portion of the URL pathname that was matched.\n */\n pathname: string;\n /**\n * The portion of the URL pathname that was matched before child routes.\n */\n pathnameBase: string;\n /**\n * The pattern that was used to match.\n */\n pattern: PathPattern;\n}\n\ntype Mutable = {\n -readonly [P in keyof T]: T[P];\n};\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/utils/match-path\n */\nexport function matchPath<\n ParamKey extends ParamParseKey,\n Path extends string\n>(\n pattern: PathPattern | Path,\n pathname: string\n): PathMatch | null {\n if (typeof pattern === \"string\") {\n pattern = { path: pattern, caseSensitive: false, end: true };\n }\n\n let [matcher, compiledParams] = compilePath(\n pattern.path,\n pattern.caseSensitive,\n pattern.end\n );\n\n let match = pathname.match(matcher);\n if (!match) return null;\n\n let matchedPathname = match[0];\n let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n let captureGroups = match.slice(1);\n let params: Params = compiledParams.reduce>(\n (memo, { paramName, isOptional }, index) => {\n // We need to compute the pathnameBase here using the raw splat value\n // instead of using params[\"*\"] later because it will be decoded then\n if (paramName === \"*\") {\n let splatValue = captureGroups[index] || \"\";\n pathnameBase = matchedPathname\n .slice(0, matchedPathname.length - splatValue.length)\n .replace(/(.)\\/+$/, \"$1\");\n }\n\n const value = captureGroups[index];\n if (isOptional && !value) {\n memo[paramName] = undefined;\n } else {\n memo[paramName] = safelyDecodeURIComponent(value || \"\", paramName);\n }\n return memo;\n },\n {}\n );\n\n return {\n params,\n pathname: matchedPathname,\n pathnameBase,\n pattern,\n };\n}\n\ntype CompiledPathParam = { paramName: string; isOptional?: boolean };\n\nfunction compilePath(\n path: string,\n caseSensitive = false,\n end = true\n): [RegExp, CompiledPathParam[]] {\n warning(\n path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"),\n `Route path \"${path}\" will be treated as if it were ` +\n `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n );\n\n let params: CompiledPathParam[] = [];\n let regexpSource =\n \"^\" +\n path\n .replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n .replace(/[\\\\.*+^${}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n .replace(/\\/:(\\w+)(\\?)?/g, (_: string, paramName: string, isOptional) => {\n params.push({ paramName, isOptional: isOptional != null });\n return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n });\n\n if (path.endsWith(\"*\")) {\n params.push({ paramName: \"*\" });\n regexpSource +=\n path === \"*\" || path === \"/*\"\n ? \"(.*)$\" // Already matched the initial /, just match the rest\n : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n } else if (end) {\n // When matching to the end, ignore trailing slashes\n regexpSource += \"\\\\/*$\";\n } else if (path !== \"\" && path !== \"/\") {\n // If our path is non-empty and contains anything beyond an initial slash,\n // then we have _some_ form of path in our regex, so we should expect to\n // match only if we find the end of this path segment. Look for an optional\n // non-captured trailing slash (to match a portion of the URL) or the end\n // of the path (if we've matched to the end). We used to do this with a\n // word boundary but that gives false positives on routes like\n // /user-preferences since `-` counts as a word boundary.\n regexpSource += \"(?:(?=\\\\/|$))\";\n } else {\n // Nothing to match for \"\" or \"/\"\n }\n\n let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n return [matcher, params];\n}\n\nfunction safelyDecodeURI(value: string) {\n try {\n return decodeURI(value);\n } catch (error) {\n warning(\n false,\n `The URL path \"${value}\" could not be decoded because it is is a ` +\n `malformed URL segment. This is probably due to a bad percent ` +\n `encoding (${error}).`\n );\n\n return value;\n }\n}\n\nfunction safelyDecodeURIComponent(value: string, paramName: string) {\n try {\n return decodeURIComponent(value);\n } catch (error) {\n warning(\n false,\n `The value for the URL param \"${paramName}\" will not be decoded because` +\n ` the string \"${value}\" is a malformed URL segment. This is probably` +\n ` due to a bad percent encoding (${error}).`\n );\n\n return value;\n }\n}\n\n/**\n * @private\n */\nexport function stripBasename(\n pathname: string,\n basename: string\n): string | null {\n if (basename === \"/\") return pathname;\n\n if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n return null;\n }\n\n // We want to leave trailing slash behavior in the user's control, so if they\n // specify a basename with a trailing slash, we should support it\n let startIndex = basename.endsWith(\"/\")\n ? basename.length - 1\n : basename.length;\n let nextChar = pathname.charAt(startIndex);\n if (nextChar && nextChar !== \"/\") {\n // pathname does not start with basename/\n return null;\n }\n\n return pathname.slice(startIndex) || \"/\";\n}\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/utils/resolve-path\n */\nexport function resolvePath(to: To, fromPathname = \"/\"): Path {\n let {\n pathname: toPathname,\n search = \"\",\n hash = \"\",\n } = typeof to === \"string\" ? parsePath(to) : to;\n\n let pathname = toPathname\n ? toPathname.startsWith(\"/\")\n ? toPathname\n : resolvePathname(toPathname, fromPathname)\n : fromPathname;\n\n return {\n pathname,\n search: normalizeSearch(search),\n hash: normalizeHash(hash),\n };\n}\n\nfunction resolvePathname(relativePath: string, fromPathname: string): string {\n let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n let relativeSegments = relativePath.split(\"/\");\n\n relativeSegments.forEach((segment) => {\n if (segment === \"..\") {\n // Keep the root \"\" segment so the pathname starts at /\n if (segments.length > 1) segments.pop();\n } else if (segment !== \".\") {\n segments.push(segment);\n }\n });\n\n return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nfunction getInvalidPathError(\n char: string,\n field: string,\n dest: string,\n path: Partial\n) {\n return (\n `Cannot include a '${char}' character in a manually specified ` +\n `\\`to.${field}\\` field [${JSON.stringify(\n path\n )}]. Please separate it out to the ` +\n `\\`to.${dest}\\` field. Alternatively you may provide the full path as ` +\n `a string in and the router will parse it for you.`\n );\n}\n\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same. Both of the following examples should link back to the root:\n *\n * \n * \n * \n *\n * \n * \n * }> // <-- Does not contribute\n * // <-- Does not contribute\n * \n * \n */\nexport function getPathContributingMatches<\n T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[]) {\n return matches.filter(\n (match, index) =>\n index === 0 || (match.route.path && match.route.path.length > 0)\n );\n}\n\n/**\n * @private\n */\nexport function resolveTo(\n toArg: To,\n routePathnames: string[],\n locationPathname: string,\n isPathRelative = false\n): Path {\n let to: Partial;\n if (typeof toArg === \"string\") {\n to = parsePath(toArg);\n } else {\n to = { ...toArg };\n\n invariant(\n !to.pathname || !to.pathname.includes(\"?\"),\n getInvalidPathError(\"?\", \"pathname\", \"search\", to)\n );\n invariant(\n !to.pathname || !to.pathname.includes(\"#\"),\n getInvalidPathError(\"#\", \"pathname\", \"hash\", to)\n );\n invariant(\n !to.search || !to.search.includes(\"#\"),\n getInvalidPathError(\"#\", \"search\", \"hash\", to)\n );\n }\n\n let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n let toPathname = isEmptyPath ? \"/\" : to.pathname;\n\n let from: string;\n\n // Routing is relative to the current pathname if explicitly requested.\n //\n // If a pathname is explicitly provided in `to`, it should be relative to the\n // route context. This is explained in `Note on `` values` in our\n // migration guide from v5 as a means of disambiguation between `to` values\n // that begin with `/` and those that do not. However, this is problematic for\n // `to` values that do not provide a pathname. `to` can simply be a search or\n // hash string, in which case we should assume that the navigation is relative\n // to the current location's pathname and *not* the route pathname.\n if (toPathname == null) {\n from = locationPathname;\n } else if (isPathRelative) {\n let fromSegments = routePathnames[routePathnames.length - 1]\n .replace(/^\\//, \"\")\n .split(\"/\");\n\n if (toPathname.startsWith(\"..\")) {\n let toSegments = toPathname.split(\"/\");\n\n // With relative=\"path\", each leading .. segment means \"go up one URL segment\"\n while (toSegments[0] === \"..\") {\n toSegments.shift();\n fromSegments.pop();\n }\n\n to.pathname = toSegments.join(\"/\");\n }\n\n from = \"/\" + fromSegments.join(\"/\");\n } else {\n let routePathnameIndex = routePathnames.length - 1;\n\n if (toPathname.startsWith(\"..\")) {\n let toSegments = toPathname.split(\"/\");\n\n // With relative=\"route\" (the default), each leading .. segment means\n // \"go up one route\" instead of \"go up one URL segment\". This is a key\n // difference from how works and a major reason we call this a\n // \"to\" value instead of a \"href\".\n while (toSegments[0] === \"..\") {\n toSegments.shift();\n routePathnameIndex -= 1;\n }\n\n to.pathname = toSegments.join(\"/\");\n }\n\n // If there are more \"..\" segments than parent routes, resolve relative to\n // the root / URL.\n from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n }\n\n let path = resolvePath(to, from);\n\n // Ensure the pathname has a trailing slash if the original \"to\" had one\n let hasExplicitTrailingSlash =\n toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n // Or if this was a link to the current path which has a trailing slash\n let hasCurrentTrailingSlash =\n (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n if (\n !path.pathname.endsWith(\"/\") &&\n (hasExplicitTrailingSlash || hasCurrentTrailingSlash)\n ) {\n path.pathname += \"/\";\n }\n\n return path;\n}\n\n/**\n * @private\n */\nexport function getToPathname(to: To): string | undefined {\n // Empty strings should be treated the same as / paths\n return to === \"\" || (to as Path).pathname === \"\"\n ? \"/\"\n : typeof to === \"string\"\n ? parsePath(to).pathname\n : to.pathname;\n}\n\n/**\n * @private\n */\nexport const joinPaths = (paths: string[]): string =>\n paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\n/**\n * @private\n */\nexport const normalizePathname = (pathname: string): string =>\n pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\n/**\n * @private\n */\nexport const normalizeSearch = (search: string): string =>\n !search || search === \"?\"\n ? \"\"\n : search.startsWith(\"?\")\n ? search\n : \"?\" + search;\n\n/**\n * @private\n */\nexport const normalizeHash = (hash: string): string =>\n !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\nexport type JsonFunction = (\n data: Data,\n init?: number | ResponseInit\n) => Response;\n\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\nexport const json: JsonFunction = (data, init = {}) => {\n let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n let headers = new Headers(responseInit.headers);\n if (!headers.has(\"Content-Type\")) {\n headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n }\n\n return new Response(JSON.stringify(data), {\n ...responseInit,\n headers,\n });\n};\n\nexport interface TrackedPromise extends Promise {\n _tracked?: boolean;\n _data?: any;\n _error?: any;\n}\n\nexport class AbortedDeferredError extends Error {}\n\nexport class DeferredData {\n private pendingKeysSet: Set = new Set();\n private controller: AbortController;\n private abortPromise: Promise;\n private unlistenAbortSignal: () => void;\n private subscribers: Set<(aborted: boolean, settledKey?: string) => void> =\n new Set();\n data: Record;\n init?: ResponseInit;\n deferredKeys: string[] = [];\n\n constructor(data: Record, responseInit?: ResponseInit) {\n invariant(\n data && typeof data === \"object\" && !Array.isArray(data),\n \"defer() only accepts plain objects\"\n );\n\n // Set up an AbortController + Promise we can race against to exit early\n // cancellation\n let reject: (e: AbortedDeferredError) => void;\n this.abortPromise = new Promise((_, r) => (reject = r));\n this.controller = new AbortController();\n let onAbort = () =>\n reject(new AbortedDeferredError(\"Deferred data aborted\"));\n this.unlistenAbortSignal = () =>\n this.controller.signal.removeEventListener(\"abort\", onAbort);\n this.controller.signal.addEventListener(\"abort\", onAbort);\n\n this.data = Object.entries(data).reduce(\n (acc, [key, value]) =>\n Object.assign(acc, {\n [key]: this.trackPromise(key, value),\n }),\n {}\n );\n\n if (this.done) {\n // All incoming values were resolved\n this.unlistenAbortSignal();\n }\n\n this.init = responseInit;\n }\n\n private trackPromise(\n key: string,\n value: Promise | unknown\n ): TrackedPromise | unknown {\n if (!(value instanceof Promise)) {\n return value;\n }\n\n this.deferredKeys.push(key);\n this.pendingKeysSet.add(key);\n\n // We store a little wrapper promise that will be extended with\n // _data/_error props upon resolve/reject\n let promise: TrackedPromise = Promise.race([value, this.abortPromise]).then(\n (data) => this.onSettle(promise, key, undefined, data as unknown),\n (error) => this.onSettle(promise, key, error as unknown)\n );\n\n // Register rejection listeners to avoid uncaught promise rejections on\n // errors or aborted deferred values\n promise.catch(() => {});\n\n Object.defineProperty(promise, \"_tracked\", { get: () => true });\n return promise;\n }\n\n private onSettle(\n promise: TrackedPromise,\n key: string,\n error: unknown,\n data?: unknown\n ): unknown {\n if (\n this.controller.signal.aborted &&\n error instanceof AbortedDeferredError\n ) {\n this.unlistenAbortSignal();\n Object.defineProperty(promise, \"_error\", { get: () => error });\n return Promise.reject(error);\n }\n\n this.pendingKeysSet.delete(key);\n\n if (this.done) {\n // Nothing left to abort!\n this.unlistenAbortSignal();\n }\n\n // If the promise was resolved/rejected with undefined, we'll throw an error as you\n // should always resolve with a value or null\n if (error === undefined && data === undefined) {\n let undefinedError = new Error(\n `Deferred data for key \"${key}\" resolved/rejected with \\`undefined\\`, ` +\n `you must resolve/reject with a value or \\`null\\`.`\n );\n Object.defineProperty(promise, \"_error\", { get: () => undefinedError });\n this.emit(false, key);\n return Promise.reject(undefinedError);\n }\n\n if (data === undefined) {\n Object.defineProperty(promise, \"_error\", { get: () => error });\n this.emit(false, key);\n return Promise.reject(error);\n }\n\n Object.defineProperty(promise, \"_data\", { get: () => data });\n this.emit(false, key);\n return data;\n }\n\n private emit(aborted: boolean, settledKey?: string) {\n this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));\n }\n\n subscribe(fn: (aborted: boolean, settledKey?: string) => void) {\n this.subscribers.add(fn);\n return () => this.subscribers.delete(fn);\n }\n\n cancel() {\n this.controller.abort();\n this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n this.emit(true);\n }\n\n async resolveData(signal: AbortSignal) {\n let aborted = false;\n if (!this.done) {\n let onAbort = () => this.cancel();\n signal.addEventListener(\"abort\", onAbort);\n aborted = await new Promise((resolve) => {\n this.subscribe((aborted) => {\n signal.removeEventListener(\"abort\", onAbort);\n if (aborted || this.done) {\n resolve(aborted);\n }\n });\n });\n }\n return aborted;\n }\n\n get done() {\n return this.pendingKeysSet.size === 0;\n }\n\n get unwrappedData() {\n invariant(\n this.data !== null && this.done,\n \"Can only unwrap data on initialized and settled deferreds\"\n );\n\n return Object.entries(this.data).reduce(\n (acc, [key, value]) =>\n Object.assign(acc, {\n [key]: unwrapTrackedPromise(value),\n }),\n {}\n );\n }\n\n get pendingKeys() {\n return Array.from(this.pendingKeysSet);\n }\n}\n\nfunction isTrackedPromise(value: any): value is TrackedPromise {\n return (\n value instanceof Promise && (value as TrackedPromise)._tracked === true\n );\n}\n\nfunction unwrapTrackedPromise(value: any) {\n if (!isTrackedPromise(value)) {\n return value;\n }\n\n if (value._error) {\n throw value._error;\n }\n return value._data;\n}\n\nexport type DeferFunction = (\n data: Record,\n init?: number | ResponseInit\n) => DeferredData;\n\nexport const defer: DeferFunction = (data, init = {}) => {\n let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n return new DeferredData(data, responseInit);\n};\n\nexport type RedirectFunction = (\n url: string,\n init?: number | ResponseInit\n) => Response;\n\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirect: RedirectFunction = (url, init = 302) => {\n let responseInit = init;\n if (typeof responseInit === \"number\") {\n responseInit = { status: responseInit };\n } else if (typeof responseInit.status === \"undefined\") {\n responseInit.status = 302;\n }\n\n let headers = new Headers(responseInit.headers);\n headers.set(\"Location\", url);\n\n return new Response(null, {\n ...responseInit,\n headers,\n });\n};\n\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirectDocument: RedirectFunction = (url, init) => {\n let response = redirect(url, init);\n response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n return response;\n};\n\nexport type ErrorResponse = {\n status: number;\n statusText: string;\n data: any;\n};\n\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nexport class ErrorResponseImpl implements ErrorResponse {\n status: number;\n statusText: string;\n data: any;\n private error?: Error;\n private internal: boolean;\n\n constructor(\n status: number,\n statusText: string | undefined,\n data: any,\n internal = false\n ) {\n this.status = status;\n this.statusText = statusText || \"\";\n this.internal = internal;\n if (data instanceof Error) {\n this.data = data.toString();\n this.error = data;\n } else {\n this.data = data;\n }\n }\n}\n\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nexport function isRouteErrorResponse(error: any): error is ErrorResponse {\n return (\n error != null &&\n typeof error.status === \"number\" &&\n typeof error.statusText === \"string\" &&\n typeof error.internal === \"boolean\" &&\n \"data\" in error\n );\n}\n","import type { History, Location, Path, To } from \"./history\";\nimport {\n Action as HistoryAction,\n createLocation,\n createPath,\n invariant,\n parsePath,\n warning,\n} from \"./history\";\nimport type {\n ActionFunction,\n AgnosticDataRouteMatch,\n AgnosticDataRouteObject,\n AgnosticRouteObject,\n DataResult,\n DeferredData,\n DeferredResult,\n DetectErrorBoundaryFunction,\n ErrorResult,\n FormEncType,\n FormMethod,\n HTMLFormMethod,\n ImmutableRouteKey,\n LoaderFunction,\n MapRoutePropertiesFunction,\n MutationFormMethod,\n RedirectResult,\n RouteData,\n RouteManifest,\n ShouldRevalidateFunctionArgs,\n Submission,\n SuccessResult,\n UIMatch,\n V7_FormMethod,\n V7_MutationFormMethod,\n} from \"./utils\";\nimport {\n ErrorResponseImpl,\n ResultType,\n convertRouteMatchToUiMatch,\n convertRoutesToDataRoutes,\n getPathContributingMatches,\n immutableRouteKeys,\n isRouteErrorResponse,\n joinPaths,\n matchRoutes,\n resolveTo,\n stripBasename,\n} from \"./utils\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A Router instance manages all navigation and data loading/mutations\n */\nexport interface Router {\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Return the basename for the router\n */\n get basename(): RouterInit[\"basename\"];\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Return the current state of the router\n */\n get state(): RouterState;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Return the routes for this router instance\n */\n get routes(): AgnosticDataRouteObject[];\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Return the window associated with the router\n */\n get window(): RouterInit[\"window\"];\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Initialize the router, including adding history listeners and kicking off\n * initial data fetches. Returns a function to cleanup listeners and abort\n * any in-progress loads\n */\n initialize(): Router;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Subscribe to router.state updates\n *\n * @param fn function to call with the new state\n */\n subscribe(fn: RouterSubscriber): () => void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Enable scroll restoration behavior in the router\n *\n * @param savedScrollPositions Object that will manage positions, in case\n * it's being restored from sessionStorage\n * @param getScrollPosition Function to get the active Y scroll position\n * @param getKey Function to get the key to use for restoration\n */\n enableScrollRestoration(\n savedScrollPositions: Record,\n getScrollPosition: GetScrollPositionFunction,\n getKey?: GetScrollRestorationKeyFunction\n ): () => void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Navigate forward/backward in the history stack\n * @param to Delta to move in the history stack\n */\n navigate(to: number): Promise;\n\n /**\n * Navigate to the given path\n * @param to Path to navigate to\n * @param opts Navigation options (method, submission, etc.)\n */\n navigate(to: To | null, opts?: RouterNavigateOptions): Promise;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Trigger a fetcher load/submission\n *\n * @param key Fetcher key\n * @param routeId Route that owns the fetcher\n * @param href href to fetch\n * @param opts Fetcher options, (method, submission, etc.)\n */\n fetch(\n key: string,\n routeId: string,\n href: string | null,\n opts?: RouterFetchOptions\n ): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Trigger a revalidation of all current route loaders and fetcher loads\n */\n revalidate(): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Utility function to create an href for the given location\n * @param location\n */\n createHref(location: Location | URL): string;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Utility function to URL encode a destination path according to the internal\n * history implementation\n * @param to\n */\n encodeLocation(to: To): Path;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Get/create a fetcher for the given key\n * @param key\n */\n getFetcher(key: string): Fetcher;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Delete the fetcher for a given key\n * @param key\n */\n deleteFetcher(key: string): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Cleanup listeners and abort any in-progress loads\n */\n dispose(): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Get a navigation blocker\n * @param key The identifier for the blocker\n * @param fn The blocker function implementation\n */\n getBlocker(key: string, fn: BlockerFunction): Blocker;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Delete a navigation blocker\n * @param key The identifier for the blocker\n */\n deleteBlocker(key: string): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * HMR needs to pass in-flight route updates to React Router\n * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)\n */\n _internalSetRoutes(routes: AgnosticRouteObject[]): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Internal fetch AbortControllers accessed by unit tests\n */\n _internalFetchControllers: Map;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Internal pending DeferredData instances accessed by unit tests\n */\n _internalActiveDeferreds: Map;\n}\n\n/**\n * State maintained internally by the router. During a navigation, all states\n * reflect the the \"old\" location unless otherwise noted.\n */\nexport interface RouterState {\n /**\n * The action of the most recent navigation\n */\n historyAction: HistoryAction;\n\n /**\n * The current location reflected by the router\n */\n location: Location;\n\n /**\n * The current set of route matches\n */\n matches: AgnosticDataRouteMatch[];\n\n /**\n * Tracks whether we've completed our initial data load\n */\n initialized: boolean;\n\n /**\n * Current scroll position we should start at for a new view\n * - number -> scroll position to restore to\n * - false -> do not restore scroll at all (used during submissions)\n * - null -> don't have a saved position, scroll to hash or top of page\n */\n restoreScrollPosition: number | false | null;\n\n /**\n * Indicate whether this navigation should skip resetting the scroll position\n * if we are unable to restore the scroll position\n */\n preventScrollReset: boolean;\n\n /**\n * Tracks the state of the current navigation\n */\n navigation: Navigation;\n\n /**\n * Tracks any in-progress revalidations\n */\n revalidation: RevalidationState;\n\n /**\n * Data from the loaders for the current matches\n */\n loaderData: RouteData;\n\n /**\n * Data from the action for the current matches\n */\n actionData: RouteData | null;\n\n /**\n * Errors caught from loaders for the current matches\n */\n errors: RouteData | null;\n\n /**\n * Map of current fetchers\n */\n fetchers: Map;\n\n /**\n * Map of current blockers\n */\n blockers: Map;\n}\n\n/**\n * Data that can be passed into hydrate a Router from SSR\n */\nexport type HydrationState = Partial<\n Pick\n>;\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface FutureConfig {\n v7_fetcherPersist: boolean;\n v7_normalizeFormMethod: boolean;\n v7_prependBasename: boolean;\n}\n\n/**\n * Initialization options for createRouter\n */\nexport interface RouterInit {\n routes: AgnosticRouteObject[];\n history: History;\n basename?: string;\n /**\n * @deprecated Use `mapRouteProperties` instead\n */\n detectErrorBoundary?: DetectErrorBoundaryFunction;\n mapRouteProperties?: MapRoutePropertiesFunction;\n future?: Partial;\n hydrationData?: HydrationState;\n window?: Window;\n}\n\n/**\n * State returned from a server-side query() call\n */\nexport interface StaticHandlerContext {\n basename: Router[\"basename\"];\n location: RouterState[\"location\"];\n matches: RouterState[\"matches\"];\n loaderData: RouterState[\"loaderData\"];\n actionData: RouterState[\"actionData\"];\n errors: RouterState[\"errors\"];\n statusCode: number;\n loaderHeaders: Record;\n actionHeaders: Record;\n activeDeferreds: Record | null;\n _deepestRenderedBoundaryId?: string | null;\n}\n\n/**\n * A StaticHandler instance manages a singular SSR navigation/fetch event\n */\nexport interface StaticHandler {\n dataRoutes: AgnosticDataRouteObject[];\n query(\n request: Request,\n opts?: { requestContext?: unknown }\n ): Promise;\n queryRoute(\n request: Request,\n opts?: { routeId?: string; requestContext?: unknown }\n ): Promise;\n}\n\ntype ViewTransitionOpts = {\n currentLocation: Location;\n nextLocation: Location;\n};\n\n/**\n * Subscriber function signature for changes to router state\n */\nexport interface RouterSubscriber {\n (\n state: RouterState,\n opts: {\n deletedFetchers: string[];\n unstable_viewTransitionOpts?: ViewTransitionOpts;\n unstable_flushSync: boolean;\n }\n ): void;\n}\n\n/**\n * Function signature for determining the key to be used in scroll restoration\n * for a given location\n */\nexport interface GetScrollRestorationKeyFunction {\n (location: Location, matches: UIMatch[]): string | null;\n}\n\n/**\n * Function signature for determining the current scroll position\n */\nexport interface GetScrollPositionFunction {\n (): number;\n}\n\nexport type RelativeRoutingType = \"route\" | \"path\";\n\n// Allowed for any navigation or fetch\ntype BaseNavigateOrFetchOptions = {\n preventScrollReset?: boolean;\n relative?: RelativeRoutingType;\n unstable_flushSync?: boolean;\n};\n\n// Only allowed for navigations\ntype BaseNavigateOptions = BaseNavigateOrFetchOptions & {\n replace?: boolean;\n state?: any;\n fromRouteId?: string;\n unstable_viewTransition?: boolean;\n};\n\n// Only allowed for submission navigations\ntype BaseSubmissionOptions = {\n formMethod?: HTMLFormMethod;\n formEncType?: FormEncType;\n} & (\n | { formData: FormData; body?: undefined }\n | { formData?: undefined; body: any }\n);\n\n/**\n * Options for a navigate() call for a normal (non-submission) navigation\n */\ntype LinkNavigateOptions = BaseNavigateOptions;\n\n/**\n * Options for a navigate() call for a submission navigation\n */\ntype SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to navigate() for a navigation\n */\nexport type RouterNavigateOptions =\n | LinkNavigateOptions\n | SubmissionNavigateOptions;\n\n/**\n * Options for a fetch() load\n */\ntype LoadFetchOptions = BaseNavigateOrFetchOptions;\n\n/**\n * Options for a fetch() submission\n */\ntype SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to fetch()\n */\nexport type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;\n\n/**\n * Potential states for state.navigation\n */\nexport type NavigationStates = {\n Idle: {\n state: \"idle\";\n location: undefined;\n formMethod: undefined;\n formAction: undefined;\n formEncType: undefined;\n formData: undefined;\n json: undefined;\n text: undefined;\n };\n Loading: {\n state: \"loading\";\n location: Location;\n formMethod: Submission[\"formMethod\"] | undefined;\n formAction: Submission[\"formAction\"] | undefined;\n formEncType: Submission[\"formEncType\"] | undefined;\n formData: Submission[\"formData\"] | undefined;\n json: Submission[\"json\"] | undefined;\n text: Submission[\"text\"] | undefined;\n };\n Submitting: {\n state: \"submitting\";\n location: Location;\n formMethod: Submission[\"formMethod\"];\n formAction: Submission[\"formAction\"];\n formEncType: Submission[\"formEncType\"];\n formData: Submission[\"formData\"];\n json: Submission[\"json\"];\n text: Submission[\"text\"];\n };\n};\n\nexport type Navigation = NavigationStates[keyof NavigationStates];\n\nexport type RevalidationState = \"idle\" | \"loading\";\n\n/**\n * Potential states for fetchers\n */\ntype FetcherStates = {\n Idle: {\n state: \"idle\";\n formMethod: undefined;\n formAction: undefined;\n formEncType: undefined;\n text: undefined;\n formData: undefined;\n json: undefined;\n data: TData | undefined;\n };\n Loading: {\n state: \"loading\";\n formMethod: Submission[\"formMethod\"] | undefined;\n formAction: Submission[\"formAction\"] | undefined;\n formEncType: Submission[\"formEncType\"] | undefined;\n text: Submission[\"text\"] | undefined;\n formData: Submission[\"formData\"] | undefined;\n json: Submission[\"json\"] | undefined;\n data: TData | undefined;\n };\n Submitting: {\n state: \"submitting\";\n formMethod: Submission[\"formMethod\"];\n formAction: Submission[\"formAction\"];\n formEncType: Submission[\"formEncType\"];\n text: Submission[\"text\"];\n formData: Submission[\"formData\"];\n json: Submission[\"json\"];\n data: TData | undefined;\n };\n};\n\nexport type Fetcher =\n FetcherStates[keyof FetcherStates];\n\ninterface BlockerBlocked {\n state: \"blocked\";\n reset(): void;\n proceed(): void;\n location: Location;\n}\n\ninterface BlockerUnblocked {\n state: \"unblocked\";\n reset: undefined;\n proceed: undefined;\n location: undefined;\n}\n\ninterface BlockerProceeding {\n state: \"proceeding\";\n reset: undefined;\n proceed: undefined;\n location: Location;\n}\n\nexport type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;\n\nexport type BlockerFunction = (args: {\n currentLocation: Location;\n nextLocation: Location;\n historyAction: HistoryAction;\n}) => boolean;\n\ninterface ShortCircuitable {\n /**\n * startNavigation does not need to complete the navigation because we\n * redirected or got interrupted\n */\n shortCircuited?: boolean;\n}\n\ninterface HandleActionResult extends ShortCircuitable {\n /**\n * Error thrown from the current action, keyed by the route containing the\n * error boundary to render the error. To be committed to the state after\n * loaders have completed\n */\n pendingActionError?: RouteData;\n /**\n * Data returned from the current action, keyed by the route owning the action.\n * To be committed to the state after loaders have completed\n */\n pendingActionData?: RouteData;\n}\n\ninterface HandleLoadersResult extends ShortCircuitable {\n /**\n * loaderData returned from the current set of loaders\n */\n loaderData?: RouterState[\"loaderData\"];\n /**\n * errors thrown from the current set of loaders\n */\n errors?: RouterState[\"errors\"];\n}\n\n/**\n * Cached info for active fetcher.load() instances so they can participate\n * in revalidation\n */\ninterface FetchLoadMatch {\n routeId: string;\n path: string;\n}\n\n/**\n * Identified fetcher.load() calls that need to be revalidated\n */\ninterface RevalidatingFetcher extends FetchLoadMatch {\n key: string;\n match: AgnosticDataRouteMatch | null;\n matches: AgnosticDataRouteMatch[] | null;\n controller: AbortController | null;\n}\n\n/**\n * Wrapper object to allow us to throw any response out from callLoaderOrAction\n * for queryRouter while preserving whether or not it was thrown or returned\n * from the loader/action\n */\ninterface QueryRouteResponse {\n type: ResultType.data | ResultType.error;\n response: Response;\n}\n\nconst validMutationMethodsArr: MutationFormMethod[] = [\n \"post\",\n \"put\",\n \"patch\",\n \"delete\",\n];\nconst validMutationMethods = new Set(\n validMutationMethodsArr\n);\n\nconst validRequestMethodsArr: FormMethod[] = [\n \"get\",\n ...validMutationMethodsArr,\n];\nconst validRequestMethods = new Set(validRequestMethodsArr);\n\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\n\nexport const IDLE_NAVIGATION: NavigationStates[\"Idle\"] = {\n state: \"idle\",\n location: undefined,\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n};\n\nexport const IDLE_FETCHER: FetcherStates[\"Idle\"] = {\n state: \"idle\",\n data: undefined,\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n};\n\nexport const IDLE_BLOCKER: BlockerUnblocked = {\n state: \"unblocked\",\n proceed: undefined,\n reset: undefined,\n location: undefined,\n};\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\nconst defaultMapRouteProperties: MapRoutePropertiesFunction = (route) => ({\n hasErrorBoundary: Boolean(route.hasErrorBoundary),\n});\n\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\nexport function createRouter(init: RouterInit): Router {\n const routerWindow = init.window\n ? init.window\n : typeof window !== \"undefined\"\n ? window\n : undefined;\n const isBrowser =\n typeof routerWindow !== \"undefined\" &&\n typeof routerWindow.document !== \"undefined\" &&\n typeof routerWindow.document.createElement !== \"undefined\";\n const isServer = !isBrowser;\n\n invariant(\n init.routes.length > 0,\n \"You must provide a non-empty routes array to createRouter\"\n );\n\n let mapRouteProperties: MapRoutePropertiesFunction;\n if (init.mapRouteProperties) {\n mapRouteProperties = init.mapRouteProperties;\n } else if (init.detectErrorBoundary) {\n // If they are still using the deprecated version, wrap it with the new API\n let detectErrorBoundary = init.detectErrorBoundary;\n mapRouteProperties = (route) => ({\n hasErrorBoundary: detectErrorBoundary(route),\n });\n } else {\n mapRouteProperties = defaultMapRouteProperties;\n }\n\n // Routes keyed by ID\n let manifest: RouteManifest = {};\n // Routes in tree format for matching\n let dataRoutes = convertRoutesToDataRoutes(\n init.routes,\n mapRouteProperties,\n undefined,\n manifest\n );\n let inFlightDataRoutes: AgnosticDataRouteObject[] | undefined;\n let basename = init.basename || \"/\";\n // Config driven behavior flags\n let future: FutureConfig = {\n v7_fetcherPersist: false,\n v7_normalizeFormMethod: false,\n v7_prependBasename: false,\n ...init.future,\n };\n // Cleanup function for history\n let unlistenHistory: (() => void) | null = null;\n // Externally-provided functions to call on all state changes\n let subscribers = new Set();\n // Externally-provided object to hold scroll restoration locations during routing\n let savedScrollPositions: Record | null = null;\n // Externally-provided function to get scroll restoration keys\n let getScrollRestorationKey: GetScrollRestorationKeyFunction | null = null;\n // Externally-provided function to get current scroll position\n let getScrollPosition: GetScrollPositionFunction | null = null;\n // One-time flag to control the initial hydration scroll restoration. Because\n // we don't get the saved positions from until _after_\n // the initial render, we need to manually trigger a separate updateState to\n // send along the restoreScrollPosition\n // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n // SSR did the initial scroll restoration.\n let initialScrollRestored = init.hydrationData != null;\n\n let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n let initialErrors: RouteData | null = null;\n\n if (initialMatches == null) {\n // If we do not match a user-provided-route, fall back to the root\n // to allow the error boundary to take over\n let error = getInternalRouterError(404, {\n pathname: init.history.location.pathname,\n });\n let { matches, route } = getShortCircuitMatches(dataRoutes);\n initialMatches = matches;\n initialErrors = { [route.id]: error };\n }\n\n let initialized =\n // All initialMatches need to be loaded before we're ready. If we have lazy\n // functions around still then we'll need to run them in initialize()\n !initialMatches.some((m) => m.route.lazy) &&\n // And we have to either have no loaders or have been provided hydrationData\n (!initialMatches.some((m) => m.route.loader) || init.hydrationData != null);\n\n let router: Router;\n let state: RouterState = {\n historyAction: init.history.action,\n location: init.history.location,\n matches: initialMatches,\n initialized,\n navigation: IDLE_NAVIGATION,\n // Don't restore on initial updateState() if we were SSR'd\n restoreScrollPosition: init.hydrationData != null ? false : null,\n preventScrollReset: false,\n revalidation: \"idle\",\n loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},\n actionData: (init.hydrationData && init.hydrationData.actionData) || null,\n errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,\n fetchers: new Map(),\n blockers: new Map(),\n };\n\n // -- Stateful internal variables to manage navigations --\n // Current navigation in progress (to be committed in completeNavigation)\n let pendingAction: HistoryAction = HistoryAction.Pop;\n\n // Should the current navigation prevent the scroll reset if scroll cannot\n // be restored?\n let pendingPreventScrollReset = false;\n\n // AbortController for the active navigation\n let pendingNavigationController: AbortController | null;\n\n // Should the current navigation enable document.startViewTransition?\n let pendingViewTransitionEnabled = false;\n\n // Store applied view transitions so we can apply them on POP\n let appliedViewTransitions: Map> = new Map<\n string,\n Set\n >();\n\n // Cleanup function for persisting applied transitions to sessionStorage\n let removePageHideEventListener: (() => void) | null = null;\n\n // We use this to avoid touching history in completeNavigation if a\n // revalidation is entirely uninterrupted\n let isUninterruptedRevalidation = false;\n\n // Use this internal flag to force revalidation of all loaders:\n // - submissions (completed or interrupted)\n // - useRevalidator()\n // - X-Remix-Revalidate (from redirect)\n let isRevalidationRequired = false;\n\n // Use this internal array to capture routes that require revalidation due\n // to a cancelled deferred on action submission\n let cancelledDeferredRoutes: string[] = [];\n\n // Use this internal array to capture fetcher loads that were cancelled by an\n // action navigation and require revalidation\n let cancelledFetcherLoads: string[] = [];\n\n // AbortControllers for any in-flight fetchers\n let fetchControllers = new Map();\n\n // Track loads based on the order in which they started\n let incrementingLoadId = 0;\n\n // Track the outstanding pending navigation data load to be compared against\n // the globally incrementing load when a fetcher load lands after a completed\n // navigation\n let pendingNavigationLoadId = -1;\n\n // Fetchers that triggered data reloads as a result of their actions\n let fetchReloadIds = new Map();\n\n // Fetchers that triggered redirect navigations\n let fetchRedirectIds = new Set();\n\n // Most recent href/match for fetcher.load calls for fetchers\n let fetchLoadMatches = new Map();\n\n // Ref-count mounted fetchers so we know when it's ok to clean them up\n let activeFetchers = new Map();\n\n // Fetchers that have requested a delete when using v7_fetcherPersist,\n // they'll be officially removed after they return to idle\n let deletedFetchers = new Set();\n\n // Store DeferredData instances for active route matches. When a\n // route loader returns defer() we stick one in here. Then, when a nested\n // promise resolves we update loaderData. If a new navigation starts we\n // cancel active deferreds for eliminated routes.\n let activeDeferreds = new Map();\n\n // Store blocker functions in a separate Map outside of router state since\n // we don't need to update UI state if they change\n let blockerFunctions = new Map();\n\n // Flag to ignore the next history update, so we can revert the URL change on\n // a POP navigation that was blocked by the user without touching router state\n let ignoreNextHistoryUpdate = false;\n\n // Initialize the router, all side effects should be kicked off from here.\n // Implemented as a Fluent API for ease of:\n // let router = createRouter(init).initialize();\n function initialize() {\n // If history informs us of a POP navigation, start the navigation but do not update\n // state. We'll update our own state once the navigation completes\n unlistenHistory = init.history.listen(\n ({ action: historyAction, location, delta }) => {\n // Ignore this event if it was just us resetting the URL from a\n // blocked POP navigation\n if (ignoreNextHistoryUpdate) {\n ignoreNextHistoryUpdate = false;\n return;\n }\n\n warning(\n blockerFunctions.size === 0 || delta != null,\n \"You are trying to use a blocker on a POP navigation to a location \" +\n \"that was not created by @remix-run/router. This will fail silently in \" +\n \"production. This can happen if you are navigating outside the router \" +\n \"via `window.history.pushState`/`window.location.hash` instead of using \" +\n \"router navigation APIs. This can also happen if you are using \" +\n \"createHashRouter and the user manually changes the URL.\"\n );\n\n let blockerKey = shouldBlockNavigation({\n currentLocation: state.location,\n nextLocation: location,\n historyAction,\n });\n\n if (blockerKey && delta != null) {\n // Restore the URL to match the current UI, but don't update router state\n ignoreNextHistoryUpdate = true;\n init.history.go(delta * -1);\n\n // Put the blocker into a blocked state\n updateBlocker(blockerKey, {\n state: \"blocked\",\n location,\n proceed() {\n updateBlocker(blockerKey!, {\n state: \"proceeding\",\n proceed: undefined,\n reset: undefined,\n location,\n });\n // Re-do the same POP navigation we just blocked\n init.history.go(delta);\n },\n reset() {\n let blockers = new Map(state.blockers);\n blockers.set(blockerKey!, IDLE_BLOCKER);\n updateState({ blockers });\n },\n });\n return;\n }\n\n return startNavigation(historyAction, location);\n }\n );\n\n if (isBrowser) {\n // FIXME: This feels gross. How can we cleanup the lines between\n // scrollRestoration/appliedTransitions persistance?\n restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n let _saveAppliedTransitions = () =>\n persistAppliedTransitions(routerWindow, appliedViewTransitions);\n routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n removePageHideEventListener = () =>\n routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n }\n\n // Kick off initial data load if needed. Use Pop to avoid modifying history\n // Note we don't do any handling of lazy here. For SPA's it'll get handled\n // in the normal navigation flow. For SSR it's expected that lazy modules are\n // resolved prior to router creation since we can't go into a fallbackElement\n // UI for SSR'd apps\n if (!state.initialized) {\n startNavigation(HistoryAction.Pop, state.location);\n }\n\n return router;\n }\n\n // Clean up a router and it's side effects\n function dispose() {\n if (unlistenHistory) {\n unlistenHistory();\n }\n if (removePageHideEventListener) {\n removePageHideEventListener();\n }\n subscribers.clear();\n pendingNavigationController && pendingNavigationController.abort();\n state.fetchers.forEach((_, key) => deleteFetcher(key));\n state.blockers.forEach((_, key) => deleteBlocker(key));\n }\n\n // Subscribe to state updates for the router\n function subscribe(fn: RouterSubscriber) {\n subscribers.add(fn);\n return () => subscribers.delete(fn);\n }\n\n // Update our state and notify the calling context of the change\n function updateState(\n newState: Partial,\n opts: {\n flushSync?: boolean;\n viewTransitionOpts?: ViewTransitionOpts;\n } = {}\n ): void {\n state = {\n ...state,\n ...newState,\n };\n\n // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n // can be removed\n let completedFetchers: string[] = [];\n let deletedFetchersKeys: string[] = [];\n\n if (future.v7_fetcherPersist) {\n state.fetchers.forEach((fetcher, key) => {\n if (fetcher.state === \"idle\") {\n if (deletedFetchers.has(key)) {\n // Unmounted from the UI and can be totally removed\n deletedFetchersKeys.push(key);\n } else {\n // Returned to idle but still mounted in the UI, so semi-remains for\n // revalidations and such\n completedFetchers.push(key);\n }\n }\n });\n }\n\n // Iterate over a local copy so that if flushSync is used and we end up\n // removing and adding a new subscriber due to the useCallback dependencies,\n // we don't get ourselves into a loop calling the new subscriber immediately\n [...subscribers].forEach((subscriber) =>\n subscriber(state, {\n deletedFetchers: deletedFetchersKeys,\n unstable_viewTransitionOpts: opts.viewTransitionOpts,\n unstable_flushSync: opts.flushSync === true,\n })\n );\n\n // Remove idle fetchers from state since we only care about in-flight fetchers.\n if (future.v7_fetcherPersist) {\n completedFetchers.forEach((key) => state.fetchers.delete(key));\n deletedFetchersKeys.forEach((key) => deleteFetcher(key));\n }\n }\n\n // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n // and setting state.[historyAction/location/matches] to the new route.\n // - Location is a required param\n // - Navigation will always be set to IDLE_NAVIGATION\n // - Can pass any other state in newState\n function completeNavigation(\n location: Location,\n newState: Partial>,\n { flushSync }: { flushSync?: boolean } = {}\n ): void {\n // Deduce if we're in a loading/actionReload state:\n // - We have committed actionData in the store\n // - The current navigation was a mutation submission\n // - We're past the submitting state and into the loading state\n // - The location being loaded is not the result of a redirect\n let isActionReload =\n state.actionData != null &&\n state.navigation.formMethod != null &&\n isMutationMethod(state.navigation.formMethod) &&\n state.navigation.state === \"loading\" &&\n location.state?._isRedirect !== true;\n\n let actionData: RouteData | null;\n if (newState.actionData) {\n if (Object.keys(newState.actionData).length > 0) {\n actionData = newState.actionData;\n } else {\n // Empty actionData -> clear prior actionData due to an action error\n actionData = null;\n }\n } else if (isActionReload) {\n // Keep the current data if we're wrapping up the action reload\n actionData = state.actionData;\n } else {\n // Clear actionData on any other completed navigations\n actionData = null;\n }\n\n // Always preserve any existing loaderData from re-used routes\n let loaderData = newState.loaderData\n ? mergeLoaderData(\n state.loaderData,\n newState.loaderData,\n newState.matches || [],\n newState.errors\n )\n : state.loaderData;\n\n // On a successful navigation we can assume we got through all blockers\n // so we can start fresh\n let blockers = state.blockers;\n if (blockers.size > 0) {\n blockers = new Map(blockers);\n blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n }\n\n // Always respect the user flag. Otherwise don't reset on mutation\n // submission navigations unless they redirect\n let preventScrollReset =\n pendingPreventScrollReset === true ||\n (state.navigation.formMethod != null &&\n isMutationMethod(state.navigation.formMethod) &&\n location.state?._isRedirect !== true);\n\n if (inFlightDataRoutes) {\n dataRoutes = inFlightDataRoutes;\n inFlightDataRoutes = undefined;\n }\n\n if (isUninterruptedRevalidation) {\n // If this was an uninterrupted revalidation then do not touch history\n } else if (pendingAction === HistoryAction.Pop) {\n // Do nothing for POP - URL has already been updated\n } else if (pendingAction === HistoryAction.Push) {\n init.history.push(location, location.state);\n } else if (pendingAction === HistoryAction.Replace) {\n init.history.replace(location, location.state);\n }\n\n let viewTransitionOpts: ViewTransitionOpts | undefined;\n\n // On POP, enable transitions if they were enabled on the original navigation\n if (pendingAction === HistoryAction.Pop) {\n // Forward takes precedence so they behave like the original navigation\n let priorPaths = appliedViewTransitions.get(state.location.pathname);\n if (priorPaths && priorPaths.has(location.pathname)) {\n viewTransitionOpts = {\n currentLocation: state.location,\n nextLocation: location,\n };\n } else if (appliedViewTransitions.has(location.pathname)) {\n // If we don't have a previous forward nav, assume we're popping back to\n // the new location and enable if that location previously enabled\n viewTransitionOpts = {\n currentLocation: location,\n nextLocation: state.location,\n };\n }\n } else if (pendingViewTransitionEnabled) {\n // Store the applied transition on PUSH/REPLACE\n let toPaths = appliedViewTransitions.get(state.location.pathname);\n if (toPaths) {\n toPaths.add(location.pathname);\n } else {\n toPaths = new Set([location.pathname]);\n appliedViewTransitions.set(state.location.pathname, toPaths);\n }\n viewTransitionOpts = {\n currentLocation: state.location,\n nextLocation: location,\n };\n }\n\n updateState(\n {\n ...newState, // matches, errors, fetchers go through as-is\n actionData,\n loaderData,\n historyAction: pendingAction,\n location,\n initialized: true,\n navigation: IDLE_NAVIGATION,\n revalidation: \"idle\",\n restoreScrollPosition: getSavedScrollPosition(\n location,\n newState.matches || state.matches\n ),\n preventScrollReset,\n blockers,\n },\n {\n viewTransitionOpts,\n flushSync: flushSync === true,\n }\n );\n\n // Reset stateful navigation vars\n pendingAction = HistoryAction.Pop;\n pendingPreventScrollReset = false;\n pendingViewTransitionEnabled = false;\n isUninterruptedRevalidation = false;\n isRevalidationRequired = false;\n cancelledDeferredRoutes = [];\n cancelledFetcherLoads = [];\n }\n\n // Trigger a navigation event, which can either be a numerical POP or a PUSH\n // replace with an optional submission\n async function navigate(\n to: number | To | null,\n opts?: RouterNavigateOptions\n ): Promise {\n if (typeof to === \"number\") {\n init.history.go(to);\n return;\n }\n\n let normalizedPath = normalizeTo(\n state.location,\n state.matches,\n basename,\n future.v7_prependBasename,\n to,\n opts?.fromRouteId,\n opts?.relative\n );\n let { path, submission, error } = normalizeNavigateOptions(\n future.v7_normalizeFormMethod,\n false,\n normalizedPath,\n opts\n );\n\n let currentLocation = state.location;\n let nextLocation = createLocation(state.location, path, opts && opts.state);\n\n // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n // URL from window.location, so we need to encode it here so the behavior\n // remains the same as POP and non-data-router usages. new URL() does all\n // the same encoding we'd get from a history.pushState/window.location read\n // without having to touch history\n nextLocation = {\n ...nextLocation,\n ...init.history.encodeLocation(nextLocation),\n };\n\n let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n\n let historyAction = HistoryAction.Push;\n\n if (userReplace === true) {\n historyAction = HistoryAction.Replace;\n } else if (userReplace === false) {\n // no-op\n } else if (\n submission != null &&\n isMutationMethod(submission.formMethod) &&\n submission.formAction === state.location.pathname + state.location.search\n ) {\n // By default on submissions to the current location we REPLACE so that\n // users don't have to double-click the back button to get to the prior\n // location. If the user redirects to a different location from the\n // action/loader this will be ignored and the redirect will be a PUSH\n historyAction = HistoryAction.Replace;\n }\n\n let preventScrollReset =\n opts && \"preventScrollReset\" in opts\n ? opts.preventScrollReset === true\n : undefined;\n\n let flushSync = (opts && opts.unstable_flushSync) === true;\n\n let blockerKey = shouldBlockNavigation({\n currentLocation,\n nextLocation,\n historyAction,\n });\n\n if (blockerKey) {\n // Put the blocker into a blocked state\n updateBlocker(blockerKey, {\n state: \"blocked\",\n location: nextLocation,\n proceed() {\n updateBlocker(blockerKey!, {\n state: \"proceeding\",\n proceed: undefined,\n reset: undefined,\n location: nextLocation,\n });\n // Send the same navigation through\n navigate(to, opts);\n },\n reset() {\n let blockers = new Map(state.blockers);\n blockers.set(blockerKey!, IDLE_BLOCKER);\n updateState({ blockers });\n },\n });\n return;\n }\n\n return await startNavigation(historyAction, nextLocation, {\n submission,\n // Send through the formData serialization error if we have one so we can\n // render at the right error boundary after we match routes\n pendingError: error,\n preventScrollReset,\n replace: opts && opts.replace,\n enableViewTransition: opts && opts.unstable_viewTransition,\n flushSync,\n });\n }\n\n // Revalidate all current loaders. If a navigation is in progress or if this\n // is interrupted by a navigation, allow this to \"succeed\" by calling all\n // loaders during the next loader round\n function revalidate() {\n interruptActiveLoads();\n updateState({ revalidation: \"loading\" });\n\n // If we're currently submitting an action, we don't need to start a new\n // navigation, we'll just let the follow up loader execution call all loaders\n if (state.navigation.state === \"submitting\") {\n return;\n }\n\n // If we're currently in an idle state, start a new navigation for the current\n // action/location and mark it as uninterrupted, which will skip the history\n // update in completeNavigation\n if (state.navigation.state === \"idle\") {\n startNavigation(state.historyAction, state.location, {\n startUninterruptedRevalidation: true,\n });\n return;\n }\n\n // Otherwise, if we're currently in a loading state, just start a new\n // navigation to the navigation.location but do not trigger an uninterrupted\n // revalidation so that history correctly updates once the navigation completes\n startNavigation(\n pendingAction || state.historyAction,\n state.navigation.location,\n { overrideNavigation: state.navigation }\n );\n }\n\n // Start a navigation to the given action/location. Can optionally provide a\n // overrideNavigation which will override the normalLoad in the case of a redirect\n // navigation\n async function startNavigation(\n historyAction: HistoryAction,\n location: Location,\n opts?: {\n submission?: Submission;\n fetcherSubmission?: Submission;\n overrideNavigation?: Navigation;\n pendingError?: ErrorResponseImpl;\n startUninterruptedRevalidation?: boolean;\n preventScrollReset?: boolean;\n replace?: boolean;\n enableViewTransition?: boolean;\n flushSync?: boolean;\n }\n ): Promise {\n // Abort any in-progress navigations and start a new one. Unset any ongoing\n // uninterrupted revalidations unless told otherwise, since we want this\n // new navigation to update history normally\n pendingNavigationController && pendingNavigationController.abort();\n pendingNavigationController = null;\n pendingAction = historyAction;\n isUninterruptedRevalidation =\n (opts && opts.startUninterruptedRevalidation) === true;\n\n // Save the current scroll position every time we start a new navigation,\n // and track whether we should reset scroll on completion\n saveScrollPosition(state.location, state.matches);\n pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let loadingNavigation = opts && opts.overrideNavigation;\n let matches = matchRoutes(routesToUse, location, basename);\n let flushSync = (opts && opts.flushSync) === true;\n\n // Short circuit with a 404 on the root error boundary if we match nothing\n if (!matches) {\n let error = getInternalRouterError(404, { pathname: location.pathname });\n let { matches: notFoundMatches, route } =\n getShortCircuitMatches(routesToUse);\n // Cancel all pending deferred on 404s since we don't keep any routes\n cancelActiveDeferreds();\n completeNavigation(\n location,\n {\n matches: notFoundMatches,\n loaderData: {},\n errors: {\n [route.id]: error,\n },\n },\n { flushSync }\n );\n return;\n }\n\n // Short circuit if it's only a hash change and not a revalidation or\n // mutation submission.\n //\n // Ignore on initial page loads because since the initial load will always\n // be \"same hash\". For example, on /page#hash and submit a \n // which will default to a navigation to /page\n if (\n state.initialized &&\n !isRevalidationRequired &&\n isHashChangeOnly(state.location, location) &&\n !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))\n ) {\n completeNavigation(location, { matches }, { flushSync });\n return;\n }\n\n // Create a controller/Request for this navigation\n pendingNavigationController = new AbortController();\n let request = createClientSideRequest(\n init.history,\n location,\n pendingNavigationController.signal,\n opts && opts.submission\n );\n let pendingActionData: RouteData | undefined;\n let pendingError: RouteData | undefined;\n\n if (opts && opts.pendingError) {\n // If we have a pendingError, it means the user attempted a GET submission\n // with binary FormData so assign here and skip to handleLoaders. That\n // way we handle calling loaders above the boundary etc. It's not really\n // different from an actionError in that sense.\n pendingError = {\n [findNearestBoundary(matches).route.id]: opts.pendingError,\n };\n } else if (\n opts &&\n opts.submission &&\n isMutationMethod(opts.submission.formMethod)\n ) {\n // Call action if we received an action submission\n let actionOutput = await handleAction(\n request,\n location,\n opts.submission,\n matches,\n { replace: opts.replace, flushSync }\n );\n\n if (actionOutput.shortCircuited) {\n return;\n }\n\n pendingActionData = actionOutput.pendingActionData;\n pendingError = actionOutput.pendingActionError;\n loadingNavigation = getLoadingNavigation(location, opts.submission);\n flushSync = false;\n\n // Create a GET request for the loaders\n request = new Request(request.url, { signal: request.signal });\n }\n\n // Call loaders\n let { shortCircuited, loaderData, errors } = await handleLoaders(\n request,\n location,\n matches,\n loadingNavigation,\n opts && opts.submission,\n opts && opts.fetcherSubmission,\n opts && opts.replace,\n flushSync,\n pendingActionData,\n pendingError\n );\n\n if (shortCircuited) {\n return;\n }\n\n // Clean up now that the action/loaders have completed. Don't clean up if\n // we short circuited because pendingNavigationController will have already\n // been assigned to a new controller for the next navigation\n pendingNavigationController = null;\n\n completeNavigation(location, {\n matches,\n ...(pendingActionData ? { actionData: pendingActionData } : {}),\n loaderData,\n errors,\n });\n }\n\n // Call the action matched by the leaf route for this navigation and handle\n // redirects/errors\n async function handleAction(\n request: Request,\n location: Location,\n submission: Submission,\n matches: AgnosticDataRouteMatch[],\n opts: { replace?: boolean; flushSync?: boolean } = {}\n ): Promise {\n interruptActiveLoads();\n\n // Put us in a submitting state\n let navigation = getSubmittingNavigation(location, submission);\n updateState({ navigation }, { flushSync: opts.flushSync === true });\n\n // Call our action and get the result\n let result: DataResult;\n let actionMatch = getTargetMatch(matches, location);\n\n if (!actionMatch.route.action && !actionMatch.route.lazy) {\n result = {\n type: ResultType.error,\n error: getInternalRouterError(405, {\n method: request.method,\n pathname: location.pathname,\n routeId: actionMatch.route.id,\n }),\n };\n } else {\n result = await callLoaderOrAction(\n \"action\",\n request,\n actionMatch,\n matches,\n manifest,\n mapRouteProperties,\n basename\n );\n\n if (request.signal.aborted) {\n return { shortCircuited: true };\n }\n }\n\n if (isRedirectResult(result)) {\n let replace: boolean;\n if (opts && opts.replace != null) {\n replace = opts.replace;\n } else {\n // If the user didn't explicity indicate replace behavior, replace if\n // we redirected to the exact same location we're currently at to avoid\n // double back-buttons\n replace =\n result.location === state.location.pathname + state.location.search;\n }\n await startRedirectNavigation(state, result, { submission, replace });\n return { shortCircuited: true };\n }\n\n if (isErrorResult(result)) {\n // Store off the pending error - we use it to determine which loaders\n // to call and will commit it when we complete the navigation\n let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n\n // By default, all submissions are REPLACE navigations, but if the\n // action threw an error that'll be rendered in an errorElement, we fall\n // back to PUSH so that the user can use the back button to get back to\n // the pre-submission form location to try again\n if ((opts && opts.replace) !== true) {\n pendingAction = HistoryAction.Push;\n }\n\n return {\n // Send back an empty object we can use to clear out any prior actionData\n pendingActionData: {},\n pendingActionError: { [boundaryMatch.route.id]: result.error },\n };\n }\n\n if (isDeferredResult(result)) {\n throw getInternalRouterError(400, { type: \"defer-action\" });\n }\n\n return {\n pendingActionData: { [actionMatch.route.id]: result.data },\n };\n }\n\n // Call all applicable loaders for the given matches, handling redirects,\n // errors, etc.\n async function handleLoaders(\n request: Request,\n location: Location,\n matches: AgnosticDataRouteMatch[],\n overrideNavigation?: Navigation,\n submission?: Submission,\n fetcherSubmission?: Submission,\n replace?: boolean,\n flushSync?: boolean,\n pendingActionData?: RouteData,\n pendingError?: RouteData\n ): Promise {\n // Figure out the right navigation we want to use for data loading\n let loadingNavigation =\n overrideNavigation || getLoadingNavigation(location, submission);\n\n // If this was a redirect from an action we don't have a \"submission\" but\n // we have it on the loading navigation so use that if available\n let activeSubmission =\n submission ||\n fetcherSubmission ||\n getSubmissionFromNavigation(loadingNavigation);\n\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n init.history,\n state,\n matches,\n activeSubmission,\n location,\n isRevalidationRequired,\n cancelledDeferredRoutes,\n cancelledFetcherLoads,\n fetchLoadMatches,\n fetchRedirectIds,\n routesToUse,\n basename,\n pendingActionData,\n pendingError\n );\n\n // Cancel pending deferreds for no-longer-matched routes or routes we're\n // about to reload. Note that if this is an action reload we would have\n // already cancelled all pending deferreds so this would be a no-op\n cancelActiveDeferreds(\n (routeId) =>\n !(matches && matches.some((m) => m.route.id === routeId)) ||\n (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))\n );\n\n pendingNavigationLoadId = ++incrementingLoadId;\n\n // Short circuit if we have no loaders to run\n if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n let updatedFetchers = markFetchRedirectsDone();\n completeNavigation(\n location,\n {\n matches,\n loaderData: {},\n // Commit pending error if we're short circuiting\n errors: pendingError || null,\n ...(pendingActionData ? { actionData: pendingActionData } : {}),\n ...(updatedFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n },\n { flushSync }\n );\n return { shortCircuited: true };\n }\n\n // If this is an uninterrupted revalidation, we remain in our current idle\n // state. If not, we need to switch to our loading state and load data,\n // preserving any new action data or existing action data (in the case of\n // a revalidation interrupting an actionReload)\n if (!isUninterruptedRevalidation) {\n revalidatingFetchers.forEach((rf) => {\n let fetcher = state.fetchers.get(rf.key);\n let revalidatingFetcher = getLoadingFetcher(\n undefined,\n fetcher ? fetcher.data : undefined\n );\n state.fetchers.set(rf.key, revalidatingFetcher);\n });\n let actionData = pendingActionData || state.actionData;\n updateState(\n {\n navigation: loadingNavigation,\n ...(actionData\n ? Object.keys(actionData).length === 0\n ? { actionData: null }\n : { actionData }\n : {}),\n ...(revalidatingFetchers.length > 0\n ? { fetchers: new Map(state.fetchers) }\n : {}),\n },\n {\n flushSync,\n }\n );\n }\n\n revalidatingFetchers.forEach((rf) => {\n if (fetchControllers.has(rf.key)) {\n abortFetcher(rf.key);\n }\n if (rf.controller) {\n // Fetchers use an independent AbortController so that aborting a fetcher\n // (via deleteFetcher) does not abort the triggering navigation that\n // triggered the revalidation\n fetchControllers.set(rf.key, rf.controller);\n }\n });\n\n // Proxy navigation abort through to revalidation fetchers\n let abortPendingFetchRevalidations = () =>\n revalidatingFetchers.forEach((f) => abortFetcher(f.key));\n if (pendingNavigationController) {\n pendingNavigationController.signal.addEventListener(\n \"abort\",\n abortPendingFetchRevalidations\n );\n }\n\n let { results, loaderResults, fetcherResults } =\n await callLoadersAndMaybeResolveData(\n state.matches,\n matches,\n matchesToLoad,\n revalidatingFetchers,\n request\n );\n\n if (request.signal.aborted) {\n return { shortCircuited: true };\n }\n\n // Clean up _after_ loaders have completed. Don't clean up if we short\n // circuited because fetchControllers would have been aborted and\n // reassigned to new controllers for the next navigation\n if (pendingNavigationController) {\n pendingNavigationController.signal.removeEventListener(\n \"abort\",\n abortPendingFetchRevalidations\n );\n }\n revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));\n\n // If any loaders returned a redirect Response, start a new REPLACE navigation\n let redirect = findRedirect(results);\n if (redirect) {\n if (redirect.idx >= matchesToLoad.length) {\n // If this redirect came from a fetcher make sure we mark it in\n // fetchRedirectIds so it doesn't get revalidated on the next set of\n // loader executions\n let fetcherKey =\n revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n fetchRedirectIds.add(fetcherKey);\n }\n await startRedirectNavigation(state, redirect.result, { replace });\n return { shortCircuited: true };\n }\n\n // Process and commit output from loaders\n let { loaderData, errors } = processLoaderData(\n state,\n matches,\n matchesToLoad,\n loaderResults,\n pendingError,\n revalidatingFetchers,\n fetcherResults,\n activeDeferreds\n );\n\n // Wire up subscribers to update loaderData as promises settle\n activeDeferreds.forEach((deferredData, routeId) => {\n deferredData.subscribe((aborted) => {\n // Note: No need to updateState here since the TrackedPromise on\n // loaderData is stable across resolve/reject\n // Remove this instance if we were aborted or if promises have settled\n if (aborted || deferredData.done) {\n activeDeferreds.delete(routeId);\n }\n });\n });\n\n let updatedFetchers = markFetchRedirectsDone();\n let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n let shouldUpdateFetchers =\n updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n\n return {\n loaderData,\n errors,\n ...(shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n };\n }\n\n // Trigger a fetcher load/submit for the given fetcher key\n function fetch(\n key: string,\n routeId: string,\n href: string | null,\n opts?: RouterFetchOptions\n ) {\n if (isServer) {\n throw new Error(\n \"router.fetch() was called during the server render, but it shouldn't be. \" +\n \"You are likely calling a useFetcher() method in the body of your component. \" +\n \"Try moving it to a useEffect or a callback.\"\n );\n }\n\n if (fetchControllers.has(key)) abortFetcher(key);\n let flushSync = (opts && opts.unstable_flushSync) === true;\n\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let normalizedPath = normalizeTo(\n state.location,\n state.matches,\n basename,\n future.v7_prependBasename,\n href,\n routeId,\n opts?.relative\n );\n let matches = matchRoutes(routesToUse, normalizedPath, basename);\n\n if (!matches) {\n setFetcherError(\n key,\n routeId,\n getInternalRouterError(404, { pathname: normalizedPath }),\n { flushSync }\n );\n return;\n }\n\n let { path, submission, error } = normalizeNavigateOptions(\n future.v7_normalizeFormMethod,\n true,\n normalizedPath,\n opts\n );\n\n if (error) {\n setFetcherError(key, routeId, error, { flushSync });\n return;\n }\n\n let match = getTargetMatch(matches, path);\n\n pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n if (submission && isMutationMethod(submission.formMethod)) {\n handleFetcherAction(\n key,\n routeId,\n path,\n match,\n matches,\n flushSync,\n submission\n );\n return;\n }\n\n // Store off the match so we can call it's shouldRevalidate on subsequent\n // revalidations\n fetchLoadMatches.set(key, { routeId, path });\n handleFetcherLoader(\n key,\n routeId,\n path,\n match,\n matches,\n flushSync,\n submission\n );\n }\n\n // Call the action for the matched fetcher.submit(), and then handle redirects,\n // errors, and revalidation\n async function handleFetcherAction(\n key: string,\n routeId: string,\n path: string,\n match: AgnosticDataRouteMatch,\n requestMatches: AgnosticDataRouteMatch[],\n flushSync: boolean,\n submission: Submission\n ) {\n interruptActiveLoads();\n fetchLoadMatches.delete(key);\n\n if (!match.route.action && !match.route.lazy) {\n let error = getInternalRouterError(405, {\n method: submission.formMethod,\n pathname: path,\n routeId: routeId,\n });\n setFetcherError(key, routeId, error, { flushSync });\n return;\n }\n\n // Put this fetcher into it's submitting state\n let existingFetcher = state.fetchers.get(key);\n updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n flushSync,\n });\n\n // Call the action for the fetcher\n let abortController = new AbortController();\n let fetchRequest = createClientSideRequest(\n init.history,\n path,\n abortController.signal,\n submission\n );\n fetchControllers.set(key, abortController);\n\n let originatingLoadId = incrementingLoadId;\n let actionResult = await callLoaderOrAction(\n \"action\",\n fetchRequest,\n match,\n requestMatches,\n manifest,\n mapRouteProperties,\n basename\n );\n\n if (fetchRequest.signal.aborted) {\n // We can delete this so long as we weren't aborted by our own fetcher\n // re-submit which would have put _new_ controller is in fetchControllers\n if (fetchControllers.get(key) === abortController) {\n fetchControllers.delete(key);\n }\n return;\n }\n\n if (deletedFetchers.has(key)) {\n updateFetcherState(key, getDoneFetcher(undefined));\n return;\n }\n\n if (isRedirectResult(actionResult)) {\n fetchControllers.delete(key);\n if (pendingNavigationLoadId > originatingLoadId) {\n // A new navigation was kicked off after our action started, so that\n // should take precedence over this redirect navigation. We already\n // set isRevalidationRequired so all loaders for the new route should\n // fire unless opted out via shouldRevalidate\n updateFetcherState(key, getDoneFetcher(undefined));\n return;\n } else {\n fetchRedirectIds.add(key);\n updateFetcherState(key, getLoadingFetcher(submission));\n return startRedirectNavigation(state, actionResult, {\n fetcherSubmission: submission,\n });\n }\n }\n\n // Process any non-redirect errors thrown\n if (isErrorResult(actionResult)) {\n setFetcherError(key, routeId, actionResult.error);\n return;\n }\n\n if (isDeferredResult(actionResult)) {\n throw getInternalRouterError(400, { type: \"defer-action\" });\n }\n\n // Start the data load for current matches, or the next location if we're\n // in the middle of a navigation\n let nextLocation = state.navigation.location || state.location;\n let revalidationRequest = createClientSideRequest(\n init.history,\n nextLocation,\n abortController.signal\n );\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let matches =\n state.navigation.state !== \"idle\"\n ? matchRoutes(routesToUse, state.navigation.location, basename)\n : state.matches;\n\n invariant(matches, \"Didn't find any matches after fetcher action\");\n\n let loadId = ++incrementingLoadId;\n fetchReloadIds.set(key, loadId);\n\n let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n state.fetchers.set(key, loadFetcher);\n\n let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n init.history,\n state,\n matches,\n submission,\n nextLocation,\n isRevalidationRequired,\n cancelledDeferredRoutes,\n cancelledFetcherLoads,\n fetchLoadMatches,\n fetchRedirectIds,\n routesToUse,\n basename,\n { [match.route.id]: actionResult.data },\n undefined // No need to send through errors since we short circuit above\n );\n\n // Put all revalidating fetchers into the loading state, except for the\n // current fetcher which we want to keep in it's current loading state which\n // contains it's action submission info + action data\n revalidatingFetchers\n .filter((rf) => rf.key !== key)\n .forEach((rf) => {\n let staleKey = rf.key;\n let existingFetcher = state.fetchers.get(staleKey);\n let revalidatingFetcher = getLoadingFetcher(\n undefined,\n existingFetcher ? existingFetcher.data : undefined\n );\n state.fetchers.set(staleKey, revalidatingFetcher);\n if (fetchControllers.has(staleKey)) {\n abortFetcher(staleKey);\n }\n if (rf.controller) {\n fetchControllers.set(staleKey, rf.controller);\n }\n });\n\n updateState({ fetchers: new Map(state.fetchers) });\n\n let abortPendingFetchRevalidations = () =>\n revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));\n\n abortController.signal.addEventListener(\n \"abort\",\n abortPendingFetchRevalidations\n );\n\n let { results, loaderResults, fetcherResults } =\n await callLoadersAndMaybeResolveData(\n state.matches,\n matches,\n matchesToLoad,\n revalidatingFetchers,\n revalidationRequest\n );\n\n if (abortController.signal.aborted) {\n return;\n }\n\n abortController.signal.removeEventListener(\n \"abort\",\n abortPendingFetchRevalidations\n );\n\n fetchReloadIds.delete(key);\n fetchControllers.delete(key);\n revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));\n\n let redirect = findRedirect(results);\n if (redirect) {\n if (redirect.idx >= matchesToLoad.length) {\n // If this redirect came from a fetcher make sure we mark it in\n // fetchRedirectIds so it doesn't get revalidated on the next set of\n // loader executions\n let fetcherKey =\n revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n fetchRedirectIds.add(fetcherKey);\n }\n return startRedirectNavigation(state, redirect.result);\n }\n\n // Process and commit output from loaders\n let { loaderData, errors } = processLoaderData(\n state,\n state.matches,\n matchesToLoad,\n loaderResults,\n undefined,\n revalidatingFetchers,\n fetcherResults,\n activeDeferreds\n );\n\n // Since we let revalidations complete even if the submitting fetcher was\n // deleted, only put it back to idle if it hasn't been deleted\n if (state.fetchers.has(key)) {\n let doneFetcher = getDoneFetcher(actionResult.data);\n state.fetchers.set(key, doneFetcher);\n }\n\n abortStaleFetchLoads(loadId);\n\n // If we are currently in a navigation loading state and this fetcher is\n // more recent than the navigation, we want the newer data so abort the\n // navigation and complete it with the fetcher data\n if (\n state.navigation.state === \"loading\" &&\n loadId > pendingNavigationLoadId\n ) {\n invariant(pendingAction, \"Expected pending action\");\n pendingNavigationController && pendingNavigationController.abort();\n\n completeNavigation(state.navigation.location, {\n matches,\n loaderData,\n errors,\n fetchers: new Map(state.fetchers),\n });\n } else {\n // otherwise just update with the fetcher data, preserving any existing\n // loaderData for loaders that did not need to reload. We have to\n // manually merge here since we aren't going through completeNavigation\n updateState({\n errors,\n loaderData: mergeLoaderData(\n state.loaderData,\n loaderData,\n matches,\n errors\n ),\n fetchers: new Map(state.fetchers),\n });\n isRevalidationRequired = false;\n }\n }\n\n // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n async function handleFetcherLoader(\n key: string,\n routeId: string,\n path: string,\n match: AgnosticDataRouteMatch,\n matches: AgnosticDataRouteMatch[],\n flushSync: boolean,\n submission?: Submission\n ) {\n let existingFetcher = state.fetchers.get(key);\n updateFetcherState(\n key,\n getLoadingFetcher(\n submission,\n existingFetcher ? existingFetcher.data : undefined\n ),\n { flushSync }\n );\n\n // Call the loader for this fetcher route match\n let abortController = new AbortController();\n let fetchRequest = createClientSideRequest(\n init.history,\n path,\n abortController.signal\n );\n fetchControllers.set(key, abortController);\n\n let originatingLoadId = incrementingLoadId;\n let result: DataResult = await callLoaderOrAction(\n \"loader\",\n fetchRequest,\n match,\n matches,\n manifest,\n mapRouteProperties,\n basename\n );\n\n // Deferred isn't supported for fetcher loads, await everything and treat it\n // as a normal load. resolveDeferredData will return undefined if this\n // fetcher gets aborted, so we just leave result untouched and short circuit\n // below if that happens\n if (isDeferredResult(result)) {\n result =\n (await resolveDeferredData(result, fetchRequest.signal, true)) ||\n result;\n }\n\n // We can delete this so long as we weren't aborted by our our own fetcher\n // re-load which would have put _new_ controller is in fetchControllers\n if (fetchControllers.get(key) === abortController) {\n fetchControllers.delete(key);\n }\n\n if (fetchRequest.signal.aborted) {\n return;\n }\n\n if (deletedFetchers.has(key)) {\n updateFetcherState(key, getDoneFetcher(undefined));\n return;\n }\n\n // If the loader threw a redirect Response, start a new REPLACE navigation\n if (isRedirectResult(result)) {\n if (pendingNavigationLoadId > originatingLoadId) {\n // A new navigation was kicked off after our loader started, so that\n // should take precedence over this redirect navigation\n updateFetcherState(key, getDoneFetcher(undefined));\n return;\n } else {\n fetchRedirectIds.add(key);\n await startRedirectNavigation(state, result);\n return;\n }\n }\n\n // Process any non-redirect errors thrown\n if (isErrorResult(result)) {\n setFetcherError(key, routeId, result.error);\n return;\n }\n\n invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n\n // Put the fetcher back into an idle state\n updateFetcherState(key, getDoneFetcher(result.data));\n }\n\n /**\n * Utility function to handle redirects returned from an action or loader.\n * Normally, a redirect \"replaces\" the navigation that triggered it. So, for\n * example:\n *\n * - user is on /a\n * - user clicks a link to /b\n * - loader for /b redirects to /c\n *\n * In a non-JS app the browser would track the in-flight navigation to /b and\n * then replace it with /c when it encountered the redirect response. In\n * the end it would only ever update the URL bar with /c.\n *\n * In client-side routing using pushState/replaceState, we aim to emulate\n * this behavior and we also do not update history until the end of the\n * navigation (including processed redirects). This means that we never\n * actually touch history until we've processed redirects, so we just use\n * the history action from the original navigation (PUSH or REPLACE).\n */\n async function startRedirectNavigation(\n state: RouterState,\n redirect: RedirectResult,\n {\n submission,\n fetcherSubmission,\n replace,\n }: {\n submission?: Submission;\n fetcherSubmission?: Submission;\n replace?: boolean;\n } = {}\n ) {\n if (redirect.revalidate) {\n isRevalidationRequired = true;\n }\n\n let redirectLocation = createLocation(state.location, redirect.location, {\n _isRedirect: true,\n });\n invariant(\n redirectLocation,\n \"Expected a location on the redirect navigation\"\n );\n\n if (isBrowser) {\n let isDocumentReload = false;\n\n if (redirect.reloadDocument) {\n // Hard reload if the response contained X-Remix-Reload-Document\n isDocumentReload = true;\n } else if (ABSOLUTE_URL_REGEX.test(redirect.location)) {\n const url = init.history.createURL(redirect.location);\n isDocumentReload =\n // Hard reload if it's an absolute URL to a new origin\n url.origin !== routerWindow.location.origin ||\n // Hard reload if it's an absolute URL that does not match our basename\n stripBasename(url.pathname, basename) == null;\n }\n\n if (isDocumentReload) {\n if (replace) {\n routerWindow.location.replace(redirect.location);\n } else {\n routerWindow.location.assign(redirect.location);\n }\n return;\n }\n }\n\n // There's no need to abort on redirects, since we don't detect the\n // redirect until the action/loaders have settled\n pendingNavigationController = null;\n\n let redirectHistoryAction =\n replace === true ? HistoryAction.Replace : HistoryAction.Push;\n\n // Use the incoming submission if provided, fallback on the active one in\n // state.navigation\n let { formMethod, formAction, formEncType } = state.navigation;\n if (\n !submission &&\n !fetcherSubmission &&\n formMethod &&\n formAction &&\n formEncType\n ) {\n submission = getSubmissionFromNavigation(state.navigation);\n }\n\n // If this was a 307/308 submission we want to preserve the HTTP method and\n // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n // redirected location\n let activeSubmission = submission || fetcherSubmission;\n if (\n redirectPreserveMethodStatusCodes.has(redirect.status) &&\n activeSubmission &&\n isMutationMethod(activeSubmission.formMethod)\n ) {\n await startNavigation(redirectHistoryAction, redirectLocation, {\n submission: {\n ...activeSubmission,\n formAction: redirect.location,\n },\n // Preserve this flag across redirects\n preventScrollReset: pendingPreventScrollReset,\n });\n } else {\n // If we have a navigation submission, we will preserve it through the\n // redirect navigation\n let overrideNavigation = getLoadingNavigation(\n redirectLocation,\n submission\n );\n await startNavigation(redirectHistoryAction, redirectLocation, {\n overrideNavigation,\n // Send fetcher submissions through for shouldRevalidate\n fetcherSubmission,\n // Preserve this flag across redirects\n preventScrollReset: pendingPreventScrollReset,\n });\n }\n }\n\n async function callLoadersAndMaybeResolveData(\n currentMatches: AgnosticDataRouteMatch[],\n matches: AgnosticDataRouteMatch[],\n matchesToLoad: AgnosticDataRouteMatch[],\n fetchersToLoad: RevalidatingFetcher[],\n request: Request\n ) {\n // Call all navigation loaders and revalidating fetcher loaders in parallel,\n // then slice off the results into separate arrays so we can handle them\n // accordingly\n let results = await Promise.all([\n ...matchesToLoad.map((match) =>\n callLoaderOrAction(\n \"loader\",\n request,\n match,\n matches,\n manifest,\n mapRouteProperties,\n basename\n )\n ),\n ...fetchersToLoad.map((f) => {\n if (f.matches && f.match && f.controller) {\n return callLoaderOrAction(\n \"loader\",\n createClientSideRequest(init.history, f.path, f.controller.signal),\n f.match,\n f.matches,\n manifest,\n mapRouteProperties,\n basename\n );\n } else {\n let error: ErrorResult = {\n type: ResultType.error,\n error: getInternalRouterError(404, { pathname: f.path }),\n };\n return error;\n }\n }),\n ]);\n let loaderResults = results.slice(0, matchesToLoad.length);\n let fetcherResults = results.slice(matchesToLoad.length);\n\n await Promise.all([\n resolveDeferredResults(\n currentMatches,\n matchesToLoad,\n loaderResults,\n loaderResults.map(() => request.signal),\n false,\n state.loaderData\n ),\n resolveDeferredResults(\n currentMatches,\n fetchersToLoad.map((f) => f.match),\n fetcherResults,\n fetchersToLoad.map((f) => (f.controller ? f.controller.signal : null)),\n true\n ),\n ]);\n\n return { results, loaderResults, fetcherResults };\n }\n\n function interruptActiveLoads() {\n // Every interruption triggers a revalidation\n isRevalidationRequired = true;\n\n // Cancel pending route-level deferreds and mark cancelled routes for\n // revalidation\n cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n\n // Abort in-flight fetcher loads\n fetchLoadMatches.forEach((_, key) => {\n if (fetchControllers.has(key)) {\n cancelledFetcherLoads.push(key);\n abortFetcher(key);\n }\n });\n }\n\n function updateFetcherState(\n key: string,\n fetcher: Fetcher,\n opts: { flushSync?: boolean } = {}\n ) {\n state.fetchers.set(key, fetcher);\n updateState(\n { fetchers: new Map(state.fetchers) },\n { flushSync: (opts && opts.flushSync) === true }\n );\n }\n\n function setFetcherError(\n key: string,\n routeId: string,\n error: any,\n opts: { flushSync?: boolean } = {}\n ) {\n let boundaryMatch = findNearestBoundary(state.matches, routeId);\n deleteFetcher(key);\n updateState(\n {\n errors: {\n [boundaryMatch.route.id]: error,\n },\n fetchers: new Map(state.fetchers),\n },\n { flushSync: (opts && opts.flushSync) === true }\n );\n }\n\n function getFetcher(key: string): Fetcher {\n if (future.v7_fetcherPersist) {\n activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n // If this fetcher was previously marked for deletion, unmark it since we\n // have a new instance\n if (deletedFetchers.has(key)) {\n deletedFetchers.delete(key);\n }\n }\n return state.fetchers.get(key) || IDLE_FETCHER;\n }\n\n function deleteFetcher(key: string): void {\n let fetcher = state.fetchers.get(key);\n // Don't abort the controller if this is a deletion of a fetcher.submit()\n // in it's loading phase since - we don't want to abort the corresponding\n // revalidation and want them to complete and land\n if (\n fetchControllers.has(key) &&\n !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))\n ) {\n abortFetcher(key);\n }\n fetchLoadMatches.delete(key);\n fetchReloadIds.delete(key);\n fetchRedirectIds.delete(key);\n deletedFetchers.delete(key);\n state.fetchers.delete(key);\n }\n\n function deleteFetcherAndUpdateState(key: string): void {\n if (future.v7_fetcherPersist) {\n let count = (activeFetchers.get(key) || 0) - 1;\n if (count <= 0) {\n activeFetchers.delete(key);\n deletedFetchers.add(key);\n } else {\n activeFetchers.set(key, count);\n }\n } else {\n deleteFetcher(key);\n }\n updateState({ fetchers: new Map(state.fetchers) });\n }\n\n function abortFetcher(key: string) {\n let controller = fetchControllers.get(key);\n invariant(controller, `Expected fetch controller: ${key}`);\n controller.abort();\n fetchControllers.delete(key);\n }\n\n function markFetchersDone(keys: string[]) {\n for (let key of keys) {\n let fetcher = getFetcher(key);\n let doneFetcher = getDoneFetcher(fetcher.data);\n state.fetchers.set(key, doneFetcher);\n }\n }\n\n function markFetchRedirectsDone(): boolean {\n let doneKeys = [];\n let updatedFetchers = false;\n for (let key of fetchRedirectIds) {\n let fetcher = state.fetchers.get(key);\n invariant(fetcher, `Expected fetcher: ${key}`);\n if (fetcher.state === \"loading\") {\n fetchRedirectIds.delete(key);\n doneKeys.push(key);\n updatedFetchers = true;\n }\n }\n markFetchersDone(doneKeys);\n return updatedFetchers;\n }\n\n function abortStaleFetchLoads(landedId: number): boolean {\n let yeetedKeys = [];\n for (let [key, id] of fetchReloadIds) {\n if (id < landedId) {\n let fetcher = state.fetchers.get(key);\n invariant(fetcher, `Expected fetcher: ${key}`);\n if (fetcher.state === \"loading\") {\n abortFetcher(key);\n fetchReloadIds.delete(key);\n yeetedKeys.push(key);\n }\n }\n }\n markFetchersDone(yeetedKeys);\n return yeetedKeys.length > 0;\n }\n\n function getBlocker(key: string, fn: BlockerFunction) {\n let blocker: Blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n if (blockerFunctions.get(key) !== fn) {\n blockerFunctions.set(key, fn);\n }\n\n return blocker;\n }\n\n function deleteBlocker(key: string) {\n state.blockers.delete(key);\n blockerFunctions.delete(key);\n }\n\n // Utility function to update blockers, ensuring valid state transitions\n function updateBlocker(key: string, newBlocker: Blocker) {\n let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n // Poor mans state machine :)\n // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n invariant(\n (blocker.state === \"unblocked\" && newBlocker.state === \"blocked\") ||\n (blocker.state === \"blocked\" && newBlocker.state === \"blocked\") ||\n (blocker.state === \"blocked\" && newBlocker.state === \"proceeding\") ||\n (blocker.state === \"blocked\" && newBlocker.state === \"unblocked\") ||\n (blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\"),\n `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`\n );\n\n let blockers = new Map(state.blockers);\n blockers.set(key, newBlocker);\n updateState({ blockers });\n }\n\n function shouldBlockNavigation({\n currentLocation,\n nextLocation,\n historyAction,\n }: {\n currentLocation: Location;\n nextLocation: Location;\n historyAction: HistoryAction;\n }): string | undefined {\n if (blockerFunctions.size === 0) {\n return;\n }\n\n // We ony support a single active blocker at the moment since we don't have\n // any compelling use cases for multi-blocker yet\n if (blockerFunctions.size > 1) {\n warning(false, \"A router only supports one blocker at a time\");\n }\n\n let entries = Array.from(blockerFunctions.entries());\n let [blockerKey, blockerFunction] = entries[entries.length - 1];\n let blocker = state.blockers.get(blockerKey);\n\n if (blocker && blocker.state === \"proceeding\") {\n // If the blocker is currently proceeding, we don't need to re-check\n // it and can let this navigation continue\n return;\n }\n\n // At this point, we know we're unblocked/blocked so we need to check the\n // user-provided blocker function\n if (blockerFunction({ currentLocation, nextLocation, historyAction })) {\n return blockerKey;\n }\n }\n\n function cancelActiveDeferreds(\n predicate?: (routeId: string) => boolean\n ): string[] {\n let cancelledRouteIds: string[] = [];\n activeDeferreds.forEach((dfd, routeId) => {\n if (!predicate || predicate(routeId)) {\n // Cancel the deferred - but do not remove from activeDeferreds here -\n // we rely on the subscribers to do that so our tests can assert proper\n // cleanup via _internalActiveDeferreds\n dfd.cancel();\n cancelledRouteIds.push(routeId);\n activeDeferreds.delete(routeId);\n }\n });\n return cancelledRouteIds;\n }\n\n // Opt in to capturing and reporting scroll positions during navigations,\n // used by the component\n function enableScrollRestoration(\n positions: Record,\n getPosition: GetScrollPositionFunction,\n getKey?: GetScrollRestorationKeyFunction\n ) {\n savedScrollPositions = positions;\n getScrollPosition = getPosition;\n getScrollRestorationKey = getKey || null;\n\n // Perform initial hydration scroll restoration, since we miss the boat on\n // the initial updateState() because we've not yet rendered \n // and therefore have no savedScrollPositions available\n if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n initialScrollRestored = true;\n let y = getSavedScrollPosition(state.location, state.matches);\n if (y != null) {\n updateState({ restoreScrollPosition: y });\n }\n }\n\n return () => {\n savedScrollPositions = null;\n getScrollPosition = null;\n getScrollRestorationKey = null;\n };\n }\n\n function getScrollKey(location: Location, matches: AgnosticDataRouteMatch[]) {\n if (getScrollRestorationKey) {\n let key = getScrollRestorationKey(\n location,\n matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))\n );\n return key || location.key;\n }\n return location.key;\n }\n\n function saveScrollPosition(\n location: Location,\n matches: AgnosticDataRouteMatch[]\n ): void {\n if (savedScrollPositions && getScrollPosition) {\n let key = getScrollKey(location, matches);\n savedScrollPositions[key] = getScrollPosition();\n }\n }\n\n function getSavedScrollPosition(\n location: Location,\n matches: AgnosticDataRouteMatch[]\n ): number | null {\n if (savedScrollPositions) {\n let key = getScrollKey(location, matches);\n let y = savedScrollPositions[key];\n if (typeof y === \"number\") {\n return y;\n }\n }\n return null;\n }\n\n function _internalSetRoutes(newRoutes: AgnosticDataRouteObject[]) {\n manifest = {};\n inFlightDataRoutes = convertRoutesToDataRoutes(\n newRoutes,\n mapRouteProperties,\n undefined,\n manifest\n );\n }\n\n router = {\n get basename() {\n return basename;\n },\n get state() {\n return state;\n },\n get routes() {\n return dataRoutes;\n },\n get window() {\n return routerWindow;\n },\n initialize,\n subscribe,\n enableScrollRestoration,\n navigate,\n fetch,\n revalidate,\n // Passthrough to history-aware createHref used by useHref so we get proper\n // hash-aware URLs in DOM paths\n createHref: (to: To) => init.history.createHref(to),\n encodeLocation: (to: To) => init.history.encodeLocation(to),\n getFetcher,\n deleteFetcher: deleteFetcherAndUpdateState,\n dispose,\n getBlocker,\n deleteBlocker,\n _internalFetchControllers: fetchControllers,\n _internalActiveDeferreds: activeDeferreds,\n // TODO: Remove setRoutes, it's temporary to avoid dealing with\n // updating the tree while validating the update algorithm.\n _internalSetRoutes,\n };\n\n return router;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nexport const UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\n\nexport interface CreateStaticHandlerOptions {\n basename?: string;\n /**\n * @deprecated Use `mapRouteProperties` instead\n */\n detectErrorBoundary?: DetectErrorBoundaryFunction;\n mapRouteProperties?: MapRoutePropertiesFunction;\n}\n\nexport function createStaticHandler(\n routes: AgnosticRouteObject[],\n opts?: CreateStaticHandlerOptions\n): StaticHandler {\n invariant(\n routes.length > 0,\n \"You must provide a non-empty routes array to createStaticHandler\"\n );\n\n let manifest: RouteManifest = {};\n let basename = (opts ? opts.basename : null) || \"/\";\n let mapRouteProperties: MapRoutePropertiesFunction;\n if (opts?.mapRouteProperties) {\n mapRouteProperties = opts.mapRouteProperties;\n } else if (opts?.detectErrorBoundary) {\n // If they are still using the deprecated version, wrap it with the new API\n let detectErrorBoundary = opts.detectErrorBoundary;\n mapRouteProperties = (route) => ({\n hasErrorBoundary: detectErrorBoundary(route),\n });\n } else {\n mapRouteProperties = defaultMapRouteProperties;\n }\n\n let dataRoutes = convertRoutesToDataRoutes(\n routes,\n mapRouteProperties,\n undefined,\n manifest\n );\n\n /**\n * The query() method is intended for document requests, in which we want to\n * call an optional action and potentially multiple loaders for all nested\n * routes. It returns a StaticHandlerContext object, which is very similar\n * to the router state (location, loaderData, actionData, errors, etc.) and\n * also adds SSR-specific information such as the statusCode and headers\n * from action/loaders Responses.\n *\n * It _should_ never throw and should report all errors through the\n * returned context.errors object, properly associating errors to their error\n * boundary. Additionally, it tracks _deepestRenderedBoundaryId which can be\n * used to emulate React error boundaries during SSr by performing a second\n * pass only down to the boundaryId.\n *\n * The one exception where we do not return a StaticHandlerContext is when a\n * redirect response is returned or thrown from any action/loader. We\n * propagate that out and return the raw Response so the HTTP server can\n * return it directly.\n */\n async function query(\n request: Request,\n { requestContext }: { requestContext?: unknown } = {}\n ): Promise {\n let url = new URL(request.url);\n let method = request.method;\n let location = createLocation(\"\", createPath(url), null, \"default\");\n let matches = matchRoutes(dataRoutes, location, basename);\n\n // SSR supports HEAD requests while SPA doesn't\n if (!isValidMethod(method) && method !== \"HEAD\") {\n let error = getInternalRouterError(405, { method });\n let { matches: methodNotAllowedMatches, route } =\n getShortCircuitMatches(dataRoutes);\n return {\n basename,\n location,\n matches: methodNotAllowedMatches,\n loaderData: {},\n actionData: null,\n errors: {\n [route.id]: error,\n },\n statusCode: error.status,\n loaderHeaders: {},\n actionHeaders: {},\n activeDeferreds: null,\n };\n } else if (!matches) {\n let error = getInternalRouterError(404, { pathname: location.pathname });\n let { matches: notFoundMatches, route } =\n getShortCircuitMatches(dataRoutes);\n return {\n basename,\n location,\n matches: notFoundMatches,\n loaderData: {},\n actionData: null,\n errors: {\n [route.id]: error,\n },\n statusCode: error.status,\n loaderHeaders: {},\n actionHeaders: {},\n activeDeferreds: null,\n };\n }\n\n let result = await queryImpl(request, location, matches, requestContext);\n if (isResponse(result)) {\n return result;\n }\n\n // When returning StaticHandlerContext, we patch back in the location here\n // since we need it for React Context. But this helps keep our submit and\n // loadRouteData operating on a Request instead of a Location\n return { location, basename, ...result };\n }\n\n /**\n * The queryRoute() method is intended for targeted route requests, either\n * for fetch ?_data requests or resource route requests. In this case, we\n * are only ever calling a single action or loader, and we are returning the\n * returned value directly. In most cases, this will be a Response returned\n * from the action/loader, but it may be a primitive or other value as well -\n * and in such cases the calling context should handle that accordingly.\n *\n * We do respect the throw/return differentiation, so if an action/loader\n * throws, then this method will throw the value. This is important so we\n * can do proper boundary identification in Remix where a thrown Response\n * must go to the Catch Boundary but a returned Response is happy-path.\n *\n * One thing to note is that any Router-initiated Errors that make sense\n * to associate with a status code will be thrown as an ErrorResponse\n * instance which include the raw Error, such that the calling context can\n * serialize the error as they see fit while including the proper response\n * code. Examples here are 404 and 405 errors that occur prior to reaching\n * any user-defined loaders.\n */\n async function queryRoute(\n request: Request,\n {\n routeId,\n requestContext,\n }: { requestContext?: unknown; routeId?: string } = {}\n ): Promise {\n let url = new URL(request.url);\n let method = request.method;\n let location = createLocation(\"\", createPath(url), null, \"default\");\n let matches = matchRoutes(dataRoutes, location, basename);\n\n // SSR supports HEAD requests while SPA doesn't\n if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n throw getInternalRouterError(405, { method });\n } else if (!matches) {\n throw getInternalRouterError(404, { pathname: location.pathname });\n }\n\n let match = routeId\n ? matches.find((m) => m.route.id === routeId)\n : getTargetMatch(matches, location);\n\n if (routeId && !match) {\n throw getInternalRouterError(403, {\n pathname: location.pathname,\n routeId,\n });\n } else if (!match) {\n // This should never hit I don't think?\n throw getInternalRouterError(404, { pathname: location.pathname });\n }\n\n let result = await queryImpl(\n request,\n location,\n matches,\n requestContext,\n match\n );\n if (isResponse(result)) {\n return result;\n }\n\n let error = result.errors ? Object.values(result.errors)[0] : undefined;\n if (error !== undefined) {\n // If we got back result.errors, that means the loader/action threw\n // _something_ that wasn't a Response, but it's not guaranteed/required\n // to be an `instanceof Error` either, so we have to use throw here to\n // preserve the \"error\" state outside of queryImpl.\n throw error;\n }\n\n // Pick off the right state value to return\n if (result.actionData) {\n return Object.values(result.actionData)[0];\n }\n\n if (result.loaderData) {\n let data = Object.values(result.loaderData)[0];\n if (result.activeDeferreds?.[match.route.id]) {\n data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n }\n return data;\n }\n\n return undefined;\n }\n\n async function queryImpl(\n request: Request,\n location: Location,\n matches: AgnosticDataRouteMatch[],\n requestContext: unknown,\n routeMatch?: AgnosticDataRouteMatch\n ): Promise | Response> {\n invariant(\n request.signal,\n \"query()/queryRoute() requests must contain an AbortController signal\"\n );\n\n try {\n if (isMutationMethod(request.method.toLowerCase())) {\n let result = await submit(\n request,\n matches,\n routeMatch || getTargetMatch(matches, location),\n requestContext,\n routeMatch != null\n );\n return result;\n }\n\n let result = await loadRouteData(\n request,\n matches,\n requestContext,\n routeMatch\n );\n return isResponse(result)\n ? result\n : {\n ...result,\n actionData: null,\n actionHeaders: {},\n };\n } catch (e) {\n // If the user threw/returned a Response in callLoaderOrAction, we throw\n // it to bail out and then return or throw here based on whether the user\n // returned or threw\n if (isQueryRouteResponse(e)) {\n if (e.type === ResultType.error) {\n throw e.response;\n }\n return e.response;\n }\n // Redirects are always returned since they don't propagate to catch\n // boundaries\n if (isRedirectResponse(e)) {\n return e;\n }\n throw e;\n }\n }\n\n async function submit(\n request: Request,\n matches: AgnosticDataRouteMatch[],\n actionMatch: AgnosticDataRouteMatch,\n requestContext: unknown,\n isRouteRequest: boolean\n ): Promise | Response> {\n let result: DataResult;\n\n if (!actionMatch.route.action && !actionMatch.route.lazy) {\n let error = getInternalRouterError(405, {\n method: request.method,\n pathname: new URL(request.url).pathname,\n routeId: actionMatch.route.id,\n });\n if (isRouteRequest) {\n throw error;\n }\n result = {\n type: ResultType.error,\n error,\n };\n } else {\n result = await callLoaderOrAction(\n \"action\",\n request,\n actionMatch,\n matches,\n manifest,\n mapRouteProperties,\n basename,\n { isStaticRequest: true, isRouteRequest, requestContext }\n );\n\n if (request.signal.aborted) {\n let method = isRouteRequest ? \"queryRoute\" : \"query\";\n throw new Error(\n `${method}() call aborted: ${request.method} ${request.url}`\n );\n }\n }\n\n if (isRedirectResult(result)) {\n // Uhhhh - this should never happen, we should always throw these from\n // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n // can get back on the \"throw all redirect responses\" train here should\n // this ever happen :/\n throw new Response(null, {\n status: result.status,\n headers: {\n Location: result.location,\n },\n });\n }\n\n if (isDeferredResult(result)) {\n let error = getInternalRouterError(400, { type: \"defer-action\" });\n if (isRouteRequest) {\n throw error;\n }\n result = {\n type: ResultType.error,\n error,\n };\n }\n\n if (isRouteRequest) {\n // Note: This should only be non-Response values if we get here, since\n // isRouteRequest should throw any Response received in callLoaderOrAction\n if (isErrorResult(result)) {\n throw result.error;\n }\n\n return {\n matches: [actionMatch],\n loaderData: {},\n actionData: { [actionMatch.route.id]: result.data },\n errors: null,\n // Note: statusCode + headers are unused here since queryRoute will\n // return the raw Response or value\n statusCode: 200,\n loaderHeaders: {},\n actionHeaders: {},\n activeDeferreds: null,\n };\n }\n\n if (isErrorResult(result)) {\n // Store off the pending error - we use it to determine which loaders\n // to call and will commit it when we complete the navigation\n let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n let context = await loadRouteData(\n request,\n matches,\n requestContext,\n undefined,\n {\n [boundaryMatch.route.id]: result.error,\n }\n );\n\n // action status codes take precedence over loader status codes\n return {\n ...context,\n statusCode: isRouteErrorResponse(result.error)\n ? result.error.status\n : 500,\n actionData: null,\n actionHeaders: {\n ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n },\n };\n }\n\n // Create a GET request for the loaders\n let loaderRequest = new Request(request.url, {\n headers: request.headers,\n redirect: request.redirect,\n signal: request.signal,\n });\n let context = await loadRouteData(loaderRequest, matches, requestContext);\n\n return {\n ...context,\n // action status codes take precedence over loader status codes\n ...(result.statusCode ? { statusCode: result.statusCode } : {}),\n actionData: {\n [actionMatch.route.id]: result.data,\n },\n actionHeaders: {\n ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n },\n };\n }\n\n async function loadRouteData(\n request: Request,\n matches: AgnosticDataRouteMatch[],\n requestContext: unknown,\n routeMatch?: AgnosticDataRouteMatch,\n pendingActionError?: RouteData\n ): Promise<\n | Omit<\n StaticHandlerContext,\n \"location\" | \"basename\" | \"actionData\" | \"actionHeaders\"\n >\n | Response\n > {\n let isRouteRequest = routeMatch != null;\n\n // Short circuit if we have no loaders to run (queryRoute())\n if (\n isRouteRequest &&\n !routeMatch?.route.loader &&\n !routeMatch?.route.lazy\n ) {\n throw getInternalRouterError(400, {\n method: request.method,\n pathname: new URL(request.url).pathname,\n routeId: routeMatch?.route.id,\n });\n }\n\n let requestMatches = routeMatch\n ? [routeMatch]\n : getLoaderMatchesUntilBoundary(\n matches,\n Object.keys(pendingActionError || {})[0]\n );\n let matchesToLoad = requestMatches.filter(\n (m) => m.route.loader || m.route.lazy\n );\n\n // Short circuit if we have no loaders to run (query())\n if (matchesToLoad.length === 0) {\n return {\n matches,\n // Add a null for all matched routes for proper revalidation on the client\n loaderData: matches.reduce(\n (acc, m) => Object.assign(acc, { [m.route.id]: null }),\n {}\n ),\n errors: pendingActionError || null,\n statusCode: 200,\n loaderHeaders: {},\n activeDeferreds: null,\n };\n }\n\n let results = await Promise.all([\n ...matchesToLoad.map((match) =>\n callLoaderOrAction(\n \"loader\",\n request,\n match,\n matches,\n manifest,\n mapRouteProperties,\n basename,\n { isStaticRequest: true, isRouteRequest, requestContext }\n )\n ),\n ]);\n\n if (request.signal.aborted) {\n let method = isRouteRequest ? \"queryRoute\" : \"query\";\n throw new Error(\n `${method}() call aborted: ${request.method} ${request.url}`\n );\n }\n\n // Process and commit output from loaders\n let activeDeferreds = new Map();\n let context = processRouteLoaderData(\n matches,\n matchesToLoad,\n results,\n pendingActionError,\n activeDeferreds\n );\n\n // Add a null for any non-loader matches for proper revalidation on the client\n let executedLoaders = new Set(\n matchesToLoad.map((match) => match.route.id)\n );\n matches.forEach((match) => {\n if (!executedLoaders.has(match.route.id)) {\n context.loaderData[match.route.id] = null;\n }\n });\n\n return {\n ...context,\n matches,\n activeDeferreds:\n activeDeferreds.size > 0\n ? Object.fromEntries(activeDeferreds.entries())\n : null,\n };\n }\n\n return {\n dataRoutes,\n query,\n queryRoute,\n };\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nexport function getStaticContextFromError(\n routes: AgnosticDataRouteObject[],\n context: StaticHandlerContext,\n error: any\n) {\n let newContext: StaticHandlerContext = {\n ...context,\n statusCode: 500,\n errors: {\n [context._deepestRenderedBoundaryId || routes[0].id]: error,\n },\n };\n return newContext;\n}\n\nfunction isSubmissionNavigation(\n opts: BaseNavigateOrFetchOptions\n): opts is SubmissionNavigateOptions {\n return (\n opts != null &&\n ((\"formData\" in opts && opts.formData != null) ||\n (\"body\" in opts && opts.body !== undefined))\n );\n}\n\nfunction normalizeTo(\n location: Path,\n matches: AgnosticDataRouteMatch[],\n basename: string,\n prependBasename: boolean,\n to: To | null,\n fromRouteId?: string,\n relative?: RelativeRoutingType\n) {\n let contextualMatches: AgnosticDataRouteMatch[];\n let activeRouteMatch: AgnosticDataRouteMatch | undefined;\n if (fromRouteId) {\n // Grab matches up to the calling route so our route-relative logic is\n // relative to the correct source route\n contextualMatches = [];\n for (let match of matches) {\n contextualMatches.push(match);\n if (match.route.id === fromRouteId) {\n activeRouteMatch = match;\n break;\n }\n }\n } else {\n contextualMatches = matches;\n activeRouteMatch = matches[matches.length - 1];\n }\n\n // Resolve the relative path\n let path = resolveTo(\n to ? to : \".\",\n getPathContributingMatches(contextualMatches).map((m) => m.pathnameBase),\n stripBasename(location.pathname, basename) || location.pathname,\n relative === \"path\"\n );\n\n // When `to` is not specified we inherit search/hash from the current\n // location, unlike when to=\".\" and we just inherit the path.\n // See https://github.com/remix-run/remix/issues/927\n if (to == null) {\n path.search = location.search;\n path.hash = location.hash;\n }\n\n // Add an ?index param for matched index routes if we don't already have one\n if (\n (to == null || to === \"\" || to === \".\") &&\n activeRouteMatch &&\n activeRouteMatch.route.index &&\n !hasNakedIndexQuery(path.search)\n ) {\n path.search = path.search\n ? path.search.replace(/^\\?/, \"?index&\")\n : \"?index\";\n }\n\n // If we're operating within a basename, prepend it to the pathname. If\n // this is a root navigation, then just use the raw basename which allows\n // the basename to have full control over the presence of a trailing slash\n // on root actions\n if (prependBasename && basename !== \"/\") {\n path.pathname =\n path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n }\n\n return createPath(path);\n}\n\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(\n normalizeFormMethod: boolean,\n isFetcher: boolean,\n path: string,\n opts?: BaseNavigateOrFetchOptions\n): {\n path: string;\n submission?: Submission;\n error?: ErrorResponseImpl;\n} {\n // Return location verbatim on non-submission navigations\n if (!opts || !isSubmissionNavigation(opts)) {\n return { path };\n }\n\n if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n return {\n path,\n error: getInternalRouterError(405, { method: opts.formMethod }),\n };\n }\n\n let getInvalidBodyError = () => ({\n path,\n error: getInternalRouterError(400, { type: \"invalid-body\" }),\n });\n\n // Create a Submission on non-GET navigations\n let rawFormMethod = opts.formMethod || \"get\";\n let formMethod = normalizeFormMethod\n ? (rawFormMethod.toUpperCase() as V7_FormMethod)\n : (rawFormMethod.toLowerCase() as FormMethod);\n let formAction = stripHashFromPath(path);\n\n if (opts.body !== undefined) {\n if (opts.formEncType === \"text/plain\") {\n // text only support POST/PUT/PATCH/DELETE submissions\n if (!isMutationMethod(formMethod)) {\n return getInvalidBodyError();\n }\n\n let text =\n typeof opts.body === \"string\"\n ? opts.body\n : opts.body instanceof FormData ||\n opts.body instanceof URLSearchParams\n ? // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n Array.from(opts.body.entries()).reduce(\n (acc, [name, value]) => `${acc}${name}=${value}\\n`,\n \"\"\n )\n : String(opts.body);\n\n return {\n path,\n submission: {\n formMethod,\n formAction,\n formEncType: opts.formEncType,\n formData: undefined,\n json: undefined,\n text,\n },\n };\n } else if (opts.formEncType === \"application/json\") {\n // json only supports POST/PUT/PATCH/DELETE submissions\n if (!isMutationMethod(formMethod)) {\n return getInvalidBodyError();\n }\n\n try {\n let json =\n typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n\n return {\n path,\n submission: {\n formMethod,\n formAction,\n formEncType: opts.formEncType,\n formData: undefined,\n json,\n text: undefined,\n },\n };\n } catch (e) {\n return getInvalidBodyError();\n }\n }\n }\n\n invariant(\n typeof FormData === \"function\",\n \"FormData is not available in this environment\"\n );\n\n let searchParams: URLSearchParams;\n let formData: FormData;\n\n if (opts.formData) {\n searchParams = convertFormDataToSearchParams(opts.formData);\n formData = opts.formData;\n } else if (opts.body instanceof FormData) {\n searchParams = convertFormDataToSearchParams(opts.body);\n formData = opts.body;\n } else if (opts.body instanceof URLSearchParams) {\n searchParams = opts.body;\n formData = convertSearchParamsToFormData(searchParams);\n } else if (opts.body == null) {\n searchParams = new URLSearchParams();\n formData = new FormData();\n } else {\n try {\n searchParams = new URLSearchParams(opts.body);\n formData = convertSearchParamsToFormData(searchParams);\n } catch (e) {\n return getInvalidBodyError();\n }\n }\n\n let submission: Submission = {\n formMethod,\n formAction,\n formEncType:\n (opts && opts.formEncType) || \"application/x-www-form-urlencoded\",\n formData,\n json: undefined,\n text: undefined,\n };\n\n if (isMutationMethod(submission.formMethod)) {\n return { path, submission };\n }\n\n // Flatten submission onto URLSearchParams for GET submissions\n let parsedPath = parsePath(path);\n // On GET navigation submissions we can drop the ?index param from the\n // resulting location since all loaders will run. But fetcher GET submissions\n // only run a single loader so we need to preserve any incoming ?index params\n if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n searchParams.append(\"index\", \"\");\n }\n parsedPath.search = `?${searchParams}`;\n\n return { path: createPath(parsedPath), submission };\n}\n\n// Filter out all routes below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(\n matches: AgnosticDataRouteMatch[],\n boundaryId?: string\n) {\n let boundaryMatches = matches;\n if (boundaryId) {\n let index = matches.findIndex((m) => m.route.id === boundaryId);\n if (index >= 0) {\n boundaryMatches = matches.slice(0, index);\n }\n }\n return boundaryMatches;\n}\n\nfunction getMatchesToLoad(\n history: History,\n state: RouterState,\n matches: AgnosticDataRouteMatch[],\n submission: Submission | undefined,\n location: Location,\n isRevalidationRequired: boolean,\n cancelledDeferredRoutes: string[],\n cancelledFetcherLoads: string[],\n fetchLoadMatches: Map,\n fetchRedirectIds: Set,\n routesToUse: AgnosticDataRouteObject[],\n basename: string | undefined,\n pendingActionData?: RouteData,\n pendingError?: RouteData\n): [AgnosticDataRouteMatch[], RevalidatingFetcher[]] {\n let actionResult = pendingError\n ? Object.values(pendingError)[0]\n : pendingActionData\n ? Object.values(pendingActionData)[0]\n : undefined;\n\n let currentUrl = history.createURL(state.location);\n let nextUrl = history.createURL(location);\n\n // Pick navigation matches that are net-new or qualify for revalidation\n let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;\n let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);\n\n let navigationMatches = boundaryMatches.filter((match, index) => {\n if (match.route.lazy) {\n // We haven't loaded this route yet so we don't know if it's got a loader!\n return true;\n }\n if (match.route.loader == null) {\n return false;\n }\n\n // Always call the loader on new route instances and pending defer cancellations\n if (\n isNewLoader(state.loaderData, state.matches[index], match) ||\n cancelledDeferredRoutes.some((id) => id === match.route.id)\n ) {\n return true;\n }\n\n // This is the default implementation for when we revalidate. If the route\n // provides it's own implementation, then we give them full control but\n // provide this value so they can leverage it if needed after they check\n // their own specific use cases\n let currentRouteMatch = state.matches[index];\n let nextRouteMatch = match;\n\n return shouldRevalidateLoader(match, {\n currentUrl,\n currentParams: currentRouteMatch.params,\n nextUrl,\n nextParams: nextRouteMatch.params,\n ...submission,\n actionResult,\n defaultShouldRevalidate:\n // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n isRevalidationRequired ||\n // Clicked the same link, resubmitted a GET form\n currentUrl.pathname + currentUrl.search ===\n nextUrl.pathname + nextUrl.search ||\n // Search params affect all loaders\n currentUrl.search !== nextUrl.search ||\n isNewRouteInstance(currentRouteMatch, nextRouteMatch),\n });\n });\n\n // Pick fetcher.loads that need to be revalidated\n let revalidatingFetchers: RevalidatingFetcher[] = [];\n fetchLoadMatches.forEach((f, key) => {\n // Don't revalidate if fetcher won't be present in the subsequent render\n if (!matches.some((m) => m.route.id === f.routeId)) {\n return;\n }\n\n let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n\n // If the fetcher path no longer matches, push it in with null matches so\n // we can trigger a 404 in callLoadersAndMaybeResolveData. Note this is\n // currently only a use-case for Remix HMR where the route tree can change\n // at runtime and remove a route previously loaded via a fetcher\n if (!fetcherMatches) {\n revalidatingFetchers.push({\n key,\n routeId: f.routeId,\n path: f.path,\n matches: null,\n match: null,\n controller: null,\n });\n return;\n }\n\n // Revalidating fetchers are decoupled from the route matches since they\n // load from a static href. They revalidate based on explicit revalidation\n // (submission, useRevalidator, or X-Remix-Revalidate)\n let fetcher = state.fetchers.get(key);\n let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n\n let shouldRevalidate = false;\n if (fetchRedirectIds.has(key)) {\n // Never trigger a revalidation of an actively redirecting fetcher\n shouldRevalidate = false;\n } else if (cancelledFetcherLoads.includes(key)) {\n // Always revalidate if the fetcher was cancelled\n shouldRevalidate = true;\n } else if (\n fetcher &&\n fetcher.state !== \"idle\" &&\n fetcher.data === undefined\n ) {\n // If the fetcher hasn't ever completed loading yet, then this isn't a\n // revalidation, it would just be a brand new load if an explicit\n // revalidation is required\n shouldRevalidate = isRevalidationRequired;\n } else {\n // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n // to explicit revalidations only\n shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {\n currentUrl,\n currentParams: state.matches[state.matches.length - 1].params,\n nextUrl,\n nextParams: matches[matches.length - 1].params,\n ...submission,\n actionResult,\n defaultShouldRevalidate: isRevalidationRequired,\n });\n }\n\n if (shouldRevalidate) {\n revalidatingFetchers.push({\n key,\n routeId: f.routeId,\n path: f.path,\n matches: fetcherMatches,\n match: fetcherMatch,\n controller: new AbortController(),\n });\n }\n });\n\n return [navigationMatches, revalidatingFetchers];\n}\n\nfunction isNewLoader(\n currentLoaderData: RouteData,\n currentMatch: AgnosticDataRouteMatch,\n match: AgnosticDataRouteMatch\n) {\n let isNew =\n // [a] -> [a, b]\n !currentMatch ||\n // [a, b] -> [a, c]\n match.route.id !== currentMatch.route.id;\n\n // Handle the case that we don't have data for a re-used route, potentially\n // from a prior error or from a cancelled pending deferred\n let isMissingData = currentLoaderData[match.route.id] === undefined;\n\n // Always load if this is a net-new route or we don't yet have data\n return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(\n currentMatch: AgnosticDataRouteMatch,\n match: AgnosticDataRouteMatch\n) {\n let currentPath = currentMatch.route.path;\n return (\n // param change for this match, /users/123 -> /users/456\n currentMatch.pathname !== match.pathname ||\n // splat param changed, which is not present in match.path\n // e.g. /files/images/avatar.jpg -> files/finances.xls\n (currentPath != null &&\n currentPath.endsWith(\"*\") &&\n currentMatch.params[\"*\"] !== match.params[\"*\"])\n );\n}\n\nfunction shouldRevalidateLoader(\n loaderMatch: AgnosticDataRouteMatch,\n arg: ShouldRevalidateFunctionArgs\n) {\n if (loaderMatch.route.shouldRevalidate) {\n let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n if (typeof routeChoice === \"boolean\") {\n return routeChoice;\n }\n }\n\n return arg.defaultShouldRevalidate;\n}\n\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(\n route: AgnosticDataRouteObject,\n mapRouteProperties: MapRoutePropertiesFunction,\n manifest: RouteManifest\n) {\n if (!route.lazy) {\n return;\n }\n\n let lazyRoute = await route.lazy();\n\n // If the lazy route function was executed and removed by another parallel\n // call then we can return - first lazy() to finish wins because the return\n // value of lazy is expected to be static\n if (!route.lazy) {\n return;\n }\n\n let routeToUpdate = manifest[route.id];\n invariant(routeToUpdate, \"No route found in manifest\");\n\n // Update the route in place. This should be safe because there's no way\n // we could yet be sitting on this route as we can't get there without\n // resolving lazy() first.\n //\n // This is different than the HMR \"update\" use-case where we may actively be\n // on the route being updated. The main concern boils down to \"does this\n // mutation affect any ongoing navigations or any current state.matches\n // values?\". If not, it should be safe to update in place.\n let routeUpdates: Record = {};\n for (let lazyRouteProperty in lazyRoute) {\n let staticRouteValue =\n routeToUpdate[lazyRouteProperty as keyof typeof routeToUpdate];\n\n let isPropertyStaticallyDefined =\n staticRouteValue !== undefined &&\n // This property isn't static since it should always be updated based\n // on the route updates\n lazyRouteProperty !== \"hasErrorBoundary\";\n\n warning(\n !isPropertyStaticallyDefined,\n `Route \"${routeToUpdate.id}\" has a static property \"${lazyRouteProperty}\" ` +\n `defined but its lazy function is also returning a value for this property. ` +\n `The lazy route property \"${lazyRouteProperty}\" will be ignored.`\n );\n\n if (\n !isPropertyStaticallyDefined &&\n !immutableRouteKeys.has(lazyRouteProperty as ImmutableRouteKey)\n ) {\n routeUpdates[lazyRouteProperty] =\n lazyRoute[lazyRouteProperty as keyof typeof lazyRoute];\n }\n }\n\n // Mutate the route with the provided updates. Do this first so we pass\n // the updated version to mapRouteProperties\n Object.assign(routeToUpdate, routeUpdates);\n\n // Mutate the `hasErrorBoundary` property on the route based on the route\n // updates and remove the `lazy` function so we don't resolve the lazy\n // route again.\n Object.assign(routeToUpdate, {\n // To keep things framework agnostic, we use the provided\n // `mapRouteProperties` (or wrapped `detectErrorBoundary`) function to\n // set the framework-aware properties (`element`/`hasErrorBoundary`) since\n // the logic will differ between frameworks.\n ...mapRouteProperties(routeToUpdate),\n lazy: undefined,\n });\n}\n\nasync function callLoaderOrAction(\n type: \"loader\" | \"action\",\n request: Request,\n match: AgnosticDataRouteMatch,\n matches: AgnosticDataRouteMatch[],\n manifest: RouteManifest,\n mapRouteProperties: MapRoutePropertiesFunction,\n basename: string,\n opts: {\n isStaticRequest?: boolean;\n isRouteRequest?: boolean;\n requestContext?: unknown;\n } = {}\n): Promise {\n let resultType;\n let result;\n let onReject: (() => void) | undefined;\n\n let runHandler = (handler: ActionFunction | LoaderFunction) => {\n // Setup a promise we can race against so that abort signals short circuit\n let reject: () => void;\n let abortPromise = new Promise((_, r) => (reject = r));\n onReject = () => reject();\n request.signal.addEventListener(\"abort\", onReject);\n return Promise.race([\n handler({\n request,\n params: match.params,\n context: opts.requestContext,\n }),\n abortPromise,\n ]);\n };\n\n try {\n let handler = match.route[type];\n\n if (match.route.lazy) {\n if (handler) {\n // Run statically defined handler in parallel with lazy()\n let handlerError;\n let values = await Promise.all([\n // If the handler throws, don't let it immediately bubble out,\n // since we need to let the lazy() execution finish so we know if this\n // route has a boundary that can handle the error\n runHandler(handler).catch((e) => {\n handlerError = e;\n }),\n loadLazyRouteModule(match.route, mapRouteProperties, manifest),\n ]);\n if (handlerError) {\n throw handlerError;\n }\n result = values[0];\n } else {\n // Load lazy route module, then run any returned handler\n await loadLazyRouteModule(match.route, mapRouteProperties, manifest);\n\n handler = match.route[type];\n if (handler) {\n // Handler still run even if we got interrupted to maintain consistency\n // with un-abortable behavior of handler execution on non-lazy or\n // previously-lazy-loaded routes\n result = await runHandler(handler);\n } else if (type === \"action\") {\n let url = new URL(request.url);\n let pathname = url.pathname + url.search;\n throw getInternalRouterError(405, {\n method: request.method,\n pathname,\n routeId: match.route.id,\n });\n } else {\n // lazy() route has no loader to run. Short circuit here so we don't\n // hit the invariant below that errors on returning undefined.\n return { type: ResultType.data, data: undefined };\n }\n }\n } else if (!handler) {\n let url = new URL(request.url);\n let pathname = url.pathname + url.search;\n throw getInternalRouterError(404, {\n pathname,\n });\n } else {\n result = await runHandler(handler);\n }\n\n invariant(\n result !== undefined,\n `You defined ${type === \"action\" ? \"an action\" : \"a loader\"} for route ` +\n `\"${match.route.id}\" but didn't return anything from your \\`${type}\\` ` +\n `function. Please return a value or \\`null\\`.`\n );\n } catch (e) {\n resultType = ResultType.error;\n result = e;\n } finally {\n if (onReject) {\n request.signal.removeEventListener(\"abort\", onReject);\n }\n }\n\n if (isResponse(result)) {\n let status = result.status;\n\n // Process redirects\n if (redirectStatusCodes.has(status)) {\n let location = result.headers.get(\"Location\");\n invariant(\n location,\n \"Redirects returned/thrown from loaders/actions must have a Location header\"\n );\n\n // Support relative routing in internal redirects\n if (!ABSOLUTE_URL_REGEX.test(location)) {\n location = normalizeTo(\n new URL(request.url),\n matches.slice(0, matches.indexOf(match) + 1),\n basename,\n true,\n location\n );\n } else if (!opts.isStaticRequest) {\n // Strip off the protocol+origin for same-origin + same-basename absolute\n // redirects. If this is a static request, we can let it go back to the\n // browser as-is\n let currentUrl = new URL(request.url);\n let url = location.startsWith(\"//\")\n ? new URL(currentUrl.protocol + location)\n : new URL(location);\n let isSameBasename = stripBasename(url.pathname, basename) != null;\n if (url.origin === currentUrl.origin && isSameBasename) {\n location = url.pathname + url.search + url.hash;\n }\n }\n\n // Don't process redirects in the router during static requests requests.\n // Instead, throw the Response and let the server handle it with an HTTP\n // redirect. We also update the Location header in place in this flow so\n // basename and relative routing is taken into account\n if (opts.isStaticRequest) {\n result.headers.set(\"Location\", location);\n throw result;\n }\n\n return {\n type: ResultType.redirect,\n status,\n location,\n revalidate: result.headers.get(\"X-Remix-Revalidate\") !== null,\n reloadDocument: result.headers.get(\"X-Remix-Reload-Document\") !== null,\n };\n }\n\n // For SSR single-route requests, we want to hand Responses back directly\n // without unwrapping. We do this with the QueryRouteResponse wrapper\n // interface so we can know whether it was returned or thrown\n if (opts.isRouteRequest) {\n let queryRouteResponse: QueryRouteResponse = {\n type:\n resultType === ResultType.error ? ResultType.error : ResultType.data,\n response: result,\n };\n throw queryRouteResponse;\n }\n\n let data: any;\n let contentType = result.headers.get(\"Content-Type\");\n // Check between word boundaries instead of startsWith() due to the last\n // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n data = await result.json();\n } else {\n data = await result.text();\n }\n\n if (resultType === ResultType.error) {\n return {\n type: resultType,\n error: new ErrorResponseImpl(status, result.statusText, data),\n headers: result.headers,\n };\n }\n\n return {\n type: ResultType.data,\n data,\n statusCode: result.status,\n headers: result.headers,\n };\n }\n\n if (resultType === ResultType.error) {\n return { type: resultType, error: result };\n }\n\n if (isDeferredData(result)) {\n return {\n type: ResultType.deferred,\n deferredData: result,\n statusCode: result.init?.status,\n headers: result.init?.headers && new Headers(result.init.headers),\n };\n }\n\n return { type: ResultType.data, data: result };\n}\n\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches. During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(\n history: History,\n location: string | Location,\n signal: AbortSignal,\n submission?: Submission\n): Request {\n let url = history.createURL(stripHashFromPath(location)).toString();\n let init: RequestInit = { signal };\n\n if (submission && isMutationMethod(submission.formMethod)) {\n let { formMethod, formEncType } = submission;\n // Didn't think we needed this but it turns out unlike other methods, patch\n // won't be properly normalized to uppercase and results in a 405 error.\n // See: https://fetch.spec.whatwg.org/#concept-method\n init.method = formMethod.toUpperCase();\n\n if (formEncType === \"application/json\") {\n init.headers = new Headers({ \"Content-Type\": formEncType });\n init.body = JSON.stringify(submission.json);\n } else if (formEncType === \"text/plain\") {\n // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n init.body = submission.text;\n } else if (\n formEncType === \"application/x-www-form-urlencoded\" &&\n submission.formData\n ) {\n // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n init.body = convertFormDataToSearchParams(submission.formData);\n } else {\n // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n init.body = submission.formData;\n }\n }\n\n return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData: FormData): URLSearchParams {\n let searchParams = new URLSearchParams();\n\n for (let [key, value] of formData.entries()) {\n // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n searchParams.append(key, typeof value === \"string\" ? value : value.name);\n }\n\n return searchParams;\n}\n\nfunction convertSearchParamsToFormData(\n searchParams: URLSearchParams\n): FormData {\n let formData = new FormData();\n for (let [key, value] of searchParams.entries()) {\n formData.append(key, value);\n }\n return formData;\n}\n\nfunction processRouteLoaderData(\n matches: AgnosticDataRouteMatch[],\n matchesToLoad: AgnosticDataRouteMatch[],\n results: DataResult[],\n pendingError: RouteData | undefined,\n activeDeferreds: Map\n): {\n loaderData: RouterState[\"loaderData\"];\n errors: RouterState[\"errors\"] | null;\n statusCode: number;\n loaderHeaders: Record;\n} {\n // Fill in loaderData/errors from our loaders\n let loaderData: RouterState[\"loaderData\"] = {};\n let errors: RouterState[\"errors\"] | null = null;\n let statusCode: number | undefined;\n let foundError = false;\n let loaderHeaders: Record = {};\n\n // Process loader results into state.loaderData/state.errors\n results.forEach((result, index) => {\n let id = matchesToLoad[index].route.id;\n invariant(\n !isRedirectResult(result),\n \"Cannot handle redirect results in processLoaderData\"\n );\n if (isErrorResult(result)) {\n // Look upwards from the matched route for the closest ancestor\n // error boundary, defaulting to the root match\n let boundaryMatch = findNearestBoundary(matches, id);\n let error = result.error;\n // If we have a pending action error, we report it at the highest-route\n // that throws a loader error, and then clear it out to indicate that\n // it was consumed\n if (pendingError) {\n error = Object.values(pendingError)[0];\n pendingError = undefined;\n }\n\n errors = errors || {};\n\n // Prefer higher error values if lower errors bubble to the same boundary\n if (errors[boundaryMatch.route.id] == null) {\n errors[boundaryMatch.route.id] = error;\n }\n\n // Clear our any prior loaderData for the throwing route\n loaderData[id] = undefined;\n\n // Once we find our first (highest) error, we set the status code and\n // prevent deeper status codes from overriding\n if (!foundError) {\n foundError = true;\n statusCode = isRouteErrorResponse(result.error)\n ? result.error.status\n : 500;\n }\n if (result.headers) {\n loaderHeaders[id] = result.headers;\n }\n } else {\n if (isDeferredResult(result)) {\n activeDeferreds.set(id, result.deferredData);\n loaderData[id] = result.deferredData.data;\n } else {\n loaderData[id] = result.data;\n }\n\n // Error status codes always override success status codes, but if all\n // loaders are successful we take the deepest status code.\n if (\n result.statusCode != null &&\n result.statusCode !== 200 &&\n !foundError\n ) {\n statusCode = result.statusCode;\n }\n if (result.headers) {\n loaderHeaders[id] = result.headers;\n }\n }\n });\n\n // If we didn't consume the pending action error (i.e., all loaders\n // resolved), then consume it here. Also clear out any loaderData for the\n // throwing route\n if (pendingError) {\n errors = pendingError;\n loaderData[Object.keys(pendingError)[0]] = undefined;\n }\n\n return {\n loaderData,\n errors,\n statusCode: statusCode || 200,\n loaderHeaders,\n };\n}\n\nfunction processLoaderData(\n state: RouterState,\n matches: AgnosticDataRouteMatch[],\n matchesToLoad: AgnosticDataRouteMatch[],\n results: DataResult[],\n pendingError: RouteData | undefined,\n revalidatingFetchers: RevalidatingFetcher[],\n fetcherResults: DataResult[],\n activeDeferreds: Map\n): {\n loaderData: RouterState[\"loaderData\"];\n errors?: RouterState[\"errors\"];\n} {\n let { loaderData, errors } = processRouteLoaderData(\n matches,\n matchesToLoad,\n results,\n pendingError,\n activeDeferreds\n );\n\n // Process results from our revalidating fetchers\n for (let index = 0; index < revalidatingFetchers.length; index++) {\n let { key, match, controller } = revalidatingFetchers[index];\n invariant(\n fetcherResults !== undefined && fetcherResults[index] !== undefined,\n \"Did not find corresponding fetcher result\"\n );\n let result = fetcherResults[index];\n\n // Process fetcher non-redirect errors\n if (controller && controller.signal.aborted) {\n // Nothing to do for aborted fetchers\n continue;\n } else if (isErrorResult(result)) {\n let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);\n if (!(errors && errors[boundaryMatch.route.id])) {\n errors = {\n ...errors,\n [boundaryMatch.route.id]: result.error,\n };\n }\n state.fetchers.delete(key);\n } else if (isRedirectResult(result)) {\n // Should never get here, redirects should get processed above, but we\n // keep this to type narrow to a success result in the else\n invariant(false, \"Unhandled fetcher revalidation redirect\");\n } else if (isDeferredResult(result)) {\n // Should never get here, deferred data should be awaited for fetchers\n // in resolveDeferredResults\n invariant(false, \"Unhandled fetcher deferred data\");\n } else {\n let doneFetcher = getDoneFetcher(result.data);\n state.fetchers.set(key, doneFetcher);\n }\n }\n\n return { loaderData, errors };\n}\n\nfunction mergeLoaderData(\n loaderData: RouteData,\n newLoaderData: RouteData,\n matches: AgnosticDataRouteMatch[],\n errors: RouteData | null | undefined\n): RouteData {\n let mergedLoaderData = { ...newLoaderData };\n for (let match of matches) {\n let id = match.route.id;\n if (newLoaderData.hasOwnProperty(id)) {\n if (newLoaderData[id] !== undefined) {\n mergedLoaderData[id] = newLoaderData[id];\n } else {\n // No-op - this is so we ignore existing data if we have a key in the\n // incoming object with an undefined value, which is how we unset a prior\n // loaderData if we encounter a loader error\n }\n } else if (loaderData[id] !== undefined && match.route.loader) {\n // Preserve existing keys not included in newLoaderData and where a loader\n // wasn't removed by HMR\n mergedLoaderData[id] = loaderData[id];\n }\n\n if (errors && errors.hasOwnProperty(id)) {\n // Don't keep any loader data below the boundary\n break;\n }\n }\n return mergedLoaderData;\n}\n\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(\n matches: AgnosticDataRouteMatch[],\n routeId?: string\n): AgnosticDataRouteMatch {\n let eligibleMatches = routeId\n ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1)\n : [...matches];\n return (\n eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) ||\n matches[0]\n );\n}\n\nfunction getShortCircuitMatches(routes: AgnosticDataRouteObject[]): {\n matches: AgnosticDataRouteMatch[];\n route: AgnosticDataRouteObject;\n} {\n // Prefer a root layout route if present, otherwise shim in a route object\n let route =\n routes.length === 1\n ? routes[0]\n : routes.find((r) => r.index || !r.path || r.path === \"/\") || {\n id: `__shim-error-route__`,\n };\n\n return {\n matches: [\n {\n params: {},\n pathname: \"\",\n pathnameBase: \"\",\n route,\n },\n ],\n route,\n };\n}\n\nfunction getInternalRouterError(\n status: number,\n {\n pathname,\n routeId,\n method,\n type,\n }: {\n pathname?: string;\n routeId?: string;\n method?: string;\n type?: \"defer-action\" | \"invalid-body\";\n } = {}\n) {\n let statusText = \"Unknown Server Error\";\n let errorMessage = \"Unknown @remix-run/router error\";\n\n if (status === 400) {\n statusText = \"Bad Request\";\n if (method && pathname && routeId) {\n errorMessage =\n `You made a ${method} request to \"${pathname}\" but ` +\n `did not provide a \\`loader\\` for route \"${routeId}\", ` +\n `so there is no way to handle the request.`;\n } else if (type === \"defer-action\") {\n errorMessage = \"defer() is not supported in actions\";\n } else if (type === \"invalid-body\") {\n errorMessage = \"Unable to encode submission body\";\n }\n } else if (status === 403) {\n statusText = \"Forbidden\";\n errorMessage = `Route \"${routeId}\" does not match URL \"${pathname}\"`;\n } else if (status === 404) {\n statusText = \"Not Found\";\n errorMessage = `No route matches URL \"${pathname}\"`;\n } else if (status === 405) {\n statusText = \"Method Not Allowed\";\n if (method && pathname && routeId) {\n errorMessage =\n `You made a ${method.toUpperCase()} request to \"${pathname}\" but ` +\n `did not provide an \\`action\\` for route \"${routeId}\", ` +\n `so there is no way to handle the request.`;\n } else if (method) {\n errorMessage = `Invalid request method \"${method.toUpperCase()}\"`;\n }\n }\n\n return new ErrorResponseImpl(\n status || 500,\n statusText,\n new Error(errorMessage),\n true\n );\n}\n\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(\n results: DataResult[]\n): { result: RedirectResult; idx: number } | undefined {\n for (let i = results.length - 1; i >= 0; i--) {\n let result = results[i];\n if (isRedirectResult(result)) {\n return { result, idx: i };\n }\n }\n}\n\nfunction stripHashFromPath(path: To) {\n let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n return createPath({ ...parsedPath, hash: \"\" });\n}\n\nfunction isHashChangeOnly(a: Location, b: Location): boolean {\n if (a.pathname !== b.pathname || a.search !== b.search) {\n return false;\n }\n\n if (a.hash === \"\") {\n // /page -> /page#hash\n return b.hash !== \"\";\n } else if (a.hash === b.hash) {\n // /page#hash -> /page#hash\n return true;\n } else if (b.hash !== \"\") {\n // /page#hash -> /page#other\n return true;\n }\n\n // If the hash is removed the browser will re-perform a request to the server\n // /page#hash -> /page\n return false;\n}\n\nfunction isDeferredResult(result: DataResult): result is DeferredResult {\n return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result: DataResult): result is ErrorResult {\n return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result?: DataResult): result is RedirectResult {\n return (result && result.type) === ResultType.redirect;\n}\n\nexport function isDeferredData(value: any): value is DeferredData {\n let deferred: DeferredData = value;\n return (\n deferred &&\n typeof deferred === \"object\" &&\n typeof deferred.data === \"object\" &&\n typeof deferred.subscribe === \"function\" &&\n typeof deferred.cancel === \"function\" &&\n typeof deferred.resolveData === \"function\"\n );\n}\n\nfunction isResponse(value: any): value is Response {\n return (\n value != null &&\n typeof value.status === \"number\" &&\n typeof value.statusText === \"string\" &&\n typeof value.headers === \"object\" &&\n typeof value.body !== \"undefined\"\n );\n}\n\nfunction isRedirectResponse(result: any): result is Response {\n if (!isResponse(result)) {\n return false;\n }\n\n let status = result.status;\n let location = result.headers.get(\"Location\");\n return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isQueryRouteResponse(obj: any): obj is QueryRouteResponse {\n return (\n obj &&\n isResponse(obj.response) &&\n (obj.type === ResultType.data || obj.type === ResultType.error)\n );\n}\n\nfunction isValidMethod(method: string): method is FormMethod | V7_FormMethod {\n return validRequestMethods.has(method.toLowerCase() as FormMethod);\n}\n\nfunction isMutationMethod(\n method: string\n): method is MutationFormMethod | V7_MutationFormMethod {\n return validMutationMethods.has(method.toLowerCase() as MutationFormMethod);\n}\n\nasync function resolveDeferredResults(\n currentMatches: AgnosticDataRouteMatch[],\n matchesToLoad: (AgnosticDataRouteMatch | null)[],\n results: DataResult[],\n signals: (AbortSignal | null)[],\n isFetcher: boolean,\n currentLoaderData?: RouteData\n) {\n for (let index = 0; index < results.length; index++) {\n let result = results[index];\n let match = matchesToLoad[index];\n // If we don't have a match, then we can have a deferred result to do\n // anything with. This is for revalidating fetchers where the route was\n // removed during HMR\n if (!match) {\n continue;\n }\n\n let currentMatch = currentMatches.find(\n (m) => m.route.id === match!.route.id\n );\n let isRevalidatingLoader =\n currentMatch != null &&\n !isNewRouteInstance(currentMatch, match) &&\n (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n\n if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {\n // Note: we do not have to touch activeDeferreds here since we race them\n // against the signal in resolveDeferredData and they'll get aborted\n // there if needed\n let signal = signals[index];\n invariant(\n signal,\n \"Expected an AbortSignal for revalidating fetcher deferred result\"\n );\n await resolveDeferredData(result, signal, isFetcher).then((result) => {\n if (result) {\n results[index] = result || results[index];\n }\n });\n }\n }\n}\n\nasync function resolveDeferredData(\n result: DeferredResult,\n signal: AbortSignal,\n unwrap = false\n): Promise {\n let aborted = await result.deferredData.resolveData(signal);\n if (aborted) {\n return;\n }\n\n if (unwrap) {\n try {\n return {\n type: ResultType.data,\n data: result.deferredData.unwrappedData,\n };\n } catch (e) {\n // Handle any TrackedPromise._error values encountered while unwrapping\n return {\n type: ResultType.error,\n error: e,\n };\n }\n }\n\n return {\n type: ResultType.data,\n data: result.deferredData.data,\n };\n}\n\nfunction hasNakedIndexQuery(search: string): boolean {\n return new URLSearchParams(search).getAll(\"index\").some((v) => v === \"\");\n}\n\nfunction getTargetMatch(\n matches: AgnosticDataRouteMatch[],\n location: Location | string\n) {\n let search =\n typeof location === \"string\" ? parsePath(location).search : location.search;\n if (\n matches[matches.length - 1].route.index &&\n hasNakedIndexQuery(search || \"\")\n ) {\n // Return the leaf index route when index is present\n return matches[matches.length - 1];\n }\n // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n // pathless layout routes)\n let pathMatches = getPathContributingMatches(matches);\n return pathMatches[pathMatches.length - 1];\n}\n\nfunction getSubmissionFromNavigation(\n navigation: Navigation\n): Submission | undefined {\n let { formMethod, formAction, formEncType, text, formData, json } =\n navigation;\n if (!formMethod || !formAction || !formEncType) {\n return;\n }\n\n if (text != null) {\n return {\n formMethod,\n formAction,\n formEncType,\n formData: undefined,\n json: undefined,\n text,\n };\n } else if (formData != null) {\n return {\n formMethod,\n formAction,\n formEncType,\n formData,\n json: undefined,\n text: undefined,\n };\n } else if (json !== undefined) {\n return {\n formMethod,\n formAction,\n formEncType,\n formData: undefined,\n json,\n text: undefined,\n };\n }\n}\n\nfunction getLoadingNavigation(\n location: Location,\n submission?: Submission\n): NavigationStates[\"Loading\"] {\n if (submission) {\n let navigation: NavigationStates[\"Loading\"] = {\n state: \"loading\",\n location,\n formMethod: submission.formMethod,\n formAction: submission.formAction,\n formEncType: submission.formEncType,\n formData: submission.formData,\n json: submission.json,\n text: submission.text,\n };\n return navigation;\n } else {\n let navigation: NavigationStates[\"Loading\"] = {\n state: \"loading\",\n location,\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n };\n return navigation;\n }\n}\n\nfunction getSubmittingNavigation(\n location: Location,\n submission: Submission\n): NavigationStates[\"Submitting\"] {\n let navigation: NavigationStates[\"Submitting\"] = {\n state: \"submitting\",\n location,\n formMethod: submission.formMethod,\n formAction: submission.formAction,\n formEncType: submission.formEncType,\n formData: submission.formData,\n json: submission.json,\n text: submission.text,\n };\n return navigation;\n}\n\nfunction getLoadingFetcher(\n submission?: Submission,\n data?: Fetcher[\"data\"]\n): FetcherStates[\"Loading\"] {\n if (submission) {\n let fetcher: FetcherStates[\"Loading\"] = {\n state: \"loading\",\n formMethod: submission.formMethod,\n formAction: submission.formAction,\n formEncType: submission.formEncType,\n formData: submission.formData,\n json: submission.json,\n text: submission.text,\n data,\n };\n return fetcher;\n } else {\n let fetcher: FetcherStates[\"Loading\"] = {\n state: \"loading\",\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n data,\n };\n return fetcher;\n }\n}\n\nfunction getSubmittingFetcher(\n submission: Submission,\n existingFetcher?: Fetcher\n): FetcherStates[\"Submitting\"] {\n let fetcher: FetcherStates[\"Submitting\"] = {\n state: \"submitting\",\n formMethod: submission.formMethod,\n formAction: submission.formAction,\n formEncType: submission.formEncType,\n formData: submission.formData,\n json: submission.json,\n text: submission.text,\n data: existingFetcher ? existingFetcher.data : undefined,\n };\n return fetcher;\n}\n\nfunction getDoneFetcher(data: Fetcher[\"data\"]): FetcherStates[\"Idle\"] {\n let fetcher: FetcherStates[\"Idle\"] = {\n state: \"idle\",\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n data,\n };\n return fetcher;\n}\n\nfunction restoreAppliedTransitions(\n _window: Window,\n transitions: Map>\n) {\n try {\n let sessionPositions = _window.sessionStorage.getItem(\n TRANSITIONS_STORAGE_KEY\n );\n if (sessionPositions) {\n let json = JSON.parse(sessionPositions);\n for (let [k, v] of Object.entries(json || {})) {\n if (v && Array.isArray(v)) {\n transitions.set(k, new Set(v || []));\n }\n }\n }\n } catch (e) {\n // no-op, use default empty object\n }\n}\n\nfunction persistAppliedTransitions(\n _window: Window,\n transitions: Map>\n) {\n if (transitions.size > 0) {\n let json: Record = {};\n for (let [k, v] of transitions) {\n json[k] = [...v];\n }\n try {\n _window.sessionStorage.setItem(\n TRANSITIONS_STORAGE_KEY,\n JSON.stringify(json)\n );\n } catch (error) {\n warning(\n false,\n `Failed to save applied view transitions in sessionStorage (${error}).`\n );\n }\n }\n}\n\n//#endregion\n","import * as React from \"react\";\nimport type {\n AgnosticIndexRouteObject,\n AgnosticNonIndexRouteObject,\n AgnosticRouteMatch,\n History,\n LazyRouteFunction,\n Location,\n Action as NavigationType,\n RelativeRoutingType,\n Router,\n StaticHandlerContext,\n To,\n TrackedPromise,\n} from \"@remix-run/router\";\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nexport interface IndexRouteObject {\n caseSensitive?: AgnosticIndexRouteObject[\"caseSensitive\"];\n path?: AgnosticIndexRouteObject[\"path\"];\n id?: AgnosticIndexRouteObject[\"id\"];\n loader?: AgnosticIndexRouteObject[\"loader\"];\n action?: AgnosticIndexRouteObject[\"action\"];\n hasErrorBoundary?: AgnosticIndexRouteObject[\"hasErrorBoundary\"];\n shouldRevalidate?: AgnosticIndexRouteObject[\"shouldRevalidate\"];\n handle?: AgnosticIndexRouteObject[\"handle\"];\n index: true;\n children?: undefined;\n element?: React.ReactNode | null;\n errorElement?: React.ReactNode | null;\n Component?: React.ComponentType | null;\n ErrorBoundary?: React.ComponentType | null;\n lazy?: LazyRouteFunction;\n}\n\nexport interface NonIndexRouteObject {\n caseSensitive?: AgnosticNonIndexRouteObject[\"caseSensitive\"];\n path?: AgnosticNonIndexRouteObject[\"path\"];\n id?: AgnosticNonIndexRouteObject[\"id\"];\n loader?: AgnosticNonIndexRouteObject[\"loader\"];\n action?: AgnosticNonIndexRouteObject[\"action\"];\n hasErrorBoundary?: AgnosticNonIndexRouteObject[\"hasErrorBoundary\"];\n shouldRevalidate?: AgnosticNonIndexRouteObject[\"shouldRevalidate\"];\n handle?: AgnosticNonIndexRouteObject[\"handle\"];\n index?: false;\n children?: RouteObject[];\n element?: React.ReactNode | null;\n errorElement?: React.ReactNode | null;\n Component?: React.ComponentType | null;\n ErrorBoundary?: React.ComponentType | null;\n lazy?: LazyRouteFunction;\n}\n\nexport type RouteObject = IndexRouteObject | NonIndexRouteObject;\n\nexport type DataRouteObject = RouteObject & {\n children?: DataRouteObject[];\n id: string;\n};\n\nexport interface RouteMatch<\n ParamKey extends string = string,\n RouteObjectType extends RouteObject = RouteObject\n> extends AgnosticRouteMatch {}\n\nexport interface DataRouteMatch extends RouteMatch {}\n\nexport interface DataRouterContextObject extends NavigationContextObject {\n router: Router;\n staticContext?: StaticHandlerContext;\n}\n\nexport const DataRouterContext =\n React.createContext(null);\nif (__DEV__) {\n DataRouterContext.displayName = \"DataRouter\";\n}\n\nexport const DataRouterStateContext = React.createContext<\n Router[\"state\"] | null\n>(null);\nif (__DEV__) {\n DataRouterStateContext.displayName = \"DataRouterState\";\n}\n\nexport const AwaitContext = React.createContext(null);\nif (__DEV__) {\n AwaitContext.displayName = \"Await\";\n}\n\nexport interface NavigateOptions {\n replace?: boolean;\n state?: any;\n preventScrollReset?: boolean;\n relative?: RelativeRoutingType;\n unstable_flushSync?: boolean;\n unstable_viewTransition?: boolean;\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level `` API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport interface Navigator {\n createHref: History[\"createHref\"];\n // Optional for backwards-compat with Router/HistoryRouter usage (edge case)\n encodeLocation?: History[\"encodeLocation\"];\n go: History[\"go\"];\n push(to: To, state?: any, opts?: NavigateOptions): void;\n replace(to: To, state?: any, opts?: NavigateOptions): void;\n}\n\ninterface NavigationContextObject {\n basename: string;\n navigator: Navigator;\n static: boolean;\n}\n\nexport const NavigationContext = React.createContext(\n null!\n);\n\nif (__DEV__) {\n NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n location: Location;\n navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext(\n null!\n);\n\nif (__DEV__) {\n LocationContext.displayName = \"Location\";\n}\n\nexport interface RouteContextObject {\n outlet: React.ReactElement | null;\n matches: RouteMatch[];\n isDataRoute: boolean;\n}\n\nexport const RouteContext = React.createContext({\n outlet: null,\n matches: [],\n isDataRoute: false,\n});\n\nif (__DEV__) {\n RouteContext.displayName = \"Route\";\n}\n\nexport const RouteErrorContext = React.createContext(null);\n\nif (__DEV__) {\n RouteErrorContext.displayName = \"RouteError\";\n}\n","import * as React from \"react\";\nimport type {\n Blocker,\n BlockerFunction,\n Location,\n ParamParseKey,\n Params,\n Path,\n PathMatch,\n PathPattern,\n RelativeRoutingType,\n Router as RemixRouter,\n RevalidationState,\n To,\n UIMatch,\n} from \"@remix-run/router\";\nimport {\n IDLE_BLOCKER,\n Action as NavigationType,\n UNSAFE_convertRouteMatchToUiMatch as convertRouteMatchToUiMatch,\n UNSAFE_getPathContributingMatches as getPathContributingMatches,\n UNSAFE_invariant as invariant,\n isRouteErrorResponse,\n joinPaths,\n matchPath,\n matchRoutes,\n parsePath,\n resolveTo,\n stripBasename,\n UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n DataRouteMatch,\n NavigateOptions,\n RouteContextObject,\n RouteMatch,\n RouteObject,\n} from \"./context\";\nimport {\n AwaitContext,\n DataRouterContext,\n DataRouterStateContext,\n LocationContext,\n NavigationContext,\n RouteContext,\n RouteErrorContext,\n} from \"./context\";\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\nexport function useHref(\n to: To,\n { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useHref() may be used only in the context of a component.`\n );\n\n let { basename, navigator } = React.useContext(NavigationContext);\n let { hash, pathname, search } = useResolvedPath(to, { relative });\n\n let joinedPathname = pathname;\n\n // If we're operating within a basename, prepend it to the pathname prior\n // to creating the href. If this is a root navigation, then just use the raw\n // basename which allows the basename to have full control over the presence\n // of a trailing slash on root links\n if (basename !== \"/\") {\n joinedPathname =\n pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n }\n\n return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a ``.\n *\n * @see https://reactrouter.com/hooks/use-in-router-context\n */\nexport function useInRouterContext(): boolean {\n return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/hooks/use-location\n */\nexport function useLocation(): Location {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useLocation() may be used only in the context of a component.`\n );\n\n return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\nexport function useNavigationType(): NavigationType {\n return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * ``.\n *\n * @see https://reactrouter.com/hooks/use-match\n */\nexport function useMatch<\n ParamKey extends ParamParseKey,\n Path extends string\n>(pattern: PathPattern | Path): PathMatch | null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useMatch() may be used only in the context of a component.`\n );\n\n let { pathname } = useLocation();\n return React.useMemo(\n () => matchPath(pattern, pathname),\n [pathname, pattern]\n );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n (to: To, options?: NavigateOptions): void;\n (delta: number): void;\n}\n\nconst navigateEffectWarning =\n `You should call navigate() in a React.useEffect(), not when ` +\n `your component is first rendered.`;\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(\n cb: Parameters[0]\n) {\n let isStatic = React.useContext(NavigationContext).static;\n if (!isStatic) {\n // We should be able to get rid of this once react 18.3 is released\n // See: https://github.com/facebook/react/pull/26395\n // eslint-disable-next-line react-hooks/rules-of-hooks\n React.useLayoutEffect(cb);\n }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by ``s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/hooks/use-navigate\n */\nexport function useNavigate(): NavigateFunction {\n let { isDataRoute } = React.useContext(RouteContext);\n // Conditional usage is OK here because the usage of a data router is static\n // eslint-disable-next-line react-hooks/rules-of-hooks\n return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\n\nfunction useNavigateUnstable(): NavigateFunction {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useNavigate() may be used only in the context of a component.`\n );\n\n let dataRouterContext = React.useContext(DataRouterContext);\n let { basename, navigator } = React.useContext(NavigationContext);\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n let routePathnamesJson = JSON.stringify(\n getPathContributingMatches(matches).map((match) => match.pathnameBase)\n );\n\n let activeRef = React.useRef(false);\n useIsomorphicLayoutEffect(() => {\n activeRef.current = true;\n });\n\n let navigate: NavigateFunction = React.useCallback(\n (to: To | number, options: NavigateOptions = {}) => {\n warning(activeRef.current, navigateEffectWarning);\n\n // Short circuit here since if this happens on first render the navigate\n // is useless because we haven't wired up our history listener yet\n if (!activeRef.current) return;\n\n if (typeof to === \"number\") {\n navigator.go(to);\n return;\n }\n\n let path = resolveTo(\n to,\n JSON.parse(routePathnamesJson),\n locationPathname,\n options.relative === \"path\"\n );\n\n // If we're operating within a basename, prepend it to the pathname prior\n // to handing off to history (but only if we're not in a data router,\n // otherwise it'll prepend the basename inside of the router).\n // If this is a root navigation, then we navigate to the raw basename\n // which allows the basename to have full control over the presence of a\n // trailing slash on root links\n if (dataRouterContext == null && basename !== \"/\") {\n path.pathname =\n path.pathname === \"/\"\n ? basename\n : joinPaths([basename, path.pathname]);\n }\n\n (!!options.replace ? navigator.replace : navigator.push)(\n path,\n options.state,\n options\n );\n },\n [\n basename,\n navigator,\n routePathnamesJson,\n locationPathname,\n dataRouterContext,\n ]\n );\n\n return navigate;\n}\n\nconst OutletContext = React.createContext(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/hooks/use-outlet-context\n */\nexport function useOutletContext(): Context {\n return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by `` to render child routes.\n *\n * @see https://reactrouter.com/hooks/use-outlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n let outlet = React.useContext(RouteContext).outlet;\n if (outlet) {\n return (\n {outlet}\n );\n }\n return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/hooks/use-params\n */\nexport function useParams<\n ParamsOrKey extends string | Record = string\n>(): Readonly<\n [ParamsOrKey] extends [string] ? Params : Partial\n> {\n let { matches } = React.useContext(RouteContext);\n let routeMatch = matches[matches.length - 1];\n return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/hooks/use-resolved-path\n */\nexport function useResolvedPath(\n to: To,\n { relative }: { relative?: RelativeRoutingType } = {}\n): Path {\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n // Use the full pathname for the leaf match so we include splat values\n // for \".\" links\n let routePathnamesJson = JSON.stringify(\n getPathContributingMatches(matches).map((match, idx) =>\n idx === matches.length - 1 ? match.pathname : match.pathnameBase\n )\n );\n\n return React.useMemo(\n () =>\n resolveTo(\n to,\n JSON.parse(routePathnamesJson),\n locationPathname,\n relative === \"path\"\n ),\n [to, routePathnamesJson, locationPathname, relative]\n );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an `` to render their child route's\n * element.\n *\n * @see https://reactrouter.com/hooks/use-routes\n */\nexport function useRoutes(\n routes: RouteObject[],\n locationArg?: Partial | string\n): React.ReactElement | null {\n return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nexport function useRoutesImpl(\n routes: RouteObject[],\n locationArg?: Partial | string,\n dataRouterState?: RemixRouter[\"state\"]\n): React.ReactElement | null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useRoutes() may be used only in the context of a component.`\n );\n\n let { navigator } = React.useContext(NavigationContext);\n let { matches: parentMatches } = React.useContext(RouteContext);\n let routeMatch = parentMatches[parentMatches.length - 1];\n let parentParams = routeMatch ? routeMatch.params : {};\n let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n let parentRoute = routeMatch && routeMatch.route;\n\n if (__DEV__) {\n // You won't get a warning about 2 different under a \n // without a trailing *, but this is a best-effort warning anyway since we\n // cannot even give the warning unless they land at the parent route.\n //\n // Example:\n //\n // \n // {/* This route path MUST end with /* because otherwise\n // it will never match /blog/post/123 */}\n // } />\n // } />\n // \n //\n // function Blog() {\n // return (\n // \n // } />\n // \n // );\n // }\n let parentPath = (parentRoute && parentRoute.path) || \"\";\n warningOnce(\n parentPathname,\n !parentRoute || parentPath.endsWith(\"*\"),\n `You rendered descendant (or called \\`useRoutes()\\`) at ` +\n `\"${parentPathname}\" (under ) but the ` +\n `parent route path has no trailing \"*\". This means if you navigate ` +\n `deeper, the parent won't match anymore and therefore the child ` +\n `routes will never render.\\n\\n` +\n `Please change the parent to .`\n );\n }\n\n let locationFromContext = useLocation();\n\n let location;\n if (locationArg) {\n let parsedLocationArg =\n typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n invariant(\n parentPathnameBase === \"/\" ||\n parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n `When overriding the location using \\`\\` or \\`useRoutes(routes, location)\\`, ` +\n `the location pathname must begin with the portion of the URL pathname that was ` +\n `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n );\n\n location = parsedLocationArg;\n } else {\n location = locationFromContext;\n }\n\n let pathname = location.pathname || \"/\";\n let remainingPathname =\n parentPathnameBase === \"/\"\n ? pathname\n : pathname.slice(parentPathnameBase.length) || \"/\";\n\n let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n if (__DEV__) {\n warning(\n parentRoute || matches != null,\n `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n );\n\n warning(\n matches == null ||\n matches[matches.length - 1].route.element !== undefined ||\n matches[matches.length - 1].route.Component !== undefined,\n `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" ` +\n `does not have an element or Component. This means it will render an with a ` +\n `null value by default resulting in an \"empty\" page.`\n );\n }\n\n let renderedMatches = _renderMatches(\n matches &&\n matches.map((match) =>\n Object.assign({}, match, {\n params: Object.assign({}, parentParams, match.params),\n pathname: joinPaths([\n parentPathnameBase,\n // Re-encode pathnames that were decoded inside matchRoutes\n navigator.encodeLocation\n ? navigator.encodeLocation(match.pathname).pathname\n : match.pathname,\n ]),\n pathnameBase:\n match.pathnameBase === \"/\"\n ? parentPathnameBase\n : joinPaths([\n parentPathnameBase,\n // Re-encode pathnames that were decoded inside matchRoutes\n navigator.encodeLocation\n ? navigator.encodeLocation(match.pathnameBase).pathname\n : match.pathnameBase,\n ]),\n })\n ),\n parentMatches,\n dataRouterState\n );\n\n // When a user passes in a `locationArg`, the associated routes need to\n // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n // to use the scoped location instead of the global location.\n if (locationArg && renderedMatches) {\n return (\n \n {renderedMatches}\n \n );\n }\n\n return renderedMatches;\n}\n\nfunction DefaultErrorComponent() {\n let error = useRouteError();\n let message = isRouteErrorResponse(error)\n ? `${error.status} ${error.statusText}`\n : error instanceof Error\n ? error.message\n : JSON.stringify(error);\n let stack = error instanceof Error ? error.stack : null;\n let lightgrey = \"rgba(200,200,200, 0.5)\";\n let preStyles = { padding: \"0.5rem\", backgroundColor: lightgrey };\n let codeStyles = { padding: \"2px 4px\", backgroundColor: lightgrey };\n\n let devInfo = null;\n if (__DEV__) {\n console.error(\n \"Error handled by React Router default ErrorBoundary:\",\n error\n );\n\n devInfo = (\n <>\n

💿 Hey developer 👋

\n

\n You can provide a way better UX than this when your app throws errors\n by providing your own ErrorBoundary or{\" \"}\n errorElement prop on your route.\n

\n \n );\n }\n\n return (\n <>\n

Unexpected Application Error!

\n

{message}

\n {stack ? 
{stack}
: null}\n {devInfo}\n \n );\n}\n\nconst defaultErrorElement = ;\n\ntype RenderErrorBoundaryProps = React.PropsWithChildren<{\n location: Location;\n revalidation: RevalidationState;\n error: any;\n component: React.ReactNode;\n routeContext: RouteContextObject;\n}>;\n\ntype RenderErrorBoundaryState = {\n location: Location;\n revalidation: RevalidationState;\n error: any;\n};\n\nexport class RenderErrorBoundary extends React.Component<\n RenderErrorBoundaryProps,\n RenderErrorBoundaryState\n> {\n constructor(props: RenderErrorBoundaryProps) {\n super(props);\n this.state = {\n location: props.location,\n revalidation: props.revalidation,\n error: props.error,\n };\n }\n\n static getDerivedStateFromError(error: any) {\n return { error: error };\n }\n\n static getDerivedStateFromProps(\n props: RenderErrorBoundaryProps,\n state: RenderErrorBoundaryState\n ) {\n // When we get into an error state, the user will likely click \"back\" to the\n // previous page that didn't have an error. Because this wraps the entire\n // application, that will have no effect--the error page continues to display.\n // This gives us a mechanism to recover from the error when the location changes.\n //\n // Whether we're in an error state or not, we update the location in state\n // so that when we are in an error state, it gets reset when a new location\n // comes in and the user recovers from the error.\n if (\n state.location !== props.location ||\n (state.revalidation !== \"idle\" && props.revalidation === \"idle\")\n ) {\n return {\n error: props.error,\n location: props.location,\n revalidation: props.revalidation,\n };\n }\n\n // If we're not changing locations, preserve the location but still surface\n // any new errors that may come through. We retain the existing error, we do\n // this because the error provided from the app state may be cleared without\n // the location changing.\n return {\n error: props.error || state.error,\n location: state.location,\n revalidation: props.revalidation || state.revalidation,\n };\n }\n\n componentDidCatch(error: any, errorInfo: any) {\n console.error(\n \"React Router caught the following error during render\",\n error,\n errorInfo\n );\n }\n\n render() {\n return this.state.error ? (\n \n \n \n ) : (\n this.props.children\n );\n }\n}\n\ninterface RenderedRouteProps {\n routeContext: RouteContextObject;\n match: RouteMatch;\n children: React.ReactNode | null;\n}\n\nfunction RenderedRoute({ routeContext, match, children }: RenderedRouteProps) {\n let dataRouterContext = React.useContext(DataRouterContext);\n\n // Track how deep we got in our render pass to emulate SSR componentDidCatch\n // in a DataStaticRouter\n if (\n dataRouterContext &&\n dataRouterContext.static &&\n dataRouterContext.staticContext &&\n (match.route.errorElement || match.route.ErrorBoundary)\n ) {\n dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n }\n\n return (\n \n {children}\n \n );\n}\n\nexport function _renderMatches(\n matches: RouteMatch[] | null,\n parentMatches: RouteMatch[] = [],\n dataRouterState: RemixRouter[\"state\"] | null = null\n): React.ReactElement | null {\n if (matches == null) {\n if (dataRouterState?.errors) {\n // Don't bail if we have data router errors so we can render them in the\n // boundary. Use the pre-matched (or shimmed) matches\n matches = dataRouterState.matches as DataRouteMatch[];\n } else {\n return null;\n }\n }\n\n let renderedMatches = matches;\n\n // If we have data errors, trim matches to the highest error boundary\n let errors = dataRouterState?.errors;\n if (errors != null) {\n let errorIndex = renderedMatches.findIndex(\n (m) => m.route.id && errors?.[m.route.id]\n );\n invariant(\n errorIndex >= 0,\n `Could not find a matching route for errors on route IDs: ${Object.keys(\n errors\n ).join(\",\")}`\n );\n renderedMatches = renderedMatches.slice(\n 0,\n Math.min(renderedMatches.length, errorIndex + 1)\n );\n }\n\n return renderedMatches.reduceRight((outlet, match, index) => {\n let error = match.route.id ? errors?.[match.route.id] : null;\n // Only data routers handle errors\n let errorElement: React.ReactNode | null = null;\n if (dataRouterState) {\n errorElement = match.route.errorElement || defaultErrorElement;\n }\n let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n let getChildren = () => {\n let children: React.ReactNode;\n if (error) {\n children = errorElement;\n } else if (match.route.Component) {\n // Note: This is a de-optimized path since React won't re-use the\n // ReactElement since it's identity changes with each new\n // React.createElement call. We keep this so folks can use\n // `` in `` but generally `Component`\n // usage is only advised in `RouterProvider` when we can convert it to\n // `element` ahead of time.\n children = ;\n } else if (match.route.element) {\n children = match.route.element;\n } else {\n children = outlet;\n }\n return (\n \n );\n };\n // Only wrap in an error boundary within data router usages when we have an\n // ErrorBoundary/errorElement on this route. Otherwise let it bubble up to\n // an ancestor ErrorBoundary/errorElement\n return dataRouterState &&\n (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? (\n \n ) : (\n getChildren()\n );\n }, null as React.ReactElement | null);\n}\n\nenum DataRouterHook {\n UseBlocker = \"useBlocker\",\n UseRevalidator = \"useRevalidator\",\n UseNavigateStable = \"useNavigate\",\n}\n\nenum DataRouterStateHook {\n UseBlocker = \"useBlocker\",\n UseLoaderData = \"useLoaderData\",\n UseActionData = \"useActionData\",\n UseRouteError = \"useRouteError\",\n UseNavigation = \"useNavigation\",\n UseRouteLoaderData = \"useRouteLoaderData\",\n UseMatches = \"useMatches\",\n UseRevalidator = \"useRevalidator\",\n UseNavigateStable = \"useNavigate\",\n UseRouteId = \"useRouteId\",\n}\n\nfunction getDataRouterConsoleError(\n hookName: DataRouterHook | DataRouterStateHook\n) {\n return `${hookName} must be used within a data router. See https://reactrouter.com/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n let ctx = React.useContext(DataRouterContext);\n invariant(ctx, getDataRouterConsoleError(hookName));\n return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n let state = React.useContext(DataRouterStateContext);\n invariant(state, getDataRouterConsoleError(hookName));\n return state;\n}\n\nfunction useRouteContext(hookName: DataRouterStateHook) {\n let route = React.useContext(RouteContext);\n invariant(route, getDataRouterConsoleError(hookName));\n return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName: DataRouterStateHook) {\n let route = useRouteContext(hookName);\n let thisRoute = route.matches[route.matches.length - 1];\n invariant(\n thisRoute.route.id,\n `${hookName} can only be used on routes that contain a unique \"id\"`\n );\n return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nexport function useRouteId() {\n return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nexport function useNavigation() {\n let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nexport function useRevalidator() {\n let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n return React.useMemo(\n () => ({\n revalidate: dataRouterContext.router.revalidate,\n state: state.revalidation,\n }),\n [dataRouterContext.router.revalidate, state.revalidation]\n );\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nexport function useMatches(): UIMatch[] {\n let { matches, loaderData } = useDataRouterState(\n DataRouterStateHook.UseMatches\n );\n return React.useMemo(\n () => matches.map((m) => convertRouteMatchToUiMatch(m, loaderData)),\n [matches, loaderData]\n );\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nexport function useLoaderData(): unknown {\n let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n\n if (state.errors && state.errors[routeId] != null) {\n console.error(\n `You cannot \\`useLoaderData\\` in an errorElement (routeId: ${routeId})`\n );\n return undefined;\n }\n return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nexport function useRouteLoaderData(routeId: string): unknown {\n let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nexport function useActionData(): unknown {\n let state = useDataRouterState(DataRouterStateHook.UseActionData);\n let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n return state.actionData ? state.actionData[routeId] : undefined;\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error. This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nexport function useRouteError(): unknown {\n let error = React.useContext(RouteErrorContext);\n let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n // If this was a render error, we put it in a RouteError context inside\n // of RenderErrorBoundary\n if (error) {\n return error;\n }\n\n // Otherwise look for errors from our data router state\n return state.errors?.[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor `` value\n */\nexport function useAsyncValue(): unknown {\n let value = React.useContext(AwaitContext);\n return value?._data;\n}\n\n/**\n * Returns the error from the nearest ancestor `` value\n */\nexport function useAsyncError(): unknown {\n let value = React.useContext(AwaitContext);\n return value?._error;\n}\n\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation. Mostly used to avoid\n * using half-filled form data. This does not handle hard-reloads or\n * cross-origin navigations.\n */\nexport function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker {\n let { router, basename } = useDataRouterContext(DataRouterHook.UseBlocker);\n let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n\n let [blockerKey, setBlockerKey] = React.useState(\"\");\n let blockerFunction = React.useCallback(\n (arg) => {\n if (typeof shouldBlock !== \"function\") {\n return !!shouldBlock;\n }\n if (basename === \"/\") {\n return shouldBlock(arg);\n }\n\n // If they provided us a function and we've got an active basename, strip\n // it from the locations we expose to the user to match the behavior of\n // useLocation\n let { currentLocation, nextLocation, historyAction } = arg;\n return shouldBlock({\n currentLocation: {\n ...currentLocation,\n pathname:\n stripBasename(currentLocation.pathname, basename) ||\n currentLocation.pathname,\n },\n nextLocation: {\n ...nextLocation,\n pathname:\n stripBasename(nextLocation.pathname, basename) ||\n nextLocation.pathname,\n },\n historyAction,\n });\n },\n [basename, shouldBlock]\n );\n\n // This effect is in charge of blocker key assignment and deletion (which is\n // tightly coupled to the key)\n React.useEffect(() => {\n let key = String(++blockerId);\n setBlockerKey(key);\n return () => router.deleteBlocker(key);\n }, [router]);\n\n // This effect handles assigning the blockerFunction. This is to handle\n // unstable blocker function identities, and happens only after the prior\n // effect so we don't get an orphaned blockerFunction in the router with a\n // key of \"\". Until then we just have the IDLE_BLOCKER.\n React.useEffect(() => {\n if (blockerKey !== \"\") {\n router.getBlocker(blockerKey, blockerFunction);\n }\n }, [router, blockerKey, blockerFunction]);\n\n // Prefer the blocker from `state` not `router.state` since DataRouterContext\n // is memoized so this ensures we update on blocker state updates\n return blockerKey && state.blockers.has(blockerKey)\n ? state.blockers.get(blockerKey)!\n : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable(): NavigateFunction {\n let { router } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n\n let activeRef = React.useRef(false);\n useIsomorphicLayoutEffect(() => {\n activeRef.current = true;\n });\n\n let navigate: NavigateFunction = React.useCallback(\n (to: To | number, options: NavigateOptions = {}) => {\n warning(activeRef.current, navigateEffectWarning);\n\n // Short circuit here since if this happens on first render the navigate\n // is useless because we haven't wired up our router subscriber yet\n if (!activeRef.current) return;\n\n if (typeof to === \"number\") {\n router.navigate(to);\n } else {\n router.navigate(to, { fromRouteId: id, ...options });\n }\n },\n [router, id]\n );\n\n return navigate;\n}\n\nconst alreadyWarned: Record = {};\n\nfunction warningOnce(key: string, cond: boolean, message: string) {\n if (!cond && !alreadyWarned[key]) {\n alreadyWarned[key] = true;\n warning(false, message);\n }\n}\n","import type {\n InitialEntry,\n LazyRouteFunction,\n Location,\n MemoryHistory,\n RelativeRoutingType,\n Router as RemixRouter,\n RouterState,\n RouterSubscriber,\n To,\n TrackedPromise,\n} from \"@remix-run/router\";\nimport {\n AbortedDeferredError,\n Action as NavigationType,\n createMemoryHistory,\n UNSAFE_getPathContributingMatches as getPathContributingMatches,\n UNSAFE_invariant as invariant,\n parsePath,\n resolveTo,\n stripBasename,\n UNSAFE_warning as warning,\n} from \"@remix-run/router\";\nimport * as React from \"react\";\n\nimport type {\n DataRouteObject,\n IndexRouteObject,\n Navigator,\n NonIndexRouteObject,\n RouteMatch,\n RouteObject,\n} from \"./context\";\nimport {\n AwaitContext,\n DataRouterContext,\n DataRouterStateContext,\n LocationContext,\n NavigationContext,\n RouteContext,\n} from \"./context\";\nimport {\n _renderMatches,\n useAsyncValue,\n useInRouterContext,\n useLocation,\n useNavigate,\n useOutlet,\n useRoutes,\n useRoutesImpl,\n} from \"./hooks\";\n\nexport interface FutureConfig {\n v7_startTransition: boolean;\n}\n\nexport interface RouterProviderProps {\n fallbackElement?: React.ReactNode;\n router: RemixRouter;\n future?: Partial;\n}\n\n/**\n Webpack + React 17 fails to compile on any of the following because webpack\n complains that `startTransition` doesn't exist in `React`:\n * import { startTransition } from \"react\"\n * import * as React from from \"react\";\n \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n * import * as React from from \"react\";\n \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n Moving it to a constant such as the following solves the Webpack/React 17 issue:\n * import * as React from from \"react\";\n const START_TRANSITION = \"startTransition\";\n START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n However, that introduces webpack/terser minification issues in production builds\n in React 18 where minification/obfuscation ends up removing the call of\n React.startTransition entirely from the first half of the ternary. Grabbing\n this exported reference once up front resolves that issue.\n\n See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nexport function RouterProvider({\n fallbackElement,\n router,\n future,\n}: RouterProviderProps): React.ReactElement {\n let [state, setStateImpl] = React.useState(router.state);\n let { v7_startTransition } = future || {};\n\n let setState = React.useCallback(\n (newState: RouterState) => {\n if (v7_startTransition && startTransitionImpl) {\n startTransitionImpl(() => setStateImpl(newState));\n } else {\n setStateImpl(newState);\n }\n },\n [setStateImpl, v7_startTransition]\n );\n\n // Need to use a layout effect here so we are subscribed early enough to\n // pick up on any render-driven redirects/navigations (useEffect/)\n React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n\n let navigator = React.useMemo((): Navigator => {\n return {\n createHref: router.createHref,\n encodeLocation: router.encodeLocation,\n go: (n) => router.navigate(n),\n push: (to, state, opts) =>\n router.navigate(to, {\n state,\n preventScrollReset: opts?.preventScrollReset,\n }),\n replace: (to, state, opts) =>\n router.navigate(to, {\n replace: true,\n state,\n preventScrollReset: opts?.preventScrollReset,\n }),\n };\n }, [router]);\n\n let basename = router.basename || \"/\";\n\n let dataRouterContext = React.useMemo(\n () => ({\n router,\n navigator,\n static: false,\n basename,\n }),\n [router, navigator, basename]\n );\n\n // The fragment and {null} here are important! We need them to keep React 18's\n // useId happy when we are server-rendering since we may have a