@cloudflare/pages-shared 0.0.6 → 0.0.8

package/README.md

@@ -0,0 +1,5 @@
+# `@cloudflare/pages-shared`
+
+This is a package that is used internally to power Wrangler and Cloudflare Pages. It contains all the code that is shared between these clients (and possibly any other in the future e.g. the dashboard).
+
+Code should be written so that it can be run in almost any environment (e.g. Deno, Node, browser, Workers), but note that there's currently a bit of weirdness here for `asset-server`, hence the `environment-polyfills` piece.

package/{src/asset-server → asset-server}/handler.ts

@@ -34,6 +34,11 @@ export const HEADERS_VERSION = 2;
 export const HEADERS_VERSION_V1 = 1;
 export const ANALYTICS_VERSION = 1;
 
+// In rolling this out, we're taking a conservative approach to only generate these Link headers from <link> elements that have these attributes.
+// We'll ignore any <link> elements that contain other attributes (e.g. `fetchpriority`, `crossorigin` or `data-please-dont-generate-a-header`).
+// We're not confident in browser support for all of these additional attributes, so we'll wait until we have that information before proceeding further.
+const ALLOWED_EARLY_HINT_LINK_ATTRIBUTES = ["rel", "as", "href"];
+
 // Takes metadata headers and "normalise" them
 // to the latest version
 export function normaliseHeaders(
@@ -295,41 +300,6 @@ export async function generateHandler<
 			...Object.fromEntries(extraHeaders.entries()),
 		});
 
