@netlify/plugin-nextjs 4.41.3 → 5.0.0-beta.1

package/dist/run/revalidate.js

@@ -0,0 +1,13 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  nextResponseProxy
+} from "../esm-chunks/chunk-B6QMRLBH.js";
+import "../esm-chunks/chunk-RSKIKBZH.js";
+export {
+  nextResponseProxy
+};

package/dist/run/systemlog.js

@@ -0,0 +1,15 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  StructuredLogger,
+  logger
+} from "../esm-chunks/chunk-YZXA5QBC.js";
+import "../esm-chunks/chunk-RSKIKBZH.js";
+export {
+  StructuredLogger,
+  logger
+};

package/edge-runtime/README.md

@@ -0,0 +1,29 @@
+# Edge runtime
+
+This directory contains the logic required to create Netlify Edge Functions to support a Next.js
+site.
+
+It stands out from the rest of the project because it contains files that run in Deno, not Node.js.
+Therefore any files within `edge-runtime/` should not be imported from anywhere outside this
+directory.
+
+There are a few sub-directories you should know about.
+
+## `lib/`
+
+Files that are imported by the generated edge functions.
+
+## `shim/`
+
+Files that are inlined in the generated edge functions. This means that _you must not import these
+files_ from anywhere in the application, because they contain just fragments of a valid program.
+
+## `vendor/`
+
+Third-party dependencies used in the generated edge functions and pulled in ahead of time to avoid a
+build time dependency on any package registry.
+
+This directory is automatically managed by the build script and can be re-generated by running
+`npm run build`.
+
+You should not commit this directory to version control.

package/edge-runtime/lib/headers.ts

@@ -0,0 +1,26 @@
+// Next 13 supports request header mutations and has the side effect of prepending header values with 'x-middleware-request'
+// as part of invoking NextResponse.next() in the middleware. We need to remove that before sending the response the user
+// as the code that removes it in Next isn't run based on how we handle the middleware
+//
+// Related Next.js code:
+// * https://github.com/vercel/next.js/blob/68d06fe015b28d8f81da52ca107a5f4bd72ab37c/packages/next/server/next-server.ts#L1918-L1928
+// * https://github.com/vercel/next.js/blob/43c9d8940dc42337dd2f7d66aa90e6abf952278e/packages/next/server/web/spec-extension/response.ts#L10-L27
+export function updateModifiedHeaders(requestHeaders: Headers, responseHeaders: Headers) {
+  const overriddenHeaders = responseHeaders.get('x-middleware-override-headers')
+
+  if (!overriddenHeaders) {
+    return
+  }
+
+  const headersToUpdate = overriddenHeaders.split(',').map((header) => header.trim())
+
+  for (const header of headersToUpdate) {
+    const oldHeaderKey = 'x-middleware-request-' + header
+    const headerValue = responseHeaders.get(oldHeaderKey) || ''
+
+    requestHeaders.set(header, headerValue)
+    responseHeaders.delete(oldHeaderKey)
+  }
+
+  responseHeaders.delete('x-middleware-override-headers')
+}

package/edge-runtime/lib/middleware.ts

