Nextjs should have more options for trailing slash.

[armspkt]

Feature request

Is your feature request related to a problem? Please describe.

Nuxtjs have several options to choose trailing slash. (undefined, true, false)
nuxt-modules/i18n#422

Describe the solution you'd like

Nextjs should have more options for trailing slash.
If use undefined Nextjs should not redirect route when use URL that ends with a slash

trailingSlashes: true

/abc/ -> /abc/ (keeps the same)
/abc -> /abc/ (changes)

trailingSlashes: false

/abc -> /abc (keeps the same)
/abc/ -> /abc (changes)

trailingSlashes: undefined (default)

/abc/ -> /abc/ (keeps the same)
/abc -> /abc (keeps the same)

[Janpot]

@armspkt Can you expand a bit more on why you need this behavior (other than "just because nuxt does it this way"). Is there a specific use-case you're trying to solve? What's the practical use of having different urls point to the same content? Is there a benefit to having that behavior?

[zwingliernst]

Old one, but now facing a similar issue.
Because the removing of the trailing-slash happens before the middleware, it chains 308-responses. This hurts SEO again.
Some more control would be desirable in that case.
In general it should be after middleware.ts not before it, since next.js cannot know if middleware would return a 308 itself

[armspkt]

@Janpot I need this feature because many users on my website access via both (with a slash and without a slash) and I think it good to have those options that we don't have to redirect for the better user experience and I saw many sites work that way too.

There is no specific use-case for Nextjs yet but There is a case about i18n localePath for Nuxtjs. nuxt/nuxt#6331

I think it better to have more options to choose from.

Is there a specific use-case you're trying to solve?

• there's not yet.

What's the practical use of having different urls point to the same content?

• I saw many websites did not redirect from slash to not have slash.
  eg. https://nextjs.org/showcase and https://nextjs.org/showcase/
  Why nextjs-site have the same content but not redirect?

https://www.youtube.com/feed/trending and https://www.youtube.com/feed/trending/
https://github.com/pulls and https://github.com/pulls/
https://twitter.com/explore and https://twitter.com/explore/
https://www.facebook.com/groups/feed and https://www.facebook.com/groups/feed/

Can you explain why those websites did not redirect?

Is there a benefit to having that behavior?

• In my opinion, it better for user experience and I saw some developers want it works this way too.

I don't want it because Nuxtjs have it but I want it because it is nice to have feature.
That's all.

[btk]

If you have users accessing the same content via 2 URLs, it's actually better for SEO to redirect them all to one route. It doesn't matter which one you pick, you should stick with it, and Next.js forces you to do that by default hence making the better choice for your site, which is what frameworks are for.

We should consider the already established websites that uses both trailing and non trailing slash ending urls, which is moving to next. For those sites redirecting some of these pages can hurt their established SEO no?

[cobrexus]

For those sites redirecting some of these pages can hurt their established SEO no?

No.

If you have multiple URLs to access the same content, search engines will index both URLs and treat them as duplicate content and this will harm your SEO.

If you redirect the URLs and keep your routing patterns constant, search engines will be able to index your site better, and they will detect redirects and realise that it is the same page they are accessing, preventing them from treating it as duplicate content.

[jonathanmcchesney]

The omission of allowing routes with both trailing and without trailing slashes has actively hurt our application and I’m sure many others.

We have a use case where our app redirects to other application urls, those urls may or may not be following the same routing standards and some will require exclusively one or the other. As such any application url that isn’t following the same pattern will not work with this change. It’s also not possible or feasible to get these applications to follow the same pattern as some are long established without active development etc.

By not allowing a user an option to avoid forced redirection to a trailing slash or non trailing slashes, any sites or applications that had required this functionality beforehand are now only left with one option and that would be to move away from next.is and that may not be feasible depending on the maturity of the application. Especially with enterprise applications and websites this is a big negative and certainly a reason to avoid using next.js.

[Janpot]

@jonathanmcchesney Since you're linking out of your Next.js application, couldn't you just use a plain old anchor?

<a href="/hello/world/">Trailing slash</a>

[jonathanmcchesney]

We aren’t linking out of our application, we are routing to other applications from inside our application.

I.e the the base of our app is:

https://{ip}/base/path

But using iframes etc we allow other applications to be viewed within our application using the following pattern:

App1:
https://{ip}/base/path/apps/{appId}/route1

