@revealui/core 0.0.1-pre.1 → 0.0.1-pre.2

package/dist/exports/bin-entry.js

@@ -1,3 +1,5 @@
 #!/usr/bin/env node
 
-import "../../dist/node/cli/bin.js";
+// Import the CLI from node/cli/index.js (created by build script from core/cli/bin.js)
+// This matches the package.json exports structure
+import("../node/cli/index.js");

package/dist/node/cli/index.js

@@ -0,0 +1,3 @@
+// CLI entry point - imports from core/cli/bin.js
+export * from "../../core/cli/bin.js";
+export { default } from "../../core/cli/bin.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revealui/core",
-  "version": "0.0.1-pre.1",
+  "version": "0.0.1-pre.2",
   "description": "Modern React 19 framework with Next.js 16, Vike, and PayloadCMS integration. Production-ready, Vercel-optimized, and enterprise-grade.",
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "LICENSE_SUMMARY.md"
   ],
   "bin": {
-    "reveal": "./dist/core/cli/bin.js"
+    "reveal": "./dist/exports/bin-entry.js"
   },
   "license": "Apache-2.0",
   "keywords": [

package/dist/core/__internal/index.ts

@@ -1,63 +0,0 @@
-import { PageConfigRuntime } from "../../types/interfaces/page"
-import { handleNodeEnv_vitePluginVercel } from "../gaurds/assertions/assertNodeEnv"
-import {
-  getGlobalContext,
-  initGlobalContext_getGlobalContextAsync,
-} from "../globals/contexts"
-import { getPageFilesAll } from "../processing/getters/getPageFiles"
-import { getRenderContext } from "../renderer/page/renderPageAlreadyRouted"
-import { PageRoutes } from "../router"
-import { routeInternal } from "../router/routeInternal"
-
-export { getPagesAndRoutes, route }
-export type { PageConfigRuntime as PageConfig, PageFile, PageRoutes }
-
-export { getPageFilesAllSafe }
-
-type PageFile = {
-  fileType: "page" | "layout" | "error" | "config" | "data" | "onBeforeRender" | "onRenderClient" | "onRenderHtml" | "env" | "route" | "renderer" | "head" | "client" | "server" | "default" | "config" | "css" | "unknown" | ".page.server" | ".page.client" | ".page.route" | ".css" | string
-  filePath: string
-  isEnv: (env: "CLIENT_ONLY" | "SERVER_ONLY" | "CLIENT_AND_SERVER") => boolean
-  fileExports?: Record<string, unknown>
-  loadFile?: () => Promise<void>
-  exportNames?: string[]
-  loadExportNames?: () => Promise<void>
-  isRelevant: (pageId: string) => boolean
-  isDefaultPageFile: boolean
-  isRendererPageFile: boolean
-  isErrorPageFile: boolean
-  pageId: string
-}
-
-async function getPagesAndRoutes() {
-  handleNodeEnv_vitePluginVercel()
-  const renderContext = await getRenderContext()
-  const { pageRoutes, pageFilesAll, pageConfigs, allPageIds } = renderContext
-  return {
-    pageRoutes,
-    pageFilesAll,
-    pageConfigs,
-    allPageIds,
-  }
-}
-
-/**
- * Safely gets all page files
- * @param isProduction - Whether running in production mode
- * @returns Array of page files
- * @internal
- * Note: This will be refactored once global config refactoring is complete
- * @see https://github.com/revealjs/reveal/pull/1823
- */
-async function getPageFilesAllSafe(isProduction: boolean) {
-  await initGlobalContext_getGlobalContextAsync(isProduction)
-  const globalContext = getGlobalContext()
-  const pageFilesAll = await getPageFilesAll(false, globalContext.isProduction)
-  return pageFilesAll
-}
-
-async function route(pageContext: Parameters<typeof routeInternal>[0]) {
-  const pageContextFromRoute = await routeInternal(pageContext)
-  // Old interface
-  return { pageContextAddendum: pageContextFromRoute }
-}

package/dist/core/__tests__/assertNoInfiniteHttpRedirect.spec.ts

@@ -1,76 +0,0 @@
-import { assert, describe, expect, it } from "vitest"
-import { assertNoInfiniteHttpRedirect } from "../gaurds/assertions/assertNoInfiniteHttpRedirect"
-import { stripAnsi } from "../utils/string/stripAnsi"
-
-describe("assertNoInfiniteHttpRedirect()", () => {
-  it("works", () => {
-    expectErr(
-      () => {
-        assertNoInfiniteHttpRedirect("/a", "/a")
-      },
-      (msg) => {
-        expect(msg).toMatchInlineSnapshot(
-          '"[reveal][Wrong Usage] Infinite loop of HTTP URL redirects: /a -> /a"'
-        )
-      }
-    )
-    assertNoInfiniteHttpRedirect("/a", "/b")
-    expectErr(
-      () => {
-        assertNoInfiniteHttpRedirect("/a", "/a")
-      },
-      (msg) => {
-        expect(msg).toMatchInlineSnapshot(
-          '"[reveal][Wrong Usage] Infinite loop of HTTP URL redirects: /a -> /a"'
-        )
-      }
-    )
-    expectErr(
-      () => {
-        assertNoInfiniteHttpRedirect("/b", "/a")
-      },
-      (msg) => {
-        expect(msg).toMatchInlineSnapshot(
-          '"[reveal][Wrong Usage] Infinite loop of HTTP URL redirects: /a -> /b -> /a"'
-        )
-      }
-    )
-    assertNoInfiniteHttpRedirect("/a", "/c")
-    assertNoInfiniteHttpRedirect("/b", "/c")
-    assertNoInfiniteHttpRedirect("/c", "/d")
-    expectErr(
-      () => {
-        assertNoInfiniteHttpRedirect("/d", "/b")
-      },
-      (msg) => {
-        expect(msg).toMatchInlineSnapshot(
-          '"[reveal][Wrong Usage] Infinite loop of HTTP URL redirects: /b -> /c -> /d -> /b"'
-        )
-      }
-    )
-    assertNoInfiniteHttpRedirect("/a", "/e")
-    assertNoInfiniteHttpRedirect("/e", "/c")
-    expectErr(
-      () => {
-        assertNoInfiniteHttpRedirect("/d", "/a")
-      },
-      (msg) => {
-        expect(msg).toMatchInlineSnapshot(
-          '"[reveal][Wrong Usage] Infinite loop of HTTP URL redirects: /a -> /b -> /c -> /d -> /a"'
-        )
-      }
-    )
-  })
-})
-
-function expectErr(fn: Function, validate: (msg: string) => void) {
-  let err: Error | undefined
-  try {
-    fn()
-  } catch (err_) {
-    err = err_ as Error
-  }
-  expect(err).toBeTruthy()
-  assert(err)
-  validate(stripAnsi(err.message))
-}

package/dist/core/__tests__/deduceRouteStringFromFilesystemPath.spec.ts

@@ -1,88 +0,0 @@
-import { deduceRouteStringFromFilesystemPath } from "../router/deduceRouteStringFromFilesystemPath.js";
-import { expect, describe, it } from "vitest";
-
-describe("deduceRouteStringFromFilesystemPath", () => {
-  it("basics", () => {
-    let p1 = "/pages/index";
-    expect(deduceRouteStringFromFilesystemPath(p1, [])).toBe("/");
-    p1 = "/pages/index/index";
-    expect(deduceRouteStringFromFilesystemPath(p1, [])).toBe("/");
-
-    const p2 = "/pages/about";
-    expect(deduceRouteStringFromFilesystemPath(p2, [])).toBe("/about");
-
-    const p3 = "/pages/contact/index";
-    expect(deduceRouteStringFromFilesystemPath(p3, [])).toBe("/contact");
-    expect(deduceRouteStringFromFilesystemPath(p3, [])).toBe("/contact");
-    expect(deduceRouteStringFromFilesystemPath(p3, [])).toBe("/contact");
-  });
-
-  it("ignored directories", () => {
-    let p = "/src/pages/index/index";
-    expect(deduceRouteStringFromFilesystemPath(p, [])).toBe("/");
-    p = "/src/pages/about/index";
-    expect(deduceRouteStringFromFilesystemPath(p, [])).toBe("/about");
-    expect(deduceRouteStringFromFilesystemPath(p, [])).toBe("/about");
-  });
-
-  it("filesystem roots", () => {
-    // prettier-ignore
-    // biome-ignore format:
-    const pS = [
-      '/pages/admin/index/index',
-      '/pages/admin/login/index',
-      '/pages/index/index',
-      '/pages/about/index',
-    ]
-    expect(deduceRouteStringFromFilesystemPath(pS[0]!, [])).toBe("/admin");
-    expect(deduceRouteStringFromFilesystemPath(pS[1]!, [])).toBe(
-      "/admin/login",
-    );
-    expect(deduceRouteStringFromFilesystemPath(pS[3]!, [])).toBe("/about");
-    const fsBase = { filesystemRoot: "/pages/admin", urlRoot: "/_admin" };
-    expect(deduceRouteStringFromFilesystemPath(pS[0]!, [fsBase])).toBe(
-      "/_admin",
-    );
-    expect(deduceRouteStringFromFilesystemPath(pS[1]!, [fsBase])).toBe(
-      "/_admin/login",
-    );
-    expect(deduceRouteStringFromFilesystemPath(pS[3]!, [fsBase])).toBe(
-      "/about",
-    );
-  });
-
-  it("domain-driven file structure", () => {
-    // prettier-ignore
-    // biome-ignore format:
-    const pS = [
-      '/product/pages/index',
-      '/product/pages/@id',
-      '/auth/pages/index/index',
-      '/auth/pages/login/index',
-      '/marketing/pages/index/index',
-      '/marketing/pages/about/index',
-    ]
-    const fsBase = { filesystemRoot: "/marketing/pages", urlRoot: "/" };
-    expect(deduceRouteStringFromFilesystemPath(pS[0]!, [fsBase])).toBe(
-      "/product",
-    );
-    expect(deduceRouteStringFromFilesystemPath(pS[1]!, [fsBase])).toBe(
-      "/product/@id",
-    );
-    expect(deduceRouteStringFromFilesystemPath(pS[2]!, [fsBase])).toBe("/auth");
-    expect(deduceRouteStringFromFilesystemPath(pS[3]!, [fsBase])).toBe(
-      "/auth/login",
-    );
-    expect(deduceRouteStringFromFilesystemPath(pS[4]!, [fsBase])).toBe("/");
-    expect(deduceRouteStringFromFilesystemPath(pS[5]!, [fsBase])).toBe(
-      "/about",
-    );
-  });
-
-  it("all features", () => {
-    let p1 = "/src/product/src/pages/@id";
-    let p2 = "/src/auth/src/pages/index";
-    expect(deduceRouteStringFromFilesystemPath(p1, [])).toBe("/product/@id");
-    expect(deduceRouteStringFromFilesystemPath(p2, [])).toBe("/auth");
-  });
-});

package/dist/core/__tests__/freezePartial.spec.ts

@@ -1,40 +0,0 @@
-import { expect, describe, it } from "vitest";
-import pc from "@brillout/picocolors";
-import { freezePartial } from "../gaurds/normalization/freezePartial";
-
-describe("freezePartial", () => {
-  it("works", () => {
-    const obj = {
-      question: 42,
-      changeme: "hello",
-    };
-    freezePartial(obj, {
-      changeme: (val) => ["bonjour", "hello"].includes(val as any),
-    });
-
-    expect(obj.question).toBe(42);
-    expect(() => {
-      obj.question = 4;
-    }).toThrowError(
-      `You aren't allowed to mutate property ${pc.cyan("question")}`,
-    );
-    expect(obj.question).toBe(42);
-
-    expect(() => {
-      // @ts-ignore
-      delete obj.question;
-    }).toThrowError("Cannot delete property 'question' of #<Object>");
-    expect(() => {
-      (obj as any).newProp = 11;
-    }).toThrowError("Cannot add property newProp, object is not extensible");
-
-    expect(obj.changeme).toBe("hello");
-    expect(() => {
-      obj.changeme = "abc";
-    }).toThrowError(
-      `Setting wrong value ${pc.cyan('"abc"')} for property ${pc.cyan("changeme")}`,
-    );
-    obj.changeme = "bonjour";
-    expect(obj.changeme).toBe("bonjour");
-  });
-});

package/dist/core/__tests__/getValuePrintable.spec.ts

@@ -1,15 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getValuePrintable } from "../processing/getters/getValuePrintable";
-
-describe("getValuePrintable()", () => {
-  it("works", () => {
-    expect(getValuePrintable("Hello, World")).toBe('"Hello, World"');
-    expect(getValuePrintable("1")).toBe('"1"');
-    expect(getValuePrintable('1"')).toBe('"1\\""');
-    expect(getValuePrintable(1)).toBe("1");
-    expect(getValuePrintable(true)).toBe("true");
-    expect(getValuePrintable(false)).toBe("false");
-    expect(getValuePrintable(undefined)).toBe("undefined");
-    expect(getValuePrintable(null)).toBe("null");
-  });
-});