-		// Iterate through rules and find rules that match the path
-		const headersMatcher = generateRulesMatcher(
-			headerRules,
-			({ set = {}, unset = [] }, replacements) => {
-				const replacedSet: Record<string, string> = {};
-				Object.keys(set).forEach((key) => {
-					replacedSet[key] = replacer(set[key], replacements);
-				});
-				return {
-					set: replacedSet,
-					unset,
-				};
-			}
-		);
-		const matches = headersMatcher({ request });
-
-		// This keeps track of every header that we've set from _headers
-		// because we want to combine user declared headers but overwrite
-		// existing and extra ones
-		const setMap = new Set();
-		// Apply every matched rule in order
-		matches.forEach(({ set = {}, unset = [] }) => {
-			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());
-				}
-			});
-			unset.forEach((key) => {
-				headers.delete(key);
-			});
-		});
-
 		if (earlyHintsCache) {
 			const preEarlyHintsHeaders = new Headers(headers);
 
@@ -357,6 +327,16 @@ export async function generateHandler<
 							const transformedResponse = new HTMLRewriter()
 								.on("link[rel=preconnect],link[rel=preload]", {
 									element(element) {
+										for (const [attributeName] of element.attributes) {
+											if (
+												!ALLOWED_EARLY_HINT_LINK_ATTRIBUTES.includes(
+													attributeName.toLowerCase()
+												)
+											) {
+												return;
+											}
+										}
+
 										const href = element.getAttribute("href") || undefined;
 										const rel = element.getAttribute("rel") || undefined;
 										const as = element.getAttribute("as") || undefined;
@@ -396,6 +376,41 @@ export async function generateHandler<
 			}
 		}
 
+		// Iterate through rules and find rules that match the path
+		const headersMatcher = generateRulesMatcher(
+			headerRules,
+			({ set = {}, unset = [] }, replacements) => {
+				const replacedSet: Record<string, string> = {};
+				Object.keys(set).forEach((key) => {
+					replacedSet[key] = replacer(set[key], replacements);
+				});
+				return {
+					set: replacedSet,
+					unset,
+				};
+			}
+		);
+		const matches = headersMatcher({ request });
+
+		// This keeps track of every header that we've set from _headers
+		// because we want to combine user declared headers but overwrite
+		// existing and extra ones
+		const setMap = new Set();
+		// Apply every matched rule in order
+		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());
+				}
+			});
+		});
+
 		// https://fetch.spec.whatwg.org/#null-body-status
 		return new Response(
 			[101, 204, 205, 304].includes(response.status) ? null : response.body,

package/package.json

@@ -1,13 +1,13 @@
 {
 	"name": "@cloudflare/pages-shared",
-	"version": "0.0.6",
+	"version": "0.0.8",
 	"files": [
 		"tsconfig.json",
-		"src/**/*",
-		"dist/**/*"
+		"asset-server/**/*",
+		"environment-polyfills/**/*",
+		"metadata-generator/**/*"
 	],
 	"scripts": {
-		"build": "node scripts/build.js",
 		"check:type": "tsc"
 	},
 	"jest": {
@@ -36,11 +36,11 @@
 		]
 	},
 	"dependencies": {
-		"@miniflare/core": "2.8.1"
+		"@miniflare/core": "2.9.0"
 	},
 	"devDependencies": {
-		"@miniflare/cache": "2.8.1",
-		"@miniflare/html-rewriter": "2.8.1",
+		"@miniflare/cache": "2.9.0",
+		"@miniflare/html-rewriter": "2.9.0",
 		"@types/service-worker-mock": "^2.0.1",
 		"concurrently": "^7.3.0",
 		"glob": "^8.0.3",

package/dist/asset-server/handler.js

@@ -1,395 +0,0 @@
-import {
-  FoundResponse,
-  InternalServerErrorResponse,
-  MethodNotAllowedResponse,
-  MovedPermanentlyResponse,
-  NotAcceptableResponse,
-  NotFoundResponse,
-  NotModifiedResponse,
-  OkResponse,
-  PermanentRedirectResponse,
-  SeeOtherResponse,
-  TemporaryRedirectResponse
-} from "./responses";
-import { generateRulesMatcher, replacer } from "./rulesEngine";
-export const ASSET_PRESERVATION_CACHE = "assetPreservationCache";
-const CACHE_CONTROL_PRESERVATION = "public, s-maxage=604800";
-export const CACHE_CONTROL_BROWSER = "public, max-age=0, must-revalidate";
-export const REDIRECTS_VERSION = 1;
-export const HEADERS_VERSION = 2;
-export const HEADERS_VERSION_V1 = 1;
-export const ANALYTICS_VERSION = 1;
-export function normaliseHeaders(headers) {
-  if (headers.version === HEADERS_VERSION) {
-    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 {};
-  }
-}
-export async function generateHandler({
-  request,
-  metadata,
-  xServerEnvHeader,
-  logError,
-  findAssetEntryForPath,
-  getAssetKey,
-  negotiateContent,
-  fetchAsset,
-  generateNotFoundResponse = async (notFoundRequest, notFoundFindAssetEntryForPath, notFoundServeAsset) => {
-    let assetEntry;
-    if (assetEntry = await notFoundFindAssetEntryForPath("/index.html")) {
-      return notFoundServeAsset(assetEntry, { preserve: false });
-    }
-    return new NotFoundResponse();
-  },
-  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_VERSION ? metadata.redirects.staticRules || {} : {};
-  const staticRedirectsMatcher = () => {
-    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 generateRedirectsMatcher = () => generateRulesMatcher(
-    metadata.redirects?.version === REDIRECTS_VERSION ? metadata.redirects.rules : {},
-    ({ status, to }, replacements) => ({
-      status,
-      to: replacer(to, replacements)
-    })
-  );
-  let assetEntry;
-  async function generateResponse() {
-    const match = staticRedirectsMatcher() || generateRedirectsMatcher()({ request })[0];
-    if (match) {
-      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}${destination.search ? "" : search}${destination.hash}`;
-      switch (status) {
-        case 301:
-          return new MovedPermanentlyResponse(location);
-        case 303:
-          return new SeeOtherResponse(location);
-        case 307:
-          return new TemporaryRedirectResponse(location);
-        case 308:
-          return new PermanentRedirectResponse(location);
-        case 302:
-        default:
-          return new FoundResponse(location);
-      }
-    }
-    if (!request.method.match(/^(get|head)$/i)) {
-      return new MethodNotAllowedResponse();
-    }
-    try {
-      pathname = globalThis.decodeURIComponent(pathname);
-    } catch (err) {
-    }
-    if (pathname.endsWith("/")) {
-      if (assetEntry = await findAssetEntryForPath(`${pathname}index.html`)) {
-        return serveAsset(assetEntry);
-      } else if (pathname.endsWith("/index/")) {
-        return new PermanentRedirectResponse(
-          `/${pathname.slice(1, -"index/".length)}${search}`
-        );
-      } else if (assetEntry = await findAssetEntryForPath(
-        `${pathname.replace(/\/$/, ".html")}`
-      )) {
-        return new PermanentRedirectResponse(
-          `/${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 PermanentRedirectResponse(
-            `${extensionlessPath.replace(/\/index$/, "/")}${search}`
-          );
-        } else if (await findAssetEntryForPath(extensionlessPath) || extensionlessPath === "/") {
-          return serveAsset(assetEntry);
-        } else {
-          return new PermanentRedirectResponse(`${extensionlessPath}${search}`);
-        }
-      } else {
-        return serveAsset(assetEntry);
-      }
-    } else if (pathname.endsWith("/index")) {
-      return new PermanentRedirectResponse(
-        `/${pathname.slice(1, -"index".length)}${search}`
-      );
-    } else if (assetEntry = await findAssetEntryForPath(`${pathname}.html`)) {
-      return serveAsset(assetEntry);
-    } else if (hasFileExtension(pathname)) {
-      return notFound();
-    }
-    if (assetEntry = await findAssetEntryForPath(`${pathname}/index.html`)) {
-      return new PermanentRedirectResponse(`${pathname}/${search}`);
-    } else {
-      return notFound();
-    }
-  }
-  async function attachHeaders(response) {
-    const existingHeaders = new Headers(response.headers);
-    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({
-      ...Object.fromEntries(existingHeaders.entries()),
-      ...Object.fromEntries(extraHeaders.entries())
-    });
-    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 = [] }) => {
-      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());
-        }
-      });
-      unset.forEach((key) => {
-        headers.delete(key);
-      });
-    });
-    if (earlyHintsCache) {
-      const preEarlyHintsHeaders = new Headers(headers);
-      const earlyHintsCacheKey = `${protocol}//${host}${pathname}`;
-      const earlyHintsResponse = await earlyHintsCache.match(
-        earlyHintsCacheKey
-      );
-      if (earlyHintsResponse) {
-        const earlyHintsLinkHeader = earlyHintsResponse.headers.get("Link");
-        if (earlyHintsLinkHeader) {
-          headers.set("Link", earlyHintsLinkHeader);
-        }
-      }
-      const clonedResponse = response.clone();
-      if (waitUntil) {
-        waitUntil(
-          (async () => {
-            try {
-              const links = [];
-              const transformedResponse = new HTMLRewriter().on("link[rel=preconnect],link[rel=preload]", {
-                element(element) {
-                  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");
-              if (linkHeader) {
-                await earlyHintsCache.put(
-                  earlyHintsCacheKey,
-                  new Response(null, { headers: { Link: linkHeader } })
-                );
-              }
-            } catch (err) {
-            }
-          })()
-        );
-      }
-    }
-    return new Response(
-      [101, 204, 205, 304].includes(response.status) ? null : response.body,
-      {
-        headers,
-        status: response.status,
-        statusText: response.statusText
-      }
-    );
-  }
-  return await attachHeaders(await generateResponse());
-  async function serveAsset(servingAssetEntry, options = { preserve: true }) {
-    let content;
-    try {
-      content = negotiateContent(request, servingAssetEntry);
-    } catch (err) {
-      return new NotAcceptableResponse();
-    }
-    const assetKey = getAssetKey(servingAssetEntry, content);
-    const etag = `"${assetKey}"`;
-    const weakEtag = `W/${etag}`;
-    const ifNoneMatch = request.headers.get("if-none-match");
-    if (ifNoneMatch === weakEtag || ifNoneMatch === etag) {
-      return new NotModifiedResponse();
-    }
-    try {
-      const asset = await fetchAsset(assetKey);
-      const headers = {
-        etag,
-        "content-type": asset.contentType
-      };
-      let encodeBody = "automatic";
-      if (xServerEnvHeader) {
-        headers["x-server-env"] = xServerEnvHeader;
-      }
-      if (content.encoding) {
-        encodeBody = "manual";
-        headers["cache-control"] = "no-transform";
-        headers["content-encoding"] = content.encoding;
-      }
-      const response = new OkResponse(
-        request.method === "HEAD" ? null : asset.body,
-        {
-          headers,
-          encodeBody
-        }
-      );
-      if (isCacheable(request)) {
-        response.headers.append("cache-control", CACHE_CONTROL_BROWSER);
-      }
-      attachAdditionalHeaders(response, content, servingAssetEntry, asset);
-      if (isPreview(new URL(request.url))) {
-        response.headers.set("x-robots-tag", "noindex");
-      }
-      if (options.preserve) {
-        const preservedResponse = new Response(
-          [101, 204, 205, 304].includes(response.status) ? null : response.clone().body,
-          response
-        );
-        preservedResponse.headers.set(
-          "cache-control",
-          CACHE_CONTROL_PRESERVATION
-        );
-        preservedResponse.headers.set("x-robots-tag", "noindex");
-        if (waitUntil && caches) {
-          waitUntil(
-            caches.open(ASSET_PRESERVATION_CACHE).then(
-              (assetPreservationCache) => assetPreservationCache.put(request.url, preservedResponse)
-            ).catch((err) => {
-              logError(err);
-            })
-          );
-        }
-      }
-      if (asset.contentType.startsWith("text/html") && metadata.analytics?.version === ANALYTICS_VERSION) {
-        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 InternalServerErrorResponse(err);
-    }
-  }
-  async function notFound() {
-    if (caches) {
-      const assetPreservationCache = await caches.open(
-        ASSET_PRESERVATION_CACHE
-      );
-      const preservedResponse = await assetPreservationCache.match(request.url);
-      if (preservedResponse) {
-        return preservedResponse;
-      }
-    }
-    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 (err) {
-          return new NotAcceptableResponse();
-        }
-        const assetKey = getAssetKey(assetEntry, content);
-        try {
-          const { body, contentType } = await fetchAsset(assetKey);
-          const response = new NotFoundResponse(body);
-          response.headers.set("content-type", contentType);
-          return response;
-        } catch (err) {
-          logError(err);
-          return new InternalServerErrorResponse(err);
-        }
-      }
-    }
-    return await generateNotFoundResponse(
-      request,
-      findAssetEntryForPath,
-      serveAsset
-    );
-  }
-}
-export 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 hasFileExtension(path) {
-  return /\/.+\.[a-z0-9]+$/i.test(path);
-}
-function isPreview(url) {
-  if (url.hostname.endsWith(".pages.dev")) {
-    return url.hostname.split(".").length > 3 ? true : false;
-  }
-  return false;
-}