App2:
https://{ip}/base/path/apps/{appId}/route2/

For the above example these could be two routes for two different applications. They both could follow different routing patterns. The ability to be able to use the url to navigate to each of these applications within our application is very important.

[nikosantis]

Yeah, i think we need that, idk if this solutions is the best, but, need a solution.
How nextjs do this https://nextjs.org/showcase and https://nextjs.org/showcase/?

[sebqq]

Yeah, i think we need that, idk if this solutions is the best, but, need a solution.

How nextjs do this https://nextjs.org/showcase and https://nextjs.org/showcase/?

Check their website's next.config.js file. I think that you will find your answer there.

[nikosantis]

Yeah, i think we need that, idk if this solutions is the best, but, need a solution.
How nextjs do this https://nextjs.org/showcase and https://nextjs.org/showcase/?

Check their website's next.config.js file. I think that you will find your answer there.

Now in "next": "^9.4.5-canary.32" have a solution by default :)

[Unsfer]

Something wrong going on when using basePath and trailingSlash: true:
Next/Link removes trailing slash when going to "/"
And in some old browsers got error (which was not in 9.4.5-canary.27)

Unhandled promise rejection,TypeError: t.entries is not a function
/_next/static/runtime/polyfills-35e39b6a0bf08dcb376c.js

Using 9.4.5-canary.34

[Janpot]

@Unsfer Do you know, by any chance, which browser throws this error?

[Unsfer]

It was some old version of FF, which doesn't sopport Object.entries. I think it's supposed to be polyfilled

[aralroca]

A richer system would be very good to be able to decide in which paths redirects should be avoided at all costs. For example, in our case, as I commented here:

#15867 (comment)

We want to avoid 308 before 404 pages.

We want this:

And the current feature forces to:

[timneutkens]

@aralroca feel free to reach out to [email protected] and we'll see what we can do for your specific case under enterprise support.

[u3u]

By default Next.js will redirect urls with trailing slashes to their counterpart without a trailing slash.

Can I disable it? Or can it be used only as a designated route?
I think this is a good feature, but my boss requires the URL to remain the same. 😥
If I use patch-package to remove the default redirection and removePathTrailingSlash, will there be any side effects?

diff --git a/node_modules/next/dist/client/normalize-trailing-slash.js b/node_modules/next/dist/client/normalize-trailing-slash.js
index 9ceda38..71b277b 100644
--- a/node_modules/next/dist/client/normalize-trailing-slash.js
+++ b/node_modules/next/dist/client/normalize-trailing-slash.js
@@ -1,6 +1,6 @@
 "use strict";exports.__esModule=true;exports.removePathTrailingSlash=removePathTrailingSlash;exports.normalizePathTrailingSlash=void 0;/**
  * Removes the trailing slash of a path if there is one. Preserves the root path `/`.
- */function removePathTrailingSlash(path){return path.endsWith('/')&&path!=='/'?path.slice(0,-1):path;}/**
+ */function removePathTrailingSlash(path){return path;}/**
  * Normalizes the trailing slash of a path according to the `trailingSlash` option
  * in `next.config.js`.
  */const normalizePathTrailingSlash=process.env.__NEXT_TRAILING_SLASH?path=>{if(/\.[^/]+\/?$/.test(path)){return removePathTrailingSlash(path);}else if(path.endsWith('/')){return path;}else{return path+'/';}}:removePathTrailingSlash;exports.normalizePathTrailingSlash=normalizePathTrailingSlash;
diff --git a/node_modules/next/dist/lib/load-custom-routes.js b/node_modules/next/dist/lib/load-custom-routes.js
index c56f7e4..f67024f 100644
--- a/node_modules/next/dist/lib/load-custom-routes.js
+++ b/node_modules/next/dist/lib/load-custom-routes.js
@@ -5,5 +5,5 @@ const errMatches=err.message.match(/at (\d{0,})/);if(errMatches){const position=
 // for not being a string
 const{tokens,error}=tryParsePath(route.source);if(error){invalidParts.push('`source` parse failed');}sourceTokens=tokens;}// make sure no unnamed patterns are attempted to be used in the
 // destination as this can cause confusion and is not allowed