package/dist/core/__tests__/injectHtmlTags.spec.ts

@@ -1,101 +0,0 @@
-import {
-  injectAtOpeningTag,
-  injectAtClosingTag,
-} from "../assets/injectHtmlTags.js";
-import { expect, describe, it } from "vitest";
-
-const htmlHead1 = "<html><head></head></html>";
-const htmlHead2 = `<html>
-  <head></head>
-</html>`;
-const htmlHead3 = `<html>
-  <head>
-  </head>
-</html>`;
-
-const htmlBody1 = "<html><body></body></html>";
-const htmlBody2 = `<html>
-  <body></body>
-</html>`;
-const htmlBody3 = `<html>
-  <body>
-  </body>
-</html>`;
-
-const tag1 = '<link href="/foo.ttf">';
-const tag2 = '<script src="/foo.js"></script>';
-
-describe("injectHtmlTags", () => {
-  it("injectAtOpeningTag()", () => {
-    expect(injectAtOpeningTag("head", htmlHead1, tag1)).toMatchInlineSnapshot(
-      `"<html><head><link href="/foo.ttf"></head></html>"`,
-    );
-    expect(
-      injectAtOpeningTag("head", htmlHead1, `${tag1}${tag1}`),
-    ).toMatchInlineSnapshot(
-      `"<html><head><link href="/foo.ttf"><link href="/foo.ttf"></head></html>"`,
-    );
-    expect(
-      injectAtOpeningTag("head", htmlHead2, `${tag1}${tag1}`),
-    ).toMatchInlineSnapshot(
-      `
-      "<html>
-        <head>
-          <link href="/foo.ttf">
-          <link href="/foo.ttf">
-        </head>
-      </html>"
-    `,
-    );
-    expect(
-      injectAtOpeningTag("head", htmlHead3, `${tag2}${tag2}${tag1}`),
-    ).toMatchInlineSnapshot(
-      `
-      "<html>
-        <head>
-          <script src="/foo.js"></script>
-          <script src="/foo.js"></script>
-          <link href="/foo.ttf">
-        </head>
-      </html>"
-    `,
-    );
-  });
-
-  it("injectAtClosingTag()", () => {
-    expect(injectAtClosingTag("body", htmlBody1, tag1)).toMatchInlineSnapshot(
-      `"<html><body><link href="/foo.ttf"></body></html>"`,
-    );
-    expect(
-      injectAtClosingTag("body", htmlBody1, `${tag1}${tag1}`),
-    ).toMatchInlineSnapshot(
-      `"<html><body><link href="/foo.ttf"><link href="/foo.ttf"></body></html>"`,
-    );
-    expect(
-      injectAtClosingTag("body", htmlBody2, `${tag1}${tag1}`),
-    ).toMatchInlineSnapshot(
-      `
-      "<html>
-        <body>
-          <link href="/foo.ttf">
-          <link href="/foo.ttf">
-        </body>
-      </html>"
-    `,
-    );
-    expect(
-      injectAtClosingTag("body", htmlBody3, `${tag1}${tag2}${tag1}${tag2}`),
-    ).toMatchInlineSnapshot(
-      `
-      "<html>
-        <body>
-          <link href="/foo.ttf">
-          <script src="/foo.js"></script>
-          <link href="/foo.ttf">
-          <script src="/foo.js"></script>
-        </body>
-      </html>"
-    `,
-    );
-  });
-});