@@ -0,0 +1,60 @@
+import type { Context } from '@netlify/edge-functions'
+
+import { ElementHandlers } from '../vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts'
+
+type NextDataTransform = <T>(data: T) => T
+
+interface ResponseCookies {
+  // This is non-standard that Next.js adds.
+  // https://github.com/vercel/next.js/blob/de08f8b3d31ef45131dad97a7d0e95fa01001167/packages/next/src/compiled/@edge-runtime/cookies/index.js#L158
+  readonly _headers: Headers
+}
+
+interface MiddlewareResponse extends Response {
+  originResponse: Response
+  dataTransforms: NextDataTransform[]
+  elementHandlers: Array<[selector: string, handlers: ElementHandlers]>
+  get cookies(): ResponseCookies
+}
+
+interface MiddlewareRequest {
+  request: Request
+  context: Context
+  originalRequest: Request
+  next(): Promise<MiddlewareResponse>
+  rewrite(destination: string | URL, init?: ResponseInit): Response
+}
+
+export function isMiddlewareRequest(
+  response: Response | MiddlewareRequest,
+): response is MiddlewareRequest {
+  return 'originalRequest' in response
+}
+
+export function isMiddlewareResponse(
+  response: Response | MiddlewareResponse,
+): response is MiddlewareResponse {
+  return 'dataTransforms' in response
+}
+
+export const addMiddlewareHeaders = async (
+  originResponse: Promise<Response> | Response,
+  middlewareResponse: Response,
+) => {
+  // If there are extra headers, we need to add them to the response.
+  if ([...middlewareResponse.headers.keys()].length === 0) {
+    return originResponse
+  }
+
+  // We need to await the response to get the origin headers, then we can add the ones from middleware.
+  const res = await originResponse
+  const response = new Response(res.body, res)
+  middlewareResponse.headers.forEach((value, key) => {
+    if (key === 'set-cookie') {
+      response.headers.append(key, value)
+    } else {
+      response.headers.set(key, value)
+    }
+  })
+  return response
+}

package/edge-runtime/lib/next-request.ts

@@ -0,0 +1,59 @@
+import type { Context } from '@netlify/edge-functions'
+
+interface I18NConfig {
+  defaultLocale: string
+  localeDetection?: false
+  locales: string[]
+}
+
+export interface RequestData {
+  geo?: {
+    city?: string
+    country?: string
+    region?: string
+    latitude?: string
+    longitude?: string
+    timezone?: string
+  }
+  headers: Record<string, string>
+  ip?: string
+  method: string
+  nextConfig?: {
+    basePath?: string
+    i18n?: I18NConfig | null
+    trailingSlash?: boolean
+  }
+  page?: {
+    name?: string
+    params?: { [key: string]: string }
+  }
+  url: string
+  body?: ReadableStream<Uint8Array>
+}
+
+export const buildNextRequest = (
+  request: Request,
+  context: Context,
+  nextConfig?: RequestData['nextConfig'],
+): RequestData => {
+  const { url, method, body, headers } = request
+  const { country, subdivision, city, latitude, longitude, timezone } = context.geo
+  const geo: RequestData['geo'] = {
+    country: country?.code,
+    region: subdivision?.code,
+    city,
+    latitude: latitude?.toString(),
+    longitude: longitude?.toString(),
+    timezone,
+  }
+
+  return {
+    headers: Object.fromEntries(headers.entries()),
+    geo,
+    url,
+    method,
+    ip: context.ip,
+    body: body ?? undefined,
+    nextConfig,
+  }
+}

package/edge-runtime/lib/response.ts