-if(typeof route.destination==='string'){if(route.destination.startsWith('/')&&Array.isArray(sourceTokens)){const unnamedInDest=new Set();for(const token of sourceTokens){if(typeof token==='object'&&typeof token.name==='number'){const unnamedIndex=new RegExp(`:${token.name}(?!\\d)`);if(route.destination.match(unnamedIndex)){unnamedInDest.add(`:${token.name}`);}}}if(unnamedInDest.size>0){invalidParts.push(`\`destination\` has unnamed params ${[...unnamedInDest].join(', ')}`);}else{const{tokens:destTokens,error:destinationParseFailed}=tryParsePath(route.destination,true);if(destinationParseFailed){invalidParts.push('`destination` parse failed');}else{const sourceSegments=new Set(sourceTokens.map(item=>typeof item==='object'&&item.name).filter(Boolean));const invalidDestSegments=new Set();for(const token of destTokens){if(typeof token==='object'&&!sourceSegments.has(token.name)){invalidDestSegments.add(token.name);}}if(invalidDestSegments.size){invalidParts.push(`\`destination\` has segments not in \`source\` (${[...invalidDestSegments].join(', ')})`);}}}}}const hasInvalidKeys=invalidKeys.length>0;const hasInvalidParts=invalidParts.length>0;if(hasInvalidKeys||hasInvalidParts){console.error(`${invalidParts.join(', ')}${invalidKeys.length?(hasInvalidParts?',':'')+` invalid field${invalidKeys.length===1?'':'s'}: `+invalidKeys.join(','):''} for route ${JSON.stringify(route)}`);numInvalidRoutes++;}}if(numInvalidRoutes>0){if(hadInvalidStatus){console.error(`\nValid redirect statusCode values are ${[...allowedStatusCodes].join(', ')}`);}console.error();throw new Error(`Invalid ${type}${numInvalidRoutes===1?'':'s'} found`);}}async function loadRedirects(config){if(typeof config.redirects!=='function'){return[];}const _redirects=await config.redirects();checkCustomRoutes(_redirects,'redirect');return _redirects;}async function loadRewrites(config){if(typeof config.rewrites!=='function'){return[];}const _rewrites=await config.rewrites();checkCustomRoutes(_rewrites,'rewrite');return _rewrites;}async function loadHeaders(config){if(typeof config.headers!=='function'){return[];}const _headers=await config.headers();checkCustomRoutes(_headers,'header');return _headers;}async function loadCustomRoutes(config){const[headers,rewrites,redirects]=await Promise.all([loadHeaders(config),loadRewrites(config),loadRedirects(config)]);if(config.trailingSlash){redirects.unshift({source:'/:file((?:[^/]+/)*[^/]+\\.\\w+)/',destination:'/:file',permanent:true},{source:'/:notfile((?:[^/]+/)*[^/\\.]+)',destination:'/:notfile/',permanent:true});if(config.basePath){redirects.unshift({source:config.basePath,destination:config.basePath+'/',permanent:true,basePath:false});}}else{redirects.unshift({source:'/:path+/',destination:'/:path+',permanent:true});if(config.basePath){redirects.unshift({source:config.basePath+'/',destination:config.basePath,permanent:true,basePath:false});}}return{headers,rewrites,redirects};}
+if(typeof route.destination==='string'){if(route.destination.startsWith('/')&&Array.isArray(sourceTokens)){const unnamedInDest=new Set();for(const token of sourceTokens){if(typeof token==='object'&&typeof token.name==='number'){const unnamedIndex=new RegExp(`:${token.name}(?!\\d)`);if(route.destination.match(unnamedIndex)){unnamedInDest.add(`:${token.name}`);}}}if(unnamedInDest.size>0){invalidParts.push(`\`destination\` has unnamed params ${[...unnamedInDest].join(', ')}`);}else{const{tokens:destTokens,error:destinationParseFailed}=tryParsePath(route.destination,true);if(destinationParseFailed){invalidParts.push('`destination` parse failed');}else{const sourceSegments=new Set(sourceTokens.map(item=>typeof item==='object'&&item.name).filter(Boolean));const invalidDestSegments=new Set();for(const token of destTokens){if(typeof token==='object'&&!sourceSegments.has(token.name)){invalidDestSegments.add(token.name);}}if(invalidDestSegments.size){invalidParts.push(`\`destination\` has segments not in \`source\` (${[...invalidDestSegments].join(', ')})`);}}}}}const hasInvalidKeys=invalidKeys.length>0;const hasInvalidParts=invalidParts.length>0;if(hasInvalidKeys||hasInvalidParts){console.error(`${invalidParts.join(', ')}${invalidKeys.length?(hasInvalidParts?',':'')+` invalid field${invalidKeys.length===1?'':'s'}: `+invalidKeys.join(','):''} for route ${JSON.stringify(route)}`);numInvalidRoutes++;}}if(numInvalidRoutes>0){if(hadInvalidStatus){console.error(`\nValid redirect statusCode values are ${[...allowedStatusCodes].join(', ')}`);}console.error();throw new Error(`Invalid ${type}${numInvalidRoutes===1?'':'s'} found`);}}async function loadRedirects(config){if(typeof config.redirects!=='function'){return[];}const _redirects=await config.redirects();checkCustomRoutes(_redirects,'redirect');return _redirects;}async function loadRewrites(config){if(typeof config.rewrites!=='function'){return[];}const _rewrites=await config.rewrites();checkCustomRoutes(_rewrites,'rewrite');return _rewrites;}async function loadHeaders(config){if(typeof config.headers!=='function'){return[];}const _headers=await config.headers();checkCustomRoutes(_headers,'header');return _headers;}async function loadCustomRoutes(config){const[headers,rewrites,redirects]=await Promise.all([loadHeaders(config),loadRewrites(config),loadRedirects(config)]);if(config.trailingSlash){redirects.unshift({source:'/:file((?:[^/]+/)*[^/]+\\.\\w+)/',destination:'/:file',permanent:true},{source:'/:notfile((?:[^/]+/)*[^/\\.]+)',destination:'/:notfile/',permanent:true});if(config.basePath){redirects.unshift({source:config.basePath,destination:config.basePath+'/',permanent:true,basePath:false});}}return{headers,rewrites,redirects};}
 //# sourceMappingURL=load-custom-routes.js.map

