astro 7.2.2 → 7.2.4

package/dist/core/fetch/index.js

@@ -1,67 +1,30 @@
-import { ActionHandler } from "../../actions/handler.js";
+import { handleAction } from "../../actions/handler.js";
 import { FetchState as BaseFetchState } from "./fetch-state.js";
-import { CacheHandler } from "../cache/handler.js";
-import { appSymbol } from "../constants.js";
-import { I18n } from "../i18n/handler.js";
-import { AstroMiddleware } from "../middleware/astro-middleware.js";
-import { PagesHandler } from "../pages/handler.js";
+import { handleCache } from "../cache/handler.js";
+import { finalizeI18n, getI18n } from "../i18n/handler.js";
+import { getAmbientManifest } from "../manifest/ambient.js";
+import { handleMiddlewareWithErrorFallback } from "../middleware/astro-middleware.js";
+import { handlePagesWithErrorFallback } from "../pages/handler.js";
 import { renderRedirect } from "../redirects/render.js";
-import { AstroHandler } from "../routing/handler.js";
+import { handleRequest } from "../routing/handler.js";
 import { provideSession } from "../session/provider.js";
-import { TrailingSlashHandler } from "../routing/trailing-slash-handler.js";
-function getApp(request) {
-  const app = Reflect.get(request, appSymbol);
-  if (!app) {
-    throw new Error(
-      "FetchState(request) called on a request without an attached app. Ensure it runs inside Astro's request pipeline."
-    );
-  }
-  return app;
-}
+import { handleTrailingSlash } from "../routing/trailing-slash-handler.js";
 class FetchState extends BaseFetchState {
   constructor(request) {
-    super(getApp(request).pipeline, request);
+    super(getAmbientManifest(), request);
   }
 }
-const astroHandlers = /* @__PURE__ */ new WeakMap();
 function astro(state) {
-  const app = getApp(state.request);
-  let handler = astroHandlers.get(app);
-  if (!handler) {
-    handler = new AstroHandler(app);
-    astroHandlers.set(app, handler);
-  }
-  return handler.handle(state);
+  return handleRequest(state);
 }
-const trailingSlashHandlers = /* @__PURE__ */ new WeakMap();
 function trailingSlash(state) {
-  const app = getApp(state.request);
-  let handler = trailingSlashHandlers.get(app);
-  if (!handler) {
-    handler = new TrailingSlashHandler(app);
-    trailingSlashHandlers.set(app, handler);
-  }
-  return handler.handle(state);
+  return handleTrailingSlash(state);
 }
-const middlewareInstances = /* @__PURE__ */ new WeakMap();
 function middleware(state, next) {
-  const app = getApp(state.request);
-  let mw = middlewareInstances.get(app);
-  if (!mw) {
-    mw = new AstroMiddleware(app.pipeline);
-    middlewareInstances.set(app, mw);
-  }
-  return mw.handleWithErrorFallback(app, state, (s, _ctx) => next(s));
+  return handleMiddlewareWithErrorFallback(state, (s, _ctx) => next(s));
 }
-const pagesHandlers = /* @__PURE__ */ new WeakMap();
 function pages(state) {
-  const app = getApp(state.request);
-  let handler = pagesHandlers.get(app);
-  if (!handler) {
-    handler = new PagesHandler(app.pipeline);
-    pagesHandlers.set(app, handler);
-  }
-  return handler.handleWithErrorFallback(app, state);
+  return handlePagesWithErrorFallback(state);
 }
 function sessions(state) {
   return provideSession(state);
@@ -72,40 +35,16 @@ function redirects(state) {
   }
   return void 0;
 }
-const actionHandlers = /* @__PURE__ */ new WeakMap();
 function actions(state) {
-  const app = getApp(state.request);
-  let handler = actionHandlers.get(app);
-  if (!handler) {
-    handler = new ActionHandler();
-    actionHandlers.set(app, handler);
-  }
-  return handler.handle(state.getAPIContext(), state);
-}
-const i18nHandlers = /* @__PURE__ */ new WeakMap();
-function getI18n(app) {
-  let handler = i18nHandlers.get(app);
-  if (handler === void 0) {
-    const config = app.manifest.i18n;
-    handler = config && config.strategy !== "manual" ? new I18n(config, app.manifest.base, app.manifest.trailingSlash, app.manifest.buildFormat) : null;
-    i18nHandlers.set(app, handler);
-  }
-  return handler;
+  return handleAction(state.getAPIContext(), state);
 }
 function i18n(state, response) {
-  const handler = getI18n(getApp(state.request));
-  if (!handler) return Promise.resolve(response);
-  return handler.finalize(state, response);
+  const compiled = getI18n(state.manifest);
+  if (!compiled) return Promise.resolve(response);
+  return finalizeI18n(compiled, state, response);
 }