package/dist/core/__tests__/isHtml.spec.ts

@@ -1,23 +0,0 @@
-import { expect, describe, it } from "vitest";
-import { isHtml } from "../gaurds/validators/isHtml";
-
-describe("isHtml()", () => {
-  it("works", () => {
-    // Correctly identified as not HTML:
-    expect(isHtml("Hello, World")).toBe(false);
-    expect(isHtml("This is less than <, this is greater than >.")).toBe(false);
-    expect(isHtml(" a < 3 && b > 3")).toBe(false);
-    expect(isHtml("<<Important Text>>")).toBe(false);
-    expect(isHtml("<a>")).toBe(false);
-
-    // Correctly identified as HTML
-    expect(isHtml("<a>Foo</a>")).toBe(true);
-    expect(isHtml("<input type='submit' value='Ok' />")).toBe(true);
-    expect(isHtml("<br/>")).toBe(true);
-
-    // We don't handle, but could with more tweaking:
-    expect(isHtml("<br>")).toBe(false);
-    expect(isHtml("Foo &amp; bar")).toBe(false);
-    expect(isHtml("<input type='submit' value='Ok'>")).toBe(false);
-  });
-});

package/dist/core/__tests__/isNpmPackage.spec.ts

@@ -1,93 +0,0 @@
-import { expect, describe, it, assert } from "vitest";
-import {
-  isDistinguishable,
-  isValidPathAlias,
-  parse,
-} from "../gaurds/validators/isNpmPackage";
-
-describe("parse()", () => {
-  it("basics", () => {
-    expect(parse("some-pkg")).toStrictEqual({
-      pkgName: "some-pkg",
-      importPath: null,
-    });
-    expect(parse("@scope/name")).toStrictEqual({
-      pkgName: "@scope/name",
-      importPath: null,
-    });
-    expect(parse("@scope/name/path")).toStrictEqual({
-      pkgName: "@scope/name",
-      importPath: "path",
-    });
-    expect(parse("@scope/name/some/deep/path.js")).toStrictEqual({
-      pkgName: "@scope/name",
-      importPath: "some/deep/path.js",
-    });
-    expect(parse("somePkg")).toBe(null); // NPM packages are not allowed upper case characters in their name
-    expect(parse("./some/path")).toBe(null);
-    expect(parse("/some-path")).toBe(null);
-    expect(parse("\\some/path")).toBe(null);
-    expect(parse(".\\some-path")).toBe(null);
-    expect(parse("#alias")).toBe(null);
-    expect(parse("a!bc")).toBe(null);
-  });
-  it("edge cases", () => {
-    expect(parse("")).toBe(null);
-    expect(parse("a")).toStrictEqual({ pkgName: "a", importPath: null });
-    expect(parse("0")).toStrictEqual({ pkgName: "0", importPath: null }); // https://www.npmjs.com/package/0
-    expect(parse("-")).toBe(null); // actually wrong: https://www.npmjs.com/package/-
-    expect(parse("_")).toBe(null);
-    expect(parse(".")).toBe(null);
-    expect(parse(".a")).toBe(null);
-    expect(parse("a.js")).toStrictEqual({ pkgName: "a.js", importPath: null }); // https://www.npmjs.com/package/a.js
-    expect(parse("a.")).toStrictEqual({ pkgName: "a.", importPath: null }); // https://www.npmjs.com/package/a.js
-    expect(parse("a-")).toStrictEqual({ pkgName: "a-", importPath: null });
-    expect(parse("a_")).toStrictEqual({ pkgName: "a_", importPath: null });
-    expect(parse("@")).toBe(null);
-    expect(parse("@/")).toBe(null);
-    expect(parse("@/a")).toBe(null);
-    expect(parse("@a")).toBe(null);
-    expect(parse("@a/")).toBe(null);
-    expect(parse("@a/b")).toStrictEqual({ pkgName: "@a/b", importPath: null });
-    expect(parse("@a!b/c")).toBe(null);
-    expect(parse("@a/b/c!")).toStrictEqual({
-      pkgName: "@a/b",
-      importPath: "c!",
-    });
-  });
-});
-
-describe("isValidPathAlias()", () => {
-  it("basics", () => {
-    // Un-distinguishable from npm package names
-    expect(isValidPathAlias("a")).toBe(false);
-    expect(isValidPathAlias("a/b")).toBe(false);
-    expect(isValidPathAlias("a/b/c")).toBe(false);
-    expect(isValidPathAlias("a/b/c/d")).toBe(false);
-    expect(isValidPathAlias("@")).toBe(false);
-    expect(isValidPathAlias("@a")).toBe(false);
-    expect(isValidPathAlias("@a/b")).toBe(false);
-    expect(isValidPathAlias("@a/b/c")).toBe(false);
-    expect(isValidPathAlias("@a/b/c/d")).toBe(false);
-
-    // Edge-case needed by contra.com
-    expect(isValidPathAlias("@/a")).toBe(true);
-
-    // Starts with a special character
-    expect(isValidPathAlias("A")).toBe(false);
-    expect(isValidPathAlias("a!")).toBe(false);
-    // Even though they are distinguishable
-    assert(isDistinguishable("A"));
-    assert(isDistinguishable("a!"));
-
-    // Valid path aliases
-    expect(isValidPathAlias("#")).toBe(true);
-    expect(isValidPathAlias("#a")).toBe(true);
-    expect(isValidPathAlias("!")).toBe(true);
-    expect(isValidPathAlias("!a")).toBe(true);
-    expect(isValidPathAlias("/")).toBe(true);
-    expect(isValidPathAlias("/a")).toBe(true);
-    expect(isValidPathAlias("$a/b/c")).toBe(true);
-    expect(isValidPathAlias("%bla")).toBe(true);
-  });
-});