@@ -0,0 +1,145 @@
+import type { Context } from '@netlify/edge-functions'
+import { HTMLRewriter } from '../vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts'
+
+import { updateModifiedHeaders } from './headers.ts'
+import { normalizeDataUrl, relativizeURL } from './util.ts'
+import { addMiddlewareHeaders, isMiddlewareRequest, isMiddlewareResponse } from './middleware.ts'
+
+export interface FetchEventResult {
+  response: Response
+  waitUntil: Promise<any>
+}
+
+export const buildResponse = async ({
+  result,
+  request,
+  context,
+}: {
+  result: FetchEventResult
+  request: Request
+  context: Context
+}) => {
+  updateModifiedHeaders(request.headers, result.response.headers)
+
+  // They've returned the MiddlewareRequest directly, so we'll call `next()` for them.
+  if (isMiddlewareRequest(result.response)) {
+    result.response = await result.response.next()
+  }
+
+  if (isMiddlewareResponse(result.response)) {
+    const { response } = result
+    if (request.method === 'HEAD' || request.method === 'OPTIONS') {
+      return response.originResponse
+    }
+
+    // NextResponse doesn't set cookies onto the originResponse, so we need to copy them over
+    // In some cases, it's possible there are no headers set. See https://github.com/netlify/pod-ecosystem-frameworks/issues/475
+    if (response.cookies._headers?.has('set-cookie')) {
+      response.originResponse.headers.set(
+        'set-cookie',
+        response.cookies._headers.get('set-cookie')!,
+      )
+    }
+
+    // If it's JSON we don't need to use the rewriter, we can just parse it
+    if (response.originResponse.headers.get('content-type')?.includes('application/json')) {
+      const props = await response.originResponse.json()
+      const transformed = response.dataTransforms.reduce((prev, transform) => {
+        return transform(prev)
+      }, props)
+      const body = JSON.stringify(transformed)
+      const headers = new Headers(response.headers)
+      headers.set('content-length', String(body.length))
+
+      return Response.json(transformed, { ...response, headers })
+    }
+
+    // This var will hold the contents of the script tag
+    let buffer = ''
+    // Create an HTMLRewriter that matches the Next data script tag
+    const rewriter = new HTMLRewriter()
+
+    if (response.dataTransforms.length > 0) {
+      rewriter.on('script[id="__NEXT_DATA__"]', {
+        text(textChunk) {
+          // Grab all the chunks in the Next data script tag
+          buffer += textChunk.text
+          if (textChunk.lastInTextNode) {
+            try {
+              // When we have all the data, try to parse it as JSON
+              const data = JSON.parse(buffer.trim())
+              // Apply all of the transforms to the props
+              const props = response.dataTransforms.reduce(
+                (prev, transform) => transform(prev),
+                data.props,
+              )
+              // Replace the data with the transformed props
+              // With `html: true` the input is treated as raw HTML
+              // @see https://developers.cloudflare.com/workers/runtime-apis/html-rewriter/#global-types
+              textChunk.replace(JSON.stringify({ ...data, props }), { html: true })
+            } catch (err) {
+              console.log('Could not parse', err)
+            }
+          } else {
+            // Remove the chunk after we've appended it to the buffer
+            textChunk.remove()
+          }
+        },
+      })
+    }
+
+    if (response.elementHandlers.length > 0) {
+      response.elementHandlers.forEach(([selector, handlers]) => rewriter.on(selector, handlers))
+    }
+    return rewriter.transform(response.originResponse)
+  }
+  const res = new Response(result.response.body, result.response)
+  request.headers.set('x-nf-next-middleware', 'skip')
+
+  const rewrite = res.headers.get('x-middleware-rewrite')
+
+  // Data requests (i.e. requests for /_next/data ) need special handling
+  const isDataReq = request.headers.get('x-nextjs-data')
+
+  if (rewrite) {
+    const rewriteUrl = new URL(rewrite, request.url)
+    const baseUrl = new URL(request.url)
+    const relativeUrl = relativizeURL(rewrite, request.url)
+
+    // Data requests might be rewritten to an external URL
+    // This header tells the client router the redirect target, and if it's external then it will do a full navigation
+    if (isDataReq) {
+      res.headers.set('x-nextjs-rewrite', relativeUrl)
+    }
+    if (rewriteUrl.origin !== baseUrl.origin) {
+      // Netlify Edge Functions don't support proxying to external domains, but Next middleware does
+      const proxied = fetch(new Request(rewriteUrl.toString(), request))
+      return addMiddlewareHeaders(proxied, res)
+    }
+    res.headers.set('x-middleware-rewrite', relativeUrl)
+
+    request.headers.set('x-original-path', new URL(request.url, `http://n`).pathname)
+    request.headers.set('x-middleware-rewrite', rewrite)
+
+    return addMiddlewareHeaders(context.rewrite(rewrite), res)
+  }
+
+  const redirect = res.headers.get('Location')
+
+  // Data requests shouldn't automatically redirect in the browser (they might be HTML pages): they're handled by the router
+  if (redirect && isDataReq) {
+    res.headers.delete('location')
+    res.headers.set('x-nextjs-redirect', relativizeURL(redirect, request.url))
+  }
+
+  const nextRedirect = res.headers.get('x-nextjs-redirect')
+
+  if (nextRedirect && isDataReq) {
+    res.headers.set('x-nextjs-redirect', normalizeDataUrl(nextRedirect))
+  }
+
+  if (res.headers.get('x-middleware-next') === '1') {
+    return addMiddlewareHeaders(context.next(), res)
+  }
+  return res
+}