package/dist/asset-server/patchUrl.js

@@ -1,15 +0,0 @@
-globalThis.URL = function(globalURL) {
-  PatchedURL.prototype = globalURL.prototype;
-  PatchedURL.createObjectURL = globalURL.createObjectURL;
-  PatchedURL.revokeObjectURL = globalURL.revokeObjectURL;
-  return PatchedURL;
-  function PatchedURL(input, base) {
-    const url = new globalURL(encodeURI(input), base);
-    return new Proxy(url, {
-      get(target, prop) {
-        return globalThis.decodeURIComponent(target[prop]);
-      }
-    });
-  }
-}(URL);
-export {};

package/dist/asset-server/responses.js

@@ -1,123 +0,0 @@
-function mergeHeaders(base, extra) {
-  base = new Headers(base ?? {});
-  extra = new Headers(extra ?? {});
-  return new Headers({
-    ...Object.fromEntries(base.entries()),
-    ...Object.fromEntries(extra.entries())
-  });
-}
-export class OkResponse extends Response {
-  constructor(...[body, init]) {
-    super(body, {
-      ...init,
-      status: 200,
-      statusText: "OK"
-    });
-  }
-}
-export class MovedPermanentlyResponse extends Response {
-  constructor(location, init) {
-    super(`Redirecting to ${location}`, {
-      ...init,
-      status: 301,
-      statusText: "Moved Permanently",
-      headers: mergeHeaders(init?.headers, {
-        location
-      })
-    });
-  }
-}
-export class FoundResponse extends Response {
-  constructor(location, init) {
-    super(`Redirecting to ${location}`, {
-      ...init,
-      status: 302,
-      statusText: "Found",
-      headers: mergeHeaders(init?.headers, {
-        location
-      })
-    });
-  }
-}
-export class NotModifiedResponse extends Response {
-  constructor(...[_body, _init]) {
-    super(void 0, {
-      status: 304,
-      statusText: "Not Modified"
-    });
-  }
-}
-export class PermanentRedirectResponse extends Response {
-  constructor(location, init) {
-    super(void 0, {
-      ...init,
-      status: 308,
-      statusText: "Permanent Redirect",
-      headers: mergeHeaders(init?.headers, {
-        location
-      })
-    });
-  }
-}
-export class NotFoundResponse extends Response {
-  constructor(...[body, init]) {
-    super(body, {
-      ...init,
-      status: 404,
-      statusText: "Not Found"
-    });
-  }
-}
-export class MethodNotAllowedResponse extends Response {
-  constructor(...[body, init]) {
-    super(body, {
-      ...init,
-      status: 405,
-      statusText: "Method Not Allowed"
-    });
-  }
-}
-export class NotAcceptableResponse extends Response {
-  constructor(...[body, init]) {
-    super(body, {
-      ...init,
-      status: 406,
-      statusText: "Not Acceptable"
-    });
-  }
-}
-export class InternalServerErrorResponse 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"
-    });
-  }
-}
-export class SeeOtherResponse extends Response {
-  constructor(location, init) {
-    super(`Redirecting to ${location}`, {
-      ...init,
-      status: 303,
-      statusText: "See Other",
-      headers: mergeHeaders(init?.headers, { location })
-    });
-  }
-}
-export class TemporaryRedirectResponse extends Response {
-  constructor(location, init) {
-    super(`Redirecting to ${location}`, {
-      ...init,
-      status: 307,
-      statusText: "Temporary Redirect",
-      headers: mergeHeaders(init?.headers, { location })
-    });
-  }
-}