[joeitu]

Have you tried this solution?

[u3u]

Have you tried this solution?

Of course, I have been using this solution without problems. But with the next version of the upgrade may need to be modified in different places. My changes here are based on v9.5.5.

[Daemeron]

I think not being forced to opt-in into automatic trailingSlash url normalisation would be very helpful. My team wanted to upgrade to latest version of Next.js recently but this change keeps us from doing so.

Our use-case is international website that does not use trailing slashes at the end of the url except for home pages for different countries:

• /gb-en/ <- home page /
• /gb-en/page-1 <- page-1 /page-1

We would benefit from trailingSlashes: undefined (default)

[Zauberfisch]

related issue: #18164

And I agree, this should be optional

[aralroca]

Definitely, the option of not doing any redirect should be implemented.

[jonathanmcchesney]

This is a blocking issue for our team. We have to support a plethora of different application routes for applications we integrate with, some containing hashbang urls, some ending with trailing slashes, and some without trailing slashes. These redirects as a result are mutating our application routes which have strict route checking.

e.g.

app/1/#/some/route1 (wont work with a trailing slash)
app/1/#/some/route2/ (wont work without a trailing slash)
app/1/#/some/route1?theme=dark
app/1/#/some/route2/?theme=dark

Is there also currently a way to optionally redirect for hashbang urls, as some of the apps we integrate with use these. At present if we go to app/1/#/some/route1, we are redirected to app/1#/some/route1.

[PiotrSzlagura]

I would love such option to be present, as I'm currently facing issues with redirect chains because of this.

[joeitu]

This issue is more than two years old now, and still no fix available?

Did someone find a workaround?

[WavyWalk]

Did you find any workaround?

[NotCJSBirdie]

I would love the option to be present as well. It's 2022 folks are there any updates regarding this potential feature?

[PGuimarais]

Any updates on this?

It seems we're forced into using trailingSlash as per this aws-amplify bug .

But this now breaks our blog which is linked to our main site through a rewrite. It would be nice to override this behavior at the rewrite level.

[artursOs]

We also need this customisation feature for Seo purposes to be able to do smthn like "region/" , "/region/country/" , but "/region/country/city"

[btk]

In terms of design, how vercel.json is perfect actually.

But since now changing this to default "undefined" will break things, maybe we can have something like;

trailingSlash: "preserve"
or
trailingSlash: "unrecommended-undefined"
/abc/ -> /abc/ (keeps the same)
/abc -> /abc (keeps the same)

Seems to me this would fix a lot problems, while keeping the best practices out of the box?