package/{src/templates/edge-shared/next-utils.ts → edge-runtime/lib/routing.ts}

@@ -1,26 +1,25 @@
 /**
  * Various router utils ported to Deno from Next.js source
- * https://github.com/vercel/next.js/blob/7280c3ced186bb9a7ae3d7012613ef93f20b0fa9/packages/next/shared/lib/router/utils/
  * Licence: https://github.com/vercel/next.js/blob/7280c3ced186bb9a7ae3d7012613ef93f20b0fa9/license.md
  *
  * Some types have been re-implemented to be more compatible with Deno or avoid chains of dependent files
  */
 
-// Deno imports
 import type { Key } from '../vendor/deno.land/x/path_to_regexp@v6.2.1/index.ts'
 
 import { compile, pathToRegexp } from '../vendor/deno.land/x/path_to_regexp@v6.2.1/index.ts'
 import { getCookies } from '../vendor/deno.land/std@0.175.0/http/cookie.ts'
 
-// Inlined/re-implemented types
-
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ Inlined/re-implemented types                                            │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
 export interface ParsedUrlQuery {
   [key: string]: string | string[]
 }
 
 export interface Params {
-  // Yeah, best we get
-  // deno-lint-ignore no-explicit-any
   [param: string]: any
 }
 
@@ -55,6 +54,7 @@ export type Header = {
   missing?: RouteHas[]
   regex: string
 }
+
 export type Redirect = {
   source: string
   destination: string
@@ -85,7 +85,12 @@ export type RoutesManifest = {
   }
   dynamicRoutes: DynamicRoute[]
 }
-// escape-regexp.ts
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/escape-regexp.ts                           │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
 // regexp is based on https://github.com/sindresorhus/escape-string-regexp
 const reHasRegExp = /[|\\{}()[\]^$+*?.-]/
 const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g
@@ -95,12 +100,18 @@ export function escapeStringRegexp(str: string) {
   if (reHasRegExp.test(str)) {
     return str.replace(reReplaceRegExp, '\\$&')
   }
+
   return str
 }
 
-// querystring.ts
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/querystring.ts                │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
 export function searchParamsToUrlQuery(searchParams: URLSearchParams): ParsedUrlQuery {
   const query: ParsedUrlQuery = {}
+
   searchParams.forEach((value, key) => {
     if (typeof query[key] === 'undefined') {
       query[key] = value
@@ -110,10 +121,15 @@ export function searchParamsToUrlQuery(searchParams: URLSearchParams): ParsedUrl
       query[key] = [query[key] as string, value]
     }
   })
+
   return query
 }
 