package/dist/asset-server/rulesEngine.js

@@ -1,44 +0,0 @@
-const ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
-const escapeRegex = (str) => {
-  return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
-};
-const HOST_PLACEHOLDER_REGEX = /(?<=^https:\\\/\\\/[^/]*?):([^\\]+)(?=\\)/g;
-const PLACEHOLDER_REGEX = /:(\w+)/g;
-export const replacer = (str, replacements) => {
-  for (const [replacement, value] of Object.entries(replacements)) {
-    str = str.replaceAll(`:${replacement}`, value);
-  }
-  return str;
-};
-export const generateRulesMatcher = (rules, replacerFn = (match) => match) => {
-  if (!rules)
-    return () => [];
-  const compiledRules = Object.entries(rules).map(([rule, match]) => {
-    const crossHost = rule.startsWith("https://");
-    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 + "$";
-    try {
-      const regExp = new RegExp(rule);
-      return [{ crossHost, regExp }, match];
-    } catch {
-    }
-  }).filter((value) => value !== void 0);
-  return ({ request }) => {
-    const { pathname, host } = new URL(request.url);
-    return compiledRules.map(([{ crossHost, regExp }, match]) => {
-      const test = crossHost ? `https://${host}${pathname}` : pathname;
-      const result = regExp.exec(test);
-      if (result) {
-        return replacerFn(match, result.groups || {});
-      }
-    }).filter((value) => value !== void 0);
-  };
-};