[blakebutcher]

Running into this problem also. Our CMS provides canonical URLs for structural pages with trailing slashes, and for content detail pages with numeric IDs but no trailing slashes. Being able to apply the trailingSlash behaviour to specific URL patterns would be desirable.

[u3u]

An experimental skipTrailingSlashRedirect option seems to have been added recently (#43201) and is included in the v12.3.4 release (v12.3.3...v12.3.4)

/** @type {import('next').NextConfig} */
const nextConfig = {
  experimental: {
    skipTrailingSlashRedirect: true,
  },
}

[joeitu]

Exiting!
Should the config also include trailingSlash: true or trailingSlash: false ? or should trailingSlash should be removed from the config file?

[LucasSolcher]

I used this approach setting
skipTrailingSlashRedirect: true,
and not setting
trailingSlash: true

and setting in the middleware:

  if (pathname !== "/foo") { //testing with request to '/foo'
    return NextResponse.next()
  } else {
    request.nextUrl.pathname += '/'
    return NextResponse.redirect(request.nextUrl)
  }

However it will end in an infinite loop alternating requests to foo and foo/

Changing it to

  if (pathname !== "/foo") {
    return NextResponse.next()
  } else {
    request.nextUrl.pathname += '/'
    return NextResponse.rewrite(request.nextUrl)
  }

does basically nothing. It will not end in a loop but itt will keep the foo without the '/'

Interestingly

  if (pathname !== "/foo") {
    return NextResponse.next()
  } else {
    request.nextUrl.pathname = '/bar'
    return NextResponse.rewrite(request.nextUrl)
  }

will redirect to bar. Just the trailing slash will not be added in any case

[davidkassa]

Has anyone found a way to opt out of the trailing slash for a single url? My use-case is that the AWS HTTP API Gateway JWT authorizer does not work with a trailing slash on the openid-configuration path. Ideally, for me, I only want to intercept this single url like this:

import { NextResponse } from "next/server"

export default async function middleware(req) {
    const { pathname } = req.nextUrl

    if (pathname.endsWith("/")) {
        return NextResponse.redirect(new URL(pathname.slice(0, -1), req.url))
    }

    return NextResponse.next()
}

export const config = {
    matcher: ["/api/auth/.well-known/(openid-configuration?)"]
}

But then all my routes are stripped of their trailing slash. If I add a /(.*) global matcher then I catch JS and it just times out.

[danpoletaev]

After hours of researching and testing I come up with something like this.

In middleware.ts I added redirects from locale/pathname/ -> locale.
Added default locale, so that I don't have 2 routes pointing to the same page. If user requests a page without locale I added redirect -> /en (my default locale)

Down below is my code, maybe it would help someone:

middleware.ts

import { NextRequest, NextResponse } from "next/server";

const PUBLIC_FILE = /\.(.*)$/;

export async function middleware(req: NextRequest) {
	if (req.nextUrl.pathname.startsWith('/_next') || req.nextUrl.pathname.includes('/api/') || PUBLIC_FILE.test(req.nextUrl.pathname)) {
		return;
	}

	const href = req.nextUrl.href;
	const isLastTrailingSlash = href[href.length - 1] === '/';

	const { host, pathname, locale } = req.nextUrl;
	const realPathName = pathname !== '/' ? (isLastTrailingSlash ? pathname.substring(0, pathname.length - 1) : pathname) : '';
	const protocol = host === 'localhost:3000' ? 'http://' : 'https://';

	if (locale === 'default') {
		return NextResponse.redirect(new URL(`${protocol}${host}/en${realPathName}`), 301);
	}

	if (href === `http://${host}/` || href === `https://${host}` || href === `https://${host}/` || href === `https://${host}`) {
		return NextResponse.redirect(new URL(`${protocol}${host}/${locale}${realPathName}`), 301);
	}
	if (isLastTrailingSlash) {
		return NextResponse.redirect(new URL(`${protocol}${host}/${locale}${realPathName}`), 301);
	}

	return NextResponse.next();
}

// next.config.js
/** @type {import('next').NextConfig} */
const { i18n } = require('./next-i18next.config');
const nextConfig = {
	reactStrictMode: true,
	swcMinify: true,
	i18n,
	trailingSlash: false,
	skipTrailingSlashRedirect: true,
};
module.exports = nextConfig;

// next-i18next.config.js
module.exports = {
	i18n: {
		defaultLocale: 'default',
		locales: [...],
		localeDetection: false,
	},
	react: { useSuspense: false }, //this line
	trailingSlash: false,
};

P.S. On the client side on initial page /en it adds trailing slash after few seconds, when the page is generated, but it does not affect HTTP requests.

I checked on that tool https://technicalseo.com/tools/hreflang/. All pages ending with .../ are being redirected to pages without slash with 301 code and pages without slash return 200

[tadghh]

Alternative, considering this is going to be running on every request using regex might be pricey

import { NextResponse } from "next/server";

export async function middleware(req) {
	if (
		req.nextUrl.pathname.startsWith("/_next") ||
		req.nextUrl.pathname.includes("/api/")
	) {
		return;
	}

	const { host, pathname, protocol } = req.nextUrl;
	const pathLength = pathname.length;
	let isTrailingSlash = pathLength != 1 && pathname[pathLength - 1] == "/";

	if (!isTrailingSlash) {
		return;
	}
	else {
		return NextResponse.redirect(
			new URL(`${protocol}//${host}${pathname.slice(0, -1)}`),
			301
		);
	}

	return NextResponse.next();
}

[ryanwhitemedia]

Adding another comment here to give reasons why we need these options other than "just cause nuxt has it" @Janpot

We are experiencing issues with firebase authentication using our own domain. Our trailing slash breaks their auth routes. We have these rewrites which handles the custom domain stuff. Unfortunately our trailing slash breaks it and sends auth/handler to auth/handler/handler with their setup and the trailing slash.

 async rewrites() {
    return [
      {
        source: '/__/auth/:path*',
        destination: 'https://APP.firebaseapp.com/__/auth/'
      },
  },

So hving an option to just ignorePaths in the trailing slash config so we can disable for the auth routes would solve this. Instead we have had to look at lots of other work arounds including enforcing trailing slashes in cloudflare, adding new rewrites which are messy and causing other CORS errors now.

If we had one config option to just disable it for specific routes it would be a 30 second fix, we have spent hours trying ti fix this though and anything we do conflicts with NextJS or vice versa.

 async rewrites() {
    return [
      {
        source: '/__/auth/handler',
        destination: 'https://APP.firebaseapp.com/__/auth/handler'
      },
      {
        source: '/__/auth/handler/handler.js',
        destination: 'https://APP.firebaseapp.com/__/auth/handler.js'
      },
      {
        source: '/__/auth/handler/experiments.js',
        destination: 'https://APP.firebaseapp.com/__/auth/experiments.js'
      },
      {
        source: '/__/auth/handler/iframe',
        destination: 'https://APP.firebaseapp.com/__/auth/iframe'
      },
      {
        source: '/__/auth/handler/iframe.js',
        destination: 'https://APP.firebaseapp.com/__/auth/iframe.js'
      },
    ];
  },

[ivolocastic]

We're having similar problem. Trailing slash is used site wide, but since we're migrating large site to Next, the original urls don't have trailing slashes and while trying to redirect them to new ones, it causes redirect chains (because first redirect is always 308 - adding the slash) which can harm SEO which is really important to us since there is a lot of traffic.

It would be really helpful to be able to disable trailing slashes for certain routes.

We even tried with the skipTrailingSlashRedirect flag from the docs, but there is some weird redirection loops happening. Here's the codesandobx

[tavareshenrique]

Can I disable trailingSlash for page router?

Today NextJS does this:

Take this route from my page: /slug/my-test

And send it to: /slug/my-test/

This behavior is harmful to me, can I disable this behavior?

I'm on NextJS version 13.4.7.

[Jdruwe]

For me skipTrailingSlashRedirect seems to be working

[H-pun]

IDK, but in my case, using skipTrailingSlashRedirect only prevents the route from redirecting with a 308 status code—it still forces the destination path to follow the trailing slash option. I had to do it like this for both routes. Kinda ugly, though:

const nextConfig = {
  skipTrailingSlashRedirect: true,
  rewrites: async () => {
    return {
        {
          source: "/jupyter/:path*/",
          destination: `${process.env.JUPYTERHUB_URL}/jupyter/:path*/`,
        },
        {
          source: "/jupyter/:path*",
          destination: `${process.env.JUPYTERHUB_URL}/jupyter/:path*`,
        }
      ],
    };
  },
};