-// parse-url.ts
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/parse-url.ts                  │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
 interface ParsedUrl {
   hash: string
   hostname?: string | null
@@ -127,6 +143,7 @@ interface ParsedUrl {
 
 export function parseUrl(url: string): ParsedUrl {
   const parsedURL = url.startsWith('/') ? new URL(url, 'http://n') : new URL(url)
+
   return {
     hash: parsedURL.hash,
     hostname: parsedURL.hostname,
@@ -139,8 +156,13 @@ export function parseUrl(url: string): ParsedUrl {
   }
 }
 
-// prepare-destination.ts
-// Changed to use WHATWG Fetch Request instead of IncomingMessage
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/prepare-destination.ts        │
+  │ — Changed to use WHATWG Fetch `Request` instead of                      │
+  │ `http.IncomingMessage`.                                                 │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
 export function matchHas(
   req: Pick<Request, 'headers' | 'url'>,
   query: Params,
@@ -178,10 +200,13 @@ export function matchHas(
     }
     if (!hasItem.value && value && key) {
       params[getSafeParamName(key)] = value
+
       return true
     } else if (value) {
       const matcher = new RegExp(`^${hasItem.value}$`)
-      const matches = Array.isArray(value) ? value.slice(-1)[0].match(matcher) : value.match(matcher)
+      const matches = Array.isArray(value)
+        ? value.slice(-1)[0].match(matcher)
+        : value.match(matcher)
 
       if (matches) {
         if (Array.isArray(matches)) {
@@ -281,7 +306,9 @@ export function prepareDestination(args: {
     // the value needs to start with a forward-slash to be compiled
     // correctly
     if (Array.isArray(strOrArray)) {
-      destQuery[key] = strOrArray.map((value) => compileNonPath(unescapeSegments(value), args.params))
+      destQuery[key] = strOrArray.map((value) =>
+        compileNonPath(unescapeSegments(value), args.params),
+      )
     } else {
       destQuery[key] = compileNonPath(unescapeSegments(strOrArray), args.params)
     }
@@ -355,14 +382,21 @@ function getSafeParamName(paramName: string) {
 }
 
 function escapeSegment(str: string, segmentName: string) {
-  return str.replace(new RegExp(`:${escapeStringRegexp(segmentName)}`, 'g'), `__ESC_COLON_${segmentName}`)
+  return str.replace(
+    new RegExp(`:${escapeStringRegexp(segmentName)}`, 'g'),
+    `__ESC_COLON_${segmentName}`,
+  )
 }
 
 function unescapeSegments(str: string) {
   return str.replace(/__ESC_COLON_/gi, ':')
 }
 
-// is-dynamic.ts
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/is-dynamic.ts                 │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
 // Identify /[param]/ in route string
 const TEST_ROUTE = /\/\[[^/]+?\](?=\/|$)/
 
@@ -370,11 +404,17 @@ export function isDynamicRoute(route: string): boolean {
   return TEST_ROUTE.test(route)
 }
 
-// packages/next/shared/lib/router/utils/middleware-route-matcher.ts
-// 12.3 middleware route matcher
-
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/shared/lib/router/utils/middleware-route-matcher.ts       │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
 export interface MiddlewareRouteMatch {
-  (pathname: string | null | undefined, request: Pick<Request, 'headers' | 'url'>, query: Params): boolean
+  (
+    pathname: string | null | undefined,
+    request: Pick<Request, 'headers' | 'url'>,
+    query: Params,
+  ): boolean
 }
 
 export interface MiddlewareMatcher {
@@ -385,7 +425,11 @@ export interface MiddlewareMatcher {
 }
 
 export function getMiddlewareRouteMatcher(matchers: MiddlewareMatcher[]): MiddlewareRouteMatch {
-  return (pathname: string | null | undefined, req: Pick<Request, 'headers' | 'url'>, query: Params) => {
+  return (
+    pathname: string | null | undefined,
+    req: Pick<Request, 'headers' | 'url'>,
+    query: Params,
+  ) => {
     for (const matcher of matchers) {
       const routeMatch = new RegExp(matcher.regexp).exec(pathname!)
       if (!routeMatch) {

package/edge-runtime/lib/util.ts

@@ -0,0 +1,26 @@
+// If the redirect is a data URL, we need to normalize it.
+// https://github.com/vercel/next.js/blob/25e0988e7c9033cb1503cbe0c62ba5de2e97849c/packages/next/src/shared/lib/router/utils/get-next-pathname-info.ts#L69-L76
+export function normalizeDataUrl(redirect: string) {
+  if (redirect.startsWith('/_next/data/') && redirect.includes('.json')) {
+    const paths = redirect
+      .replace(/^\/_next\/data\//, '')
+      .replace(/\.json/, '')
+      .split('/')
+
+    redirect = paths[1] !== 'index' ? `/${paths.slice(1).join('/')}` : '/'
+  }
+
+  return redirect
+}
+
+/**
+ * This is how Next handles rewritten URLs.
+ */
+export function relativizeURL(url: string | string, base: string | URL) {
+  const baseURL = typeof base === 'string' ? new URL(base) : base
+  const relative = new URL(url, base)
+  const origin = `${baseURL.protocol}//${baseURL.host}`
+  return `${relative.protocol}//${relative.host}` === origin
+    ? relative.toString().replace(origin, '')
+    : relative.toString()
+}

package/edge-runtime/middleware.ts

@@ -0,0 +1,53 @@
+import type { Context } from '@netlify/edge-functions'
+
+import matchers from './matchers.json' assert { type: 'json' }
+
+import { buildNextRequest, RequestData } from './lib/next-request.ts'
+import { buildResponse } from './lib/response.ts'
+import { FetchEventResult } from './lib/response.ts'
+import {
+  type MiddlewareRouteMatch,
+  getMiddlewareRouteMatcher,
+  searchParamsToUrlQuery,
+} from './lib/routing.ts'
+
+type NextHandler = (params: { request: RequestData }) => Promise<FetchEventResult>
+
+const matchesMiddleware: MiddlewareRouteMatch = getMiddlewareRouteMatcher(matchers || [])
+
+/**
+ * Runs a Next.js middleware as a Netlify Edge Function. It translates a web
+ * platform Request into a NextRequest instance on the way in, and translates
+ * a NextResponse into a web platform Response on the way out.
+ *
+ * @param request Incoming request
+ * @param context Netlify-specific context object
+ * @param nextHandler Next.js middleware handler
+ */
+export async function handleMiddleware(
+  request: Request,
+  context: Context,
+  nextHandler: NextHandler,
+) {
+  const nextRequest = buildNextRequest(request, context)
+  const url = new URL(request.url)
+
+  // While we have already checked the path when mapping to the edge function,
+  // Next.js supports extra rules that we need to check here too, because we
+  // might be running an edge function for a path we should not. If we find
+  // that's the case, short-circuit the execution.
+  if (!matchesMiddleware(url.pathname, request, searchParamsToUrlQuery(url.searchParams))) {
+    return
+  }
+
+  try {
+    const result = await nextHandler({ request: nextRequest })
+    const response = await buildResponse({ result, request: request, context })
+
+    return response
+  } catch (error) {
+    console.error(error)
+
+    return new Response(error.message, { status: 500 })
+  }
+}

package/edge-runtime/shim/index.js

@@ -0,0 +1,11 @@
+// NOTE: This is a fragment of a JavaScript program that will be inlined with
+// a Webpack bundle. You should not import this file from anywhere in the
+// application.
+import { AsyncLocalStorage } from 'node:async_hooks'
+import process from 'node:process'
+
+globalThis.process = process
+
+globalThis.AsyncLocalStorage = AsyncLocalStorage
+
+var _ENTRIES = {}

package/{src/templates → edge-runtime}/vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts

@@ -53,7 +53,7 @@ export class HTMLRewriter {
   constructor() {
     if (!initialized.settled && !executing) {
       executing = true;
-      fetch("https://deno.land/x/html_rewriter@v0.1.0-pre.17/vendor/html_rewriter_bg.wasm")
+      fetch(new URL("./vendor/html_rewriter_bg.wasm", import.meta.url).href)
         .then(r => r.ok ? r : (() => { throw Error('WASM response not ok') })())
         .then(toWASMResponse)
         .then(initWASM)

package/edge-runtime/vendor/import_map.json

@@ -0,0 +1,13 @@
+{
+  "imports": {
+    "https://ghuc.cc/worker-tools/resolvable-promise/index.ts": "./raw.githubusercontent.com/worker-tools/resolvable-promise/master/index.ts",
+    "https://deno.land/": "./deno.land/",
+    "https://esm.sh/": "./esm.sh/",
+    "https://raw.githubusercontent.com/": "./raw.githubusercontent.com/"
+  },
+  "scopes": {
+    "./esm.sh/": {
+      "/v91/next@12.2.5/deno/dist/compiled/cookie.js": "./esm.sh/v91/next@12.2.5/deno/dist/compiled/cookie.js"
+    }
+  }
+}