package/dist/environment-polyfills/index.js

@@ -1,10 +0,0 @@
-export const polyfill = (environment) => {
-  Object.entries(environment).map(([name, value]) => {
-    Object.defineProperty(globalThis, name, {
-      value,
-      configurable: true,
-      enumerable: true,
-      writable: true
-    });
-  });
-};

package/dist/environment-polyfills/miniflare.js

@@ -1,13 +0,0 @@
-import {
-  fetch as miniflareFetch,
-  Headers as MiniflareHeaders,
-  Request as MiniflareRequest,
-  Response as MiniflareResponse
-} from "@miniflare/core";
-import { polyfill } from ".";
-polyfill({
-  fetch: miniflareFetch,
-  Headers: MiniflareHeaders,
-  Request: MiniflareRequest,
-  Response: MiniflareResponse
-});

package/dist/environment-polyfills/types.js

@@ -1 +0,0 @@
-export {};

package/dist/index.js

@@ -1 +0,0 @@
-export {};

package/dist/metadata-generator/constants.js

@@ -1,13 +0,0 @@
-export const REDIRECTS_VERSION = 1;
-export const HEADERS_VERSION = 2;
-export const ANALYTICS_VERSION = 1;
-export const ROUTES_JSON_VERSION = 1;
-export const PERMITTED_STATUS_CODES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-export const HEADER_SEPARATOR = ":";
-export const MAX_LINE_LENGTH = 2e3;
-export const MAX_HEADER_RULES = 100;
-export const MAX_DYNAMIC_REDIRECT_RULES = 100;
-export const MAX_STATIC_REDIRECT_RULES = 2e3;
-export const UNSET_OPERATOR = "! ";
-export const SPLAT_REGEX = /\*/g;
-export const PLACEHOLDER_REGEX = /:\w+/g;