-const cacheHandlers = /* @__PURE__ */ new WeakMap();
 function cache(state, next) {
-  const app = getApp(state.request);
-  let handler = cacheHandlers.get(app);
-  if (!handler) {
-    handler = new CacheHandler(app);
-    cacheHandlers.set(app, handler);
-  }
-  return handler.handle(state, next);
+  return handleCache(state, next);
 }
 export {
   FetchState,

package/dist/core/fetch/vite-plugin.js

@@ -63,7 +63,8 @@ function vitePluginFetchable({ settings }) {
         }
         return {
           code: `import { DefaultFetchHandler } from 'astro/app/fetch/default-handler';
-export default new DefaultFetchHandler();`
+export default new DefaultFetchHandler();
+export const isDefaultFetchHandler = true;`
         };
       }
     }

package/dist/core/i18n/domain.js

@@ -1,9 +1,9 @@
 import {
   appendForwardSlash,
-  collapseDuplicateLeadingSlashes,
   joinPaths,
   prependForwardSlash,
-  removeTrailingForwardSlash
+  removeTrailingForwardSlash,
+  stripRequestBase
 } from "@astrojs/internal-helpers/path";
 import { normalizeTheLocale } from "../../i18n/path.js";
 function computePathnameFromDomain(request, url, i18n, base, trailingSlash, logger, pathnameFromRequest) {
@@ -32,13 +32,13 @@ function computePathnameFromDomain(request, url, i18n, base, trailingSlash, logg
           }
         }
         if (locale) {
-          const requestPathname = pathnameFromRequest ?? removeBase(url.pathname, base);
+          const requestPathname = pathnameFromRequest ?? stripRequestBase(url.pathname, base);
           pathname = prependForwardSlash(joinPaths(normalizeTheLocale(locale), requestPathname));
           if (trailingSlash === "always") {
             pathname = appendForwardSlash(pathname);
           } else if (trailingSlash === "never") {
             pathname = removeTrailingForwardSlash(pathname);
-          } else if (requestPathname.endsWith("/")) {
+          } else if (url.pathname.endsWith("/")) {
             pathname = appendForwardSlash(pathname);
           }
         }
@@ -53,13 +53,6 @@ function computePathnameFromDomain(request, url, i18n, base, trailingSlash, logg
   }
   return pathname;
 }
-function removeBase(pathname, base) {
-  pathname = collapseDuplicateLeadingSlashes(pathname);
-  if (pathname.startsWith(base)) {
-    return pathname.slice(removeTrailingForwardSlash(base).length + 1);
-  }
-  return pathname;
-}
 export {
   computePathnameFromDomain
 };

package/dist/core/i18n/handler.d.ts

@@ -1,18 +1,33 @@
+import { I18nRouter } from '../../i18n/router.js';
 import type { SSRManifest } from '../app/types.js';
 import type { FetchState } from '../fetch/fetch-state.js';
 /**
- * Post-processes a rendered `Response` against the app's i18n
- * configuration. This is the logic that previously ran as the internal
- * `createI18nMiddleware` middleware — lifted out of the middleware layer
- * so it runs as an explicit step in `AstroHandler.render` after the
- * middleware chain returns.
- *
- * Public entry points in `astro:i18n` (`createMiddleware`) preserve the
- * middleware-shaped API by wrapping an `I18n` instance in a
- * `MiddlewareHandler` closure.
+ * The compiled i18n configuration for a manifest: the config values plus the
+ * `I18nRouter` (with its inverted domain lookup table), compiled once and
+ * reused across requests.
  */
-export declare class I18n {
-    #private;
-    constructor(i18n: NonNullable<SSRManifest['i18n']>, base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], format: SSRManifest['buildFormat']);
-    finalize(state: FetchState, response: Response): Promise<Response>;
+export interface CompiledI18n {
+    config: NonNullable<SSRManifest['i18n']>;
+    base: SSRManifest['base'];
+    trailingSlash: SSRManifest['trailingSlash'];
+    format: SSRManifest['buildFormat'];
+    router: I18nRouter;
 }
+/**
+ * Pure compile from explicit values — used by `astro:i18n`'s manual-mode
+ * middleware wrapper (`src/i18n/middleware.ts`), which receives the values as
+ * arguments rather than reading a manifest.
+ */
+export declare function compileI18n(i18n: NonNullable<SSRManifest['i18n']>, base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], format: SSRManifest['buildFormat']): CompiledI18n;
+/**
+ * The compiled i18n post-processor for a manifest, or `null` when i18n is
+ * unset or the routing strategy is `manual`.
+ */
+export declare function getI18n(manifest: SSRManifest): CompiledI18n | null;
+/**
+ * Post-processes a rendered `Response` against the compiled i18n
+ * configuration, as an explicit step in `handleRequest` after the middleware
+ * chain returns. The manual-strategy public API (`astro:i18n.middleware(...)`)
+ * wraps this in a middleware-shaped closure.
+ */
+export declare function finalizeI18n(compiled: CompiledI18n, state: FetchState, response: Response): Promise<Response>;

package/dist/core/i18n/handler.js

@@ -1,116 +1,116 @@
 import { appendForwardSlash } from "@astrojs/internal-helpers/path";
 import { computeFallbackRoute } from "../../i18n/fallback.js";
 import { I18nRouter } from "../../i18n/router.js";
-import { PipelineFeatures } from "../base-pipeline.js";
+import { markFeatureUsed, FetchFeatures } from "../fetch/features.js";
 import { shouldAppendForwardSlash } from "../build/util.js";
-class I18n {
-  #i18n;
-  #base;
-  #trailingSlash;
-  #format;
-  #router;
-  constructor(i18n, base, trailingSlash, format) {
-    this.#i18n = i18n;
-    this.#base = base;
-    this.#trailingSlash = trailingSlash;
-    this.#format = format;
-    this.#router = new I18nRouter({
-      strategy: i18n.strategy,
-      defaultLocale: i18n.defaultLocale,
-      locales: i18n.locales,
-      base,
-      domains: i18n.domainLookupTable ? Object.keys(i18n.domainLookupTable).reduce(
-        (acc, domain) => {
-          const locale = i18n.domainLookupTable[domain];
-          if (!acc[domain]) {
-            acc[domain] = [];
-          }
-          acc[domain].push(locale);
-          return acc;
-        },
-        {}
-      ) : void 0
-    });
+import { createManifestMemo } from "../manifest/memo.js";
+function compileI18n(i18n, base, trailingSlash, format) {
+  const router = new I18nRouter({
+    strategy: i18n.strategy,
+    defaultLocale: i18n.defaultLocale,
+    locales: i18n.locales,
+    base,
+    domains: i18n.domainLookupTable ? Object.keys(i18n.domainLookupTable).reduce(
+      (acc, domain) => {
+        const locale = i18n.domainLookupTable[domain];
+        if (!acc[domain]) {
+          acc[domain] = [];
+        }
+        acc[domain].push(locale);
+        return acc;
+      },
+      {}
+    ) : void 0
+  });
+  return { config: i18n, base, trailingSlash, format, router };
+}
+const i18nMemo = createManifestMemo((manifest) => {
+  const config = manifest.i18n;
+  return config && config.strategy !== "manual" ? compileI18n(config, manifest.base, manifest.trailingSlash, manifest.buildFormat) : null;
+});
+function getI18n(manifest) {
+  return i18nMemo.get(manifest);
+}
+async function finalizeI18n(compiled, state, response) {
+  markFeatureUsed(state.manifest, FetchFeatures.i18n);
+  const i18n = compiled.config;
+  if (state.skipErrorReroute && typeof i18n.fallback === "undefined") {
+    return response;
   }
-  async finalize(state, response) {
-    state.pipeline.usedFeatures |= PipelineFeatures.i18n;
-    const i18n = this.#i18n;
-    if (state.skipErrorReroute && typeof i18n.fallback === "undefined") {
-      return response;
-    }
-    if (state.responseRouteType !== "page" && state.responseRouteType !== "fallback") {
-      return response;
+  if (state.responseRouteType !== "page" && state.responseRouteType !== "fallback") {
+    return response;
+  }
+  const url = state.url;
+  const currentLocale = state.computeCurrentLocale();
+  const isPrerendered = state.routeData.prerender;
+  const routerContext = {
+    currentLocale,
+    currentDomain: url.hostname,
+    routeType: state.responseRouteType,
+    isReroute: false
+  };
+  const routeDecision = compiled.router.match(url.pathname, routerContext);
+  switch (routeDecision.type) {
+    case "redirect": {
+      let location = routeDecision.location;
+      if (shouldAppendForwardSlash(compiled.trailingSlash, compiled.format)) {
+        location = appendForwardSlash(location);
+      }
+      return new Response(null, {
+        status: routeDecision.status ?? 302,
+        headers: { Location: location }
+      });
     }
-    const url = state.url;
-    const currentLocale = state.computeCurrentLocale();
-    const isPrerendered = state.routeData.prerender;
-    const routerContext = {
-      currentLocale,
-      currentDomain: url.hostname,
-      routeType: state.responseRouteType,
-      isReroute: false
-    };
-    const routeDecision = this.#router.match(url.pathname, routerContext);
-    switch (routeDecision.type) {
-      case "redirect": {
-        let location = routeDecision.location;
-        if (shouldAppendForwardSlash(this.#trailingSlash, this.#format)) {
-          location = appendForwardSlash(location);
-        }
-        return new Response(null, {
-          status: routeDecision.status ?? 302,
-          headers: { Location: location }
+    case "notFound": {
+      if (isPrerendered) {
+        const prerenderedRes = new Response(response.body, {
+          status: 404,
+          headers: response.headers
         });
-      }
-      case "notFound": {
-        if (isPrerendered) {
-          const prerenderedRes = new Response(response.body, {
-            status: 404,
-            headers: response.headers
-          });
-          state.skipErrorReroute = true;
-          if (routeDecision.location) {
-            prerenderedRes.headers.set("Location", routeDecision.location);
-          }
-          return prerenderedRes;
-        }
-        const headers = new Headers();
+        state.skipErrorReroute = true;
         if (routeDecision.location) {
-          headers.set("Location", routeDecision.location);
+          prerenderedRes.headers.set("Location", routeDecision.location);
         }
-        return new Response(null, { status: 404, headers });
+        return prerenderedRes;
       }
-      case "continue":
-        break;
-    }
-    if (i18n.fallback && i18n.fallbackType) {
-      const effectiveStatus = state.responseRouteType === "fallback" ? 404 : response.status;
-      const fallbackDecision = computeFallbackRoute({
-        pathname: url.pathname,
-        responseStatus: effectiveStatus,
-        currentLocale,
-        fallback: i18n.fallback,
-        fallbackType: i18n.fallbackType,
-        locales: i18n.locales,
-        defaultLocale: i18n.defaultLocale,
-        strategy: i18n.strategy,
-        base: this.#base
-      });
-      switch (fallbackDecision.type) {
-        case "redirect":
-          return new Response(null, {
-            status: 302,
-            headers: { Location: fallbackDecision.pathname + url.search }
-          });
-        case "rewrite":
-          return await state.rewrite(fallbackDecision.pathname + url.search);
-        case "none":
-          break;
+      const headers = new Headers();
+      if (routeDecision.location) {
+        headers.set("Location", routeDecision.location);
       }
+      return new Response(null, { status: 404, headers });
+    }
+    case "continue":
+      break;
+  }
+  if (i18n.fallback && i18n.fallbackType) {
+    const effectiveStatus = state.responseRouteType === "fallback" ? 404 : response.status;
+    const fallbackDecision = computeFallbackRoute({
+      pathname: url.pathname,
+      responseStatus: effectiveStatus,
+      currentLocale,
+      fallback: i18n.fallback,
+      fallbackType: i18n.fallbackType,
+      locales: i18n.locales,
+      defaultLocale: i18n.defaultLocale,
+      strategy: i18n.strategy,
+      base: compiled.base
+    });
+    switch (fallbackDecision.type) {
+      case "redirect":
+        return new Response(null, {
+          status: 302,
+          headers: { Location: fallbackDecision.pathname + url.search }
+        });
+      case "rewrite":
+        return await state.rewrite(fallbackDecision.pathname + url.search);
+      case "none":
+        break;
     }
-    return response;
   }
+  return response;
 }
 export {
-  I18n
+  compileI18n,
+  finalizeI18n,
+  getI18n
 };

package/dist/core/logger/manifest-logger.d.ts

@@ -0,0 +1,31 @@
+import type { SSRManifest } from '../app/types.js';
+import type { AstroLogger } from './core.js';
+/**
+ * One identity-stable logger per manifest. Created on first access as a
+ * console logger at `manifest.logLevel`.
+ *
+ * The instance is never replaced: `getResolvedLogger` swaps the
+ * destination in place via `AstroLogger.setDestination`, so every holder
+ * (state-captured logger, adapterLogger's retained options) writes to the
+ * new destination immediately.
+ */
+export declare function getLogger(manifest: SSRManifest): AstroLogger;
+/**
+ * Composition-time injection (dev server logger, DevApp console logger, an
+ * App facade constructed with a custom logger path, tests). Must be called
+ * before the first `getLogger()` read to take effect deterministically;
+ * replaces the stored instance either way.
+ */
+export declare function setLogger(manifest: SSRManifest, logger: AstroLogger): void;
+/**
+ * The manifest's logger with the user-configured destination (the
+ * `manifest.logger` thunk) resolved and applied via `setDestination` on the
+ * identity-stable logger. Memoized single-flight; awaited at request entry.
+ *
+ * Never rejects: a destination that fails to load is reported through the
+ * unswapped (console) logger, which stays in place — a broken custom
+ * destination cannot fail a request. Because the derivation always resolves,
+ * the memo's delete-on-rejection retry path never triggers: the thunk runs
+ * at most once per manifest.
+ */
+export declare function getResolvedLogger(manifest: SSRManifest): Promise<AstroLogger>;

package/dist/core/logger/manifest-logger.js

@@ -0,0 +1,37 @@
+import { createAsyncManifestMemo } from "../manifest/memo.js";
+import { createConsoleLogger } from "./impls/console.js";
+const loggers = /* @__PURE__ */ new WeakMap();
+function getLogger(manifest) {
+  let logger = loggers.get(manifest);
+  if (!logger) {
+    logger = createConsoleLogger({ level: manifest.logLevel });
+    loggers.set(manifest, logger);
+  }
+  return logger;
+}
+function setLogger(manifest, logger) {
+  loggers.set(manifest, logger);
+}
+const resolvedLogger = createAsyncManifestMemo(async (manifest) => {
+  const logger = getLogger(manifest);
+  try {
+    const destination = (await manifest.logger?.())?.default;
+    if (destination) {
+      logger.setDestination(destination);
+    }
+  } catch (error) {
+    logger.error(
+      "config",
+      "Failed to load the configured logger destination; continuing with the console logger.\n" + (error instanceof Error ? error.stack ?? error.message : String(error))
+    );
+  }
+  return logger;
+});
+function getResolvedLogger(manifest) {
+  return resolvedLogger.get(manifest);
+}
+export {
+  getLogger,
+  getResolvedLogger,
+  setLogger
+};

package/dist/core/manifest/ambient-source.d.ts

@@ -0,0 +1,2 @@
+import type { SSRManifest } from '../app/types.js';
+export declare const manifest: SSRManifest | undefined;

package/dist/core/manifest/ambient-source.js

@@ -0,0 +1,4 @@
+const manifest = void 0;
+export {
+  manifest
+};

package/dist/core/manifest/ambient.d.ts

@@ -0,0 +1,16 @@
+import type { SSRManifest } from '../app/types.js';
+/**
+ * Registers a manifest for environments where `virtual:astro:manifest` cannot
+ * resolve (plain Node: unit tests, embedders). Internal API — deliberately not
+ * exported from any public entrypoint.
+ * Pass `undefined` to clear (test teardown).
+ */
+export declare function setAmbientManifest(manifest: SSRManifest | undefined): void;
+/**
+ * The ambient manifest: the explicitly registered one, else the virtual
+ * module's. Throws lazily when neither is available, so merely importing a
+ * module that uses this never fails — only actually handling a request does.
+ */
+export declare function getAmbientManifest(): SSRManifest;
+/** The ambient manifest if one is available, else `undefined`. Never throws. */
+export declare function tryGetAmbientManifest(): SSRManifest | undefined;

package/dist/core/manifest/ambient.js

@@ -0,0 +1,22 @@
+import { NoManifestAvailable } from "../errors/errors-data.js";
+import { AstroError } from "../errors/index.js";
+import { manifest as viteManifest } from "#astro-internal/ambient-manifest";
+let registered;
+function setAmbientManifest(manifest) {
+  registered = manifest;
+}
+function getAmbientManifest() {
+  const manifest = registered ?? viteManifest;
+  if (!manifest) {
+    throw new AstroError(NoManifestAvailable);
+  }
+  return manifest;
+}
+function tryGetAmbientManifest() {
+  return registered ?? viteManifest;
+}
+export {
+  getAmbientManifest,
+  setAmbientManifest,
+  tryGetAmbientManifest
+};

package/dist/core/manifest/derived.d.ts

@@ -0,0 +1,3 @@
+import type { SSRManifest } from '../app/types.js';
+/** The manifest's `site` as a `URL` (used for `Astro.site`). */
+export declare function getSite(manifest: SSRManifest): URL | undefined;

package/dist/core/manifest/derived.js

@@ -0,0 +1,10 @@
+import { createManifestMemo } from "./memo.js";
+const sites = createManifestMemo(
+  (manifest) => manifest.site ? new URL(manifest.site) : void 0
+);
+function getSite(manifest) {
+  return sites.get(manifest);
+}
+export {
+  getSite
+};

package/dist/core/manifest/memo.d.ts

@@ -0,0 +1,31 @@
+import type { SSRManifest } from '../app/types.js';
+/**
+ * Shared helpers for "derived once per process per manifest" memoization.
+ * Manifest-keyed WeakMaps are the sanctioned memoization primitive of the
+ * request core: each derivation lives in its owning module with its own memo —
+ * there is deliberately no central registry and no "get all derived state"
+ * function anywhere.
+ *
+ * Note: values are scoped per manifest OBJECT. Two `App`s constructed over the
+ * same manifest object (e.g. the cloudflare custom-fetch worker) share every
+ * memoized derivation.
+ */
+export interface ManifestMemo<T> {
+    get(manifest: SSRManifest): T;
+    /** Whether a value is currently stored for the manifest (derived or set). */
+    has(manifest: SSRManifest): boolean;
+    /** Replaces the stored value atomically (HMR replacement). */
+    set(manifest: SSRManifest, value: T): void;
+    invalidate(manifest: SSRManifest): void;
+}
+export declare function createManifestMemo<T>(derive: (manifest: SSRManifest) => T): ManifestMemo<T>;
+export interface AsyncManifestMemo<T> {
+    get(manifest: SSRManifest): Promise<T>;
+    invalidate(manifest: SSRManifest): void;
+}
+/**
+ * Caches the PROMISE (single-flight: concurrent callers share one derivation).
+ * On rejection the entry is DELETED so the next call retries a failed lazy
+ * resolve instead of caching the failure forever.
+ */
+export declare function createAsyncManifestMemo<T>(derive: (manifest: SSRManifest) => Promise<T>): AsyncManifestMemo<T>;

package/dist/core/manifest/memo.js

@@ -0,0 +1,47 @@
+function createManifestMemo(derive) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return {
+    get(manifest) {
+      if (cache.has(manifest)) {
+        return cache.get(manifest);
+      }
+      const value = derive(manifest);
+      cache.set(manifest, value);
+      return value;
+    },
+    has(manifest) {
+      return cache.has(manifest);
+    },
+    set(manifest, value) {
+      cache.set(manifest, value);
+    },
+    invalidate(manifest) {
+      cache.delete(manifest);
+    }
+  };
+}
+function createAsyncManifestMemo(derive) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return {
+    get(manifest) {
+      let promise = cache.get(manifest);
+      if (!promise) {
+        promise = derive(manifest);
+        cache.set(manifest, promise);
+        promise.catch(() => {
+          if (cache.get(manifest) === promise) {
+            cache.delete(manifest);
+          }
+        });
+      }
+      return promise;
+    },
+    invalidate(manifest) {
+      cache.delete(manifest);
+    }
+  };
+}
+export {
+  createAsyncManifestMemo,
+  createManifestMemo
+};