@cloudflare/pages-shared 0.13.71 → 0.13.72

package/dist/asset-server/handler.js

@@ -0,0 +1,890 @@
+// ../workers-shared/utils/responses.ts
+var OkResponse = class _OkResponse extends Response {
+  static {
+    this.status = 200;
+  }
+  constructor(body, init) {
+    super(body, {
+      ...init,
+      status: _OkResponse.status
+    });
+  }
+};
+var NotFoundResponse = class _NotFoundResponse extends Response {
+  static {
+    this.status = 404;
+  }
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: _NotFoundResponse.status,
+      statusText: "Not Found"
+    });
+  }
+};
+var MethodNotAllowedResponse = class _MethodNotAllowedResponse extends Response {
+  static {
+    this.status = 405;
+  }
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: _MethodNotAllowedResponse.status,
+      statusText: "Method Not Allowed"
+    });
+  }
+};
+var InternalServerErrorResponse = class _InternalServerErrorResponse extends Response {
+  static {
+    this.status = 500;
+  }
+  constructor(_, init) {
+    super(null, {
+      ...init,
+      status: _InternalServerErrorResponse.status
+    });
+  }
+};
+var NotModifiedResponse = class _NotModifiedResponse extends Response {
+  static {
+    this.status = 304;
+  }
+  constructor(...[_body, init]) {
+    super(null, {
+      ...init,
+      status: _NotModifiedResponse.status,
+      statusText: "Not Modified"
+    });
+  }
+};
+var MovedPermanentlyResponse = class _MovedPermanentlyResponse extends Response {
+  static {
+    this.status = 301;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _MovedPermanentlyResponse.status,
+      statusText: "Moved Permanently",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+};
+var FoundResponse = class _FoundResponse extends Response {
+  static {
+    this.status = 302;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _FoundResponse.status,
+      statusText: "Found",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+};
+var SeeOtherResponse = class _SeeOtherResponse extends Response {
+  static {
+    this.status = 303;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _SeeOtherResponse.status,
+      statusText: "See Other",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+};
+var TemporaryRedirectResponse = class _TemporaryRedirectResponse extends Response {
+  static {
+    this.status = 307;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _TemporaryRedirectResponse.status,
+      statusText: "Temporary Redirect",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+};
+var PermanentRedirectResponse = class _PermanentRedirectResponse extends Response {
+  static {
+    this.status = 308;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _PermanentRedirectResponse.status,
+      statusText: "Permanent Redirect",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+};
+
+// ../workers-shared/asset-worker/src/utils/rules-engine.ts
+var ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
+var escapeRegex = (str) => {
+  return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
+};
+var HOST_PLACEHOLDER_REGEX = /(?<=^https:\\\/\\\/[^/]*?):([A-Za-z]\w*)(?=\\)/g;
+var PLACEHOLDER_REGEX = /:([A-Za-z]\w*)/g;
+var replacer = (str, replacements) => {
+  for (const [replacement, value] of Object.entries(replacements)) {
+    str = str.replaceAll(`:${replacement}`, value);
+  }
+  return str;
+};
+var generateRuleRegExp = (rule) => {
+  rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
+  const host_matches = rule.matchAll(HOST_PLACEHOLDER_REGEX);
+  for (const host_match of host_matches) {
+    rule = rule.split(host_match[0]).join(`(?<${host_match[1]}>[^/.]+)`);
+  }
+  const path_matches = rule.matchAll(PLACEHOLDER_REGEX);
+  for (const path_match of path_matches) {
+    rule = rule.split(path_match[0]).join(`(?<${path_match[1]}>[^/]+)`);
+  }
+  rule = "^" + rule + "$";
+  return RegExp(rule);
+};
+var generateRulesMatcher = (rules, replacerFn = (match) => match) => {
+  if (!rules) {
+    return () => [];
+  }
+  const compiledRules = Object.entries(rules).map(([rule, match]) => {
+    const crossHost = rule.startsWith("https://");
+    try {
+      const regExp = generateRuleRegExp(rule);
+      return [{ crossHost, regExp }, match];
+    } catch {
+    }
+  }).filter((value) => value !== void 0);
+  return ({ request }) => {
+    const { pathname, hostname } = new URL(request.url);
+    return compiledRules.map(([{ crossHost, regExp }, match]) => {
+      const test = crossHost ? `https://${hostname}${pathname}` : pathname;
+      const result = regExp.exec(test);
+      if (result) {
+        return replacerFn(match, result.groups || {});
+      }
+    }).filter((value) => value !== void 0);
+  };
+};
+
+// asset-server/responses.ts
+function mergeHeaders(base, extra) {
+  const baseHeaders = new Headers(base ?? {});
+  const extraHeaders = new Headers(extra ?? {});
+  return new Headers({
+    ...Object.fromEntries(baseHeaders.entries()),
+    ...Object.fromEntries(extraHeaders.entries())
+  });
+}
+function stripLeadingDoubleSlashes(location) {
+  return location.replace(/^(\/|%2F|%2f|%5C|%5c|%09|\s|\\)+(.*)/, "/$2");
+}
+var OkResponse2 = class extends Response {
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: 200,
+      statusText: "OK"
+    });
+  }
+};
+var MovedPermanentlyResponse2 = class extends Response {
+  constructor(location, init, {
+    preventLeadingDoubleSlash = true
+  } = {
+    preventLeadingDoubleSlash: true
+  }) {
+    location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+    super(`Redirecting to ${location}`, {
+      ...init,
+      status: 301,
+      statusText: "Moved Permanently",
+      headers: mergeHeaders(init?.headers, {
+        location
+      })
+    });
+  }
+};
+var FoundResponse2 = class extends Response {
+  constructor(location, init, {
+    preventLeadingDoubleSlash = true
+  } = {
+    preventLeadingDoubleSlash: true
+  }) {
+    location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+    super(`Redirecting to ${location}`, {
+      ...init,
+      status: 302,
+      statusText: "Found",
+      headers: mergeHeaders(init?.headers, {
+        location
+      })
+    });
+  }
+};
+var NotModifiedResponse2 = class extends Response {
+  constructor(...[_body, _init]) {
+    super(void 0, {
+      status: 304,
+      statusText: "Not Modified"
+    });
+  }
+};
+var PermanentRedirectResponse2 = class extends Response {
+  constructor(location, init, {
+    preventLeadingDoubleSlash = true
+  } = {
+    preventLeadingDoubleSlash: true
+  }) {
+    location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+    super(void 0, {
+      ...init,
+      status: 308,
+      statusText: "Permanent Redirect",
+      headers: mergeHeaders(init?.headers, {
+        location
+      })
+    });
+  }
+};
+var NotFoundResponse2 = class extends Response {
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: 404,
+      statusText: "Not Found"
+    });
+  }
+};
+var MethodNotAllowedResponse2 = class extends Response {
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: 405,
+      statusText: "Method Not Allowed"
+    });
+  }
+};
+var NotAcceptableResponse = class extends Response {
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: 406,
+      statusText: "Not Acceptable"
+    });
+  }
+};
+var InternalServerErrorResponse2 = class extends Response {
+  constructor(err, init) {
+    let body = void 0;
+    if (globalThis.DEBUG) {
+      body = `${err.message}
+
+${err.stack}`;
+    }
+    super(body, {
+      ...init,
+      status: 500,
+      statusText: "Internal Server Error"
+    });
+  }
+};
+var SeeOtherResponse2 = class extends Response {
+  constructor(location, init, {
+    preventLeadingDoubleSlash = true
+  } = {
+    preventLeadingDoubleSlash: true
+  }) {
+    location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+    super(`Redirecting to ${location}`, {
+      ...init,
+      status: 303,
+      statusText: "See Other",
+      headers: mergeHeaders(init?.headers, { location })
+    });
+  }
+};
+var TemporaryRedirectResponse2 = class extends Response {
+  constructor(location, init, {
+    preventLeadingDoubleSlash = true
+  } = {
+    preventLeadingDoubleSlash: true
+  }) {
+    location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+    super(`Redirecting to ${location}`, {
+      ...init,
+      status: 307,
+      statusText: "Temporary Redirect",
+      headers: mergeHeaders(init?.headers, { location })
+    });
+  }
+};
+
+// asset-server/handler.ts
+var ASSET_PRESERVATION_CACHE = "assetPreservationCacheV2";
+var CACHE_CONTROL_PRESERVATION = "public, s-maxage=604800";
+var CACHE_PRESERVATION_WRITE_FREQUENCY = 86400;
+var CACHE_CONTROL_BROWSER2 = "public, max-age=0, must-revalidate";
+var REDIRECTS_VERSION2 = 1;
+var HEADERS_VERSION2 = 2;
+var HEADERS_VERSION_V1 = 1;
+var ANALYTICS_VERSION = 1;
+var ALLOWED_EARLY_HINT_LINK_ATTRIBUTES = ["rel", "as", "href"];
+function normaliseHeaders(headers) {
+  if (headers.version === HEADERS_VERSION2) {
+    return headers.rules;
+  } else if (headers.version === HEADERS_VERSION_V1) {
+    return Object.keys(headers.rules).reduce(
+      (acc, key) => {
+        acc[key] = {
+          set: headers.rules[key]
+        };
+        return acc;
+      },
+      {}
+    );
+  } else {
+    return {};
+  }
+}
+function generateETagHeader(assetKey) {
+  const strongETag = `"${assetKey}"`;
+  const weakETag = `W/"${assetKey}"`;
+  return { strongETag, weakETag };
+}
+function checkIfNoneMatch(request, strongETag, weakETag) {
+  const ifNoneMatch = request.headers.get("if-none-match");
+  return ifNoneMatch === weakETag || ifNoneMatch === strongETag;
+}
+async function generateHandler({
+  request,
+  metadata,
+  xServerEnvHeader,
+  xDeploymentIdHeader,
+  xWebAnalyticsHeader,
+  logError,
+  setMetrics,
+  findAssetEntryForPath,
+  getAssetKey,
+  negotiateContent,
+  fetchAsset,
+  generateNotFoundResponse = async (notFoundRequest, notFoundFindAssetEntryForPath, notFoundServeAsset) => {
+    let assetEntry;
+    if (assetEntry = await notFoundFindAssetEntryForPath("/index.html")) {
+      return notFoundServeAsset(assetEntry, { preserve: false });
+    }
+    return new NotFoundResponse2();
+  },
+  attachAdditionalHeaders = () => {
+  },
+  caches,
+  waitUntil
+}) {
+  const url = new URL(request.url);
+  const { protocol, host, search } = url;
+  let { pathname } = url;
+  const earlyHintsCache = metadata.deploymentId ? await caches?.open(`eh:${metadata.deploymentId}`) : void 0;
+  const headerRules = metadata.headers ? normaliseHeaders(metadata.headers) : {};
+  const staticRules = metadata.redirects?.version === REDIRECTS_VERSION2 ? metadata.redirects.staticRules || {} : {};
+  const staticRedirectsMatcher2 = () => {
+    const withHostMatch = staticRules[`https://${host}${pathname}`];
+    const withoutHostMatch = staticRules[pathname];
+    if (withHostMatch && withoutHostMatch) {
+      if (withHostMatch.lineNumber < withoutHostMatch.lineNumber) {
+        return withHostMatch;
+      } else {
+        return withoutHostMatch;
+      }
+    }
+    return withHostMatch || withoutHostMatch;
+  };
+  const generateRedirectsMatcher2 = () => generateRulesMatcher(
+    metadata.redirects?.version === REDIRECTS_VERSION2 ? metadata.redirects.rules : {},
+    ({ status, to }, replacements) => ({
+      status,
+      to: replacer(to, replacements)
+    })
+  );
+  let assetEntry;
+  async function generateResponse() {
+    const match = staticRedirectsMatcher2() || generateRedirectsMatcher2()({ request })[0];
+    if (match) {
+      if (match.status === 200) {
+        pathname = new URL(match.to, request.url).pathname;
+      } else {
+        const { status, to } = match;
+        const destination = new URL(to, request.url);
+        const location = destination.origin === new URL(request.url).origin ? `${destination.pathname}${destination.search || search}${destination.hash}` : `${destination.href.slice(0, destination.href.length - (destination.search.length + destination.hash.length))}${destination.search ? destination.search : search}${destination.hash}`;
+        switch (status) {
+          case 301:
+            return new MovedPermanentlyResponse2(location, void 0, {
+              preventLeadingDoubleSlash: false
+            });
+          case 303:
+            return new SeeOtherResponse2(location, void 0, {
+              preventLeadingDoubleSlash: false
+            });
+          case 307:
+            return new TemporaryRedirectResponse2(location, void 0, {
+              preventLeadingDoubleSlash: false
+            });
+          case 308:
+            return new PermanentRedirectResponse2(location, void 0, {
+              preventLeadingDoubleSlash: false
+            });
+          case 302:
+          default:
+            return new FoundResponse2(location, void 0, {
+              preventLeadingDoubleSlash: false
+            });
+        }
+      }
+    }
+    if (!request.method.match(/^(get|head)$/i)) {
+      return new MethodNotAllowedResponse2();
+    }
+    try {
+      pathname = globalThis.decodeURIComponent(pathname);
+    } catch {
+    }
+    if (pathname.endsWith("/")) {
+      if (assetEntry = await findAssetEntryForPath(`${pathname}index.html`)) {
+        return serveAsset(assetEntry);
+      } else if (pathname.endsWith("/index/")) {
+        return new PermanentRedirectResponse2(
+          `/${pathname.slice(1, -"index/".length)}${search}`
+        );
+      } else if (assetEntry = await findAssetEntryForPath(
+        `${pathname.replace(/\/$/, ".html")}`
+      )) {
+        return new PermanentRedirectResponse2(
+          `/${pathname.slice(1, -1)}${search}`
+        );
+      } else {
+        return notFound();
+      }
+    }
+    if (assetEntry = await findAssetEntryForPath(pathname)) {
+      if (pathname.endsWith(".html")) {
+        const extensionlessPath = pathname.slice(0, -".html".length);
+        if (extensionlessPath.endsWith("/index")) {
+          return new PermanentRedirectResponse2(
+            `${extensionlessPath.replace(/\/index$/, "/")}${search}`
+          );
+        } else if (await findAssetEntryForPath(extensionlessPath) || extensionlessPath === "/") {
+          return serveAsset(assetEntry);
+        } else {
+          return new PermanentRedirectResponse2(`${extensionlessPath}${search}`);
+        }
+      } else {
+        return serveAsset(assetEntry);
+      }
+    } else if (pathname.endsWith("/index")) {
+      return new PermanentRedirectResponse2(
+        `/${pathname.slice(1, -"index".length)}${search}`
+      );
+    } else if (assetEntry = await findAssetEntryForPath(`${pathname}.html`)) {
+      return serveAsset(assetEntry);
+    }
+    if (assetEntry = await findAssetEntryForPath(`${pathname}/index.html`)) {
+      return new PermanentRedirectResponse2(`${pathname}/${search}`);
+    } else {
+      return notFound();
+    }
+  }
+  function isNullBodyStatus(status) {
+    return [101, 204, 205, 304].includes(status);
+  }
+  async function attachHeaders(response) {
+    const existingHeaders = new Headers(response.headers);
+    const eTag = existingHeaders.get("eTag")?.match(/^"(.*)"$/)?.[1];
+    const extraHeaders = new Headers({
+      "access-control-allow-origin": "*",
+      "referrer-policy": "strict-origin-when-cross-origin",
+      ...existingHeaders.has("content-type") ? { "x-content-type-options": "nosniff" } : {}
+    });
+    const headers = new Headers({
+      // But we intentionally override existing headers
+      ...Object.fromEntries(existingHeaders.entries()),
+      ...Object.fromEntries(extraHeaders.entries())
+    });
+    if (earlyHintsCache && isHTMLContentType(response.headers.get("Content-Type")) && eTag) {
+      const preEarlyHintsHeaders = new Headers(headers);
+      const earlyHintsCacheKey = `${protocol}//${host}/${eTag}`;
+      const earlyHintsResponse = await earlyHintsCache.match(earlyHintsCacheKey);
+      if (earlyHintsResponse) {
+        const earlyHintsLinkHeader = earlyHintsResponse.headers.get("Link");
+        if (earlyHintsLinkHeader) {
+          headers.set("Link", earlyHintsLinkHeader);
+          if (setMetrics) {
+            setMetrics({ earlyHintsResult: "used-hit" });
+          }
+        } else {
+          if (setMetrics) {
+            setMetrics({ earlyHintsResult: "notused-hit" });
+          }
+        }
+      } else {
+        if (setMetrics) {
+          setMetrics({ earlyHintsResult: "notused-miss" });
+        }
+        const clonedResponse = response.clone();
+        if (waitUntil) {
+          waitUntil(
+            (async () => {
+              try {
+                const links = [];
+                const transformedResponse = new HTMLRewriter().on(
+                  "link[rel~=preconnect],link[rel~=preload],link[rel~=modulepreload]",
+                  {
+                    element(element) {
+                      for (const [attributeName] of element.attributes) {
+                        if (!ALLOWED_EARLY_HINT_LINK_ATTRIBUTES.includes(
+                          attributeName.toLowerCase()
+                        )) {
+                          return;
+                        }
+                      }
+                      const href = element.getAttribute("href") || void 0;
+                      const rel = element.getAttribute("rel") || void 0;
+                      const as = element.getAttribute("as") || void 0;
+                      if (href && !href.startsWith("data:") && rel) {
+                        links.push({ href, rel, as });
+                      }
+                    }
+                  }
+                ).transform(clonedResponse);
+                await transformedResponse.text();
+                links.forEach(({ href, rel, as }) => {
+                  let link = `<${href}>; rel="${rel}"`;
+                  if (as) {
+                    link += `; as=${as}`;
+                  }
+                  preEarlyHintsHeaders.append("Link", link);
+                });
+                const linkHeader = preEarlyHintsHeaders.get("Link");
+                const earlyHintsHeaders = new Headers({
+                  "Cache-Control": "max-age=2592000"
+                  // 30 days
+                });
+                if (linkHeader) {
+                  earlyHintsHeaders.append("Link", linkHeader);
+                }
+                await earlyHintsCache.put(
+                  earlyHintsCacheKey,
+                  new Response(null, { headers: earlyHintsHeaders })
+                );
+              } catch {
+                await earlyHintsCache.put(
+                  earlyHintsCacheKey,
+                  new Response(null, {
+                    headers: {
+                      "Cache-Control": "max-age=86400"
+                      // 1 day
+                    }
+                  })
+                );
+              }
+            })()
+          );
+        }
+      }
+    } else {
+      if (setMetrics) {
+        setMetrics({ earlyHintsResult: "disabled" });
+      }
+    }
+    const headersMatcher = generateRulesMatcher(
+      headerRules,
+      ({ set = {}, unset = [] }, replacements) => {
+        const replacedSet = {};
+        Object.keys(set).forEach((key) => {
+          replacedSet[key] = replacer(set[key], replacements);
+        });
+        return {
+          set: replacedSet,
+          unset
+        };
+      }
+    );
+    const matches = headersMatcher({ request });
+    const setMap = /* @__PURE__ */ new Set();
+    matches.forEach(({ set = {}, unset = [] }) => {
+      unset.forEach((key) => {
+        headers.delete(key);
+      });
+      Object.keys(set).forEach((key) => {
+        if (setMap.has(key.toLowerCase())) {
+          headers.append(key, set[key]);
+        } else {
+          headers.set(key, set[key]);
+          setMap.add(key.toLowerCase());
+        }
+      });
+    });
+    return new Response(
+      isNullBodyStatus(response.status) ? null : response.body,
+      {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+      }
+    );
+  }
+  const responseWithoutHeaders = await generateResponse();
+  if (responseWithoutHeaders.status >= 500) {
+    return responseWithoutHeaders;
+  }
+  const responseWithHeaders = await attachHeaders(responseWithoutHeaders);
+  if (responseWithHeaders.status === 404) {
+    if (responseWithHeaders.headers.has("cache-control")) {
+      responseWithHeaders.headers.delete("cache-control");
+    }
+    responseWithHeaders.headers.append("cache-control", "no-store");
+  }
+  return responseWithHeaders;
+  async function serveAsset(servingAssetEntry, options = { preserve: true }) {
+    let content;
+    try {
+      content = negotiateContent(request, servingAssetEntry);
+    } catch {
+      return new NotAcceptableResponse();
+    }
+    const assetKey = getAssetKey(servingAssetEntry, content);
+    const { strongETag, weakETag } = generateETagHeader(assetKey);
+    const isIfNoneMatch = checkIfNoneMatch(request, strongETag, weakETag);
+    if (isIfNoneMatch) {
+      return new NotModifiedResponse2();
+    }
+    try {
+      const asset = await fetchAsset(assetKey);
+      const headers = {
+        etag: strongETag,
+        "content-type": asset.contentType
+      };
+      let encodeBody = "automatic";
+      if (xServerEnvHeader) {
+        headers["x-server-env"] = xServerEnvHeader;
+      }
+      if (xDeploymentIdHeader && metadata.deploymentId) {
+        headers["x-deployment-id"] = metadata.deploymentId;
+      }
+      if (content.encoding) {
+        encodeBody = "manual";
+        headers["cache-control"] = "no-transform";
+        headers["content-encoding"] = content.encoding;
+      }
+      const response = new OkResponse2(
+        request.method === "HEAD" ? null : asset.body,
+        {
+          headers,
+          encodeBody
+        }
+      );
+      if (isCacheable(request)) {
+        response.headers.append("cache-control", CACHE_CONTROL_BROWSER2);
+      }
+      attachAdditionalHeaders(response, content, servingAssetEntry, asset);
+      if (isPreview(new URL(request.url))) {
+        response.headers.set("x-robots-tag", "noindex");
+      }
+      if (options.preserve && waitUntil && caches) {
+        waitUntil(
+          (async () => {
+            try {
+              const assetPreservationCache = await caches.open(
+                ASSET_PRESERVATION_CACHE
+              );
+              const match = await assetPreservationCache.match(request);
+              if (!match || assetKey !== await match.text() || isPreservationCacheResponseExpiring(match)) {
+                const preservedResponse = new Response(assetKey, response);
+                preservedResponse.headers.set(
+                  "cache-control",
+                  CACHE_CONTROL_PRESERVATION
+                );
+                preservedResponse.headers.set("x-robots-tag", "noindex");
+                await assetPreservationCache.put(
+                  request.url,
+                  preservedResponse
+                );
+              }
+            } catch (err) {
+              logError(err);
+            }
+          })()
+        );
+      }
+      if (isHTMLContentType(asset.contentType) && metadata.analytics?.version === ANALYTICS_VERSION) {
+        if (xWebAnalyticsHeader) {
+          response.headers.set("x-cf-pages-analytics", "1");
+        }
+        return new HTMLRewriter().on("body", {
+          element(e) {
+            e.append(
+              `<!-- Cloudflare Pages Analytics --><script defer src='https://static.cloudflareinsights.com/beacon.min.js' data-cf-beacon='{"token": "${metadata.analytics?.token}"}'><\/script><!-- Cloudflare Pages Analytics -->`,
+              { html: true }
+            );
+          }
+        }).transform(response);
+      }
+      return response;
+    } catch (err) {
+      logError(err);
+      return new InternalServerErrorResponse2(err);
+    }
+  }
+  async function notFound() {
+    if (caches) {
+      try {
+        const assetPreservationCache = await caches.open(
+          ASSET_PRESERVATION_CACHE
+        );
+        const preservedResponse = await assetPreservationCache.match(
+          request.url
+        );
+        if (preservedResponse) {
+          if (setMetrics) {
+            setMetrics({ preservationCacheResult: "checked-hit" });
+          }
+          const assetKey = await preservedResponse.text();
+          if (isNullBodyStatus(preservedResponse.status)) {
+            return new Response(null, preservedResponse);
+          }
+          if (assetKey) {
+            const { strongETag, weakETag } = generateETagHeader(assetKey);
+            const isIfNoneMatch = checkIfNoneMatch(
+              request,
+              strongETag,
+              weakETag
+            );
+            if (isIfNoneMatch) {
+              if (setMetrics) {
+                setMetrics({ preservationCacheResult: "not-modified" });
+              }
+              return new NotModifiedResponse2();
+            }
+            const asset = await fetchAsset(assetKey);
+            if (asset) {
+              return new Response(asset.body, preservedResponse);
+            } else {
+              logError(
+                new Error(
+                  `preservation cache contained assetKey that does not exist in storage: ${assetKey}`
+                )
+              );
+            }
+          } else {
+            logError(new Error(`cached response had no assetKey: ${assetKey}`));
+          }
+        } else {
+          if (setMetrics) {
+            setMetrics({ preservationCacheResult: "checked-miss" });
+          }
+        }
+      } catch (err) {
+        logError(err);
+      }
+    } else {
+      if (setMetrics) {
+        setMetrics({ preservationCacheResult: "disabled" });
+      }
+    }
+    let cwd = pathname;
+    while (cwd) {
+      cwd = cwd.slice(0, cwd.lastIndexOf("/"));
+      if (assetEntry = await findAssetEntryForPath(`${cwd}/404.html`)) {
+        let content;
+        try {
+          content = negotiateContent(request, assetEntry);
+        } catch {
+          return new NotAcceptableResponse();
+        }
+        const assetKey = getAssetKey(assetEntry, content);
+        try {
+          const { body, contentType } = await fetchAsset(assetKey);
+          const response = new NotFoundResponse2(body);
+          response.headers.set("content-type", contentType);
+          return response;
+        } catch (err) {
+          logError(err);
+          return new InternalServerErrorResponse2(err);
+        }
+      }
+    }
+    return await generateNotFoundResponse(
+      request,
+      findAssetEntryForPath,
+      serveAsset
+    );
+  }
+}
+function parseQualityWeightedList(list = "") {
+  const items = {};
+  list.replace(/\s/g, "").split(",").forEach((el) => {
+    const [item, weight] = el.split(";q=");
+    items[item] = weight ? parseFloat(weight) : 1;
+  });
+  return items;
+}
+function isCacheable(request) {
+  return !request.headers.has("authorization") && !request.headers.has("range");
+}
+function isPreview(url) {
+  if (url.hostname.endsWith(".pages.dev")) {
+    return url.hostname.split(".").length > 3 ? true : false;
+  }
+  return false;
+}
+function isPreservationCacheResponseExpiring(response) {
+  const ageHeader = response.headers.get("age");
+  if (!ageHeader) {
+    return false;
+  }
+  try {
+    const age = parseInt(ageHeader);
+    const jitter = Math.floor(Math.random() * 43200);
+    if (age > CACHE_PRESERVATION_WRITE_FREQUENCY + jitter) {
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function isHTMLContentType(contentType) {
+  return contentType?.toLowerCase().startsWith("text/html") || false;
+}
+export {
+  ANALYTICS_VERSION,
+  ASSET_PRESERVATION_CACHE,
+  CACHE_CONTROL_BROWSER2 as CACHE_CONTROL_BROWSER,
+  CACHE_PRESERVATION_WRITE_FREQUENCY,
+  HEADERS_VERSION2 as HEADERS_VERSION,
+  HEADERS_VERSION_V1,
+  REDIRECTS_VERSION2 as REDIRECTS_VERSION,
+  generateHandler,
+  isPreservationCacheResponseExpiring,
+  normaliseHeaders,
+  parseQualityWeightedList
+};