package/dist/metadata-generator/createMetadataObject.js

@@ -1,118 +0,0 @@
-import {
-  ANALYTICS_VERSION,
-  REDIRECTS_VERSION,
-  HEADERS_VERSION,
-  SPLAT_REGEX,
-  PLACEHOLDER_REGEX
-} from "./constants";
-export function createMetadataObject({
-  redirects,
-  headers,
-  webAnalyticsToken,
-  deploymentId,
-  logger = (_message) => {
-  }
-}) {
-  return {
-    ...constructRedirects({ redirects, logger }),
-    ...constructHeaders({ headers, logger }),
-    ...constructWebAnalytics({ webAnalyticsToken, logger }),
-    deploymentId
-  };
-}
-function constructRedirects({
-  redirects,
-  logger
-}) {
-  if (!redirects)
-    return {};
-  const num_valid = redirects.rules.length;
-  const num_invalid = redirects.invalid.length;
-  logger(
-    `Parsed ${num_valid} valid redirect rule${num_valid === 1 ? "" : "s"}.`
-  );
-  if (num_invalid > 0) {
-    logger(`Found invalid redirect lines:`);
-    for (const { line, lineNumber, message } of redirects.invalid) {
-      if (line)
-        logger(`  - ${lineNumber ? `#${lineNumber}: ` : ""}${line}`);
-      logger(`    ${message}`);
-    }
-  }
-  if (num_valid === 0) {
-    return {};
-  }
-  const staticRedirects = {};
-  const dynamicRedirects = {};
-  let canCreateStaticRule = true;
-  for (const rule of redirects.rules) {
-    if (!rule.from.match(SPLAT_REGEX) && !rule.from.match(PLACEHOLDER_REGEX)) {
-      if (canCreateStaticRule) {
-        staticRedirects[rule.from] = { status: rule.status, to: rule.to };
-        continue;
-      } else {
-        logger(
-          `Info: the redirect rule ${rule.from} \u2192 ${rule.status} ${rule.to} could be made more performant by bringing it above any lines with splats or placeholders.`
-        );
-      }
-    }
-    dynamicRedirects[rule.from] = { status: rule.status, to: rule.to };
-    canCreateStaticRule = false;
-  }
-  return {
-    redirects: {
-      version: REDIRECTS_VERSION,
-      staticRules: staticRedirects,
-      rules: dynamicRedirects
-    }
-  };
-}
-function constructHeaders({
-  headers,
-  logger
-}) {
-  if (!headers)
-    return {};
-  const num_valid = headers.rules.length;
-  const num_invalid = headers.invalid.length;
-  logger(`Parsed ${num_valid} valid header rule${num_valid === 1 ? "" : "s"}.`);
-  if (num_invalid > 0) {
-    logger(`Found invalid header lines:`);
-    for (const { line, lineNumber, message } of headers.invalid) {
-      if (line)
-        logger(`  - ${lineNumber ? `#${lineNumber}: ` : ""} ${line}`);
-      logger(`    ${message}`);
-    }
-  }
-  if (num_valid === 0) {
-    return {};
-  }
-  const rules = {};
-  for (const rule of headers.rules) {
-    rules[rule.path] = {};
-    if (Object.keys(rule.headers).length) {
-      rules[rule.path].set = rule.headers;
-    }
-    if (rule.unsetHeaders.length) {
-      rules[rule.path].unset = rule.unsetHeaders;
-    }
-  }
-  return {
-    headers: {
-      version: HEADERS_VERSION,
-      rules
-    }
-  };
-}
-function constructWebAnalytics({
-  webAnalyticsToken
-}) {
-  if (!webAnalyticsToken)
-    return {};
-  return {
-    analytics: {
-      version: ANALYTICS_VERSION,
-      token: webAnalyticsToken
-    }
-  };
-}

package/dist/metadata-generator/parseHeaders.js

@@ -1,140 +0,0 @@
-import {
-  MAX_LINE_LENGTH,
-  MAX_HEADER_RULES,
-  HEADER_SEPARATOR,
-  UNSET_OPERATOR
-} from "./constants";
-import { validateUrl } from "./validateURL";
-const LINE_IS_PROBABLY_A_PATH = new RegExp(/^([^\s]+:\/\/|^\/)/);
-export function parseHeaders(input) {
-  const lines = input.split("\n");
-  const rules = [];
-  const invalid = [];
-  let rule = void 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (line.length === 0 || line.startsWith("#"))
-      continue;
-    if (line.length > MAX_LINE_LENGTH) {
-      invalid.push({
-        message: `Ignoring line ${i + 1} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`
-      });
-      continue;
-    }
-    if (LINE_IS_PROBABLY_A_PATH.test(line)) {
-      if (rules.length >= MAX_HEADER_RULES) {
-        invalid.push({
-          message: `Maximum number of rules supported is ${MAX_HEADER_RULES}. Skipping remaining ${lines.length - i} lines of file.`
-        });
-        break;
-      }
-      if (rule) {
-        if (isValidRule(rule)) {
-          rules.push({
-            path: rule.path,
-            headers: rule.headers,
-            unsetHeaders: rule.unsetHeaders
-          });
-        } else {
-          invalid.push({
-            line: rule.line,
-            lineNumber: i + 1,
-            message: "No headers specified"
-          });
-        }
-      }
-      const [path, pathError] = validateUrl(line);
-      if (pathError) {
-        invalid.push({
-          line,
-          lineNumber: i + 1,
-          message: pathError
-        });
-        rule = void 0;
-        continue;
-      }
-      rule = {
-        path,
-        line,
-        headers: {},
-        unsetHeaders: []
-      };
-      continue;
-    }
-    if (!line.includes(HEADER_SEPARATOR)) {
-      if (!rule) {
-        invalid.push({
-          line,
-          lineNumber: i + 1,
-          message: "Expected a path beginning with at least one forward-slash"
-        });
-      } else {
-        if (line.trim().startsWith(UNSET_OPERATOR)) {
-          rule.unsetHeaders.push(line.trim().replace(UNSET_OPERATOR, ""));
-        } else {
-          invalid.push({
-            line,
-            lineNumber: i + 1,
-            message: "Expected a colon-separated header pair (e.g. name: value)"
-          });
-        }
-      }
-      continue;
-    }
-    const [rawName, ...rawValue] = line.split(HEADER_SEPARATOR);
-    const name = rawName.trim().toLowerCase();
-    if (name.includes(" ")) {
-      invalid.push({
-        line,
-        lineNumber: i + 1,
-        message: "Header name cannot include spaces"
-      });
-      continue;
-    }
-    const value = rawValue.join(HEADER_SEPARATOR).trim();
-    if (name === "") {
-      invalid.push({
-        line,
-        lineNumber: i + 1,
-        message: "No header name specified"
-      });
-      continue;
-    }
-    if (value === "") {
-      invalid.push({
-        line,
-        lineNumber: i + 1,
-        message: "No header value specified"
-      });
-      continue;
-    }
-    if (!rule) {
-      invalid.push({
-        line,
-        lineNumber: i + 1,
-        message: `Path should come before header (${name}: ${value})`
-      });
-      continue;
-    }
-    const existingValues = rule.headers[name];
-    rule.headers[name] = existingValues ? `${existingValues}, ${value}` : value;
-  }
-  if (rule) {
-    if (isValidRule(rule)) {
-      rules.push({
-        path: rule.path,
-        headers: rule.headers,
-        unsetHeaders: rule.unsetHeaders
-      });
-    } else {
-      invalid.push({ line: rule.line, message: "No headers specified" });
-    }
-  }
-  return {
-    rules,
-    invalid
-  };
-}
-function isValidRule(rule) {
-  return Object.keys(rule.headers).length > 0 || rule.unsetHeaders.length > 0;
-}

package/dist/metadata-generator/parseRedirects.js

@@ -1,100 +0,0 @@
-import {
-  MAX_LINE_LENGTH,
-  MAX_DYNAMIC_REDIRECT_RULES,
-  MAX_STATIC_REDIRECT_RULES,
-  PERMITTED_STATUS_CODES,
-  SPLAT_REGEX,
-  PLACEHOLDER_REGEX
-} from "./constants";
-import { validateUrl } from "./validateURL";
-export function parseRedirects(input) {
-  const lines = input.split("\n");
-  const rules = [];
-  const seen_paths = /* @__PURE__ */ new Set();
-  const invalid = [];
-  let staticRules = 0;
-  let dynamicRules = 0;
-  let canCreateStaticRule = true;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (line.length === 0 || line.startsWith("#"))
-      continue;
-    if (line.length > MAX_LINE_LENGTH) {
-      invalid.push({
-        message: `Ignoring line ${i + 1} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`
-      });
-      continue;
-    }
-    const tokens = line.split(/\s+/);
-    if (tokens.length < 2 || tokens.length > 3) {
-      invalid.push({
-        line,
-        lineNumber: i + 1,
-        message: `Expected exactly 2 or 3 whitespace-separated tokens. Got ${tokens.length}.`
-      });
-      continue;
-    }
-    const [str_from, str_to, str_status = "302"] = tokens;
-    const fromResult = validateUrl(str_from, true, false, false);
-    if (fromResult[0] === void 0) {
-      invalid.push({
-        line,
-        lineNumber: i + 1,
-        message: fromResult[1]
-      });
-      continue;
-    }
-    const from = fromResult[0];
-    if (canCreateStaticRule && !from.match(SPLAT_REGEX) && !from.match(PLACEHOLDER_REGEX)) {
-      staticRules += 1;
-      if (staticRules > MAX_STATIC_REDIRECT_RULES) {
-        invalid.push({
-          message: `Maximum number of static rules supported is ${MAX_STATIC_REDIRECT_RULES}. Skipping line.`
-        });
-        continue;
-      }
-    } else {
-      dynamicRules += 1;
-      canCreateStaticRule = false;
-      if (dynamicRules > MAX_DYNAMIC_REDIRECT_RULES) {
-        invalid.push({
-          message: `Maximum number of dynamic rules supported is ${MAX_DYNAMIC_REDIRECT_RULES}. Skipping remaining ${lines.length - i} lines of file.`
-        });
-        break;
-      }
-    }
-    const toResult = validateUrl(str_to, false, true, true);
-    if (toResult[0] === void 0) {
-      invalid.push({
-        line,
-        lineNumber: i + 1,
-        message: toResult[1]
-      });
-      continue;
-    }
-    const to = toResult[0];
-    const status = Number(str_status);
-    if (isNaN(status) || !PERMITTED_STATUS_CODES.has(status)) {
-      invalid.push({
-        line,
-        lineNumber: i + 1,
-        message: `Valid status codes are 301, 302 (default), 303, 307, or 308. Got ${str_status}.`
-      });
-      continue;
-    }
-    if (seen_paths.has(from)) {
-      invalid.push({
-        line,
-        lineNumber: i + 1,
-        message: `Ignoring duplicate rule for path ${from}.`
-      });
-      continue;
-    }
-    seen_paths.add(from);
-    rules.push({ from, to, status, lineNumber: i + 1 });
-  }
-  return {
-    rules,
-    invalid
-  };
-}