package/dist/core/__tests__/normalizeHeaders.spec.ts

@@ -1,142 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { normalizeHeaders } from "../gaurds/normalization/normalizeHeaders"
-
-describe("normalizeHeaders()", () => {
-  it("works", () => {
-    const myHeaders = new Headers()
-    myHeaders.append("Accept-Encoding", "deflate")
-    myHeaders.append("acCepT-encODing", "gzip")
-    myHeaders.append("accept-encoding", "br")
-    myHeaders.append("cONTENT-tYPE", "iMAge/jpeg")
-
-    const headersNormalized = {
-      "accept-encoding": "deflate, gzip, br",
-      "content-type": "iMAge/jpeg",
-    }
-    const headers1 = normalizeHeaders(myHeaders)
-    const headers2 = normalizeHeaders(headers1)
-    const headers3 = normalizeHeaders(headersNormalized)
-    expect(headers1).toStrictEqual(headersNormalized)
-    expect(headers2).toStrictEqual(headersNormalized)
-    expect(headers3).toStrictEqual(headersNormalized)
-
-    const valuesNormalized = ["deflate", "gzip", "br"]
-    const values1 = getValues(myHeaders.get("Accept-Encoding")!)
-    const values2 = getValues(headers2["accept-encoding"]!)
-    expect(values1).toStrictEqual(valuesNormalized)
-    expect(values2).toStrictEqual(valuesNormalized)
-  })
-
-  it("Real world - Cloudflare Workers", () => {
-    const { headersData, headersNormalized } = getCloudflareHeaders()
-    const headersOriginal = new Headers(headersData as [string, string][])
-    const headers1 = normalizeHeaders(headersOriginal)
-    const headers2 = normalizeHeaders(headersData)
-    const headers3 = normalizeHeaders(headersNormalized)
-    expect(headers1).toStrictEqual(headersNormalized)
-    expect(headers2).toStrictEqual(headersNormalized)
-    expect(headers3).toStrictEqual(headersNormalized)
-  })
-
-  it("Real world - Express.js + curl", () => {
-    const headersOriginal = {
-      host: "localhost:3000",
-      "user-agent": "curl/8.2.1",
-      accept: "*/*",
-    }
-    const headers = normalizeHeaders(headersOriginal)
-    expect(headers).toStrictEqual(headersOriginal)
-  })
-  it("Real world - Express.js + Chrome", () => {
-    const headersOriginal = {
-      host: "localhost:3000",
-      connection: "keep-alive",
-      "sec-ch-ua":
-        '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
-      "sec-ch-ua-mobile": "?0",
-      "sec-ch-ua-platform": '"Linux"',
-      "upgrade-insecure-requests": "1",
-      "user-agent":
-        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-      accept:
-        "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-      "sec-fetch-site": "none",
-      "sec-fetch-mode": "navigate",
-      "sec-fetch-user": "?1",
-      "sec-fetch-dest": "document",
-      "accept-encoding": "gzip, deflate, br, zstd",
-      "accept-language": "en-US,en;q=0.9,fr;q=0.8",
-    }
-    const headers = normalizeHeaders(headersOriginal)
-    expect(headers).toStrictEqual(headersOriginal)
-  })
-})
-
-function getValues(headerValue: string): string[] {
-  return headerValue.split(",").map((v) => v.trimStart())
-}
-
-function getCloudflareHeaders() {
-  return {
-    headersData: [
-      [
-        "accept",
-        "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-      ],
-      ["accept-encoding", "gzip, br"],
-      ["accept-language", "en-US,en;q=0.9,fr;q=0.8"],
-      ["cache-control", "max-age=0"],
-      ["cf-connecting-ip", "92.195.254.253"],
-      ["cf-ew-preview-server", "https://609m86.cfops.net"],
-      ["cf-ipcountry", "DE"],
-      ["cf-ray", "87df32115885a5fa"],
-      ["cf-visitor", '{"scheme":"https"}'],
-      ["connection", "Keep-Alive"],
-      ["host", "reveal_worker-example.brillout.workers.dev"],
-      [
-        "sec-ch-ua",
-        '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
-      ],
-      ["sec-ch-ua-mobile", "?0"],
-      ["sec-ch-ua-platform", '"Linux"'],
-      ["sec-fetch-dest", "document"],
-      ["sec-fetch-mode", "navigate"],
-      ["sec-fetch-site", "none"],
-      ["sec-fetch-user", "?1"],
-      ["upgrade-insecure-requests", "1"],
-      [
-        "user-agent",
-        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-      ],
-      ["x-forwarded-proto", "https"],
-      ["x-real-ip", "92.195.254.253"],
-    ],
-    headersNormalized: {
-      accept:
-        "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-      "accept-encoding": "gzip, br",
-      "accept-language": "en-US,en;q=0.9,fr;q=0.8",
-      "cache-control": "max-age=0",
-      "cf-connecting-ip": "92.195.254.253",
-      "cf-ew-preview-server": "https://609m86.cfops.net",
-      "cf-ipcountry": "DE",
-      "cf-ray": "87df32115885a5fa",
-      "cf-visitor": '{"scheme":"https"}',
-      connection: "Keep-Alive",
-      host: "reveal_worker-example.brillout.workers.dev",
-      "sec-ch-ua":
-        '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
-      "sec-ch-ua-mobile": "?0",
-      "sec-ch-ua-platform": '"Linux"',
-      "sec-fetch-dest": "document",
-      "sec-fetch-mode": "navigate",
-      "sec-fetch-site": "none",
-      "sec-fetch-user": "?1",
-      "upgrade-insecure-requests": "1",
-      "user-agent":
-        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-      "x-forwarded-proto": "https",
-      "x-real-ip": "92.195.254.253",
-    },
-  }
-}