package/dist/metadata-generator/validateURL.js

@@ -1,41 +0,0 @@
-export const extractPathname = (path = "/", includeSearch, includeHash) => {
-  if (!path.startsWith("/"))
-    path = `/${path}`;
-  const url = new URL(`//${path}`, "relative://");
-  return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
-};
-const URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
-const PATH_REGEX = /^\//;
-export const validateUrl = (token, onlyRelative = false, includeSearch = false, includeHash = false) => {
-  const host = URL_REGEX.exec(token);
-  if (host && host.groups && host.groups.host) {
-    if (onlyRelative)
-      return [
-        void 0,
-        `Only relative URLs are allowed. Skipping absolute URL ${token}.`
-      ];
-    return [
-      `https://${host.groups.host}${extractPathname(
-        host.groups.path,
-        includeSearch,
-        includeHash
-      )}`,
-      void 0
-    ];
-  } else {
-    if (!token.startsWith("/") && onlyRelative)
-      token = `/${token}`;
-    const path = PATH_REGEX.exec(token);
-    if (path) {
-      try {
-        return [extractPathname(token, includeSearch, includeHash), void 0];
-      } catch {
-        return [void 0, `Error parsing URL segment ${token}. Skipping.`];
-      }
-    }
-  }
-  return [
-    void 0,
-    onlyRelative ? "URLs should begin with a forward-slash." : 'URLs should either be relative (e.g. begin with a forward-slash), or use HTTPS (e.g. begin with "https://").'
-  ];
-};

package/src/index.ts

@@ -1 +0,0 @@
-export {};