Merge remote-tracking branch 'origin/main' into dave/nodemodule-preloadmodules

55 files changed, 1475 insertions, 317 deletions

diff --git a/.github/workflows/bun-linux-build.yml b/.github/workflows/bun-linux-build.yml
index 2bc131baf..932d7eef4 100644
--- a/.github/workflows/bun-linux-build.yml
+++ b/.github/workflows/bun-linux-build.yml
@@ -153,7 +153,25 @@ jobs:
           name: "Canary (${{github.sha}})"
           tag: "canary"
           artifacts: "${{runner.temp}}/release/bun-${{matrix.tag}}.zip,${{runner.temp}}/release/bun-${{matrix.tag}}-profile.zip"
+      - uses: sarisia/actions-status-discord@v1
+        if: failure() && github.repository_owner == 'oven-sh' && github.event_name == 'pull_request'
+        with:
+          title: ""
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          status: ${{ job.status }}
+          noprefix: true
+          nocontext: true
+          description: |
+            Pull Request
+            ### [${{github.event.pull_request.title}}](https://github.com/oven-sh/bun/pull/${{github.event.number}})
+
+            @${{ github.actor }}
+
+            Build failed on ${{ matrix.tag }}:
+
+            **[View build output](https://github.com/oven-sh/bun/actions/runs/${{github.run_id}})**
 
+            [Commit ${{github.sha}}](https://github.com/oven-sh/bun/commits/${{github.sha}})
   linux-test:
     name: Tests ${{matrix.tag}}
     runs-on: ubuntu-latest
@@ -181,8 +199,8 @@ jobs:
         with:
           name: bun-${{matrix.tag}}
           path: ${{runner.temp}}/release
-      - id: install
-        name: Install
+      - id: install-bun
+        name: Install Bun
         run: |
           cd ${{runner.temp}}/release
           unzip bun-${{matrix.tag}}.zip
@@ -190,6 +208,13 @@ jobs:
           chmod +x bun
           pwd >> $GITHUB_PATH
           ./bun --version
+      - id: install-dependnecies
+        name: Install dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y openssl
+          bun install --verbose
+          bun install --cwd=test --verbose
+          bun install --cwd=packages/bun-internal-test --verbose
       - id: test
         name: Test (node runner)
         env:
@@ -198,11 +223,24 @@ jobs:
           TLS_POSTGRES_DATABASE_URL: ${{ secrets.TLS_POSTGRES_DATABASE_URL }}
         # if: ${{github.event.inputs.use_bun == 'false'}}
         run: |
-          sudo apt-get update && sudo apt-get install -y openssl
-          bun install
-          bun install --cwd test
-          bun install --cwd packages/bun-internal-test
           node packages/bun-internal-test/src/runner.node.mjs || true
+      - uses: sarisia/actions-status-discord@v1
+        if: always() && steps.test.outputs.failing_tests != '' && github.event_name == 'pull_request'
+        with:
+          title: ""
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          status: "failure"
+          noprefix: true
+          nocontext: true
+          description: |
+            Pull Request
+            ### ❌ [${{github.event.pull_request.title}}](https://github.com/oven-sh/bun/pull/${{github.event.number}})
+
+            @${{ github.actor }}, there are ${{ steps.test.outputs.failing_tests_count }} files with test failures on ${{ matrix.tag }}:
+
+            ${{ steps.test.outputs.failing_tests }}
+
+            **[View test output](https://github.com/oven-sh/bun/actions/runs/${{github.run_id}})**
       - name: Comment on PR
         if: steps.test.outputs.failing_tests != '' && github.event_name == 'pull_request'
         uses: thollander/actions-comment-pull-request@v2
diff --git a/.github/workflows/bun-mac-aarch64.yml b/.github/workflows/bun-mac-aarch64.yml
index 4bc4d1494..46ecf77f4 100644
--- a/.github/workflows/bun-mac-aarch64.yml
+++ b/.github/workflows/bun-mac-aarch64.yml
@@ -393,6 +393,25 @@ jobs:
           name: "Canary (${{github.sha}})"
           tag: "canary"
           artifacts: "${{runner.temp}}/release/${{matrix.tag}}.zip,${{runner.temp}}/release/${{matrix.tag}}-profile.zip"
+      - uses: sarisia/actions-status-discord@v1
+        if: failure() && github.repository_owner == 'oven-sh' && github.event_name == 'pull_request'
+        with:
+          title: ""
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          status: ${{ job.status }}
+          noprefix: true
+          nocontext: true
+          description: |
+            Pull Request
+            ### [${{github.event.pull_request.title}}](https://github.com/oven-sh/bun/pull/${{github.event.number}})
+
+            @${{ github.actor }}
+
+            Build failed on ${{ matrix.tag }}:
+
+            **[View build output](https://github.com/oven-sh/bun/actions/runs/${{github.run_id}})**
+
+            [Commit ${{github.sha}}](https://github.com/oven-sh/bun/commits/${{github.sha}})
   macOS-test:
     name: Tests ${{matrix.tag}}
     runs-on: ${{ matrix.runner }}
@@ -420,8 +439,8 @@ jobs:
         with:
           name: ${{matrix.tag}}
           path: ${{runner.temp}}/release
-      - id: install
-        name: Install
+      - id: install-bun
+        name: Install Bun
         run: |
           cd ${{runner.temp}}/release
           unzip ${{matrix.tag}}.zip
@@ -429,6 +448,12 @@ jobs:
           chmod +x bun
           pwd >> $GITHUB_PATH
           ./bun --version
+      - id: install
+        name: Install dependencies
+        run: |
+          bun install --verbose
+          bun install --cwd=test --verbose
+          bun install --cwd=packages/bun-internal-test --verbose
       - id: test
         name: Test (node runner)
         env:
@@ -437,10 +462,24 @@ jobs:
           TLS_POSTGRES_DATABASE_URL: ${{ secrets.TLS_POSTGRES_DATABASE_URL }}
         # if: ${{github.event.inputs.use_bun == 'false'}}
         run: |
-          bun install
-          bun install --cwd test
-          bun install --cwd packages/bun-internal-test
           node packages/bun-internal-test/src/runner.node.mjs || true
+      - uses: sarisia/actions-status-discord@v1
+        if: always() && steps.test.outputs.failing_tests != '' && github.event_name == 'pull_request'
+        with:
+          title: ""
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          status: "failure"
+          noprefix: true
+          nocontext: true
+          description: |
+            Pull Request
+            ### ❌ [${{github.event.pull_request.title}}](https://github.com/oven-sh/bun/pull/${{github.event.number}})
+
+            @${{ github.actor }}, there are ${{ steps.test.outputs.failing_tests_count }} files with test failures on ${{ matrix.tag }}:
+
+            ${{ steps.test.outputs.failing_tests }}
+
+            **[View test output](https://github.com/oven-sh/bun/actions/runs/${{github.run_id}})**
       - name: Comment on PR
         if: steps.test.outputs.failing_tests != '' && github.event_name == 'pull_request'
         uses: thollander/actions-comment-pull-request@v2
diff --git a/.github/workflows/bun-mac-x64-baseline.yml b/.github/workflows/bun-mac-x64-baseline.yml
index cf3281bd8..6d74771ac 100644
--- a/.github/workflows/bun-mac-x64-baseline.yml
+++ b/.github/workflows/bun-mac-x64-baseline.yml
@@ -397,6 +397,25 @@ jobs:
           name: "Canary (${{github.sha}})"
           tag: "canary"
           artifacts: "${{runner.temp}}/release/${{matrix.tag}}.zip,${{runner.temp}}/release/${{matrix.tag}}-profile.zip"
+      - uses: sarisia/actions-status-discord@v1
+        if: failure() && github.repository_owner == 'oven-sh' && github.event_name == 'pull_request'
+        with:
+          title: ""
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          status: ${{ job.status }}
+          noprefix: true
+          nocontext: true
+          description: |
+            Pull Request
+            ### [${{github.event.pull_request.title}}](https://github.com/oven-sh/bun/pull/${{github.event.number}})
+
+            @${{ github.actor }}
+
+            Build failed on ${{ matrix.tag }}:
+
+            **[View build output](https://github.com/oven-sh/bun/actions/runs/${{github.run_id}})**
+
+            [Commit ${{github.sha}}](https://github.com/oven-sh/bun/commits/${{github.sha}})
   macOS-test:
     name: Tests ${{matrix.tag}}
     runs-on: ${{ matrix.runner }}
@@ -424,8 +443,8 @@ jobs:
         with:
           name: ${{matrix.tag}}
           path: ${{runner.temp}}/release
-      - id: install
-        name: Install
+      - id: install-bun
+        name: Install Bun
         run: |
           cd ${{runner.temp}}/release
           unzip ${{matrix.tag}}.zip
@@ -433,6 +452,12 @@ jobs:
           chmod +x bun
           pwd >> $GITHUB_PATH
           ./bun --version
+      - id: install
+        name: Install dependencies
+        run: |
+          bun install --verbose
+          bun install --cwd=test --verbose
+          bun install --cwd=packages/bun-internal-test --verbose
       - id: test
         name: Test (node runner)
         env:
@@ -441,10 +466,27 @@ jobs:
           TLS_POSTGRES_DATABASE_URL: ${{ secrets.TLS_POSTGRES_DATABASE_URL }}
         # if: ${{github.event.inputs.use_bun == 'false'}}
         run: |
-          bun install
-          bun install --cwd test
-          bun install --cwd packages/bun-internal-test
           node packages/bun-internal-test/src/runner.node.mjs || true
+      - uses: sarisia/actions-status-discord@v1
+        if: always() && steps.test.outputs.failing_tests != '' && github.event_name == 'pull_request'
+        with:
+          title: ""
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          status: "failure"
+          noprefix: true
+          nocontext: true
+          description: |
+            Pull Request
+            ### ❌ [${{github.event.pull_request.title}}](https://github.com/oven-sh/bun/pull/${{github.event.number}})
+
+            Hey @${{ github.actor }},
+
+            ${{ steps.test.outputs.failing_tests_count }} files with test failures on ${{ matrix.tag }}:
+
+            ${{ steps.test.outputs.failing_tests }}
+
+            **[View test output](https://github.com/oven-sh/bun/actions/runs/${{github.run_id}})**
+
       - name: Comment on PR
         if: steps.test.outputs.failing_tests != '' && github.event_name == 'pull_request'
         uses: thollander/actions-comment-pull-request@v2
diff --git a/.github/workflows/bun-mac-x64.yml b/.github/workflows/bun-mac-x64.yml
index a1d8b057a..6fbaa6820 100644
--- a/.github/workflows/bun-mac-x64.yml
+++ b/.github/workflows/bun-mac-x64.yml
@@ -399,6 +399,25 @@ jobs:
           name: "Canary (${{github.sha}})"
           tag: "canary"
           artifacts: "${{runner.temp}}/release/${{matrix.tag}}.zip,${{runner.temp}}/release/${{matrix.tag}}-profile.zip"
+      - uses: sarisia/actions-status-discord@v1
+        if: failure() && github.repository_owner == 'oven-sh' && github.event_name == 'pull_request'
+        with:
+          title: ""
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          status: ${{ job.status }}
+          noprefix: true
+          nocontext: true
+          description: |
+            Pull Request
+            ### [${{github.event.pull_request.title}}](https://github.com/oven-sh/bun/pull/${{github.event.number}})
+
+            @${{ github.actor }}
+
+            Build failed on ${{ matrix.tag }}:
+
+            **[View build output](https://github.com/oven-sh/bun/actions/runs/${{github.run_id}})**
+
+            [Commit ${{github.sha}}](https://github.com/oven-sh/bun/commits/${{github.sha}})
   macOS-test:
     name: Tests ${{matrix.tag}}
     runs-on: ${{ matrix.runner }}
@@ -426,8 +445,8 @@ jobs:
         with:
           name: ${{matrix.tag}}
           path: ${{runner.temp}}/release
-      - id: install
-        name: Install
+      - id: install-bun
+        name: Install Bun
         run: |
           cd ${{runner.temp}}/release
           unzip ${{matrix.tag}}.zip
@@ -435,6 +454,12 @@ jobs:
           chmod +x bun
           pwd >> $GITHUB_PATH
           ./bun --version
+      - id: install
+        name: Install dependencies
+        run: |
+          bun install --verbose
+          bun install --cwd=test --verbose
+          bun install --cwd=packages/bun-internal-test --verbose
       - id: test
         name: Test (node runner)
         env:
@@ -443,10 +468,24 @@ jobs:
           TLS_POSTGRES_DATABASE_URL: ${{ secrets.TLS_POSTGRES_DATABASE_URL }}
         # if: ${{github.event.inputs.use_bun == 'false'}}
         run: |
-          bun install
-          bun install --cwd test
-          bun install --cwd packages/bun-internal-test
           node packages/bun-internal-test/src/runner.node.mjs || true
+      - uses: sarisia/actions-status-discord@v1
+        if: always() && steps.test.outputs.failing_tests != '' && github.event_name == 'pull_request'
+        with:
+          title: ""
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          status: "failure"
+          noprefix: true
+          nocontext: true
+          description: |
+            Pull Request
+            ### ❌ [${{github.event.pull_request.title}}](https://github.com/oven-sh/bun/pull/${{github.event.number}})
+
+            @${{ github.actor }}, there are ${{ steps.test.outputs.failing_tests_count }} files with test failures on ${{ matrix.tag }}:
+
+            ${{ steps.test.outputs.failing_tests }}
+
+            **[View test output](https://github.com/oven-sh/bun/actions/runs/${{github.run_id}})**
       - name: Comment on PR
         if: steps.test.outputs.failing_tests != '' && github.event_name == 'pull_request'
         uses: thollander/actions-comment-pull-request@v2
diff --git a/Dockerfile b/Dockerfile
index 225d1b43c..1d4915928 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -286,6 +286,7 @@ COPY packages/bun-uws ${BUN_DIR}/packages/bun-uws
 COPY packages/bun-usockets ${BUN_DIR}/packages/bun-usockets
 COPY src/deps/zlib ${BUN_DIR}/src/deps/zlib
 COPY src/deps/boringssl/include ${BUN_DIR}/src/deps/boringssl/include
+COPY src/deps/c-ares/include ${BUN_DIR}/src/deps/c-ares/include
 COPY src/deps/libuwsockets.cpp ${BUN_DIR}/src/deps/libuwsockets.cpp
 COPY src/deps/_libusockets.h ${BUN_DIR}/src/deps/_libusockets.h
 
diff --git a/docs/api/file-system-router.md b/docs/api/file-system-router.md
index 964652401..8e1fbe0fc 100644
--- a/docs/api/file-system-router.md
+++ b/docs/api/file-system-router.md
@@ -93,6 +93,7 @@ interface Bun {
       style: "nextjs";
       origin?: string;
       assetPrefix?: string;
+      fileExtensions?: string[];
     });
 
     reload(): void;
diff --git a/docs/runtime/plugins.md b/docs/runtime/plugins.md
index f9921cbad..f2e0d7c77 100644
--- a/docs/runtime/plugins.md
+++ b/docs/runtime/plugins.md
@@ -45,7 +45,7 @@ plugin(
 );
 ```
 
-Bun's plugin API is based on [esbuild](https://esbuild.github.io/plugins). Only [a subset](/docs/bundler/vs-esbuild#plugin-api) of the esbuild API is implemented, but some esbuild plugins "just work" in Bun, like the official [MDX loader](https://mdxjs.com/packages/esbuild/):
+Bun's plugin API is loosely based on [esbuild](https://esbuild.github.io/plugins). Only [a subset](/docs/bundler/vs-esbuild#plugin-api) of the esbuild API is implemented, but some esbuild plugins "just work" in Bun, like the official [MDX loader](https://mdxjs.com/packages/esbuild/):
 
 ```jsx
 import { plugin } from "bun";
@@ -217,6 +217,91 @@ import MySvelteComponent from "./component.svelte";
 console.log(mySvelteComponent.render());
 ```
 
+## Virtual Modules
+
+{% note %}
+
+This feature is currently only available at runtime with `Bun.plugin` and not yet supported in the bundler, but you can mimick the behavior using `onResolve` and `onLoad`.
+
+{% /note %}
+
+To create virtual modules at runtime, use `builder.module(specifier, callback)` in the `setup` function of a `Bun.plugin`.
+
+For example:
+
+```js
+import { plugin } from "bun";
+
+plugin({
+  name: "my-virtual-module",
+
+  setup(build) {
+    build.module(
+      // The specifier, which can be any string
+      "my-transpiled-virtual-module",
+      // The callback to run when the module is imported or required for the first time
+      () => {
+        return {
+          contents: "console.log('hello world!')",
+          loader: "js",
+        };
+      },
+    );
+
+    build.module("my-object-virtual-module", () => {
+      return {
+        exports: {
+          foo: "bar",
+        },
+        loader: "object",
+      };
+    });
+  },
+});
+
+// Sometime later
+// All of these work
+import "my-transpiled-virtual-module";
+require("my-transpiled-virtual-module");
+await import("my-transpiled-virtual-module");
+require.resolve("my-transpiled-virtual-module");
+
+import { foo } from "my-object-virtual-module";
+const object = require("my-object-virtual-module");
+await import("my-object-virtual-module");
+require.resolve("my-object-virtual-module");
+```
+
+### Overriding existing modules
+
+You can also override existing modules with `build.module`.
+
+```js
+import { plugin } from "bun";
+build.module("my-object-virtual-module", () => {
+  return {
+    exports: {
+      foo: "bar",
+    },
+    loader: "object",
+  };
+});
+
+require("my-object-virtual-module"); // { foo: "bar" }
+await import("my-object-virtual-module"); // { foo: "bar" }
+
+build.module("my-object-virtual-module", () => {
+  return {
+    exports: {
+      baz: "quix",
+    },
+    loader: "object",
+  };
+});
+require("my-object-virtual-module"); // { baz: "quix" }
+await import("my-object-virtual-module"); // { baz: "quix" }
+```
+
 ## Reading the config
 
 Plugins can read and write to the [build config](/docs/bundler#api) with `build.config`.
diff --git a/packages/bun-internal-test/bun.lockb b/packages/bun-internal-test/bun.lockb
index f0d6d2032..cef9d5e7e 100755
--- a/packages/bun-internal-test/bun.lockb
+++ b/packages/bun-internal-test/bun.lockb
diff --git a/packages/bun-types/bun.d.ts b/packages/bun-types/bun.d.ts
index a2ccebd8a..9b2d314e8 100644
--- a/packages/bun-types/bun.d.ts
+++ b/packages/bun-types/bun.d.ts
@@ -2359,11 +2359,7 @@ declare module "bun" {
     ): ServerWebSocketSendStatus;
 
     /**
-     * Returns the client IP address of the given Request.
-     *
-     * @param request The incoming request
-     *
-     * @returns An ipv4/ipv6 address string, or null if it couldn't find one.
+     * Returns the client IP address and port of the given Request. If the request was closed or is a unix socket, returns null.
      *
      * @example
      * ```js
@@ -3297,6 +3293,37 @@ declare module "bun" {
      * The config object passed to `Bun.build` as is. Can be mutated.
      */
     config: BuildConfig & { plugins: BunPlugin[] };
+
+    /**
+     * Create a lazy-loaded virtual module that can be `import`ed or `require`d from other modules
+     *
+     * @param specifier The module specifier to register the callback for
+     * @param callback The function to run when the module is imported or required
+     *
+     * ### Example
+     * @example
+     * ```ts
+     * Bun.plugin({
+     *   setup(builder) {
+     *     builder.module("hello:world", () => {
+     *       return { exports: { foo: "bar" }, loader: "object" };
+     *     });
+     *   },
+     * });
+     *
+     * // sometime later
+     * const { foo } = await import("hello:world");
+     * console.log(foo); // "bar"
+     *
+     * // or
+     * const { foo } = require("hello:world");
+     * console.log(foo); // "bar"
+     * ```
+     */
+    module(
+      specifier: string,
+      callback: () => OnLoadResult | Promise<OnLoadResult>,
+    ): void;
   }
 
   interface BunPlugin {
diff --git a/packages/bun-types/globals.d.ts b/packages/bun-types/globals.d.ts
index a1f1bd325..ea73b506d 100644
--- a/packages/bun-types/globals.d.ts
+++ b/packages/bun-types/globals.d.ts
@@ -681,7 +681,7 @@ interface Process {
    */
   setSourceMapsEnabled(enabled: boolean): void;
 
-  kill(pid: number, signal?: string | number): void;
+  kill(pid: number, signal?: string | number): true;
 
   on(event: "beforeExit", listener: BeforeExitListener): this;
   // on(event: "disconnect", listener: DisconnectListener): this;
diff --git a/packages/bun-usockets/src/bsd.c b/packages/bun-usockets/src/bsd.c
index 7683acd7d..fc501e4d9 100644
--- a/packages/bun-usockets/src/bsd.c
+++ b/packages/bun-usockets/src/bsd.c
@@ -665,9 +665,39 @@ int bsd_udp_packet_buffer_ecn(void *msgvec, int index) {
     return 0; // no ecn defaults to 0
 }
 
-static int bsd_do_connect(struct addrinfo *result, int fd)
+static int bsd_do_connect_raw(struct addrinfo *rp, int fd)
 {
-    return connect(fd, result->ai_addr, (socklen_t) result->ai_addrlen);
+     do {
+        if (connect(fd, rp->ai_addr, rp->ai_addrlen) == 0 || errno == EINPROGRESS) {
+            return 0;
+        }
+    } while (errno == EINTR);
+
+    return LIBUS_SOCKET_ERROR;
+}
+
+static int bsd_do_connect(struct addrinfo *rp, int *fd)
+{
+    while (rp != NULL) {
+        if (bsd_do_connect_raw(rp, *fd) == 0) {
+            return 0;
+        }
+
+        rp = rp->ai_next;
+        bsd_close_socket(*fd);
+
+        if (rp == NULL) {
+            return LIBUS_SOCKET_ERROR;
+        }
+
+        int resultFd = bsd_create_socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+        if (resultFd < 0) {
+            return LIBUS_SOCKET_ERROR;
+        }
+        *fd = resultFd;
+    }
+
+    return LIBUS_SOCKET_ERROR;
 }
 
 LIBUS_SOCKET_DESCRIPTOR bsd_create_connect_socket(const char *host, int port, const char *source_host, int options) {
@@ -700,18 +730,21 @@ LIBUS_SOCKET_DESCRIPTOR bsd_create_connect_socket(const char *host, int port, co
                 return LIBUS_SOCKET_ERROR;
             }
         }
-    }
-    
-    do {
-        if (bsd_do_connect(result, fd) != 0 && errno != EINPROGRESS) {
+
+        if (bsd_do_connect_raw(result, fd) != 0) {
             bsd_close_socket(fd);
             freeaddrinfo(result);
             return LIBUS_SOCKET_ERROR;
         }
-    } while (errno == EINTR);
-
+    } else {
+        if (bsd_do_connect(result, &fd) != 0) {
+            freeaddrinfo(result);
+            return LIBUS_SOCKET_ERROR;
+        }
+    }
+    
+    
     freeaddrinfo(result);
-
     return fd;
 }
 
diff --git a/packages/bun-usockets/src/socket.c b/packages/bun-usockets/src/socket.c
index 78185e681..6edefe0f5 100644
--- a/packages/bun-usockets/src/socket.c
+++ b/packages/bun-usockets/src/socket.c
@@ -290,7 +290,7 @@ unsigned int us_get_remote_address_info(char *buf, struct us_socket_t *s, const
     struct bsd_addr_t addr;
     if (bsd_remote_addr(us_poll_fd(&s->p), &addr)) {
         return 0;
-    } 
+    }
 
     int length = bsd_addr_get_ip_length(&addr);
     if (!length) {
diff --git a/src/bun.js/api/bun.zig b/src/bun.js/api/bun.zig
index 966c82d38..949ba402c 100644
--- a/src/bun.js/api/bun.zig
+++ b/src/bun.js/api/bun.zig
@@ -782,11 +782,17 @@ fn doResolveWithArgs(
     var errorable: ErrorableString = undefined;
     var query_string = ZigString.Empty;
 
+    const specifier_decoded = if (specifier.hasPrefixComptime("file://"))
+        bun.JSC.URL.pathFromFileURL(specifier)
+    else
+        specifier.dupeRef();
+    defer specifier_decoded.deref();
+
     if (comptime is_file_path) {
         VirtualMachine.resolveFilePathForAPI(
             &errorable,
             ctx.ptr(),
-            specifier,
+            specifier_decoded,
             from,
             &query_string,
             is_esm,
@@ -795,7 +801,7 @@ fn doResolveWithArgs(
         VirtualMachine.resolveForAPI(
             &errorable,
             ctx.ptr(),
-            specifier,
+            specifier_decoded,
             from,
             &query_string,
             is_esm,
diff --git a/src/bun.js/api/server.zig b/src/bun.js/api/server.zig
index 9d4a8a133..3fe411f39 100644
--- a/src/bun.js/api/server.zig
+++ b/src/bun.js/api/server.zig
@@ -4859,6 +4859,9 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
         extern fn JSSocketAddress__create(global: *JSC.JSGlobalObject, ip: JSValue, port: i32, is_ipv6: bool) JSValue;
 
         pub fn requestIP(this: *ThisServer, request: *JSC.WebCore.Request) JSC.JSValue {
+            if (this.config.address == .unix) {
+                return JSValue.jsNull();
+            }
             return if (request.request_context.getRemoteSocketInfo()) |info|
                 JSSocketAddress__create(
                     this.globalThis,
diff --git a/src/bun.js/bindings/BunPlugin.cpp b/src/bun.js/bindings/BunPlugin.cpp
index 129d7816b..b53fcf313 100644
--- a/src/bun.js/bindings/BunPlugin.cpp
+++ b/src/bun.js/bindings/BunPlugin.cpp
@@ -17,8 +17,10 @@
 #include "JavaScriptCore/RegExpObject.h"
 #include "JavaScriptCore/JSPromise.h"
 #include "BunClientData.h"
-
+#include "isBuiltinModule.h"
 #include "JavaScriptCore/RegularExpression.h"
+#include "JavaScriptCore/JSMap.h"
+#include "JavaScriptCore/JSMapInlines.h"
 
 namespace Zig {
 
@@ -86,6 +88,76 @@ static EncodedJSValue jsFunctionAppendOnLoadPluginBody(JSC::JSGlobalObject* glob
     return JSValue::encode(jsUndefined());
 }
 
+static EncodedJSValue jsFunctionAppendVirtualModulePluginBody(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callframe)
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    if (callframe->argumentCount() < 2) {
+        throwException(globalObject, scope, createError(globalObject, "module() needs 2 arguments: a module ID and a function to call"_s));
+        return JSValue::encode(jsUndefined());
+    }
+
+    JSValue moduleIdValue = callframe->uncheckedArgument(0);
+    JSValue functionValue = callframe->uncheckedArgument(1);
+
+    if (!moduleIdValue.isString()) {
+        throwException(globalObject, scope, createError(globalObject, "module() expects first argument to be a string for the module ID"_s));
+        return JSValue::encode(jsUndefined());
+    }
+
+    if (!functionValue.isCallable()) {
+        throwException(globalObject, scope, createError(globalObject, "module() expects second argument to be a function"_s));
+        return JSValue::encode(jsUndefined());
+    }
+
+    String moduleId = moduleIdValue.toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, encodedJSValue());
+
+    if (moduleId.isEmpty()) {
+        throwException(globalObject, scope, createError(globalObject, "virtual module cannot be blank"_s));
+        return JSValue::encode(jsUndefined());
+    }
+
+    if (Bun::isBuiltinModule(moduleId)) {
+        throwException(globalObject, scope, createError(globalObject, makeString("module() cannot be used to override builtin module \""_s, moduleId, "\""_s)));
+        return JSValue::encode(jsUndefined());
+    }
+
+    if (moduleId.startsWith("."_s)) {
+        throwException(globalObject, scope, createError(globalObject, "virtual module cannot start with \".\""_s));
+        return JSValue::encode(jsUndefined());
+    }
+
+    Zig::GlobalObject* global = Zig::jsCast<Zig::GlobalObject*>(globalObject);
+    if (global->onLoadPlugins.virtualModules == nullptr) {
+        global->onLoadPlugins.virtualModules = new BunPlugin::VirtualModuleMap;
+    }
+    auto* virtualModules = global->onLoadPlugins.virtualModules;
+
+    virtualModules->set(moduleId, JSC::Strong<JSC::JSObject> { vm, jsCast<JSC::JSObject*>(functionValue) });
+
+    JSMap* esmRegistry;
+
+    if (auto loaderValue = global->getIfPropertyExists(global, JSC::Identifier::fromString(vm, "Loader"_s))) {
+        if (auto registryValue = loaderValue.getObject()->getIfPropertyExists(global, JSC::Identifier::fromString(vm, "registry"_s))) {
+            esmRegistry = jsCast<JSC::JSMap*>(registryValue);
+        }
+    }
+
+    global->requireMap()->remove(globalObject, moduleIdValue);
+    esmRegistry && esmRegistry->remove(globalObject, moduleIdValue);
+
+    // bool hasBeenRequired = global->requireMap()->has(globalObject, moduleIdValue);
+    // bool hasBeenImported = esmRegistry && esmRegistry->has(globalObject, moduleIdValue);
+    // if (hasBeenRequired || hasBeenImported) {
+    //     // callAndReplaceModule(global, moduleIdValue, functionValue, global->requireMap(), esmRegistry, hasBeenRequired, hasBeenImported);
+    //     // RETURN_IF_EXCEPTION(scope, encodedJSValue());
+    // }
+
+    return JSValue::encode(jsUndefined());
+}
+
 static EncodedJSValue jsFunctionAppendOnResolvePluginBody(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callframe, BunPluginTarget target, BunPlugin::Base& plugin, void* ctx, OnAppendPluginCallback callback)
 {
     JSC::VM& vm = globalObject->vm();
@@ -143,7 +215,7 @@ static EncodedJSValue jsFunctionAppendOnResolvePluginGlobal(JSC::JSGlobalObject*
 {
     Zig::GlobalObject* global = Zig::jsCast<Zig::GlobalObject*>(globalObject);
 
-    auto& plugins = global->onResolvePlugins[target];
+    auto& plugins = global->onResolvePlugins;
     auto callback = Bun__onDidAppendPlugin;
     return jsFunctionAppendOnResolvePluginBody(globalObject, callframe, target, plugins, global->bunVM(), callback);
 }
@@ -152,7 +224,7 @@ static EncodedJSValue jsFunctionAppendOnLoadPluginGlobal(JSC::JSGlobalObject* gl
 {
     Zig::GlobalObject* global = Zig::jsCast<Zig::GlobalObject*>(globalObject);
 
-    auto& plugins = global->onLoadPlugins[target];
+    auto& plugins = global->onLoadPlugins;
     auto callback = Bun__onDidAppendPlugin;
     return jsFunctionAppendOnLoadPluginBody(globalObject, callframe, target, plugins, global->bunVM(), callback);
 }
@@ -182,6 +254,11 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionAppendOnResolvePluginBun, (JSC::JSGlobalObjec
     return jsFunctionAppendOnResolvePluginGlobal(globalObject, callframe, BunPluginTargetBun);
 }
 
+JSC_DEFINE_HOST_FUNCTION(jsFunctionAppendVirtualModule, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callframe))
+{
+    return jsFunctionAppendVirtualModulePluginBody(globalObject, callframe);
+}
+
 JSC_DEFINE_HOST_FUNCTION(jsFunctionAppendOnResolvePluginBrowser, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callframe))
 {
     return jsFunctionAppendOnResolvePluginGlobal(globalObject, callframe, BunPluginTargetBrowser);
@@ -190,12 +267,12 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionAppendOnResolvePluginBrowser, (JSC::JSGlobalO
 extern "C" EncodedJSValue jsFunctionBunPluginClear(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callframe)
 {
     Zig::GlobalObject* global = reinterpret_cast<Zig::GlobalObject*>(globalObject);
-    for (uint8_t i = 0; i < BunPluginTargetMax + 1; i++) {
-        global->onLoadPlugins[i].fileNamespace.clear();
-        global->onResolvePlugins[i].fileNamespace.clear();
-        global->onLoadPlugins[i].groups.clear();
-        global->onResolvePlugins[i].namespaces.clear();
-    }
+    global->onLoadPlugins.fileNamespace.clear();
+    global->onResolvePlugins.fileNamespace.clear();
+    global->onLoadPlugins.groups.clear();
+    global->onResolvePlugins.namespaces.clear();
+
+    delete global->onLoadPlugins.virtualModules;
 
     return JSValue::encode(jsUndefined());
 }
@@ -239,76 +316,37 @@ extern "C" EncodedJSValue setupBunPlugin(JSC::JSGlobalObject* globalObject, JSC:
     }
 
     JSFunction* setupFunction = jsCast<JSFunction*>(setupFunctionValue);
-    JSObject* builderObject = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 3);
-
-    switch (target) {
-    case BunPluginTargetNode: {
-        builderObject->putDirect(vm, Identifier::fromString(vm, "target"_s), jsString(vm, String("node"_s)), 0);
-        builderObject->putDirectNativeFunction(
-            vm,
-            globalObject,
-            JSC::Identifier::fromString(vm, "onLoad"_s),
-            1,
-            jsFunctionAppendOnLoadPluginNode,
-            ImplementationVisibility::Public,
-            NoIntrinsic,
-            JSC::PropertyAttribute::DontDelete | 0);
-        builderObject->putDirectNativeFunction(
-            vm,
-            globalObject,
-            JSC::Identifier::fromString(vm, "onResolve"_s),
-            1,
-            jsFunctionAppendOnResolvePluginNode,
-            ImplementationVisibility::Public,
-            NoIntrinsic,
-            JSC::PropertyAttribute::DontDelete | 0);
-        break;
-    }
-    case BunPluginTargetBun: {
-        builderObject->putDirect(vm, Identifier::fromString(vm, "target"_s), jsString(vm, String("bun"_s)), 0);
-        builderObject->putDirectNativeFunction(
-            vm,
-            globalObject,
-            JSC::Identifier::fromString(vm, "onLoad"_s),
-            1,
-            jsFunctionAppendOnLoadPluginBun,
-            ImplementationVisibility::Public,
-            NoIntrinsic,
-            JSC::PropertyAttribute::DontDelete | 0);
-        builderObject->putDirectNativeFunction(
-            vm,
-            globalObject,
-            JSC::Identifier::fromString(vm, "onResolve"_s),
-            1,
-            jsFunctionAppendOnResolvePluginBun,
-            ImplementationVisibility::Public,
-            NoIntrinsic,
-            JSC::PropertyAttribute::DontDelete | 0);
-        break;
-    }
-    case BunPluginTargetBrowser: {
-        builderObject->putDirect(vm, Identifier::fromString(vm, "target"_s), jsString(vm, String("browser"_s)), 0);
-        builderObject->putDirectNativeFunction(
-            vm,
-            globalObject,
-            JSC::Identifier::fromString(vm, "onLoad"_s),
-            1,
-            jsFunctionAppendOnLoadPluginBrowser,
-            ImplementationVisibility::Public,
-            NoIntrinsic,
-            JSC::PropertyAttribute::DontDelete | 0);
-        builderObject->putDirectNativeFunction(
-            vm,
-            globalObject,
-            JSC::Identifier::fromString(vm, "onResolve"_s),
-            1,
-            jsFunctionAppendOnResolvePluginBrowser,
-            ImplementationVisibility::Public,
-            NoIntrinsic,
-            JSC::PropertyAttribute::DontDelete | 0);
-        break;
-    }
-    }
+    JSObject* builderObject = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 4);
+
+    builderObject->putDirect(vm, Identifier::fromString(vm, "target"_s), jsString(vm, String("bun"_s)), 0);
+    builderObject->putDirectNativeFunction(
+        vm,
+        globalObject,
+        JSC::Identifier::fromString(vm, "onLoad"_s),
+        1,
+        jsFunctionAppendOnLoadPluginBun,
+        ImplementationVisibility::Public,
+        NoIntrinsic,
+        JSC::PropertyAttribute::DontDelete | 0);
+    builderObject->putDirectNativeFunction(
+        vm,
+        globalObject,
+        JSC::Identifier::fromString(vm, "onResolve"_s),
+        1,
+        jsFunctionAppendOnResolvePluginBun,
+        ImplementationVisibility::Public,
+        NoIntrinsic,
+        JSC::PropertyAttribute::DontDelete | 0);
+
+    builderObject->putDirectNativeFunction(
+        vm,
+        globalObject,
+        JSC::Identifier::fromString(vm, "module"_s),
+        1,
+        jsFunctionAppendVirtualModule,
+        ImplementationVisibility::Public,
+        NoIntrinsic,
+        JSC::PropertyAttribute::DontDelete | 0);
 
     JSC::MarkedArgumentBuffer args;
     args.append(builderObject);
@@ -329,9 +367,7 @@ extern "C" EncodedJSValue setupBunPlugin(JSC::JSGlobalObject* globalObject, JSC:
 extern "C" EncodedJSValue jsFunctionBunPlugin(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callframe)
 {
     Zig::GlobalObject* global = reinterpret_cast<Zig::GlobalObject*>(globalObject);
-    BunPluginTarget target = global->defaultBunPluginTarget;
-
-    return setupBunPlugin(globalObject, callframe, target);
+    return setupBunPlugin(globalObject, callframe, BunPluginTargetBun);
 }
 
 void BunPlugin::Group::append(JSC::VM& vm, JSC::RegExp* filter, JSC::JSFunction* func)
@@ -513,10 +549,60 @@ EncodedJSValue BunPlugin::OnResolve::run(JSC::JSGlobalObject* globalObject, BunS
 
 extern "C" JSC::EncodedJSValue Bun__runOnResolvePlugins(Zig::GlobalObject* globalObject, BunString* namespaceString, BunString* path, BunString* from, BunPluginTarget target)
 {
-    return globalObject->onResolvePlugins[target].run(globalObject, namespaceString, path, from);
+    return globalObject->onResolvePlugins.run(globalObject, namespaceString, path, from);
 }
 
 extern "C" JSC::EncodedJSValue Bun__runOnLoadPlugins(Zig::GlobalObject* globalObject, BunString* namespaceString, BunString* path, BunPluginTarget target)
 {
-    return globalObject->onLoadPlugins[target].run(globalObject, namespaceString, path);
+    return globalObject->onLoadPlugins.run(globalObject, namespaceString, path);
+}
+
+namespace Bun {
+JSC::JSValue runVirtualModule(Zig::GlobalObject* globalObject, BunString* specifier)
+{
+    auto fallback = [&]() -> JSC::JSValue {
+        return JSValue::decode(Bun__runVirtualModule(globalObject, specifier));
+    };
+
+    if (!globalObject->onLoadPlugins.virtualModules) {
+        return fallback();
+    }
+    auto& virtualModules = *globalObject->onLoadPlugins.virtualModules;
+    WTF::String specifierString = Bun::toWTFString(*specifier);
+    if (auto virtualModuleFn = virtualModules.get(specifierString)) {
+        auto& vm = globalObject->vm();
+        JSC::JSObject* function = virtualModuleFn.get();
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+
+        JSC::MarkedArgumentBuffer arguments;
+        JSC::CallData callData = JSC::getCallData(function);
+        RELEASE_ASSERT(callData.type != JSC::CallData::Type::None);
+
+        auto result = call(globalObject, function, callData, JSC::jsUndefined(), arguments);
+        RETURN_IF_EXCEPTION(throwScope, JSC::jsUndefined());
+
+        if (auto* promise = JSC::jsDynamicCast<JSPromise*>(result)) {
+            switch (promise->status(vm)) {
+            case JSPromise::Status::Rejected:
+            case JSPromise::Status::Pending: {
+                return promise;
+            }
+            case JSPromise::Status::Fulfilled: {
+                result = promise->result(vm);
+                break;
+            }
+            }
+        }
+
+        if (!result.isObject()) {
+            JSC::throwTypeError(globalObject, throwScope, "virtual module expects an object returned"_s);
+            return JSC::jsUndefined();
+        }
+
+        return result;
+    }
+
+    return fallback();
 }
+
+}
\ No newline at end of file
diff --git a/src/bun.js/bindings/BunPlugin.h b/src/bun.js/bindings/BunPlugin.h
index cf37b739b..f4d09883d 100644
--- a/src/bun.js/bindings/BunPlugin.h
+++ b/src/bun.js/bindings/BunPlugin.h
@@ -15,6 +15,8 @@ using namespace JSC;
 
 class BunPlugin {
 public:
+    using VirtualModuleMap = WTF::HashMap<String, JSC::Strong<JSC::JSObject>>;
+
     // This is a list of pairs of regexps and functions to match against
     class Group {
 
@@ -67,7 +69,15 @@ public:
         {
         }
 
-        EncodedJSValue run(JSC::JSGlobalObject* globalObject, BunString* namespaceString, BunString* path);
+        VirtualModuleMap* virtualModules = nullptr;
+        JSC::EncodedJSValue run(JSC::JSGlobalObject* globalObject, BunString* namespaceString, BunString* path);
+
+        ~OnLoad()
+        {
+            if (virtualModules) {
+                delete virtualModules;
+            }
+        }
     };
 
     class OnResolve final : public Base {
@@ -78,8 +88,14 @@ public:
         {
         }
 
-        EncodedJSValue run(JSC::JSGlobalObject* globalObject, BunString* namespaceString, BunString* path, BunString* importer);
+        JSC::EncodedJSValue run(JSC::JSGlobalObject* globalObject, BunString* namespaceString, BunString* path, BunString* importer);
     };
 };
 
-} // namespace Zig
\ No newline at end of file
+class GlobalObject;
+
+} // namespace Zig
+
+namespace Bun {
+JSC::JSValue runVirtualModule(Zig::GlobalObject*, BunString* specifier);
+}
\ No newline at end of file
diff --git a/src/bun.js/bindings/BunString.cpp b/src/bun.js/bindings/BunString.cpp
index 416d5d334..31b331111 100644
--- a/src/bun.js/bindings/BunString.cpp
+++ b/src/bun.js/bindings/BunString.cpp
@@ -190,22 +190,6 @@ BunString toStringRef(WTF::StringImpl* wtfString)
     return { BunStringTag::WTFStringImpl, { .wtf = wtfString } };
 }
 
-BunString fromString(WTF::String& wtfString)
-{
-    if (wtfString.isEmpty())
-        return { BunStringTag::Empty };
-
-    return { BunStringTag::WTFStringImpl, { .wtf = wtfString.impl() } };
-}
-
-BunString fromString(WTF::StringImpl* wtfString)
-{
-    if (wtfString->isEmpty())
-        return { BunStringTag::Empty };
-
-    return { BunStringTag::WTFStringImpl, { .wtf = wtfString } };
-}
-
 }
 
 extern "C" JSC::EncodedJSValue BunString__toJS(JSC::JSGlobalObject* globalObject, BunString* bunString)
@@ -252,7 +236,7 @@ extern "C" BunString BunString__fromUTF8(const char* bytes, size_t length)
 
     auto str = WTF::String::fromUTF8ReplacingInvalidSequences(reinterpret_cast<const LChar*>(bytes), length);
     str.impl()->ref();
-    return Bun::fromString(str);
+    return Bun::toString(str);
 }
 
 extern "C" BunString BunString__fromLatin1(const char* bytes, size_t length)
@@ -381,7 +365,17 @@ extern "C" BunString URL__getHref(BunString* input)
     return Bun::toStringRef(url.string());
 }
 
-extern "C" BunString URL__getHrefJoin(BunString* baseStr, BunString *relativeStr)
+extern "C" BunString URL__pathFromFileURL(BunString* input)
+{
+    auto&& str = Bun::toWTFString(*input);
+    auto url = WTF::URL(str);
+    if (!url.isValid() || url.isEmpty())
+        return { BunStringTag::Dead };
+
+    return Bun::toStringRef(url.fileSystemPath());
+}
+
+extern "C" BunString URL__getHrefJoin(BunString* baseStr, BunString* relativeStr)
 {
     auto base = Bun::toWTFString(*baseStr);
     auto relative = Bun::toWTFString(*relativeStr);
@@ -455,4 +449,4 @@ extern "C" uint32_t URL__port(WTF::URL* url)
 extern "C" BunString URL__pathname(WTF::URL* url)
 {
     return Bun::toStringRef(url->path().toStringWithoutCopying());
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/ImportMetaObject.cpp b/src/bun.js/bindings/ImportMetaObject.cpp
index 4160102a5..340c3319b 100644
--- a/src/bun.js/bindings/ImportMetaObject.cpp
+++ b/src/bun.js/bindings/ImportMetaObject.cpp
@@ -64,6 +64,12 @@ static EncodedJSValue functionRequireResolve(JSC::JSGlobalObject* globalObject,
         JSC::JSValue moduleName = callFrame->argument(0);
 
         auto doIt = [&](const WTF::String& fromStr) -> JSC::EncodedJSValue {
+            if (auto* virtualModules = jsCast<Zig::GlobalObject*>(globalObject)->onLoadPlugins.virtualModules) {
+                if (virtualModules->contains(fromStr)) {
+                    return JSC::JSValue::encode(jsString(vm, fromStr));
+                }
+            }
+
             BunString from = Bun::toString(fromStr);
             auto result = Bun__resolveSyncWithSource(globalObject, JSC::JSValue::encode(moduleName), &from, false);
 
@@ -160,6 +166,14 @@ extern "C" EncodedJSValue functionImportMeta__resolveSync(JSC::JSGlobalObject* g
     JSC__JSValue from;
     bool isESM = true;
 
+    if (auto* virtualModules = jsCast<Zig::GlobalObject*>(globalObject)->onLoadPlugins.virtualModules) {
+        if (moduleName.isString()) {
+            if (virtualModules->contains(moduleName.toWTFString(globalObject))) {
+                return JSC::JSValue::encode(moduleName);
+            }
+        }
+    }
+
     if (callFrame->argumentCount() > 1) {
 
         if (callFrame->argumentCount() > 2) {
@@ -226,6 +240,7 @@ extern "C" EncodedJSValue functionImportMeta__resolveSyncPrivate(JSC::JSGlobalOb
 {
     JSC::VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
+    auto* global = jsDynamicCast<Zig::GlobalObject*>(globalObject);
 
     JSC::JSValue moduleName = callFrame->argument(0);
     JSValue from = callFrame->argument(1);
@@ -239,8 +254,15 @@ extern "C" EncodedJSValue functionImportMeta__resolveSyncPrivate(JSC::JSGlobalOb
 
     RETURN_IF_EXCEPTION(scope, JSC::JSValue::encode(JSC::JSValue {}));
 
+    if (auto* virtualModules = global->onLoadPlugins.virtualModules) {
+        if (moduleName.isString()) {
+            if (virtualModules->contains(moduleName.toWTFString(globalObject))) {
+                return JSC::JSValue::encode(moduleName);
+            }
+        }
+    }
+
     if (!isESM) {
-        auto* global = jsDynamicCast<Zig::GlobalObject*>(globalObject);
         if (LIKELY(global)) {
             auto overrideHandler = global->m_nodeModuleOverriddenResolveFilename.get();
             if (UNLIKELY(overrideHandler)) {
@@ -289,6 +311,14 @@ JSC_DEFINE_HOST_FUNCTION(functionImportMeta__resolve,
 
         JSC__JSValue from;
 
+        if (auto* virtualModules = jsCast<Zig::GlobalObject*>(globalObject)->onLoadPlugins.virtualModules) {
+            if (moduleName.isString()) {
+                if (virtualModules->contains(moduleName.toWTFString(globalObject))) {
+                    return JSC::JSValue::encode(moduleName);
+                }
+            }
+        }
+
         if (callFrame->argumentCount() > 1 && callFrame->argument(1).isString()) {
             from = JSC::JSValue::encode(callFrame->argument(1));
         } else {
diff --git a/src/bun.js/bindings/JSBundlerPlugin.cpp b/src/bun.js/bindings/JSBundlerPlugin.cpp
index 6ae266df7..d896d5b3d 100644
--- a/src/bun.js/bindings/JSBundlerPlugin.cpp
+++ b/src/bun.js/bindings/JSBundlerPlugin.cpp
@@ -31,6 +31,7 @@ namespace Bun {
 extern "C" void JSBundlerPlugin__addError(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue);
 extern "C" void JSBundlerPlugin__onLoadAsync(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue);
 extern "C" void JSBundlerPlugin__onResolveAsync(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue, JSC::EncodedJSValue);
+extern "C" void JSBundlerPlugin__onVirtualModulePlugin(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue, JSC::EncodedJSValue);
 
 JSC_DECLARE_HOST_FUNCTION(jsBundlerPluginFunction_addFilter);
 JSC_DECLARE_HOST_FUNCTION(jsBundlerPluginFunction_addError);
@@ -154,6 +155,7 @@ public:
     Bun::BundlerPlugin plugin;
     JSC::LazyProperty<JSBundlerPlugin, JSC::JSFunction> onLoadFunction;
     JSC::LazyProperty<JSBundlerPlugin, JSC::JSFunction> onResolveFunction;
+    JSC::LazyProperty<JSBundlerPlugin, JSC::JSFunction> moduleFunction;
     JSC::LazyProperty<JSBundlerPlugin, JSC::JSFunction> setupFunction;
 
 private:
diff --git a/src/bun.js/bindings/JSSocketAddress.cpp b/src/bun.js/bindings/JSSocketAddress.cpp
index 53084adb6..181507339 100644
--- a/src/bun.js/bindings/JSSocketAddress.cpp
+++ b/src/bun.js/bindings/JSSocketAddress.cpp
@@ -9,8 +9,7 @@ using namespace JSC;
 namespace Bun {
 namespace JSSocketAddress {
 
-// Using a structure with inlined offsets will be more lightweight than a class.
-
+// Using a structure with inlined offsets should be more lightweight than a class.
 Structure* createStructure(VM& vm, JSGlobalObject* globalObject)
 {
     JSC::Structure* structure = globalObject->structureCache().emptyObjectStructureForPrototype(
@@ -48,13 +47,16 @@ Structure* createStructure(VM& vm, JSGlobalObject* globalObject)
 
 extern "C" JSObject* JSSocketAddress__create(JSGlobalObject* globalObject, JSString* value, int32_t port, bool isIPv6)
 {
+    static const NeverDestroyed<String> IPv4 = MAKE_STATIC_STRING_IMPL("IPv4");
+    static const NeverDestroyed<String> IPv6 = MAKE_STATIC_STRING_IMPL("IPv6");
+
     VM& vm = globalObject->vm();
 
     auto* global = jsCast<Zig::GlobalObject*>(globalObject);
 
     JSObject* thisObject = constructEmptyObject(vm, global->JSSocketAddressStructure());
     thisObject->putDirectOffset(vm, 0, value);
-    thisObject->putDirectOffset(vm, 1, isIPv6 ? jsString(vm, Bun::JSSocketAddress::IPv6) : jsString(vm, Bun::JSSocketAddress::IPv4));
+    thisObject->putDirectOffset(vm, 1, isIPv6 ? jsString(vm, IPv6) : jsString(vm, IPv4));
     thisObject->putDirectOffset(vm, 2, jsNumber(port));
 
     return thisObject;
diff --git a/src/bun.js/bindings/JSSocketAddress.h b/src/bun.js/bindings/JSSocketAddress.h
index 5e374dac3..77bdca5d4 100644
--- a/src/bun.js/bindings/JSSocketAddress.h
+++ b/src/bun.js/bindings/JSSocketAddress.h
@@ -8,9 +8,6 @@ using namespace JSC;
 namespace Bun {
 namespace JSSocketAddress {
 
-static const NeverDestroyed<String> IPv4 = MAKE_STATIC_STRING_IMPL("IPv4");
-static const NeverDestroyed<String> IPv6 = MAKE_STATIC_STRING_IMPL("IPv6");
-
 Structure* createStructure(VM& vm, JSGlobalObject* globalObject);
 
 } // namespace JSSocketAddress
diff --git a/src/bun.js/bindings/ModuleLoader.cpp b/src/bun.js/bindings/ModuleLoader.cpp
index acda70e0a..127fb6965 100644
--- a/src/bun.js/bindings/ModuleLoader.cpp
+++ b/src/bun.js/bindings/ModuleLoader.cpp
@@ -458,7 +458,7 @@ JSValue fetchCommonJSModule(
         }
     }
 
-    if (JSC::JSValue virtualModuleResult = JSValue::decode(Bun__runVirtualModule(globalObject, specifier))) {
+    if (JSC::JSValue virtualModuleResult = Bun::runVirtualModule(globalObject, specifier)) {
         JSPromise* promise = jsCast<JSPromise*>(handleVirtualModuleResult<true>(globalObject, virtualModuleResult, res, specifier, referrer));
         switch (promise->status(vm)) {
         case JSPromise::Status::Rejected: {
@@ -633,7 +633,7 @@ static JSValue fetchESMSourceCode(
         }
     }
 
-    if (JSC::JSValue virtualModuleResult = JSValue::decode(Bun__runVirtualModule(globalObject, specifier))) {
+    if (JSC::JSValue virtualModuleResult = Bun::runVirtualModule(globalObject, specifier)) {
         return handleVirtualModuleResult<allowPromise>(globalObject, virtualModuleResult, res, specifier, referrer);
     }
 
diff --git a/src/bun.js/bindings/Process.cpp b/src/bun.js/bindings/Process.cpp
index d82d403d3..1caff9be9 100644
--- a/src/bun.js/bindings/Process.cpp
+++ b/src/bun.js/bindings/Process.cpp
@@ -1835,7 +1835,7 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionKill,
         return JSValue::encode(jsUndefined());
     }
 
-    return JSValue::encode(jsUndefined());
+    return JSValue::encode(jsBoolean(true));
 }
 
 extern "C" void Process__emitMessageEvent(Zig::GlobalObject* global, EncodedJSValue value)
diff --git a/src/bun.js/bindings/ZigGlobalObject.cpp b/src/bun.js/bindings/ZigGlobalObject.cpp
index a7d2bb7e5..b9f2e4e46 100644
--- a/src/bun.js/bindings/ZigGlobalObject.cpp
+++ b/src/bun.js/bindings/ZigGlobalObject.cpp
@@ -4036,16 +4036,45 @@ extern "C" void JSC__JSGlobalObject__queueMicrotaskCallback(Zig::GlobalObject* g
     globalObject->queueMicrotask(function, JSValue(bitwise_cast<double>(reinterpret_cast<uintptr_t>(ptr))), JSValue(bitwise_cast<double>(reinterpret_cast<uintptr_t>(callback))), jsUndefined(), jsUndefined());
 }
 
-JSC::Identifier GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject,
+JSC::Identifier GlobalObject::moduleLoaderResolve(JSGlobalObject* jsGlobalObject,
     JSModuleLoader* loader, JSValue key,
     JSValue referrer, JSValue origin)
 {
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(jsGlobalObject);
+
     ErrorableString res;
     res.success = false;
-    BunString keyZ = Bun::toString(globalObject, key);
-    BunString referrerZ = referrer && !referrer.isUndefinedOrNull() && referrer.isString() ? Bun::toString(globalObject, referrer) : BunStringEmpty;
+
+    if (key.isString()) {
+        if (auto* virtualModules = globalObject->onLoadPlugins.virtualModules) {
+            auto keyString = key.toWTFString(globalObject);
+            if (virtualModules->contains(keyString)) {
+                return JSC::Identifier::fromString(globalObject->vm(), keyString);
+            }
+        }
+    }
+
+    BunString keyZ;
+    if (key.isString()) {
+        auto moduleName = jsCast<JSString*>(key)->value(globalObject);
+        if (moduleName.startsWith("file://"_s)) {
+            auto url = WTF::URL(moduleName);
+            if (url.isValid() && !url.isEmpty()) {
+                keyZ = Bun::toStringRef(url.fileSystemPath());
+            } else {
+                keyZ = Bun::toStringRef(moduleName);
+            }
+        } else {
+            keyZ = Bun::toStringRef(moduleName);
+        }
+    } else {
+        keyZ = Bun::toStringRef(globalObject, key);
+    }
+    BunString referrerZ = referrer && !referrer.isUndefinedOrNull() && referrer.isString() ? Bun::toStringRef(globalObject, referrer) : BunStringEmpty;
     ZigString queryString = { 0, 0 };
     Zig__GlobalObject__resolve(&res, globalObject, &keyZ, &referrerZ, &queryString);
+    keyZ.deref();
+    referrerZ.deref();
 
     if (res.success) {
         if (queryString.len > 0) {
@@ -4060,25 +4089,60 @@ JSC::Identifier GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject,
     }
 }
 
-JSC::JSInternalPromise* GlobalObject::moduleLoaderImportModule(JSGlobalObject* globalObject,
+JSC::JSInternalPromise* GlobalObject::moduleLoaderImportModule(JSGlobalObject* jsGlobalObject,
     JSModuleLoader*,
     JSString* moduleNameValue,
     JSValue parameters,
     const SourceOrigin& sourceOrigin)
 {
+    auto* globalObject = reinterpret_cast<Zig::GlobalObject*>(jsGlobalObject);
     JSC::VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
 
     auto* promise = JSC::JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
     RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(globalObject, scope));
 
+    if (auto* virtualModules = globalObject->onLoadPlugins.virtualModules) {
+        auto keyString = moduleNameValue->value(globalObject);
+        if (virtualModules->contains(keyString)) {
+            auto resolvedIdentifier = JSC::Identifier::fromString(vm, keyString);
+
+            auto result = JSC::importModule(globalObject, resolvedIdentifier,
+                JSC::jsUndefined(), parameters, JSC::jsUndefined());
+
+            RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(globalObject, scope));
+            return result;
+        }
+    }
+
     auto sourceURL = sourceOrigin.url();
     ErrorableString resolved;
-    auto moduleNameZ = Bun::toString(globalObject, moduleNameValue);
-    auto sourceOriginZ = sourceURL.isEmpty() ? BunStringCwd : Bun::toString(sourceURL.fileSystemPath());
+    BunString moduleNameZ;
+
+    auto moduleName = moduleNameValue->value(globalObject);
+#if BUN_DEBUG
+    auto startRefCount = moduleName.impl()->refCount();
+#endif
+    if (moduleName.startsWith("file://"_s)) {
+        auto url = WTF::URL(moduleName);
+        if (url.isValid() && !url.isEmpty()) {
+            moduleNameZ = Bun::toStringRef(url.fileSystemPath());
+        } else {
+            moduleNameZ = Bun::toStringRef(moduleName);
+        }
+    } else {
+        moduleNameZ = Bun::toStringRef(moduleName);
+    }
+    auto sourceOriginZ = sourceURL.isEmpty() ? BunStringCwd : Bun::toStringRef(sourceURL.fileSystemPath());
     ZigString queryString = { 0, 0 };
     resolved.success = false;
     Zig__GlobalObject__resolve(&resolved, globalObject, &moduleNameZ, &sourceOriginZ, &queryString);
+    moduleNameZ.deref();
+    sourceOriginZ.deref();
+#if BUN_DEBUG
+    // TODO: ASSERT doesnt work right now
+    RELEASE_ASSERT(startRefCount == moduleName.impl()->refCount());
+#endif
     if (!resolved.success) {
         throwException(scope, resolved.result.err, globalObject);
         return promise->rejectWithCaughtException(globalObject, scope);
diff --git a/src/bun.js/bindings/ZigGlobalObject.h b/src/bun.js/bindings/ZigGlobalObject.h
index 26111725b..035d18b08 100644
--- a/src/bun.js/bindings/ZigGlobalObject.h
+++ b/src/bun.js/bindings/ZigGlobalObject.h
@@ -382,9 +382,8 @@ public:
         return false;
     }
 
-    BunPlugin::OnLoad onLoadPlugins[BunPluginTargetMax + 1] {};
-    BunPlugin::OnResolve onResolvePlugins[BunPluginTargetMax + 1] {};
-    BunPluginTarget defaultBunPluginTarget = BunPluginTargetBun;
+    BunPlugin::OnLoad onLoadPlugins {};
+    BunPlugin::OnResolve onResolvePlugins {};
 
     // This increases the cache hit rate for JSC::VM's SourceProvider cache
     // It also avoids an extra allocation for the SourceProvider
diff --git a/src/bun.js/bindings/bindings.zig b/src/bun.js/bindings/bindings.zig
index 60f8f9376..f274f72d7 100644
--- a/src/bun.js/bindings/bindings.zig
+++ b/src/bun.js/bindings/bindings.zig
@@ -5496,6 +5496,7 @@ pub const URL = opaque {
     extern fn URL__getHref(*String) String;
     extern fn URL__getFileURLString(*String) String;
     extern fn URL__getHrefJoin(*String, *String) String;
+    extern fn URL__pathFromFileURL(*String) String;
 
     pub fn hrefFromString(str: bun.String) String {
         JSC.markBinding(@src());
@@ -5516,6 +5517,12 @@ pub const URL = opaque {
         return URL__getFileURLString(&input);
     }
 
+    pub fn pathFromFileURL(str: bun.String) String {
+        JSC.markBinding(@src());
+        var input = str;
+        return URL__pathFromFileURL(&input);
+    }
+
     /// This percent-encodes the URL, punycode-encodes the hostname, and returns the result
     /// If it fails, the tag is marked Dead
     pub fn hrefFromJS(value: JSValue, globalObject: *JSC.JSGlobalObject) String {
diff --git a/src/bun.js/bindings/headers-handwritten.h b/src/bun.js/bindings/headers-handwritten.h
index e19be7abe..cef5d0804 100644
--- a/src/bun.js/bindings/headers-handwritten.h
+++ b/src/bun.js/bindings/headers-handwritten.h
@@ -17,10 +17,6 @@ typedef union BunStringImpl {
     void* wtf;
 } BunStringImpl;
 
-typedef struct BunString {
-    BunStringTag tag;
-    BunStringImpl impl;
-} BunString;
 #else
 typedef union BunStringImpl {
     ZigString zig;
@@ -34,13 +30,15 @@ enum class BunStringTag : uint8_t {
     StaticZigString = 3,
     Empty = 4,
 };
+#endif
 
 typedef struct BunString {
     BunStringTag tag;
     BunStringImpl impl;
-} BunString;
 
-#endif
+    inline void ref();
+    inline void deref();
+} BunString;
 
 typedef struct ZigErrorType {
     ZigErrorCode code;
@@ -348,3 +346,16 @@ class ScriptArguments;
 using ScriptArguments = Inspector::ScriptArguments;
 
 #endif
+
+ALWAYS_INLINE void BunString::ref()
+{
+    if (this->tag == BunStringTag::WTFStringImpl) {
+        this->impl.wtf->ref();
+    }
+}
+ALWAYS_INLINE void BunString::deref()
+{
+    if (this->tag == BunStringTag::WTFStringImpl) {
+        this->impl.wtf->deref();
+    }
+}
\ No newline at end of file
diff --git a/src/bun.js/bindings/isBuiltinModule.cpp b/src/bun.js/bindings/isBuiltinModule.cpp
new file mode 100644
index 000000000..b8e69f479
--- /dev/null
+++ b/src/bun.js/bindings/isBuiltinModule.cpp
@@ -0,0 +1,98 @@
+#include "root.h"
+
+static constexpr ASCIILiteral builtinModuleNamesSortedLength[] = {
+    "fs"_s,
+    "os"_s,
+    "v8"_s,
+    "vm"_s,
+    "ws"_s,
+    "bun"_s,
+    "dns"_s,
+    "net"_s,
+    "sys"_s,
+    "tls"_s,
+    "tty"_s,
+    "url"_s,
+    "http"_s,
+    "path"_s,
+    "repl"_s,
+    "util"_s,
+    "wasi"_s,
+    "zlib"_s,
+    "dgram"_s,
+    "http2"_s,
+    "https"_s,
+    "assert"_s,
+    "buffer"_s,
+    "crypto"_s,
+    "domain"_s,
+    "events"_s,
+    "module"_s,
+    "stream"_s,
+    "timers"_s,
+    "undici"_s,
+    "bun:ffi"_s,
+    "bun:jsc"_s,
+    "cluster"_s,
+    "console"_s,
+    "process"_s,
+    "bun:wrap"_s,
+    "punycode"_s,
+    "bun:test"_s,
+    "bun:main"_s,
+    "readline"_s,
+    "_tls_wrap"_s,
+    "constants"_s,
+    "inspector"_s,
+    "bun:sqlite"_s,
+    "path/posix"_s,
+    "path/win32"_s,
+    "perf_hooks"_s,
+    "stream/web"_s,
+    "util/types"_s,
+    "_http_agent"_s,
+    "_tls_common"_s,
+    "async_hooks"_s,
+    "detect-libc"_s,
+    "fs/promises"_s,
+    "querystring"_s,
+    "_http_client"_s,
+    "_http_common"_s,
+    "_http_server"_s,
+    "_stream_wrap"_s,
+    "dns/promises"_s,
+    "trace_events"_s,
+    "assert/strict"_s,
+    "child_process"_s,
+    "_http_incoming"_s,
+    "_http_outgoing"_s,
+    "_stream_duplex"_s,
+    "string_decoder"_s,
+    "worker_threads"_s,
+    "stream/promises"_s,
+    "timers/promises"_s,
+    "_stream_readable"_s,
+    "_stream_writable"_s,
+    "stream/consumers"_s,
+    "_stream_transform"_s,
+    "readline/promises"_s,
+    "inspector/promises"_s,
+    "_stream_passthrough"_s,
+    "diagnostics_channel"_s,
+};
+
+namespace Bun {
+
+bool isBuiltinModule(const String &namePossiblyWithNodePrefix) {
+  String name = namePossiblyWithNodePrefix;
+  if (name.startsWith("node:"_s))
+    name = name.substringSharingImpl(5);
+
+  for (auto &builtinModule : builtinModuleNamesSortedLength) {
+    if (name == builtinModule)
+      return true;
+  }
+  return false;
+}
+
+} // namespace Bun
\ No newline at end of file
diff --git a/src/bun.js/bindings/isBuiltinModule.h b/src/bun.js/bindings/isBuiltinModule.h
new file mode 100644
index 000000000..d66f025d1
--- /dev/null
+++ b/src/bun.js/bindings/isBuiltinModule.h
@@ -0,0 +1,5 @@
+#pragma once
+
+namespace Bun {
+bool isBuiltinModule(const String &namePossiblyWithNodePrefix);
+} // namespace Bun
\ No newline at end of file
diff --git a/src/bun.js/javascript.zig b/src/bun.js/javascript.zig
index caa7d3cd8..d1b87e34e 100644
--- a/src/bun.js/javascript.zig
+++ b/src/bun.js/javascript.zig
@@ -1523,7 +1523,6 @@ pub const VirtualMachine = struct {
 
     fn normalizeSpecifierForResolution(specifier_: []const u8, query_string: *[]const u8) []const u8 {
         var specifier = specifier_;
-        if (strings.hasPrefixComptime(specifier, "file://")) specifier = specifier["file://".len..];
 
         if (strings.indexOfChar(specifier, '?')) |i| {
             query_string.* = specifier[i..];
diff --git a/src/bun.js/modules/NodeModuleModule.h b/src/bun.js/modules/NodeModuleModule.h
index eb8bb5c00..eeac4c0ea 100644
--- a/src/bun.js/modules/NodeModuleModule.h
+++ b/src/bun.js/modules/NodeModuleModule.h
@@ -1,8 +1,11 @@
+#pragma once
+
 #include "CommonJSModuleRecord.h"
 #include "ImportMetaObject.h"
 #include "JavaScriptCore/JSBoundFunction.h"
 #include "JavaScriptCore/ObjectConstructor.h"
 #include "_NativeModule.h"
+#include "isBuiltinModule.h"
 
 using namespace Zig;
 using namespace JSC;
@@ -88,18 +91,6 @@ static constexpr ASCIILiteral builtinModuleNames[] = {
     "zlib"_s,
 };
 
-static bool isBuiltinModule(const String &namePossiblyWithNodePrefix) {
-  String name = namePossiblyWithNodePrefix;
-  if (name.startsWith("node:"_s))
-    name = name.substringSharingImpl(5);
-
-  for (auto &builtinModule : builtinModuleNames) {
-    if (name == builtinModule)
-      return true;
-  }
-  return false;
-}
-
 JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleModuleConstructor,
                          (JSC::JSGlobalObject * globalObject,
                           JSC::CallFrame *callFrame)) {
@@ -158,7 +149,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBuiltinModule,
   auto moduleStr = moduleName.toWTFString(globalObject);
   RETURN_IF_EXCEPTION(scope, JSValue::encode(jsBoolean(false)));
 
-  return JSValue::encode(jsBoolean(isBuiltinModule(moduleStr)));
+  return JSValue::encode(jsBoolean(Bun::isBuiltinModule(moduleStr)));
 }
 
 // Might be faster as a JS builtin
diff --git a/src/bun.js/webcore/request.zig b/src/bun.js/webcore/request.zig
index 381ae2750..7f37bea46 100644
--- a/src/bun.js/webcore/request.zig
+++ b/src/bun.js/webcore/request.zig
@@ -507,10 +507,9 @@ pub const Request = struct {
         };
         const values_to_try = values_to_try_[0 .. @as(usize, @intFromBool(!is_first_argument_a_url)) +
             @as(usize, @intFromBool(arguments.len > 1 and arguments[1].isObject()))];
-
         for (values_to_try) |value| {
             const value_type = value.jsType();
-
+            const explicit_check = values_to_try.len == 2 and value_type == .FinalObject and values_to_try[1].jsType() == .DOMWrapper;
             if (value_type == .DOMWrapper) {
                 if (value.as(Request)) |request| {
                     if (values_to_try.len == 1) {
@@ -625,23 +624,25 @@ pub const Request = struct {
 
             if (!fields.contains(.method) or !fields.contains(.headers)) {
                 if (Body.Init.init(globalThis.allocator(), globalThis, value) catch null) |init| {
-                    if (!fields.contains(.method)) {
-                        req.method = init.method;
-                        fields.insert(.method);
+                    if (!explicit_check or (explicit_check and value.fastGet(globalThis, .method) != null)) {
+                        if (!fields.contains(.method)) {
+                            req.method = init.method;
+                            fields.insert(.method);
+                        }
                     }
-
-                    if (init.headers) |headers| {
-                        if (!fields.contains(.headers)) {
-                            req.headers = headers;
-                            fields.insert(.headers);
-                        } else {
-                            headers.deref();
+                    if (!explicit_check or (explicit_check and value.fastGet(globalThis, .headers) != null)) {
+                        if (init.headers) |headers| {
+                            if (!fields.contains(.headers)) {
+                                req.headers = headers;
+                                fields.insert(.headers);
+                            } else {
+                                headers.deref();
+                            }
                         }
                     }
                 }
             }
         }
-
         if (req.url.isEmpty()) {
             globalThis.throw("Failed to construct 'Request': url is required.", .{});
             req.finalizeWithoutDeinit();
diff --git a/src/bun.zig b/src/bun.zig
index 3f09277bb..a93b3c5ae 100644
--- a/src/bun.zig
+++ b/src/bun.zig
@@ -1906,3 +1906,35 @@ pub inline fn serializableInto(comptime T: type, init: anytype) T {
 
     return result.*;
 }
+
+/// Like std.fs.Dir.makePath except instead of infinite looping on dangling
+/// symlink, it deletes the symlink and tries again.
+pub fn makePath(dir: std.fs.Dir, sub_path: []const u8) !void {
+    var it = try std.fs.path.componentIterator(sub_path);
+    var component = it.last() orelse return;
+    while (true) {
+        dir.makeDir(component.path) catch |err| switch (err) {
+            error.PathAlreadyExists => {
+                var path_buf2: [MAX_PATH_BYTES * 2]u8 = undefined;
+                copy(u8, &path_buf2, component.path);
+
+                path_buf2[component.path.len] = 0;
+                var path_to_use = path_buf2[0..component.path.len :0];
+                const result = sys.lstat(path_to_use);
+                try result.throw();
+                const is_dir = std.os.S.ISDIR(result.result.mode);
+                // dangling symlink
+                if (!is_dir) {
+                    dir.deleteTree(component.path) catch {};
+                    continue;
+                }
+            },
+            error.FileNotFound => |e| {
+                component = it.previous() orelse return e;
+                continue;
+            },
+            else => |e| return e,
+        };
+        component = it.next() orelse return;
+    }
+}
diff --git a/src/deps/libuwsockets.cpp b/src/deps/libuwsockets.cpp
index 79dd68b42..bb89b33a8 100644
--- a/src/deps/libuwsockets.cpp
+++ b/src/deps/libuwsockets.cpp
@@ -5,6 +5,8 @@
 #include <bun-usockets/src/internal/internal.h>
 #include <string_view>
 
+extern "C" const char* ares_inet_ntop(int af, const char *src, char *dst, size_t size);
+
 extern "C"
 {
 
@@ -1577,28 +1579,29 @@ extern "C"
     us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
   }
 
+  // Gets the remote address and port
+  // Returns 0 if failure / unix socket
   uint64_t uws_res_get_remote_address_info(uws_res_t *res, const char **dest, int *port, bool *is_ipv6)
   {
     // This function is manual inlining + modification of
     //      us_socket_remote_address
     //      AsyncSocket::getRemoteAddress
-    // To get { ip, port, is_ipv6 } for Bun.serve().requestIP()
     //      AsyncSocket::addressAsText
+    // To get { ip, port, is_ipv6 } for Bun.serve().requestIP()
     static thread_local char b[64];
     auto length = us_get_remote_address_info(b, (us_socket_t *)res, dest, port, (int*)is_ipv6);
 
+    if (length == 0) return 0;
     if (length == 4) {
-        length = sprintf(b, "%u.%u.%u.%u", b[0], b[1], b[2], b[3]);
-        *is_ipv6 = false;
+      length = snprintf(b, 64, "%u.%u.%u.%u", b[0], b[1], b[2], b[3]);
+      *dest = b;
+      *is_ipv6 = false;
+      return length;
     } else {
-        length = sprintf(b, "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
-            b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9], b[10], b[11],
-            b[12], b[13], b[14], b[15]);
-        *is_ipv6 = true;
+      ares_inet_ntop(AF_INET6, b, &b[16], 64 - 16);
+      *dest = &b[16];
+      *is_ipv6 = true;
+      return strlen(*dest);
     }
-
-    *dest = b;
-
-    return (unsigned int) length;
   }
 }
diff --git a/src/http_client_async.zig b/src/http_client_async.zig
index 15e29f345..6c731acd5 100644
--- a/src/http_client_async.zig
+++ b/src/http_client_async.zig
@@ -68,6 +68,10 @@ pub const Signals = struct {
     aborted: ?*std.atomic.Atomic(bool) = null,
     cert_errors: ?*std.atomic.Atomic(bool) = null,
 
+    pub fn isEmpty(this: *const Signals) bool {
+        return this.aborted == null and this.body_streaming == null and this.header_progress == null and this.cert_errors == null;
+    }
+
     pub const Store = struct {
         header_progress: std.atomic.Atomic(bool) = std.atomic.Atomic(bool).init(false),
         body_streaming: std.atomic.Atomic(bool) = std.atomic.Atomic(bool).init(false),
@@ -1350,9 +1354,6 @@ pub const InternalState = struct {
             reader.deinit();
         }
 
-        // if we are holding a cloned_metadata we need to deinit it
-        // this should never happen because we should always return the metadata to the user
-        std.debug.assert(this.cloned_metadata == null);
         // just in case we check and free to avoid leaks
         if (this.cloned_metadata != null) {
             this.cloned_metadata.?.deinit(allocator);
@@ -2673,7 +2674,7 @@ pub fn onData(this: *HTTPClient, comptime is_ssl: bool, incoming_data: []const u
             }
 
             var deferred_redirect: ?*URLBufferPool.Node = null;
-            const can_continue = this.handleResponseMetadata(
+            const should_continue = this.handleResponseMetadata(
                 &response,
                 // If there are multiple consecutive redirects
                 // and the redirect differs in hostname
@@ -2720,8 +2721,7 @@ pub fn onData(this: *HTTPClient, comptime is_ssl: bool, incoming_data: []const u
                 this.state.pending_response = response;
             }
 
-            if (!can_continue) {
-                log("onData: can_continue is false", .{});
+            if (should_continue == .finished) {
                 // this means that the request ended
                 // clone metadata and return the progress at this point
                 this.cloneMetadata();
@@ -3355,13 +3355,19 @@ fn handleResponseBodyChunkedEncodingFromSinglePacket(
     unreachable;
 }
 
+const ShouldContinue = enum {
+    continue_streaming,
+    finished,
+};
+
 pub fn handleResponseMetadata(
     this: *HTTPClient,
     response: *picohttp.Response,
     deferred_redirect: *?*URLBufferPool.Node,
-) !bool {
+) !ShouldContinue {
     var location: string = "";
     var pretend_304 = false;
+    var is_server_sent_events = false;
     for (response.headers, 0..) |header, header_i| {
         switch (hashHeaderName(header.name)) {
             hashHeaderConst("Content-Length") => {
@@ -3373,6 +3379,11 @@ pub fn handleResponseMetadata(
                     this.state.content_length = 0;
                 }
             },
+            hashHeaderConst("Content-Type") => {
+                if (strings.contains(header.value, "text/event-stream")) {
+                    is_server_sent_events = true;
+                }
+            },
             hashHeaderConst("Content-Encoding") => {
                 if (!this.disable_decompression) {
                     if (strings.eqlComptime(header.value, "gzip")) {
@@ -3429,8 +3440,8 @@ pub fn handleResponseMetadata(
 
     if (this.proxy_tunneling and this.proxy_tunnel == null) {
         if (response.status_code == 200) {
-            //signal to continue the proxing
-            return true;
+            // signal to continue the proxing
+            return ShouldContinue.continue_streaming;
         }
 
         //proxy denied connection so return proxy result (407, 403 etc)
@@ -3623,6 +3634,10 @@ pub fn handleResponseMetadata(
     } else {
         log("handleResponseMetadata: content_length is null and transfer_encoding {}", .{this.state.transfer_encoding});
     }
-    // if no body is expected we should stop processing
-    return this.method.hasBody() and (content_length == null or content_length.? > 0 or this.state.transfer_encoding == .chunked);
+
+    if (this.method.hasBody() and ((content_length != null and content_length.? > 0) or !this.state.allow_keepalive or this.state.transfer_encoding == .chunked or is_server_sent_events)) {
+        return ShouldContinue.continue_streaming;
+    } else {
+        return ShouldContinue.finished;
+    }
 }
diff --git a/src/install/install.zig b/src/install/install.zig
index 131adb00e..22c7c3c3d 100644
--- a/src/install/install.zig
+++ b/src/install/install.zig
@@ -1764,7 +1764,7 @@ pub const PackageManager = struct {
 
     pub fn sleep(this: *PackageManager) void {
         if (this.wait_count.swap(0, .Monotonic) > 0) return;
-        bun.Mimalloc.mi_collect(false);
+        Output.flush();
         _ = this.waiter.wait() catch 0;
     }
 
@@ -1829,7 +1829,7 @@ pub const PackageManager = struct {
                 switch (this.options.log_level) {
                     inline else => |log_level| {
                         if (log_level.showProgress()) this.startProgressBarIfNone();
-                        while (this.pending_tasks > 0) : (this.sleep()) {
+                        while (this.pending_tasks > 0) {
                             this.runTasks(
                                 void,
                                 {},
@@ -1843,6 +1843,13 @@ pub const PackageManager = struct {
                             ) catch |err| {
                                 return .{ .failure = err };
                             };
+
+                            if (PackageManager.verbose_install and this.pending_tasks > 0) {
+                                Output.prettyErrorln("<d>[PackageManager]<r> waiting for {d} tasks\n", .{this.pending_tasks});
+                            }
+
+                            if (this.pending_tasks > 0)
+                                this.sleep();
                         }
                     },
                 }
@@ -2942,6 +2949,8 @@ pub const PackageManager = struct {
         );
     }
 
+    const debug = Output.scoped(.PackageManager, true);
+
     /// Q: "What do we do with a dependency in a package.json?"
     /// A: "We enqueue it!"
     fn enqueueDependencyWithMainAndSuccessFn(
@@ -3068,12 +3077,36 @@ pub const PackageManager = struct {
                                     this.enqueueNetworkTask(network_task);
                                 }
                             }
+
+                            if (comptime Environment.allow_assert)
+                                debug(
+                                    "enqueueDependency({d}, {s}, {s}, {s}) = {d}",
+                                    .{
+                                        id,
+                                        @tagName(dependency.version.tag),
+                                        this.lockfile.str(&name),
+                                        this.lockfile.str(&version.literal),
+                                        result.package.meta.id,
+                                    },
+                                );
                         } else if (dependency.version.tag.isNPM()) {
                             const name_str = this.lockfile.str(&name);
                             const task_id = Task.Id.forManifest(name_str);
 
                             if (comptime Environment.allow_assert) std.debug.assert(task_id != 0);
 
+                            if (comptime Environment.allow_assert)
+                                debug(
+                                    "enqueueDependency({d}, {s}, {s}, {s}) = task {d}",
+                                    .{
+                                        id,
+                                        @tagName(dependency.version.tag),
+                                        this.lockfile.str(&name),
+                                        this.lockfile.str(&version.literal),
+                                        task_id,
+                                    },
+                                );
+
                             if (!dependency.behavior.isPeer()) {
                                 var network_entry = try this.network_dedupe_map.getOrPutContext(this.allocator, task_id, .{});
                                 if (!network_entry.found_existing) {
@@ -3174,6 +3207,18 @@ pub const PackageManager = struct {
                     id,
                 );
 
+                if (comptime Environment.allow_assert)
+                    debug(
+                        "enqueueDependency({d}, {s}, {s}, {s}) = {s}",
+                        .{
+                            id,
+                            @tagName(dependency.version.tag),
+                            this.lockfile.str(&name),
+                            this.lockfile.str(&version.literal),
+                            url,
+                        },
+                    );
+
                 if (this.git_repositories.get(clone_id)) |repo_fd| {
                     const resolved = try Repository.findCommit(
                         this.allocator,
@@ -3240,6 +3285,18 @@ pub const PackageManager = struct {
                     entry.value_ptr.* = TaskCallbackList{};
                 }
 
+                if (comptime Environment.allow_assert)
+                    debug(
+                        "enqueueDependency({d}, {s}, {s}, {s}) = {s}",
+                        .{
+                            id,
+                            @tagName(dependency.version.tag),
+                            this.lockfile.str(&name),
+                            this.lockfile.str(&version.literal),
+                            url,
+                        },
+                    );
+
                 const callback_tag = comptime if (successFn == assignRootResolution) "root_dependency" else "dependency";
                 try entry.value_ptr.append(this.allocator, @unionInit(TaskCallbackContext, callback_tag, id));
 
@@ -3307,6 +3364,18 @@ pub const PackageManager = struct {
 
                     // should not trigger a network call
                     if (comptime Environment.allow_assert) std.debug.assert(result.network_task == null);
+
+                    if (comptime Environment.allow_assert)
+                        debug(
+                            "enqueueDependency({d}, {s}, {s}, {s}) = {d}",
+                            .{
+                                id,
+                                @tagName(dependency.version.tag),
+                                this.lockfile.str(&name),
+                                this.lockfile.str(&version.literal),
+                                result.package.meta.id,
+                            },
+                        );
                 } else if (dependency.behavior.isRequired()) {
                     if (comptime dependency_tag == .workspace) {
                         this.log.addErrorFmt(
@@ -3387,6 +3456,18 @@ pub const PackageManager = struct {
                     entry.value_ptr.* = TaskCallbackList{};
                 }
 
+                if (comptime Environment.allow_assert)
+                    debug(
+                        "enqueueDependency({d}, {s}, {s}, {s}) = {s}",
+                        .{
+                            id,
+                            @tagName(dependency.version.tag),
+                            this.lockfile.str(&name),
+                            this.lockfile.str(&version.literal),
+                            url,
+                        },
+                    );
+
                 const callback_tag = comptime if (successFn == assignRootResolution) "root_dependency" else "dependency";
                 try entry.value_ptr.append(this.allocator, @unionInit(TaskCallbackContext, callback_tag, id));
 
@@ -5205,19 +5286,18 @@ pub const PackageManager = struct {
 
         // Step 1. Find the nearest package.json directory
         //
-        // We will walk up from the cwd, calling chdir on each directory until we find a package.json
-        // If we fail to find one, we will report an error saying no packages to install
+        // We will walk up from the cwd, trying to find the nearest package.json file.
         const package_json_file = brk: {
             var this_cwd = original_cwd;
             const child_json = child: {
                 while (true) {
-                    var dir = std.fs.openDirAbsolute(this_cwd, .{}) catch |err| {
-                        Output.prettyErrorln("Error {s} accessing {s}", .{ @errorName(err), this_cwd });
-                        Output.flush();
-                        return err;
-                    };
-                    defer dir.close();
-                    break :child dir.openFileZ("package.json", .{ .mode = .read_write }) catch {
+                    const this_cwd_without_trailing_slash = strings.withoutTrailingSlash(this_cwd);
+                    var buf2: [bun.MAX_PATH_BYTES + 1]u8 = undefined;
+                    @memcpy(buf2[0..this_cwd_without_trailing_slash.len], this_cwd_without_trailing_slash);
+                    buf2[this_cwd_without_trailing_slash.len..buf2.len][0.."/package.json".len].* = "/package.json".*;
+                    buf2[this_cwd_without_trailing_slash.len + "/package.json".len] = 0;
+
+                    break :child std.fs.cwd().openFileZ(buf2[0 .. this_cwd_without_trailing_slash.len + "/package.json".len :0].ptr, .{ .mode = .read_write }) catch {
                         if (std.fs.path.dirname(this_cwd)) |parent| {
                             this_cwd = parent;
                             continue;
@@ -5233,9 +5313,13 @@ pub const PackageManager = struct {
             // Check if this is a workspace; if so, use root package
             var found = false;
             while (std.fs.path.dirname(this_cwd)) |parent| : (this_cwd = parent) {
-                var dir = std.fs.openDirAbsolute(parent, .{}) catch break;
-                defer dir.close();
-                const json_file = dir.openFileZ("package.json", .{ .mode = .read_write }) catch {
+                const parent_without_trailing_slash = strings.withoutTrailingSlash(parent);
+                var buf2: [bun.MAX_PATH_BYTES + 1]u8 = undefined;
+                @memcpy(buf2[0..parent_without_trailing_slash.len], parent_without_trailing_slash);
+                buf2[parent_without_trailing_slash.len..buf2.len][0.."/package.json".len].* = "/package.json".*;
+                buf2[parent_without_trailing_slash.len + "/package.json".len] = 0;
+
+                const json_file = std.fs.cwd().openFileZ(buf2[0 .. parent_without_trailing_slash.len + "/package.json".len :0].ptr, .{ .mode = .read_write }) catch {
                     continue;
                 };
                 defer if (!found) json_file.close();
@@ -7297,7 +7381,10 @@ pub const PackageManager = struct {
                 // We use this file descriptor to know where to put it.
                 installer.node_modules_folder = cwd.openIterableDir(node_modules.relative_path, .{}) catch brk: {
                     // Avoid extra mkdir() syscall
-                    try cwd.makePath(bun.span(node_modules.relative_path));
+                    //
+                    // note: this will recursively delete any dangling symlinks
+                    // in the next.js repo, it encounters a dangling symlink in node_modules/@next/codemod/node_modules/cheerio
+                    try bun.makePath(cwd, bun.span(node_modules.relative_path));
                     break :brk try cwd.openIterableDir(node_modules.relative_path, .{});
                 };
 
@@ -7351,7 +7438,7 @@ pub const PackageManager = struct {
                 if (!installer.options.do.install_packages) return error.InstallFailed;
             }
 
-            while (this.pending_tasks > 0 and installer.options.do.install_packages) : (this.sleep()) {
+            while (this.pending_tasks > 0 and installer.options.do.install_packages) {
                 try this.runTasks(
                     *PackageInstaller,
                     &installer,
@@ -7363,6 +7450,13 @@ pub const PackageManager = struct {
                     },
                     log_level,
                 );
+
+                if (PackageManager.verbose_install and this.pending_tasks > 0) {
+                    Output.prettyErrorln("<d>[PackageManager]<r> waiting for {d} tasks\n", .{this.pending_tasks});
+                }
+
+                if (this.pending_tasks > 0)
+                    this.sleep();
             }
 
             if (!installer.options.do.install_packages) return error.InstallFailed;
@@ -7733,7 +7827,7 @@ pub const PackageManager = struct {
                 Output.flush();
             }
 
-            while (manager.pending_tasks > 0) : (manager.sleep()) {
+            while (manager.pending_tasks > 0) {
                 try manager.runTasks(
                     *PackageManager,
                     manager,
@@ -7746,6 +7840,13 @@ pub const PackageManager = struct {
                     },
                     log_level,
                 );
+
+                if (PackageManager.verbose_install and manager.pending_tasks > 0) {
+                    Output.prettyErrorln("<d>[PackageManager]<r> waiting for {d} tasks\n", .{manager.pending_tasks});
+                }
+
+                if (manager.pending_tasks > 0)
+                    manager.sleep();
             }
 
             if (comptime log_level.showProgress()) {
diff --git a/src/js/builtins/BundlerPlugin.ts b/src/js/builtins/BundlerPlugin.ts
index 7be030ee8..d2c88b667 100644
--- a/src/js/builtins/BundlerPlugin.ts
+++ b/src/js/builtins/BundlerPlugin.ts
@@ -162,6 +162,9 @@ export function runSetupFunction(this: BundlerPlugin, setup: Setup, config: Buil
     onResolve,
     onStart: notImplementedIssueFn(2771, "On-start callbacks"),
     resolve: notImplementedIssueFn(2771, "build.resolve()"),
+    module: () => {
+      throw new TypeError("module() is not supported in Bun.build() yet. Only via Bun.plugin() at runtime");
+    },
     // esbuild's options argument is different, we provide some interop
     initialOptions: {
       ...config,
diff --git a/src/js/node/http.ts b/src/js/node/http.ts
index 77f8c55de..c905b97a1 100644
--- a/src/js/node/http.ts
+++ b/src/js/node/http.ts
@@ -136,7 +136,7 @@ var FakeSocket = class Socket extends Duplex {
   address() {
     // Call server.requestIP() without doing any propety getter twice.
     var internalData;
-    return (this.#address ??= (internalData = this[kInternalSocketData])[0].requestIP(internalData[2]));
+    return (this.#address ??= (internalData = this[kInternalSocketData])[0].requestIP(internalData[2]) ?? {});
   }
 
   get bufferSize() {
diff --git a/src/js/node/net.js b/src/js/node/net.js
index 5283538c3..fc0aba548 100644
--- a/src/js/node/net.js
+++ b/src/js/node/net.js
@@ -79,17 +79,15 @@ const Socket = (function (InternalSocket) {
     enumerable: false,
   });
 
-  return Object.defineProperty(
-    function Socket(options) {
-      return new InternalSocket(options);
-    },
-    Symbol.hasInstance,
-    {
-      value(instance) {
-        return instance instanceof InternalSocket;
-      },
+  function Socket(options) {
+    return new InternalSocket(options);
+  }
+  Socket.prototype = InternalSocket.prototype;
+  return Object.defineProperty(Socket, Symbol.hasInstance, {
+    value(instance) {
+      return instance instanceof InternalSocket;
     },
-  );
+  });
 })(
   class Socket extends Duplex {
     static #Handlers = {
diff --git a/src/js/node/tls.js b/src/js/node/tls.js
index bdf06faac..1a9c46270 100644
--- a/src/js/node/tls.js
+++ b/src/js/node/tls.js
@@ -306,18 +306,15 @@ const TLSSocket = (function (InternalTLSSocket) {
     value: "TLSSocket",
     enumerable: false,
   });
-
-  return Object.defineProperty(
-    function Socket(options) {
-      return new InternalTLSSocket(options);
-    },
-    Symbol.hasInstance,
-    {
-      value(instance) {
-        return instance instanceof InternalTLSSocket;
-      },
+  function Socket(options) {
+    return new InternalTLSSocket(options);
+  }
+  Socket.prototype = InternalTLSSocket.prototype;
+  return Object.defineProperty(Socket, Symbol.hasInstance, {
+    value(instance) {
+      return instance instanceof InternalTLSSocket;
     },
-  );
+  });
 })(
   class TLSSocket extends InternalTCPSocket {
     #secureContext;
diff --git a/src/js/out/InternalModuleRegistryConstants.h b/src/js/out/InternalModuleRegistryConstants.h
index 554e3d179..e6996352c 100644
--- a/src/js/out/InternalModuleRegistryConstants.h
+++ b/src/js/out/InternalModuleRegistryConstants.h
@@ -98,7 +98,7 @@ static constexpr ASCIILiteral NodeFSPromisesCode = "(function (){\"use strict\";
 //
 
 //
-static constexpr ASCIILiteral NodeHttpCode = "(function (){\"use strict\";// src/js/out/tmp/node/http.ts\nvar checkInvalidHeaderChar = function(val) {\n  return RegExpPrototypeExec.call(headerCharRegex, val) !== null;\n}, isIPv6 = function(input) {\n  return new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\").test(input);\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, validateMsecs = function(numberlike, field) {\n  if (typeof numberlike !== \"number\" || numberlike < 0)\n    throw new ERR_INVALID_ARG_TYPE(field, \"number\", numberlike);\n  return numberlike;\n}, validateFunction = function(callable, field) {\n  if (typeof callable !== \"function\")\n    throw new ERR_INVALID_ARG_TYPE(field, \"Function\", callable);\n  return callable;\n}, createServer = function(options, callback) {\n  return new Server(options, callback);\n}, emitListeningNextTick = function(self, onListen, err, hostname, port) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen(err, hostname, port);\n    } catch (err2) {\n      self.emit(\"error\", err2);\n    }\n  if (self.listening = !err, err)\n    self.emit(\"error\", err);\n  else\n    self.emit(\"listening\", hostname, port);\n}, assignHeaders = function(object, req) {\n  var headers = req.headers.toJSON();\n  const rawHeaders = @newArrayWithSize(req.headers.count * 2);\n  var i = 0;\n  for (let key in headers)\n    rawHeaders[i++] = key, rawHeaders[i++] = headers[key];\n  object.headers = headers, object.rawHeaders = rawHeaders;\n};\nvar getDefaultHTTPSAgent = function() {\n  return _defaultHTTPSAgent \?\?= new Agent({ defaultPort: 443, protocol: \"https:\" });\n};\nvar urlToHttpOptions = function(url) {\n  var { protocol, hostname, hash, search, pathname, href, port, username, password } = url;\n  return {\n    protocol,\n    hostname: typeof hostname === \"string\" && StringPrototypeStartsWith.call(hostname, \"[\") \? StringPrototypeSlice.call(hostname, 1, -1) : hostname,\n    hash,\n    search,\n    pathname,\n    path: `${pathname || \"\"}${search || \"\"}`,\n    href,\n    port: port \? Number(port) : protocol === \"https:\" \? 443 : protocol === \"http:\" \? 80 : @undefined,\n    auth: username || password \? `${decodeURIComponent(username)}:${decodeURIComponent(password)}` : @undefined\n  };\n}, validateHost = function(host, name) {\n  if (host !== null && host !== @undefined && typeof host !== \"string\")\n    throw new Error(\"Invalid arg type in options\");\n  return host;\n}, checkIsHttpToken = function(val) {\n  return RegExpPrototypeExec.call(tokenRegExp, val) !== null;\n};\nvar _writeHead = function(statusCode, reason, obj, response) {\n  if (statusCode |= 0, statusCode < 100 || statusCode > 999)\n    throw new Error(\"status code must be between 100 and 999\");\n  if (typeof reason === \"string\")\n    response.statusMessage = reason;\n  else {\n    if (!response.statusMessage)\n      response.statusMessage = STATUS_CODES[statusCode] || \"unknown\";\n    obj = reason;\n  }\n  response.statusCode = statusCode;\n  {\n    let k;\n    if (@Array.isArray(obj)) {\n      if (obj.length % 2 !== 0)\n        throw new Error(\"raw headers must have an even number of elements\");\n      for (let n = 0;n < obj.length; n += 2)\n        if (k = obj[n + 0], k)\n          response.setHeader(k, obj[n + 1]);\n    } else if (obj) {\n      const keys = Object.keys(obj);\n      for (let i = 0;i < keys.length; i++)\n        if (k = keys[i], k)\n          response.setHeader(k, obj[k]);\n    }\n  }\n  if (statusCode === 204 || statusCode === 304 || statusCode >= 100 && statusCode <= 199)\n    response._hasBody = !1;\n}, request = function(url, options, cb) {\n  return new ClientRequest(url, options, cb);\n}, get = function(url, options, cb) {\n  const req = request(url, options, cb);\n  return req.end(), req;\n}, $, EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20), { isTypedArray } = @requireNativeModule(\"util/types\"), { Duplex, Readable, Writable } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), { getHeader, setHeader } = @lazy(\"http\"), headerCharRegex = /[^\\t\\x20-\\x7e\\x80-\\xff]/, validateHeaderName = (name, label) => {\n  if (typeof name !== \"string\" || !name || !checkIsHttpToken(name))\n    throw new Error(\"ERR_INVALID_HTTP_TOKEN\");\n}, validateHeaderValue = (name, value) => {\n  if (value === @undefined)\n    throw new Error(\"ERR_HTTP_INVALID_HEADER_VALUE\");\n  if (checkInvalidHeaderChar(value))\n    throw new Error(\"ERR_INVALID_CHAR\");\n}, { URL } = globalThis, globalReportError = globalThis.reportError, setTimeout = globalThis.setTimeout, fetch = Bun.fetch;\nvar kEmptyObject = Object.freeze(Object.create(null)), kOutHeaders = Symbol.for(\"kOutHeaders\"), kEndCalled = Symbol.for(\"kEndCalled\"), kAbortController = Symbol.for(\"kAbortController\"), kClearTimeout = Symbol(\"kClearTimeout\"), kCorked = Symbol.for(\"kCorked\"), searchParamsSymbol = Symbol.for(\"query\"), StringPrototypeSlice = @String.prototype.slice, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeToUpperCase = @String.prototype.toUpperCase, ArrayIsArray = @Array.isArray, RegExpPrototypeExec = @RegExp.prototype.exec, ObjectAssign = Object.assign, INVALID_PATH_REGEX = /[^\\u0021-\\u00ff]/;\nvar _defaultHTTPSAgent, kInternalRequest = Symbol(\"kInternalRequest\"), kInternalSocketData = Symbol.for(\"::bunternal::\"), kEmptyBuffer = @Buffer.alloc(0);\n\nclass ERR_INVALID_ARG_TYPE extends TypeError {\n  constructor(name, expected, actual) {\n    super(`The ${name} argument must be of type ${expected}. Received type ${typeof actual}`);\n    this.code = \"ERR_INVALID_ARG_TYPE\";\n  }\n}\nvar FakeSocket = class Socket extends Duplex {\n  [kInternalSocketData];\n  bytesRead = 0;\n  bytesWritten = 0;\n  connecting = !1;\n  timeout = 0;\n  isServer = !1;\n  #address;\n  address() {\n    var internalData;\n    return this.#address \?\?= (internalData = this[kInternalSocketData])[0].requestIP(internalData[2]);\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  connect(port, host, connectListener) {\n    return this;\n  }\n  _destroy(err, callback) {\n  }\n  _final(callback) {\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return 80;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n  }\n  get remoteAddress() {\n    return this.address()\?.address;\n  }\n  set remoteAddress(val) {\n    this.address().address = val;\n  }\n  get remotePort() {\n    return this.address()\?.port;\n  }\n  set remotePort(val) {\n    this.address().port = val;\n  }\n  get remoteFamily() {\n    return this.address()\?.family;\n  }\n  set remoteFamily(val) {\n    this.address().family = val;\n  }\n  resetAndDestroy() {\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    return this;\n  }\n  unref() {\n  }\n  _write(chunk, encoding, callback) {\n  }\n};\n\nclass Agent extends EventEmitter {\n  defaultPort = 80;\n  protocol = \"http:\";\n  options;\n  requests;\n  sockets;\n  freeSockets;\n  keepAliveMsecs;\n  keepAlive;\n  maxSockets;\n  maxFreeSockets;\n  scheduling;\n  maxTotalSockets;\n  totalSocketCount;\n  #fakeSocket;\n  static get globalAgent() {\n    return globalAgent;\n  }\n  static get defaultMaxSockets() {\n    return @Infinity;\n  }\n  constructor(options = kEmptyObject) {\n    super();\n    if (this.options = options = { ...options, path: null }, options.noDelay === @undefined)\n      options.noDelay = !0;\n    this.requests = kEmptyObject, this.sockets = kEmptyObject, this.freeSockets = kEmptyObject, this.keepAliveMsecs = options.keepAliveMsecs || 1000, this.keepAlive = options.keepAlive || !1, this.maxSockets = options.maxSockets || Agent.defaultMaxSockets, this.maxFreeSockets = options.maxFreeSockets || 256, this.scheduling = options.scheduling || \"lifo\", this.maxTotalSockets = options.maxTotalSockets, this.totalSocketCount = 0, this.defaultPort = options.defaultPort || 80, this.protocol = options.protocol || \"http:\";\n  }\n  createConnection() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  getName(options = kEmptyObject) {\n    let name = `http:${options.host || \"localhost\"}:`;\n    if (options.port)\n      name += options.port;\n    if (name += \":\", options.localAddress)\n      name += options.localAddress;\n    if (options.family === 4 || options.family === 6)\n      name += `:${options.family}`;\n    if (options.socketPath)\n      name += `:${options.socketPath}`;\n    return name;\n  }\n  addRequest() {\n  }\n  createSocket(req, options, cb) {\n    cb(null, this.#fakeSocket \?\?= new FakeSocket);\n  }\n  removeSocket() {\n  }\n  keepSocketAlive() {\n    return !0;\n  }\n  reuseSocket() {\n  }\n  destroy() {\n  }\n}\n\nclass Server extends EventEmitter {\n  #server;\n  #options;\n  #tls;\n  #is_tls = !1;\n  listening = !1;\n  serverName;\n  constructor(options, callback) {\n    super();\n    if (typeof options === \"function\")\n      callback = options, options = {};\n    else if (options == null || typeof options === \"object\") {\n      options = { ...options }, this.#tls = null;\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      let serverName = options.servername;\n      if (serverName && typeof serverName !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      if (this.#is_tls)\n        this.#tls = {\n          serverName,\n          key,\n          cert,\n          ca,\n          passphrase,\n          secureOptions\n        };\n      else\n        this.#tls = null;\n    } else\n      throw new Error(\"bun-http-polyfill: invalid arguments\");\n    if (this.#options = options, callback)\n      this.on(\"request\", callback);\n  }\n  closeAllConnections() {\n    const server = this.#server;\n    if (!server)\n      return;\n    this.#server = @undefined, server.stop(!0), this.emit(\"close\");\n  }\n  closeIdleConnections() {\n  }\n  close(optionalCallback) {\n    const server = this.#server;\n    if (!server) {\n      if (typeof optionalCallback === \"function\")\n        process.nextTick(optionalCallback, new Error(\"Server is not running\"));\n      return;\n    }\n    if (this.#server = @undefined, typeof optionalCallback === \"function\")\n      this.once(\"close\", optionalCallback);\n    server.stop(), this.emit(\"close\");\n  }\n  address() {\n    if (!this.#server)\n      return null;\n    const address = this.#server.hostname;\n    return {\n      address,\n      family: isIPv6(address) \? \"IPv6\" : \"IPv4\",\n      port: this.#server.port\n    };\n  }\n  listen(port, host, backlog, onListen) {\n    const server = this;\n    let socketPath;\n    if (typeof port == \"string\" && !Number.isSafeInteger(Number(port)))\n      socketPath = port;\n    if (typeof host === \"function\")\n      onListen = host, host = @undefined;\n    if (typeof port === \"function\")\n      onListen = port;\n    else if (typeof port === \"object\") {\n      if (port\?.signal\?.addEventListener(\"abort\", () => {\n        this.close();\n      }), host = port\?.host, port = port\?.port, typeof port\?.callback === \"function\")\n        onListen = port\?.callback;\n    }\n    if (typeof backlog === \"function\")\n      onListen = backlog;\n    const ResponseClass = this.#options.ServerResponse || ServerResponse, RequestClass = this.#options.IncomingMessage || IncomingMessage;\n    try {\n      const tls = this.#tls;\n      if (tls)\n        this.serverName = tls.serverName || host || \"localhost\";\n      this.#server = Bun.serve({\n        tls,\n        port,\n        hostname: host,\n        unix: socketPath,\n        websocket: {\n          open(ws) {\n            ws.data.open(ws);\n          },\n          message(ws, message) {\n            ws.data.message(ws, message);\n          },\n          close(ws, code, reason) {\n            ws.data.close(ws, code, reason);\n          },\n          drain(ws) {\n            ws.data.drain(ws);\n          }\n        },\n        fetch(req, _server) {\n          var pendingResponse, pendingError, rejectFunction, resolveFunction, reject = (err) => {\n            if (pendingError)\n              return;\n            if (pendingError = err, rejectFunction)\n              rejectFunction(err);\n          }, reply = function(resp) {\n            if (pendingResponse)\n              return;\n            if (pendingResponse = resp, resolveFunction)\n              resolveFunction(resp);\n          };\n          const http_req = new RequestClass(req), http_res = new ResponseClass({ reply, req: http_req });\n          if (http_req.socket[kInternalSocketData] = [_server, http_res, req], http_req.once(\"error\", (err) => reject(err)), http_res.once(\"error\", (err) => reject(err)), req.headers.get(\"upgrade\"))\n            server.emit(\"upgrade\", http_req, http_req.socket, kEmptyBuffer);\n          else\n            server.emit(\"request\", http_req, http_res);\n          if (pendingError)\n            throw pendingError;\n          if (pendingResponse)\n            return pendingResponse;\n          return new @Promise((resolve, reject2) => {\n            resolveFunction = resolve, rejectFunction = reject2;\n          });\n        }\n      }), setTimeout(emitListeningNextTick, 1, this, onListen, null, this.#server.hostname, this.#server.port);\n    } catch (err) {\n      server.emit(\"error\", err);\n    }\n    return this;\n  }\n  setTimeout(msecs, callback) {\n  }\n}\nclass IncomingMessage extends Readable {\n  method;\n  complete;\n  constructor(req, defaultIncomingOpts) {\n    const method = req.method;\n    super();\n    const url = new URL(req.url);\n    var { type = \"request\", [kInternalRequest]: nodeReq } = defaultIncomingOpts || {};\n    this.#noBody = type === \"request\" \? method === \"GET\" || method === \"HEAD\" || method === \"TRACE\" || method === \"CONNECT\" || method === \"OPTIONS\" || (parseInt(req.headers.get(\"Content-Length\") || \"\") || 0) === 0 : !1, this.#req = req, this.method = method, this.#type = type, this.complete = !!this.#noBody, this.#bodyStream = @undefined;\n    const socket = new FakeSocket;\n    if (url.protocol === \"https:\")\n      socket.encrypted = !0;\n    this.#fakeSocket = socket, this.url = url.pathname + url.search, this.req = nodeReq, assignHeaders(this, req);\n  }\n  headers;\n  rawHeaders;\n  _consuming = !1;\n  _dumped = !1;\n  #bodyStream;\n  #fakeSocket;\n  #noBody = !1;\n  #aborted = !1;\n  #req;\n  url;\n  #type;\n  _construct(callback) {\n    if (this.#type === \"response\" || this.#noBody) {\n      callback();\n      return;\n    }\n    const contentLength = this.#req.headers.get(\"content-length\");\n    if ((contentLength \? parseInt(contentLength, 10) : 0) === 0) {\n      this.#noBody = !0, callback();\n      return;\n    }\n    callback();\n  }\n  async#consumeStream(reader) {\n    while (!0) {\n      var { done, value } = await reader.readMany();\n      if (this.#aborted)\n        return;\n      if (done) {\n        this.push(null), this.destroy();\n        break;\n      }\n      for (var v of value)\n        this.push(v);\n    }\n  }\n  _read(size) {\n    if (this.#noBody)\n      this.push(null), this.complete = !0;\n    else if (this.#bodyStream == null) {\n      const reader = this.#req.body\?.getReader();\n      if (!reader) {\n        this.push(null);\n        return;\n      }\n      this.#bodyStream = reader, this.#consumeStream(reader);\n    }\n  }\n  get aborted() {\n    return this.#aborted;\n  }\n  #abort() {\n    if (this.#aborted)\n      return;\n    this.#aborted = !0;\n    var bodyStream = this.#bodyStream;\n    if (!bodyStream)\n      return;\n    bodyStream.cancel(), this.complete = !0, this.#bodyStream = @undefined, this.push(null);\n  }\n  get connection() {\n    return this.#fakeSocket;\n  }\n  get statusCode() {\n    return this.#req.status;\n  }\n  get statusMessage() {\n    return STATUS_CODES[this.#req.status];\n  }\n  get httpVersion() {\n    return \"1.1\";\n  }\n  get rawTrailers() {\n    return [];\n  }\n  get httpVersionMajor() {\n    return 1;\n  }\n  get httpVersionMinor() {\n    return 1;\n  }\n  get trailers() {\n    return kEmptyObject;\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n}\n\nclass OutgoingMessage extends Writable {\n  constructor() {\n    super(...arguments);\n  }\n  #headers;\n  headersSent = !1;\n  sendDate = !0;\n  req;\n  timeout;\n  #finished = !1;\n  [kEndCalled] = !1;\n  #fakeSocket;\n  #timeoutTimer;\n  [kAbortController] = null;\n  _implicitHeader() {\n  }\n  get headers() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  get connection() {\n    return this.socket;\n  }\n  get finished() {\n    return this.#finished;\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return headers.set(name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.removeAllListeners(\"timeout\"), this.#timeoutTimer = @undefined;\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar OriginalWriteHeadFn, OriginalImplicitHeadFn;\n\nclass ServerResponse extends Writable {\n  constructor(c) {\n    super();\n    if (!c)\n      c = {};\n    var req = c.req || {}, reply = c.reply;\n    if (this.req = req, this._reply = reply, this.sendDate = !0, this.statusCode = 200, this.headersSent = !1, this.statusMessage = @undefined, this.#controller = @undefined, this.#firstWrite = @undefined, this._writableState.decodeStrings = !1, this.#deferred = @undefined, req.method === \"HEAD\")\n      this._hasBody = !1;\n  }\n  req;\n  _reply;\n  sendDate;\n  statusCode;\n  #headers;\n  headersSent = !1;\n  statusMessage;\n  #controller;\n  #firstWrite;\n  _sent100 = !1;\n  _defaultKeepAlive = !1;\n  _removedConnection = !1;\n  _removedContLen = !1;\n  _hasBody = !0;\n  #deferred = @undefined;\n  #finished = !1;\n  _implicitHeader() {\n    this.writeHead(this.statusCode);\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#firstWrite && !this.headersSent) {\n      this.#firstWrite = chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      controller.write(chunk), callback();\n    });\n  }\n  _writev(chunks, callback) {\n    if (chunks.length === 1 && !this.headersSent && !this.#firstWrite) {\n      this.#firstWrite = chunks[0].chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      for (let chunk of chunks)\n        controller.write(chunk.chunk);\n      callback();\n    });\n  }\n  #ensureReadableStreamController(run) {\n    var thisController = this.#controller;\n    if (thisController)\n      return run(thisController);\n    this.headersSent = !0;\n    var firstWrite = this.#firstWrite;\n    this.#firstWrite = @undefined, this._reply(new Response(new @ReadableStream({\n      type: \"direct\",\n      pull: (controller) => {\n        if (this.#controller = controller, firstWrite)\n          controller.write(firstWrite);\n        if (firstWrite = @undefined, run(controller), !this.#finished)\n          return new @Promise((resolve) => {\n            this.#deferred = resolve;\n          });\n      }\n    }), {\n      headers: this.#headers,\n      status: this.statusCode,\n      statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n    }));\n  }\n  #drainHeadersIfObservable() {\n    if (this._implicitHeader === OriginalImplicitHeadFn && this.writeHead === OriginalWriteHeadFn)\n      return;\n    this._implicitHeader();\n  }\n  _final(callback) {\n    if (!this.headersSent) {\n      var data = this.#firstWrite || \"\";\n      this.#firstWrite = @undefined, this.#finished = !0, this.#drainHeadersIfObservable(), this._reply(new Response(data, {\n        headers: this.#headers,\n        status: this.statusCode,\n        statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n      })), callback && callback();\n      return;\n    }\n    this.#finished = !0, this.#ensureReadableStreamController((controller) => {\n      controller.end(), callback();\n      var deferred = this.#deferred;\n      if (deferred)\n        this.#deferred = @undefined, deferred();\n    });\n  }\n  writeProcessing() {\n    throw new Error(\"not implemented\");\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  assignSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  detachSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  writeContinue(callback) {\n    throw new Error(\"not implemented\");\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    var headers = this.#headers;\n    if (!headers)\n      return kEmptyObject;\n    return headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return setHeader(headers, name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  writeHead(statusCode, statusMessage, headers) {\n    return _writeHead(statusCode, statusMessage, headers, this), this;\n  }\n}\nOriginalWriteHeadFn = ServerResponse.prototype.writeHead;\nOriginalImplicitHeadFn = ServerResponse.prototype._implicitHeader;\n\nclass ClientRequest extends OutgoingMessage {\n  #timeout;\n  #res = null;\n  #upgradeOrConnect = !1;\n  #parser = null;\n  #maxHeadersCount = null;\n  #reusedSocket = !1;\n  #host;\n  #protocol;\n  #method;\n  #port;\n  #useDefaultPort;\n  #joinDuplicateHeaders;\n  #maxHeaderSize;\n  #agent = globalAgent;\n  #path;\n  #socketPath;\n  #bodyChunks = null;\n  #fetchRequest;\n  #signal = null;\n  [kAbortController] = null;\n  #timeoutTimer = @undefined;\n  #options;\n  #finished;\n  get path() {\n    return this.#path;\n  }\n  get port() {\n    return this.#port;\n  }\n  get method() {\n    return this.#method;\n  }\n  get host() {\n    return this.#host;\n  }\n  get protocol() {\n    return this.#protocol;\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = [chunk], callback();\n      return;\n    }\n    this.#bodyChunks.push(chunk), callback();\n  }\n  _writev(chunks, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = chunks, callback();\n      return;\n    }\n    this.#bodyChunks.push(...chunks), callback();\n  }\n  _final(callback) {\n    if (this.#finished = !0, this[kAbortController] = new AbortController, this[kAbortController].signal.addEventListener(\"abort\", () => {\n      this[kClearTimeout]();\n    }), this.#signal\?.aborted)\n      this[kAbortController].abort();\n    var method = this.#method, body = this.#bodyChunks\?.length === 1 \? this.#bodyChunks[0] : @Buffer.concat(this.#bodyChunks || []);\n    let url, proxy;\n    if (this.#path.startsWith(\"http://\") || this.#path.startsWith(\"https://\"))\n      url = this.#path, proxy = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}`;\n    else\n      url = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}${this.#path}`;\n    try {\n      this.#fetchRequest = fetch(url, {\n        method,\n        headers: this.getHeaders(),\n        body: body && method !== \"GET\" && method !== \"HEAD\" && method !== \"OPTIONS\" \? body : @undefined,\n        redirect: \"manual\",\n        verbose: !1,\n        signal: this[kAbortController].signal,\n        proxy,\n        timeout: !1,\n        decompress: !1\n      }).then((response) => {\n        var res = this.#res = new IncomingMessage(response, {\n          type: \"response\",\n          [kInternalRequest]: this\n        });\n        this.emit(\"response\", res);\n      }).catch((err) => {\n        this.emit(\"error\", err);\n      }).finally(() => {\n        this.#fetchRequest = null, this[kClearTimeout]();\n      });\n    } catch (err) {\n      this.emit(\"error\", err);\n    } finally {\n      callback();\n    }\n  }\n  get aborted() {\n    return this.#signal\?.aborted || !!this[kAbortController]\?.signal.aborted;\n  }\n  abort() {\n    if (this.aborted)\n      return;\n    this[kAbortController].abort();\n  }\n  constructor(input, options, cb) {\n    super();\n    if (typeof input === \"string\") {\n      const urlStr = input;\n      try {\n        var urlObject = new URL(urlStr);\n      } catch (e) {\n        @throwTypeError(`Invalid URL: ${urlStr}`);\n      }\n      input = urlToHttpOptions(urlObject);\n    } else if (input && typeof input === \"object\" && input instanceof URL)\n      input = urlToHttpOptions(input);\n    else\n      cb = options, options = input, input = null;\n    if (typeof options === \"function\")\n      cb = options, options = input || kEmptyObject;\n    else\n      options = ObjectAssign(input || {}, options);\n    var defaultAgent = options._defaultAgent || Agent.globalAgent;\n    let protocol = options.protocol;\n    if (!protocol)\n      if (options.port === 443)\n        protocol = \"https:\";\n      else\n        protocol = defaultAgent.protocol || \"http:\";\n    switch (this.#protocol = protocol, this.#agent\?.protocol) {\n      case @undefined:\n        break;\n      case \"http:\":\n        if (protocol === \"https:\") {\n          defaultAgent = this.#agent = getDefaultHTTPSAgent();\n          break;\n        }\n      case \"https:\":\n        if (protocol === \"https\") {\n          defaultAgent = this.#agent = Agent.globalAgent;\n          break;\n        }\n      default:\n        break;\n    }\n    if (options.path) {\n      const path = @String(options.path);\n      if (RegExpPrototypeExec.call(INVALID_PATH_REGEX, path) !== null)\n        throw new Error(\"Path contains unescaped characters\");\n    }\n    if (protocol !== \"http:\" && protocol !== \"https:\" && protocol) {\n      const expectedProtocol = defaultAgent\?.protocol \?\? \"http:\";\n      throw new Error(`Protocol mismatch. Expected: ${expectedProtocol}. Got: ${protocol}`);\n    }\n    const defaultPort = protocol === \"https:\" \? 443 : 80;\n    this.#port = options.port || options.defaultPort || this.#agent\?.defaultPort || defaultPort, this.#useDefaultPort = this.#port === defaultPort;\n    const host = this.#host = options.host = validateHost(options.hostname, \"hostname\") || validateHost(options.host, \"host\") || \"localhost\";\n    this.#socketPath = options.socketPath;\n    const signal = options.signal;\n    if (signal)\n      signal.addEventListener(\"abort\", () => {\n        this[kAbortController]\?.abort();\n      }), this.#signal = signal;\n    let method = options.method;\n    const methodIsString = typeof method === \"string\";\n    if (method !== null && method !== @undefined && !methodIsString)\n      throw new Error(\"ERR_INVALID_ARG_TYPE: options.method\");\n    if (methodIsString && method) {\n      if (!checkIsHttpToken(method))\n        throw new Error(\"ERR_INVALID_HTTP_TOKEN: Method\");\n      method = this.#method = StringPrototypeToUpperCase.call(method);\n    } else\n      method = this.#method = \"GET\";\n    const _maxHeaderSize = options.maxHeaderSize;\n    this.#maxHeaderSize = _maxHeaderSize;\n    var _joinDuplicateHeaders = options.joinDuplicateHeaders;\n    if (this.#joinDuplicateHeaders = _joinDuplicateHeaders, this.#path = options.path || \"/\", cb)\n      this.once(\"response\", cb);\n    this.#finished = !1, this.#res = null, this.#upgradeOrConnect = !1, this.#parser = null, this.#maxHeadersCount = null, this.#reusedSocket = !1, this.#host = host, this.#protocol = protocol;\n    var timeout = options.timeout;\n    if (timeout !== @undefined && timeout !== 0)\n      this.setTimeout(timeout, @undefined);\n    if (!ArrayIsArray(headers)) {\n      var headers = options.headers;\n      if (headers)\n        for (let key in headers)\n          this.setHeader(key, headers[key]);\n      var auth = options.auth;\n      if (auth && !this.getHeader(\"Authorization\"))\n        this.setHeader(\"Authorization\", \"Basic \" + @Buffer.from(auth).toString(\"base64\"));\n    }\n    var { signal: _signal, ...optsWithoutSignal } = options;\n    this.#options = optsWithoutSignal;\n  }\n  setSocketKeepAlive(enable = !0, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.#timeoutTimer = @undefined, this.removeAllListeners(\"timeout\");\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar tokenRegExp = /^[\\^_`a-zA-Z\\-0-9!#$%&'*+.|~]+$/, METHODS = [\n  \"ACL\",\n  \"BIND\",\n  \"CHECKOUT\",\n  \"CONNECT\",\n  \"COPY\",\n  \"DELETE\",\n  \"GET\",\n  \"HEAD\",\n  \"LINK\",\n  \"LOCK\",\n  \"M-SEARCH\",\n  \"MERGE\",\n  \"MKACTIVITY\",\n  \"MKCALENDAR\",\n  \"MKCOL\",\n  \"MOVE\",\n  \"NOTIFY\",\n  \"OPTIONS\",\n  \"PATCH\",\n  \"POST\",\n  \"PROPFIND\",\n  \"PROPPATCH\",\n  \"PURGE\",\n  \"PUT\",\n  \"REBIND\",\n  \"REPORT\",\n  \"SEARCH\",\n  \"SOURCE\",\n  \"SUBSCRIBE\",\n  \"TRACE\",\n  \"UNBIND\",\n  \"UNLINK\",\n  \"UNLOCK\",\n  \"UNSUBSCRIBE\"\n], STATUS_CODES = {\n  100: \"Continue\",\n  101: \"Switching Protocols\",\n  102: \"Processing\",\n  103: \"Early Hints\",\n  200: \"OK\",\n  201: \"Created\",\n  202: \"Accepted\",\n  203: \"Non-Authoritative Information\",\n  204: \"No Content\",\n  205: \"Reset Content\",\n  206: \"Partial Content\",\n  207: \"Multi-Status\",\n  208: \"Already Reported\",\n  226: \"IM Used\",\n  300: \"Multiple Choices\",\n  301: \"Moved Permanently\",\n  302: \"Found\",\n  303: \"See Other\",\n  304: \"Not Modified\",\n  305: \"Use Proxy\",\n  307: \"Temporary Redirect\",\n  308: \"Permanent Redirect\",\n  400: \"Bad Request\",\n  401: \"Unauthorized\",\n  402: \"Payment Required\",\n  403: \"Forbidden\",\n  404: \"Not Found\",\n  405: \"Method Not Allowed\",\n  406: \"Not Acceptable\",\n  407: \"Proxy Authentication Required\",\n  408: \"Request Timeout\",\n  409: \"Conflict\",\n  410: \"Gone\",\n  411: \"Length Required\",\n  412: \"Precondition Failed\",\n  413: \"Payload Too Large\",\n  414: \"URI Too Long\",\n  415: \"Unsupported Media Type\",\n  416: \"Range Not Satisfiable\",\n  417: \"Expectation Failed\",\n  418: \"I'm a Teapot\",\n  421: \"Misdirected Request\",\n  422: \"Unprocessable Entity\",\n  423: \"Locked\",\n  424: \"Failed Dependency\",\n  425: \"Too Early\",\n  426: \"Upgrade Required\",\n  428: \"Precondition Required\",\n  429: \"Too Many Requests\",\n  431: \"Request Header Fields Too Large\",\n  451: \"Unavailable For Legal Reasons\",\n  500: \"Internal Server Error\",\n  501: \"Not Implemented\",\n  502: \"Bad Gateway\",\n  503: \"Service Unavailable\",\n  504: \"Gateway Timeout\",\n  505: \"HTTP Version Not Supported\",\n  506: \"Variant Also Negotiates\",\n  507: \"Insufficient Storage\",\n  508: \"Loop Detected\",\n  509: \"Bandwidth Limit Exceeded\",\n  510: \"Not Extended\",\n  511: \"Network Authentication Required\"\n}, globalAgent = new Agent;\n$ = {\n  Agent,\n  Server,\n  METHODS,\n  STATUS_CODES,\n  createServer,\n  ServerResponse,\n  IncomingMessage,\n  request,\n  get,\n  maxHeaderSize: 16384,\n  validateHeaderName,\n  validateHeaderValue,\n  setMaxIdleHTTPParsers(max) {\n  },\n  globalAgent,\n  ClientRequest,\n  OutgoingMessage\n};\nreturn $})\n"_s;
+static constexpr ASCIILiteral NodeHttpCode = "(function (){\"use strict\";// src/js/out/tmp/node/http.ts\nvar checkInvalidHeaderChar = function(val) {\n  return RegExpPrototypeExec.call(headerCharRegex, val) !== null;\n}, isIPv6 = function(input) {\n  return new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\").test(input);\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, validateMsecs = function(numberlike, field) {\n  if (typeof numberlike !== \"number\" || numberlike < 0)\n    throw new ERR_INVALID_ARG_TYPE(field, \"number\", numberlike);\n  return numberlike;\n}, validateFunction = function(callable, field) {\n  if (typeof callable !== \"function\")\n    throw new ERR_INVALID_ARG_TYPE(field, \"Function\", callable);\n  return callable;\n}, createServer = function(options, callback) {\n  return new Server(options, callback);\n}, emitListeningNextTick = function(self, onListen, err, hostname, port) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen(err, hostname, port);\n    } catch (err2) {\n      self.emit(\"error\", err2);\n    }\n  if (self.listening = !err, err)\n    self.emit(\"error\", err);\n  else\n    self.emit(\"listening\", hostname, port);\n}, assignHeaders = function(object, req) {\n  var headers = req.headers.toJSON();\n  const rawHeaders = @newArrayWithSize(req.headers.count * 2);\n  var i = 0;\n  for (let key in headers)\n    rawHeaders[i++] = key, rawHeaders[i++] = headers[key];\n  object.headers = headers, object.rawHeaders = rawHeaders;\n};\nvar getDefaultHTTPSAgent = function() {\n  return _defaultHTTPSAgent \?\?= new Agent({ defaultPort: 443, protocol: \"https:\" });\n};\nvar urlToHttpOptions = function(url) {\n  var { protocol, hostname, hash, search, pathname, href, port, username, password } = url;\n  return {\n    protocol,\n    hostname: typeof hostname === \"string\" && StringPrototypeStartsWith.call(hostname, \"[\") \? StringPrototypeSlice.call(hostname, 1, -1) : hostname,\n    hash,\n    search,\n    pathname,\n    path: `${pathname || \"\"}${search || \"\"}`,\n    href,\n    port: port \? Number(port) : protocol === \"https:\" \? 443 : protocol === \"http:\" \? 80 : @undefined,\n    auth: username || password \? `${decodeURIComponent(username)}:${decodeURIComponent(password)}` : @undefined\n  };\n}, validateHost = function(host, name) {\n  if (host !== null && host !== @undefined && typeof host !== \"string\")\n    throw new Error(\"Invalid arg type in options\");\n  return host;\n}, checkIsHttpToken = function(val) {\n  return RegExpPrototypeExec.call(tokenRegExp, val) !== null;\n};\nvar _writeHead = function(statusCode, reason, obj, response) {\n  if (statusCode |= 0, statusCode < 100 || statusCode > 999)\n    throw new Error(\"status code must be between 100 and 999\");\n  if (typeof reason === \"string\")\n    response.statusMessage = reason;\n  else {\n    if (!response.statusMessage)\n      response.statusMessage = STATUS_CODES[statusCode] || \"unknown\";\n    obj = reason;\n  }\n  response.statusCode = statusCode;\n  {\n    let k;\n    if (@Array.isArray(obj)) {\n      if (obj.length % 2 !== 0)\n        throw new Error(\"raw headers must have an even number of elements\");\n      for (let n = 0;n < obj.length; n += 2)\n        if (k = obj[n + 0], k)\n          response.setHeader(k, obj[n + 1]);\n    } else if (obj) {\n      const keys = Object.keys(obj);\n      for (let i = 0;i < keys.length; i++)\n        if (k = keys[i], k)\n          response.setHeader(k, obj[k]);\n    }\n  }\n  if (statusCode === 204 || statusCode === 304 || statusCode >= 100 && statusCode <= 199)\n    response._hasBody = !1;\n}, request = function(url, options, cb) {\n  return new ClientRequest(url, options, cb);\n}, get = function(url, options, cb) {\n  const req = request(url, options, cb);\n  return req.end(), req;\n}, $, EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20), { isTypedArray } = @requireNativeModule(\"util/types\"), { Duplex, Readable, Writable } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), { getHeader, setHeader } = @lazy(\"http\"), headerCharRegex = /[^\\t\\x20-\\x7e\\x80-\\xff]/, validateHeaderName = (name, label) => {\n  if (typeof name !== \"string\" || !name || !checkIsHttpToken(name))\n    throw new Error(\"ERR_INVALID_HTTP_TOKEN\");\n}, validateHeaderValue = (name, value) => {\n  if (value === @undefined)\n    throw new Error(\"ERR_HTTP_INVALID_HEADER_VALUE\");\n  if (checkInvalidHeaderChar(value))\n    throw new Error(\"ERR_INVALID_CHAR\");\n}, { URL } = globalThis, globalReportError = globalThis.reportError, setTimeout = globalThis.setTimeout, fetch = Bun.fetch;\nvar kEmptyObject = Object.freeze(Object.create(null)), kOutHeaders = Symbol.for(\"kOutHeaders\"), kEndCalled = Symbol.for(\"kEndCalled\"), kAbortController = Symbol.for(\"kAbortController\"), kClearTimeout = Symbol(\"kClearTimeout\"), kCorked = Symbol.for(\"kCorked\"), searchParamsSymbol = Symbol.for(\"query\"), StringPrototypeSlice = @String.prototype.slice, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeToUpperCase = @String.prototype.toUpperCase, ArrayIsArray = @Array.isArray, RegExpPrototypeExec = @RegExp.prototype.exec, ObjectAssign = Object.assign, INVALID_PATH_REGEX = /[^\\u0021-\\u00ff]/;\nvar _defaultHTTPSAgent, kInternalRequest = Symbol(\"kInternalRequest\"), kInternalSocketData = Symbol.for(\"::bunternal::\"), kEmptyBuffer = @Buffer.alloc(0);\n\nclass ERR_INVALID_ARG_TYPE extends TypeError {\n  constructor(name, expected, actual) {\n    super(`The ${name} argument must be of type ${expected}. Received type ${typeof actual}`);\n    this.code = \"ERR_INVALID_ARG_TYPE\";\n  }\n}\nvar FakeSocket = class Socket extends Duplex {\n  [kInternalSocketData];\n  bytesRead = 0;\n  bytesWritten = 0;\n  connecting = !1;\n  timeout = 0;\n  isServer = !1;\n  #address;\n  address() {\n    var internalData;\n    return this.#address \?\?= (internalData = this[kInternalSocketData])[0].requestIP(internalData[2]) \?\? {};\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  connect(port, host, connectListener) {\n    return this;\n  }\n  _destroy(err, callback) {\n  }\n  _final(callback) {\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return 80;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n  }\n  get remoteAddress() {\n    return this.address()\?.address;\n  }\n  set remoteAddress(val) {\n    this.address().address = val;\n  }\n  get remotePort() {\n    return this.address()\?.port;\n  }\n  set remotePort(val) {\n    this.address().port = val;\n  }\n  get remoteFamily() {\n    return this.address()\?.family;\n  }\n  set remoteFamily(val) {\n    this.address().family = val;\n  }\n  resetAndDestroy() {\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    return this;\n  }\n  unref() {\n  }\n  _write(chunk, encoding, callback) {\n  }\n};\n\nclass Agent extends EventEmitter {\n  defaultPort = 80;\n  protocol = \"http:\";\n  options;\n  requests;\n  sockets;\n  freeSockets;\n  keepAliveMsecs;\n  keepAlive;\n  maxSockets;\n  maxFreeSockets;\n  scheduling;\n  maxTotalSockets;\n  totalSocketCount;\n  #fakeSocket;\n  static get globalAgent() {\n    return globalAgent;\n  }\n  static get defaultMaxSockets() {\n    return @Infinity;\n  }\n  constructor(options = kEmptyObject) {\n    super();\n    if (this.options = options = { ...options, path: null }, options.noDelay === @undefined)\n      options.noDelay = !0;\n    this.requests = kEmptyObject, this.sockets = kEmptyObject, this.freeSockets = kEmptyObject, this.keepAliveMsecs = options.keepAliveMsecs || 1000, this.keepAlive = options.keepAlive || !1, this.maxSockets = options.maxSockets || Agent.defaultMaxSockets, this.maxFreeSockets = options.maxFreeSockets || 256, this.scheduling = options.scheduling || \"lifo\", this.maxTotalSockets = options.maxTotalSockets, this.totalSocketCount = 0, this.defaultPort = options.defaultPort || 80, this.protocol = options.protocol || \"http:\";\n  }\n  createConnection() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  getName(options = kEmptyObject) {\n    let name = `http:${options.host || \"localhost\"}:`;\n    if (options.port)\n      name += options.port;\n    if (name += \":\", options.localAddress)\n      name += options.localAddress;\n    if (options.family === 4 || options.family === 6)\n      name += `:${options.family}`;\n    if (options.socketPath)\n      name += `:${options.socketPath}`;\n    return name;\n  }\n  addRequest() {\n  }\n  createSocket(req, options, cb) {\n    cb(null, this.#fakeSocket \?\?= new FakeSocket);\n  }\n  removeSocket() {\n  }\n  keepSocketAlive() {\n    return !0;\n  }\n  reuseSocket() {\n  }\n  destroy() {\n  }\n}\n\nclass Server extends EventEmitter {\n  #server;\n  #options;\n  #tls;\n  #is_tls = !1;\n  listening = !1;\n  serverName;\n  constructor(options, callback) {\n    super();\n    if (typeof options === \"function\")\n      callback = options, options = {};\n    else if (options == null || typeof options === \"object\") {\n      options = { ...options }, this.#tls = null;\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      let serverName = options.servername;\n      if (serverName && typeof serverName !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      if (this.#is_tls)\n        this.#tls = {\n          serverName,\n          key,\n          cert,\n          ca,\n          passphrase,\n          secureOptions\n        };\n      else\n        this.#tls = null;\n    } else\n      throw new Error(\"bun-http-polyfill: invalid arguments\");\n    if (this.#options = options, callback)\n      this.on(\"request\", callback);\n  }\n  closeAllConnections() {\n    const server = this.#server;\n    if (!server)\n      return;\n    this.#server = @undefined, server.stop(!0), this.emit(\"close\");\n  }\n  closeIdleConnections() {\n  }\n  close(optionalCallback) {\n    const server = this.#server;\n    if (!server) {\n      if (typeof optionalCallback === \"function\")\n        process.nextTick(optionalCallback, new Error(\"Server is not running\"));\n      return;\n    }\n    if (this.#server = @undefined, typeof optionalCallback === \"function\")\n      this.once(\"close\", optionalCallback);\n    server.stop(), this.emit(\"close\");\n  }\n  address() {\n    if (!this.#server)\n      return null;\n    const address = this.#server.hostname;\n    return {\n      address,\n      family: isIPv6(address) \? \"IPv6\" : \"IPv4\",\n      port: this.#server.port\n    };\n  }\n  listen(port, host, backlog, onListen) {\n    const server = this;\n    let socketPath;\n    if (typeof port == \"string\" && !Number.isSafeInteger(Number(port)))\n      socketPath = port;\n    if (typeof host === \"function\")\n      onListen = host, host = @undefined;\n    if (typeof port === \"function\")\n      onListen = port;\n    else if (typeof port === \"object\") {\n      if (port\?.signal\?.addEventListener(\"abort\", () => {\n        this.close();\n      }), host = port\?.host, port = port\?.port, typeof port\?.callback === \"function\")\n        onListen = port\?.callback;\n    }\n    if (typeof backlog === \"function\")\n      onListen = backlog;\n    const ResponseClass = this.#options.ServerResponse || ServerResponse, RequestClass = this.#options.IncomingMessage || IncomingMessage;\n    try {\n      const tls = this.#tls;\n      if (tls)\n        this.serverName = tls.serverName || host || \"localhost\";\n      this.#server = Bun.serve({\n        tls,\n        port,\n        hostname: host,\n        unix: socketPath,\n        websocket: {\n          open(ws) {\n            ws.data.open(ws);\n          },\n          message(ws, message) {\n            ws.data.message(ws, message);\n          },\n          close(ws, code, reason) {\n            ws.data.close(ws, code, reason);\n          },\n          drain(ws) {\n            ws.data.drain(ws);\n          }\n        },\n        fetch(req, _server) {\n          var pendingResponse, pendingError, rejectFunction, resolveFunction, reject = (err) => {\n            if (pendingError)\n              return;\n            if (pendingError = err, rejectFunction)\n              rejectFunction(err);\n          }, reply = function(resp) {\n            if (pendingResponse)\n              return;\n            if (pendingResponse = resp, resolveFunction)\n              resolveFunction(resp);\n          };\n          const http_req = new RequestClass(req), http_res = new ResponseClass({ reply, req: http_req });\n          if (http_req.socket[kInternalSocketData] = [_server, http_res, req], http_req.once(\"error\", (err) => reject(err)), http_res.once(\"error\", (err) => reject(err)), req.headers.get(\"upgrade\"))\n            server.emit(\"upgrade\", http_req, http_req.socket, kEmptyBuffer);\n          else\n            server.emit(\"request\", http_req, http_res);\n          if (pendingError)\n            throw pendingError;\n          if (pendingResponse)\n            return pendingResponse;\n          return new @Promise((resolve, reject2) => {\n            resolveFunction = resolve, rejectFunction = reject2;\n          });\n        }\n      }), setTimeout(emitListeningNextTick, 1, this, onListen, null, this.#server.hostname, this.#server.port);\n    } catch (err) {\n      server.emit(\"error\", err);\n    }\n    return this;\n  }\n  setTimeout(msecs, callback) {\n  }\n}\nclass IncomingMessage extends Readable {\n  method;\n  complete;\n  constructor(req, defaultIncomingOpts) {\n    const method = req.method;\n    super();\n    const url = new URL(req.url);\n    var { type = \"request\", [kInternalRequest]: nodeReq } = defaultIncomingOpts || {};\n    this.#noBody = type === \"request\" \? method === \"GET\" || method === \"HEAD\" || method === \"TRACE\" || method === \"CONNECT\" || method === \"OPTIONS\" || (parseInt(req.headers.get(\"Content-Length\") || \"\") || 0) === 0 : !1, this.#req = req, this.method = method, this.#type = type, this.complete = !!this.#noBody, this.#bodyStream = @undefined;\n    const socket = new FakeSocket;\n    if (url.protocol === \"https:\")\n      socket.encrypted = !0;\n    this.#fakeSocket = socket, this.url = url.pathname + url.search, this.req = nodeReq, assignHeaders(this, req);\n  }\n  headers;\n  rawHeaders;\n  _consuming = !1;\n  _dumped = !1;\n  #bodyStream;\n  #fakeSocket;\n  #noBody = !1;\n  #aborted = !1;\n  #req;\n  url;\n  #type;\n  _construct(callback) {\n    if (this.#type === \"response\" || this.#noBody) {\n      callback();\n      return;\n    }\n    const contentLength = this.#req.headers.get(\"content-length\");\n    if ((contentLength \? parseInt(contentLength, 10) : 0) === 0) {\n      this.#noBody = !0, callback();\n      return;\n    }\n    callback();\n  }\n  async#consumeStream(reader) {\n    while (!0) {\n      var { done, value } = await reader.readMany();\n      if (this.#aborted)\n        return;\n      if (done) {\n        this.push(null), this.destroy();\n        break;\n      }\n      for (var v of value)\n        this.push(v);\n    }\n  }\n  _read(size) {\n    if (this.#noBody)\n      this.push(null), this.complete = !0;\n    else if (this.#bodyStream == null) {\n      const reader = this.#req.body\?.getReader();\n      if (!reader) {\n        this.push(null);\n        return;\n      }\n      this.#bodyStream = reader, this.#consumeStream(reader);\n    }\n  }\n  get aborted() {\n    return this.#aborted;\n  }\n  #abort() {\n    if (this.#aborted)\n      return;\n    this.#aborted = !0;\n    var bodyStream = this.#bodyStream;\n    if (!bodyStream)\n      return;\n    bodyStream.cancel(), this.complete = !0, this.#bodyStream = @undefined, this.push(null);\n  }\n  get connection() {\n    return this.#fakeSocket;\n  }\n  get statusCode() {\n    return this.#req.status;\n  }\n  get statusMessage() {\n    return STATUS_CODES[this.#req.status];\n  }\n  get httpVersion() {\n    return \"1.1\";\n  }\n  get rawTrailers() {\n    return [];\n  }\n  get httpVersionMajor() {\n    return 1;\n  }\n  get httpVersionMinor() {\n    return 1;\n  }\n  get trailers() {\n    return kEmptyObject;\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n}\n\nclass OutgoingMessage extends Writable {\n  constructor() {\n    super(...arguments);\n  }\n  #headers;\n  headersSent = !1;\n  sendDate = !0;\n  req;\n  timeout;\n  #finished = !1;\n  [kEndCalled] = !1;\n  #fakeSocket;\n  #timeoutTimer;\n  [kAbortController] = null;\n  _implicitHeader() {\n  }\n  get headers() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  get connection() {\n    return this.socket;\n  }\n  get finished() {\n    return this.#finished;\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return headers.set(name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.removeAllListeners(\"timeout\"), this.#timeoutTimer = @undefined;\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar OriginalWriteHeadFn, OriginalImplicitHeadFn;\n\nclass ServerResponse extends Writable {\n  constructor(c) {\n    super();\n    if (!c)\n      c = {};\n    var req = c.req || {}, reply = c.reply;\n    if (this.req = req, this._reply = reply, this.sendDate = !0, this.statusCode = 200, this.headersSent = !1, this.statusMessage = @undefined, this.#controller = @undefined, this.#firstWrite = @undefined, this._writableState.decodeStrings = !1, this.#deferred = @undefined, req.method === \"HEAD\")\n      this._hasBody = !1;\n  }\n  req;\n  _reply;\n  sendDate;\n  statusCode;\n  #headers;\n  headersSent = !1;\n  statusMessage;\n  #controller;\n  #firstWrite;\n  _sent100 = !1;\n  _defaultKeepAlive = !1;\n  _removedConnection = !1;\n  _removedContLen = !1;\n  _hasBody = !0;\n  #deferred = @undefined;\n  #finished = !1;\n  _implicitHeader() {\n    this.writeHead(this.statusCode);\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#firstWrite && !this.headersSent) {\n      this.#firstWrite = chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      controller.write(chunk), callback();\n    });\n  }\n  _writev(chunks, callback) {\n    if (chunks.length === 1 && !this.headersSent && !this.#firstWrite) {\n      this.#firstWrite = chunks[0].chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      for (let chunk of chunks)\n        controller.write(chunk.chunk);\n      callback();\n    });\n  }\n  #ensureReadableStreamController(run) {\n    var thisController = this.#controller;\n    if (thisController)\n      return run(thisController);\n    this.headersSent = !0;\n    var firstWrite = this.#firstWrite;\n    this.#firstWrite = @undefined, this._reply(new Response(new @ReadableStream({\n      type: \"direct\",\n      pull: (controller) => {\n        if (this.#controller = controller, firstWrite)\n          controller.write(firstWrite);\n        if (firstWrite = @undefined, run(controller), !this.#finished)\n          return new @Promise((resolve) => {\n            this.#deferred = resolve;\n          });\n      }\n    }), {\n      headers: this.#headers,\n      status: this.statusCode,\n      statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n    }));\n  }\n  #drainHeadersIfObservable() {\n    if (this._implicitHeader === OriginalImplicitHeadFn && this.writeHead === OriginalWriteHeadFn)\n      return;\n    this._implicitHeader();\n  }\n  _final(callback) {\n    if (!this.headersSent) {\n      var data = this.#firstWrite || \"\";\n      this.#firstWrite = @undefined, this.#finished = !0, this.#drainHeadersIfObservable(), this._reply(new Response(data, {\n        headers: this.#headers,\n        status: this.statusCode,\n        statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n      })), callback && callback();\n      return;\n    }\n    this.#finished = !0, this.#ensureReadableStreamController((controller) => {\n      controller.end(), callback();\n      var deferred = this.#deferred;\n      if (deferred)\n        this.#deferred = @undefined, deferred();\n    });\n  }\n  writeProcessing() {\n    throw new Error(\"not implemented\");\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  assignSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  detachSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  writeContinue(callback) {\n    throw new Error(\"not implemented\");\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    var headers = this.#headers;\n    if (!headers)\n      return kEmptyObject;\n    return headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return setHeader(headers, name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  writeHead(statusCode, statusMessage, headers) {\n    return _writeHead(statusCode, statusMessage, headers, this), this;\n  }\n}\nOriginalWriteHeadFn = ServerResponse.prototype.writeHead;\nOriginalImplicitHeadFn = ServerResponse.prototype._implicitHeader;\n\nclass ClientRequest extends OutgoingMessage {\n  #timeout;\n  #res = null;\n  #upgradeOrConnect = !1;\n  #parser = null;\n  #maxHeadersCount = null;\n  #reusedSocket = !1;\n  #host;\n  #protocol;\n  #method;\n  #port;\n  #useDefaultPort;\n  #joinDuplicateHeaders;\n  #maxHeaderSize;\n  #agent = globalAgent;\n  #path;\n  #socketPath;\n  #bodyChunks = null;\n  #fetchRequest;\n  #signal = null;\n  [kAbortController] = null;\n  #timeoutTimer = @undefined;\n  #options;\n  #finished;\n  get path() {\n    return this.#path;\n  }\n  get port() {\n    return this.#port;\n  }\n  get method() {\n    return this.#method;\n  }\n  get host() {\n    return this.#host;\n  }\n  get protocol() {\n    return this.#protocol;\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = [chunk], callback();\n      return;\n    }\n    this.#bodyChunks.push(chunk), callback();\n  }\n  _writev(chunks, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = chunks, callback();\n      return;\n    }\n    this.#bodyChunks.push(...chunks), callback();\n  }\n  _final(callback) {\n    if (this.#finished = !0, this[kAbortController] = new AbortController, this[kAbortController].signal.addEventListener(\"abort\", () => {\n      this[kClearTimeout]();\n    }), this.#signal\?.aborted)\n      this[kAbortController].abort();\n    var method = this.#method, body = this.#bodyChunks\?.length === 1 \? this.#bodyChunks[0] : @Buffer.concat(this.#bodyChunks || []);\n    let url, proxy;\n    if (this.#path.startsWith(\"http://\") || this.#path.startsWith(\"https://\"))\n      url = this.#path, proxy = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}`;\n    else\n      url = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}${this.#path}`;\n    try {\n      this.#fetchRequest = fetch(url, {\n        method,\n        headers: this.getHeaders(),\n        body: body && method !== \"GET\" && method !== \"HEAD\" && method !== \"OPTIONS\" \? body : @undefined,\n        redirect: \"manual\",\n        verbose: !1,\n        signal: this[kAbortController].signal,\n        proxy,\n        timeout: !1,\n        decompress: !1\n      }).then((response) => {\n        var res = this.#res = new IncomingMessage(response, {\n          type: \"response\",\n          [kInternalRequest]: this\n        });\n        this.emit(\"response\", res);\n      }).catch((err) => {\n        this.emit(\"error\", err);\n      }).finally(() => {\n        this.#fetchRequest = null, this[kClearTimeout]();\n      });\n    } catch (err) {\n      this.emit(\"error\", err);\n    } finally {\n      callback();\n    }\n  }\n  get aborted() {\n    return this.#signal\?.aborted || !!this[kAbortController]\?.signal.aborted;\n  }\n  abort() {\n    if (this.aborted)\n      return;\n    this[kAbortController].abort();\n  }\n  constructor(input, options, cb) {\n    super();\n    if (typeof input === \"string\") {\n      const urlStr = input;\n      try {\n        var urlObject = new URL(urlStr);\n      } catch (e) {\n        @throwTypeError(`Invalid URL: ${urlStr}`);\n      }\n      input = urlToHttpOptions(urlObject);\n    } else if (input && typeof input === \"object\" && input instanceof URL)\n      input = urlToHttpOptions(input);\n    else\n      cb = options, options = input, input = null;\n    if (typeof options === \"function\")\n      cb = options, options = input || kEmptyObject;\n    else\n      options = ObjectAssign(input || {}, options);\n    var defaultAgent = options._defaultAgent || Agent.globalAgent;\n    let protocol = options.protocol;\n    if (!protocol)\n      if (options.port === 443)\n        protocol = \"https:\";\n      else\n        protocol = defaultAgent.protocol || \"http:\";\n    switch (this.#protocol = protocol, this.#agent\?.protocol) {\n      case @undefined:\n        break;\n      case \"http:\":\n        if (protocol === \"https:\") {\n          defaultAgent = this.#agent = getDefaultHTTPSAgent();\n          break;\n        }\n      case \"https:\":\n        if (protocol === \"https\") {\n          defaultAgent = this.#agent = Agent.globalAgent;\n          break;\n        }\n      default:\n        break;\n    }\n    if (options.path) {\n      const path = @String(options.path);\n      if (RegExpPrototypeExec.call(INVALID_PATH_REGEX, path) !== null)\n        throw new Error(\"Path contains unescaped characters\");\n    }\n    if (protocol !== \"http:\" && protocol !== \"https:\" && protocol) {\n      const expectedProtocol = defaultAgent\?.protocol \?\? \"http:\";\n      throw new Error(`Protocol mismatch. Expected: ${expectedProtocol}. Got: ${protocol}`);\n    }\n    const defaultPort = protocol === \"https:\" \? 443 : 80;\n    this.#port = options.port || options.defaultPort || this.#agent\?.defaultPort || defaultPort, this.#useDefaultPort = this.#port === defaultPort;\n    const host = this.#host = options.host = validateHost(options.hostname, \"hostname\") || validateHost(options.host, \"host\") || \"localhost\";\n    this.#socketPath = options.socketPath;\n    const signal = options.signal;\n    if (signal)\n      signal.addEventListener(\"abort\", () => {\n        this[kAbortController]\?.abort();\n      }), this.#signal = signal;\n    let method = options.method;\n    const methodIsString = typeof method === \"string\";\n    if (method !== null && method !== @undefined && !methodIsString)\n      throw new Error(\"ERR_INVALID_ARG_TYPE: options.method\");\n    if (methodIsString && method) {\n      if (!checkIsHttpToken(method))\n        throw new Error(\"ERR_INVALID_HTTP_TOKEN: Method\");\n      method = this.#method = StringPrototypeToUpperCase.call(method);\n    } else\n      method = this.#method = \"GET\";\n    const _maxHeaderSize = options.maxHeaderSize;\n    this.#maxHeaderSize = _maxHeaderSize;\n    var _joinDuplicateHeaders = options.joinDuplicateHeaders;\n    if (this.#joinDuplicateHeaders = _joinDuplicateHeaders, this.#path = options.path || \"/\", cb)\n      this.once(\"response\", cb);\n    this.#finished = !1, this.#res = null, this.#upgradeOrConnect = !1, this.#parser = null, this.#maxHeadersCount = null, this.#reusedSocket = !1, this.#host = host, this.#protocol = protocol;\n    var timeout = options.timeout;\n    if (timeout !== @undefined && timeout !== 0)\n      this.setTimeout(timeout, @undefined);\n    if (!ArrayIsArray(headers)) {\n      var headers = options.headers;\n      if (headers)\n        for (let key in headers)\n          this.setHeader(key, headers[key]);\n      var auth = options.auth;\n      if (auth && !this.getHeader(\"Authorization\"))\n        this.setHeader(\"Authorization\", \"Basic \" + @Buffer.from(auth).toString(\"base64\"));\n    }\n    var { signal: _signal, ...optsWithoutSignal } = options;\n    this.#options = optsWithoutSignal;\n  }\n  setSocketKeepAlive(enable = !0, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.#timeoutTimer = @undefined, this.removeAllListeners(\"timeout\");\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar tokenRegExp = /^[\\^_`a-zA-Z\\-0-9!#$%&'*+.|~]+$/, METHODS = [\n  \"ACL\",\n  \"BIND\",\n  \"CHECKOUT\",\n  \"CONNECT\",\n  \"COPY\",\n  \"DELETE\",\n  \"GET\",\n  \"HEAD\",\n  \"LINK\",\n  \"LOCK\",\n  \"M-SEARCH\",\n  \"MERGE\",\n  \"MKACTIVITY\",\n  \"MKCALENDAR\",\n  \"MKCOL\",\n  \"MOVE\",\n  \"NOTIFY\",\n  \"OPTIONS\",\n  \"PATCH\",\n  \"POST\",\n  \"PROPFIND\",\n  \"PROPPATCH\",\n  \"PURGE\",\n  \"PUT\",\n  \"REBIND\",\n  \"REPORT\",\n  \"SEARCH\",\n  \"SOURCE\",\n  \"SUBSCRIBE\",\n  \"TRACE\",\n  \"UNBIND\",\n  \"UNLINK\",\n  \"UNLOCK\",\n  \"UNSUBSCRIBE\"\n], STATUS_CODES = {\n  100: \"Continue\",\n  101: \"Switching Protocols\",\n  102: \"Processing\",\n  103: \"Early Hints\",\n  200: \"OK\",\n  201: \"Created\",\n  202: \"Accepted\",\n  203: \"Non-Authoritative Information\",\n  204: \"No Content\",\n  205: \"Reset Content\",\n  206: \"Partial Content\",\n  207: \"Multi-Status\",\n  208: \"Already Reported\",\n  226: \"IM Used\",\n  300: \"Multiple Choices\",\n  301: \"Moved Permanently\",\n  302: \"Found\",\n  303: \"See Other\",\n  304: \"Not Modified\",\n  305: \"Use Proxy\",\n  307: \"Temporary Redirect\",\n  308: \"Permanent Redirect\",\n  400: \"Bad Request\",\n  401: \"Unauthorized\",\n  402: \"Payment Required\",\n  403: \"Forbidden\",\n  404: \"Not Found\",\n  405: \"Method Not Allowed\",\n  406: \"Not Acceptable\",\n  407: \"Proxy Authentication Required\",\n  408: \"Request Timeout\",\n  409: \"Conflict\",\n  410: \"Gone\",\n  411: \"Length Required\",\n  412: \"Precondition Failed\",\n  413: \"Payload Too Large\",\n  414: \"URI Too Long\",\n  415: \"Unsupported Media Type\",\n  416: \"Range Not Satisfiable\",\n  417: \"Expectation Failed\",\n  418: \"I'm a Teapot\",\n  421: \"Misdirected Request\",\n  422: \"Unprocessable Entity\",\n  423: \"Locked\",\n  424: \"Failed Dependency\",\n  425: \"Too Early\",\n  426: \"Upgrade Required\",\n  428: \"Precondition Required\",\n  429: \"Too Many Requests\",\n  431: \"Request Header Fields Too Large\",\n  451: \"Unavailable For Legal Reasons\",\n  500: \"Internal Server Error\",\n  501: \"Not Implemented\",\n  502: \"Bad Gateway\",\n  503: \"Service Unavailable\",\n  504: \"Gateway Timeout\",\n  505: \"HTTP Version Not Supported\",\n  506: \"Variant Also Negotiates\",\n  507: \"Insufficient Storage\",\n  508: \"Loop Detected\",\n  509: \"Bandwidth Limit Exceeded\",\n  510: \"Not Extended\",\n  511: \"Network Authentication Required\"\n}, globalAgent = new Agent;\n$ = {\n  Agent,\n  Server,\n  METHODS,\n  STATUS_CODES,\n  createServer,\n  ServerResponse,\n  IncomingMessage,\n  request,\n  get,\n  maxHeaderSize: 16384,\n  validateHeaderName,\n  validateHeaderValue,\n  setMaxIdleHTTPParsers(max) {\n  },\n  globalAgent,\n  ClientRequest,\n  OutgoingMessage\n};\nreturn $})\n"_s;
 //
 
 //
@@ -114,7 +114,7 @@ static constexpr ASCIILiteral NodeInspectorCode = "(function (){\"use strict\";/
 //
 
 //
-static constexpr ASCIILiteral NodeNetCode = "(function (){\"use strict\";// src/js/out/tmp/node/net.ts\nvar isIPv4 = function(s) {\n  return IPv4Reg.test(s);\n}, isIPv6 = function(s) {\n  return IPv6Reg.test(s);\n}, isIP = function(s) {\n  if (isIPv4(s))\n    return 4;\n  if (isIPv6(s))\n    return 6;\n  return 0;\n}, endNT = function(socket, callback, err) {\n  socket.end(), callback(err);\n}, createConnection = function(port, host, connectListener) {\n  if (typeof port === \"object\")\n    return new Socket(port).connect(port, host, connectListener);\n  return new Socket().connect(port, host, connectListener);\n}, emitErrorNextTick = function(self, error) {\n  self.emit(\"error\", error);\n}, emitErrorAndCloseNextTick = function(self, error) {\n  self.emit(\"error\", error), self.emit(\"close\");\n}, emitListeningNextTick = function(self, onListen) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen();\n    } catch (err) {\n      self.emit(\"error\", err);\n    }\n  self.emit(\"listening\");\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, $, { Duplex } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20);\nvar IPv4Reg = new @RegExp(\"^((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$\");\nvar IPv6Reg = new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\"), { connect: bunConnect } = Bun, { setTimeout } = globalThis, bunTlsSymbol = Symbol.for(\"::buntls::\"), bunSocketServerHandlers = Symbol.for(\"::bunsocket_serverhandlers::\"), bunSocketServerConnections = Symbol.for(\"::bunnetserverconnections::\"), bunSocketServerOptions = Symbol.for(\"::bunnetserveroptions::\"), bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), bunTLSConnectOptions = Symbol.for(\"::buntlsconnectoptions::\"), SocketClass, Socket = function(InternalSocket) {\n  return SocketClass = InternalSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"Socket\",\n    enumerable: !1\n  }), Object.defineProperty(function Socket(options) {\n    return new InternalSocket(options);\n  }, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalSocket;\n    }\n  });\n}(class Socket2 extends Duplex {\n  static #Handlers = {\n    close: Socket2.#Close,\n    data({ data: self }, buffer) {\n      self.bytesRead += buffer.length;\n      const queue = self.#readQueue;\n      if (queue.isEmpty()) {\n        if (self.push(buffer))\n          return;\n      }\n      queue.push(buffer);\n    },\n    drain: Socket2.#Drain,\n    end: Socket2.#Close,\n    error(socket, error) {\n      const self = socket.data, callback = self.#writeCallback;\n      if (callback)\n        self.#writeCallback = null, callback(error);\n      self.emit(\"error\", error);\n    },\n    open(socket) {\n      const self = socket.data;\n      socket.timeout(self.timeout), socket.ref(), self[bunSocketInternal] = socket, self.connecting = !1;\n      const options = self[bunTLSConnectOptions];\n      if (options) {\n        const { session } = options;\n        if (session)\n          self.setSession(session);\n      }\n      if (!self.#upgraded)\n        self.emit(\"connect\", self);\n      Socket2.#Drain(socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self.emit(\"secure\", self);\n      const { checkServerIdentity } = self[bunTLSConnectOptions];\n      if (!verifyError && typeof checkServerIdentity === \"function\" && self.servername) {\n        const cert = self.getPeerCertificate(!0);\n        verifyError = checkServerIdentity(self.servername, cert);\n      }\n      if (self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnect\", verifyError);\n    },\n    timeout(socket) {\n      const self = socket.data;\n      self.emit(\"timeout\", self);\n    },\n    binaryType: \"buffer\"\n  };\n  static #Close(socket) {\n    const self = socket.data;\n    if (self.#closed)\n      return;\n    self.#closed = !0, self[bunSocketInternal] = null;\n    const queue = self.#readQueue;\n    if (queue.isEmpty()) {\n      if (self.push(null))\n        return;\n    }\n    queue.push(null);\n  }\n  static #Drain(socket) {\n    const self = socket.data, callback = self.#writeCallback;\n    if (callback) {\n      const chunk = self.#writeChunk, written = socket.write(chunk);\n      if (self.bytesWritten += written, written < chunk.length)\n        self.#writeChunk = chunk.slice(written);\n      else\n        self.#writeCallback = null, self.#writeChunk = null, callback(null);\n    }\n  }\n  static [bunSocketServerHandlers] = {\n    data: Socket2.#Handlers.data,\n    close(socket) {\n      Socket2.#Handlers.close(socket), this.data[bunSocketServerConnections]--;\n    },\n    end(socket) {\n      Socket2.#Handlers.end(socket), this.data[bunSocketServerConnections]--;\n    },\n    open(socket) {\n      const self = this.data, options = self[bunSocketServerOptions], { pauseOnConnect, connectionListener, InternalSocketClass, requestCert, rejectUnauthorized } = options, _socket = new InternalSocketClass({});\n      if (_socket.isServer = !0, _socket._requestCert = requestCert, _socket._rejectUnauthorized = rejectUnauthorized, _socket.#attach(this.localPort, socket), self.maxConnections && self[bunSocketServerConnections] >= self.maxConnections) {\n        const data = {\n          localAddress: _socket.localAddress,\n          localPort: _socket.localPort,\n          localFamily: _socket.localFamily,\n          remoteAddress: _socket.remoteAddress,\n          remotePort: _socket.remotePort,\n          remoteFamily: _socket.remoteFamily || \"IPv4\"\n        };\n        socket.end(), self.emit(\"drop\", data);\n        return;\n      }\n      if (!pauseOnConnect)\n        _socket.resume();\n      if (self[bunSocketServerConnections]++, typeof connectionListener == \"function\")\n        if (InternalSocketClass.name === \"TLSSocket\")\n          self.once(\"secureConnection\", () => connectionListener(_socket));\n        else\n          connectionListener(_socket);\n      self.emit(\"connection\", _socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      if (self.emit(\"secure\", self), self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnection\", verifyError);\n    },\n    error(socket, error) {\n      Socket2.#Handlers.error(socket, error), this.data.emit(\"error\", error);\n    },\n    timeout: Socket2.#Handlers.timeout,\n    connectError: Socket2.#Handlers.connectError,\n    drain: Socket2.#Handlers.drain,\n    binaryType: \"buffer\"\n  };\n  bytesRead = 0;\n  bytesWritten = 0;\n  #closed = !1;\n  connecting = !1;\n  localAddress = \"127.0.0.1\";\n  #readQueue = @createFIFO();\n  remotePort;\n  [bunSocketInternal] = null;\n  [bunTLSConnectOptions] = null;\n  timeout = 0;\n  #writeCallback;\n  #writeChunk;\n  #pendingRead;\n  isServer = !1;\n  _handle;\n  _parent;\n  _parentWrap;\n  #socket;\n  #upgraded;\n  constructor(options) {\n    const { socket, signal, write, read, allowHalfOpen = !1, ...opts } = options || {};\n    super({\n      ...opts,\n      allowHalfOpen,\n      readable: !0,\n      writable: !0\n    });\n    if (this._handle = this, this._parent = this, this._parentWrap = this, this.#pendingRead = @undefined, this.#upgraded = !1, socket instanceof Socket2)\n      this.#socket = socket;\n    signal\?.once(\"abort\", () => this.destroy()), this.once(\"connect\", () => this.emit(\"ready\"));\n  }\n  address() {\n    return {\n      address: this.localAddress,\n      family: this.localFamily,\n      port: this.localPort\n    };\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  #attach(port, socket) {\n    if (this.remotePort = port, socket.data = this, socket.timeout(this.timeout), socket.ref(), this[bunSocketInternal] = socket, this.connecting = !1, !this.#upgraded)\n      this.emit(\"connect\", this);\n    Socket2.#Drain(socket);\n  }\n  connect(port, host, connectListener) {\n    var path, connection = this.#socket, _checkServerIdentity = @undefined;\n    if (typeof port === \"string\") {\n      if (path = port, port = @undefined, typeof host === \"function\")\n        connectListener = host, host = @undefined;\n    } else if (typeof host == \"function\") {\n      if (typeof port === \"string\")\n        path = port, port = @undefined;\n      connectListener = host, host = @undefined;\n    }\n    if (typeof port == \"object\") {\n      var {\n        port,\n        host,\n        path,\n        socket,\n        localAddress,\n        localPort,\n        family,\n        hints,\n        lookup,\n        noDelay,\n        keepAlive,\n        keepAliveInitialDelay,\n        requestCert,\n        rejectUnauthorized,\n        pauseOnConnect,\n        servername,\n        checkServerIdentity,\n        session\n      } = port;\n      if (_checkServerIdentity = checkServerIdentity, this.servername = servername, socket)\n        connection = socket;\n    }\n    if (!pauseOnConnect)\n      this.resume();\n    this.connecting = !0, this.remotePort = port;\n    const bunTLS = this[bunTlsSymbol];\n    var tls = @undefined;\n    if (typeof bunTLS === \"function\") {\n      if (tls = bunTLS.call(this, port, host, !0), this._requestCert = !0, this._rejectUnauthorized = rejectUnauthorized, tls) {\n        if (tls.rejectUnauthorized = rejectUnauthorized, tls.requestCert = !0, tls.session = session || tls.session, this.servername = tls.servername, tls.checkServerIdentity = _checkServerIdentity || tls.checkServerIdentity, this[bunTLSConnectOptions] = tls, !connection && tls.socket)\n          connection = tls.socket;\n      }\n      if (connection) {\n        if (typeof connection !== \"object\" || !(connection instanceof Socket2) || typeof connection[bunTlsSymbol] === \"function\")\n          @throwTypeError(\"socket must be an instance of net.Socket\");\n      }\n      if (this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, connectListener)\n        this.on(\"secureConnect\", connectListener);\n    } else if (connectListener)\n      this.on(\"connect\", connectListener);\n    try {\n      if (connection) {\n        const socket2 = connection[bunSocketInternal];\n        if (socket2) {\n          this.connecting = !0, this.#upgraded = !0;\n          const result = socket2.upgradeTLS({\n            data: this,\n            tls,\n            socket: Socket2.#Handlers\n          });\n          if (result) {\n            const [raw, tls2] = result;\n            connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n          } else\n            throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n        } else\n          connection.once(\"connect\", () => {\n            const socket3 = connection[bunSocketInternal];\n            if (!socket3)\n              return;\n            this.connecting = !0, this.#upgraded = !0;\n            const result = socket3.upgradeTLS({\n              data: this,\n              tls,\n              socket: Socket2.#Handlers\n            });\n            if (result) {\n              const [raw, tls2] = result;\n              connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n            } else\n              throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n          });\n      } else if (path)\n        bunConnect({\n          data: this,\n          unix: path,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n      else\n        bunConnect({\n          data: this,\n          hostname: host || \"localhost\",\n          port,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n    } catch (error) {\n      process.nextTick(emitErrorAndCloseNextTick, this, error);\n    }\n    return this;\n  }\n  _destroy(err, callback) {\n    const socket = this[bunSocketInternal];\n    socket && process.nextTick(endNT, socket, callback, err);\n  }\n  _final(callback) {\n    this[bunSocketInternal]\?.end(), callback();\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return this[bunSocketInternal]\?.localPort;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n    const queue = this.#readQueue;\n    let chunk;\n    while (chunk = queue.peek()) {\n      if (!this.push(chunk))\n        return;\n      queue.shift();\n    }\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n    this[bunSocketInternal]\?.ref();\n  }\n  get remoteAddress() {\n    return this[bunSocketInternal]\?.remoteAddress;\n  }\n  get remoteFamily() {\n    return \"IPv4\";\n  }\n  resetAndDestroy() {\n    this[bunSocketInternal]\?.end();\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n    return this;\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    if (this[bunSocketInternal]\?.timeout(timeout), this.timeout = timeout, callback)\n      this.once(\"timeout\", callback);\n    return this;\n  }\n  unref() {\n    this[bunSocketInternal]\?.unref();\n  }\n  _write(chunk, encoding, callback) {\n    if (typeof chunk == \"string\" && encoding !== \"ascii\")\n      chunk = @Buffer.from(chunk, encoding);\n    var written = this[bunSocketInternal]\?.write(chunk);\n    if (written == chunk.length)\n      callback();\n    else if (this.#writeCallback)\n      callback(new Error(\"overlapping _write()\"));\n    else {\n      if (written > 0)\n        if (typeof chunk == \"string\")\n          chunk = chunk.slice(written);\n        else\n          chunk = chunk.subarray(written);\n      this.#writeCallback = callback, this.#writeChunk = chunk;\n    }\n  }\n}), connect = createConnection;\n\nclass Server extends EventEmitter {\n  #server;\n  #listening = !1;\n  [bunSocketServerConnections] = 0;\n  [bunSocketServerOptions];\n  maxConnections = 0;\n  constructor(options, connectionListener) {\n    super();\n    if (typeof options === \"function\")\n      connectionListener = options, options = {};\n    else if (options == null || typeof options === \"object\")\n      options = { ...options };\n    else\n      throw new Error(\"bun-net-polyfill: invalid arguments\");\n    const { maxConnections } = options;\n    this.maxConnections = Number.isSafeInteger(maxConnections) && maxConnections > 0 \? maxConnections : 0, options.connectionListener = connectionListener, this[bunSocketServerOptions] = options;\n  }\n  ref() {\n    return this.#server\?.ref(), this;\n  }\n  unref() {\n    return this.#server\?.unref(), this;\n  }\n  close(callback) {\n    if (this.#server) {\n      if (this.#server.stop(!0), this.#server = null, this.#listening = !1, this[bunSocketServerConnections] = 0, this.emit(\"close\"), typeof callback === \"function\")\n        callback();\n      return this;\n    }\n    if (typeof callback === \"function\") {\n      const error = new Error(\"Server is not running\");\n      error.code = \"ERR_SERVER_NOT_RUNNING\", callback(error);\n    }\n    return this;\n  }\n  address() {\n    const server = this.#server;\n    if (server) {\n      const unix = server.unix;\n      if (unix)\n        return unix;\n      let address = server.hostname;\n      const type = isIP(address), port = server.port;\n      if (typeof port === \"number\")\n        return {\n          port,\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      if (type)\n        return {\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      return address;\n    }\n    return null;\n  }\n  getConnections(callback) {\n    if (typeof callback === \"function\")\n      callback(null, this.#server \? this[bunSocketServerConnections] : 0);\n    return this;\n  }\n  listen(port, hostname, onListen) {\n    let backlog, path, exclusive = !1;\n    if (typeof port === \"string\") {\n      if (Number.isSafeInteger(hostname)) {\n        if (hostname > 0)\n          backlog = hostname;\n      } else if (typeof hostname === \"function\")\n        onListen = hostname;\n      path = port, hostname = @undefined, port = @undefined;\n    } else {\n      if (typeof hostname === \"function\")\n        onListen = hostname, hostname = @undefined;\n      if (typeof port === \"function\")\n        onListen = port, port = 0;\n      else if (typeof port === \"object\") {\n        const options = port;\n        options.signal\?.addEventListener(\"abort\", () => this.close()), hostname = options.host, exclusive = options.exclusive === !0;\n        const path2 = options.path;\n        if (port = options.port, !Number.isSafeInteger(port) || port < 0)\n          if (path2)\n            hostname = path2, port = @undefined;\n          else {\n            let message = 'The argument \\'options\\' must have the property \"port\" or \"path\"';\n            try {\n              message = `${message}. Received ${JSON.stringify(options)}`;\n            } catch {\n            }\n            const error = @makeTypeError(message);\n            throw error.code = \"ERR_INVALID_ARG_VALUE\", error;\n          }\n        else if (!Number.isSafeInteger(port) || port < 0)\n          port = 0;\n        if (typeof port.callback === \"function\")\n          onListen = port\?.callback;\n      } else if (!Number.isSafeInteger(port) || port < 0)\n        port = 0;\n      hostname = hostname || \"::\";\n    }\n    try {\n      var tls = @undefined, TLSSocketClass = @undefined;\n      const bunTLS = this[bunTlsSymbol], options = this[bunSocketServerOptions];\n      if (typeof bunTLS === \"function\")\n        [tls, TLSSocketClass] = bunTLS.call(this, port, hostname, !1), options.servername = tls.serverName, options.InternalSocketClass = TLSSocketClass;\n      else\n        options.InternalSocketClass = SocketClass;\n      this.#server = Bun.listen(path \? {\n        exclusive,\n        unix: path,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      } : {\n        exclusive,\n        port,\n        hostname,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      }), this.#server.data = this, this.#listening = !0, setTimeout(emitListeningNextTick, 1, this, onListen);\n    } catch (err) {\n      this.#listening = !1, setTimeout(emitErrorNextTick, 1, this, err);\n    }\n    return this;\n  }\n}\n$ = {\n  createServer,\n  Server,\n  createConnection,\n  connect,\n  isIP,\n  isIPv4,\n  isIPv6,\n  Socket,\n  [Symbol.for(\"::bunternal::\")]: SocketClass\n};\nreturn $})\n"_s;
+static constexpr ASCIILiteral NodeNetCode = "(function (){\"use strict\";// src/js/out/tmp/node/net.ts\nvar isIPv4 = function(s) {\n  return IPv4Reg.test(s);\n}, isIPv6 = function(s) {\n  return IPv6Reg.test(s);\n}, isIP = function(s) {\n  if (isIPv4(s))\n    return 4;\n  if (isIPv6(s))\n    return 6;\n  return 0;\n}, endNT = function(socket, callback, err) {\n  socket.end(), callback(err);\n}, createConnection = function(port, host, connectListener) {\n  if (typeof port === \"object\")\n    return new Socket(port).connect(port, host, connectListener);\n  return new Socket().connect(port, host, connectListener);\n}, emitErrorNextTick = function(self, error) {\n  self.emit(\"error\", error);\n}, emitErrorAndCloseNextTick = function(self, error) {\n  self.emit(\"error\", error), self.emit(\"close\");\n}, emitListeningNextTick = function(self, onListen) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen();\n    } catch (err) {\n      self.emit(\"error\", err);\n    }\n  self.emit(\"listening\");\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, $, { Duplex } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20);\nvar IPv4Reg = new @RegExp(\"^((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$\");\nvar IPv6Reg = new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\"), { connect: bunConnect } = Bun, { setTimeout } = globalThis, bunTlsSymbol = Symbol.for(\"::buntls::\"), bunSocketServerHandlers = Symbol.for(\"::bunsocket_serverhandlers::\"), bunSocketServerConnections = Symbol.for(\"::bunnetserverconnections::\"), bunSocketServerOptions = Symbol.for(\"::bunnetserveroptions::\"), bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), bunTLSConnectOptions = Symbol.for(\"::buntlsconnectoptions::\"), SocketClass, Socket = function(InternalSocket) {\n  SocketClass = InternalSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"Socket\",\n    enumerable: !1\n  });\n  function Socket3(options) {\n    return new InternalSocket(options);\n  }\n  return Socket3.prototype = InternalSocket.prototype, Object.defineProperty(Socket3, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalSocket;\n    }\n  });\n}(class Socket2 extends Duplex {\n  static #Handlers = {\n    close: Socket2.#Close,\n    data({ data: self }, buffer) {\n      self.bytesRead += buffer.length;\n      const queue = self.#readQueue;\n      if (queue.isEmpty()) {\n        if (self.push(buffer))\n          return;\n      }\n      queue.push(buffer);\n    },\n    drain: Socket2.#Drain,\n    end: Socket2.#Close,\n    error(socket, error) {\n      const self = socket.data, callback = self.#writeCallback;\n      if (callback)\n        self.#writeCallback = null, callback(error);\n      self.emit(\"error\", error);\n    },\n    open(socket) {\n      const self = socket.data;\n      socket.timeout(self.timeout), socket.ref(), self[bunSocketInternal] = socket, self.connecting = !1;\n      const options = self[bunTLSConnectOptions];\n      if (options) {\n        const { session } = options;\n        if (session)\n          self.setSession(session);\n      }\n      if (!self.#upgraded)\n        self.emit(\"connect\", self);\n      Socket2.#Drain(socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self.emit(\"secure\", self);\n      const { checkServerIdentity } = self[bunTLSConnectOptions];\n      if (!verifyError && typeof checkServerIdentity === \"function\" && self.servername) {\n        const cert = self.getPeerCertificate(!0);\n        verifyError = checkServerIdentity(self.servername, cert);\n      }\n      if (self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnect\", verifyError);\n    },\n    timeout(socket) {\n      const self = socket.data;\n      self.emit(\"timeout\", self);\n    },\n    binaryType: \"buffer\"\n  };\n  static #Close(socket) {\n    const self = socket.data;\n    if (self.#closed)\n      return;\n    self.#closed = !0, self[bunSocketInternal] = null;\n    const queue = self.#readQueue;\n    if (queue.isEmpty()) {\n      if (self.push(null))\n        return;\n    }\n    queue.push(null);\n  }\n  static #Drain(socket) {\n    const self = socket.data, callback = self.#writeCallback;\n    if (callback) {\n      const chunk = self.#writeChunk, written = socket.write(chunk);\n      if (self.bytesWritten += written, written < chunk.length)\n        self.#writeChunk = chunk.slice(written);\n      else\n        self.#writeCallback = null, self.#writeChunk = null, callback(null);\n    }\n  }\n  static [bunSocketServerHandlers] = {\n    data: Socket2.#Handlers.data,\n    close(socket) {\n      Socket2.#Handlers.close(socket), this.data[bunSocketServerConnections]--;\n    },\n    end(socket) {\n      Socket2.#Handlers.end(socket), this.data[bunSocketServerConnections]--;\n    },\n    open(socket) {\n      const self = this.data, options = self[bunSocketServerOptions], { pauseOnConnect, connectionListener, InternalSocketClass, requestCert, rejectUnauthorized } = options, _socket = new InternalSocketClass({});\n      if (_socket.isServer = !0, _socket._requestCert = requestCert, _socket._rejectUnauthorized = rejectUnauthorized, _socket.#attach(this.localPort, socket), self.maxConnections && self[bunSocketServerConnections] >= self.maxConnections) {\n        const data = {\n          localAddress: _socket.localAddress,\n          localPort: _socket.localPort,\n          localFamily: _socket.localFamily,\n          remoteAddress: _socket.remoteAddress,\n          remotePort: _socket.remotePort,\n          remoteFamily: _socket.remoteFamily || \"IPv4\"\n        };\n        socket.end(), self.emit(\"drop\", data);\n        return;\n      }\n      if (!pauseOnConnect)\n        _socket.resume();\n      if (self[bunSocketServerConnections]++, typeof connectionListener == \"function\")\n        if (InternalSocketClass.name === \"TLSSocket\")\n          self.once(\"secureConnection\", () => connectionListener(_socket));\n        else\n          connectionListener(_socket);\n      self.emit(\"connection\", _socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      if (self.emit(\"secure\", self), self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnection\", verifyError);\n    },\n    error(socket, error) {\n      Socket2.#Handlers.error(socket, error), this.data.emit(\"error\", error);\n    },\n    timeout: Socket2.#Handlers.timeout,\n    connectError: Socket2.#Handlers.connectError,\n    drain: Socket2.#Handlers.drain,\n    binaryType: \"buffer\"\n  };\n  bytesRead = 0;\n  bytesWritten = 0;\n  #closed = !1;\n  connecting = !1;\n  localAddress = \"127.0.0.1\";\n  #readQueue = @createFIFO();\n  remotePort;\n  [bunSocketInternal] = null;\n  [bunTLSConnectOptions] = null;\n  timeout = 0;\n  #writeCallback;\n  #writeChunk;\n  #pendingRead;\n  isServer = !1;\n  _handle;\n  _parent;\n  _parentWrap;\n  #socket;\n  #upgraded;\n  constructor(options) {\n    const { socket, signal, write, read, allowHalfOpen = !1, ...opts } = options || {};\n    super({\n      ...opts,\n      allowHalfOpen,\n      readable: !0,\n      writable: !0\n    });\n    if (this._handle = this, this._parent = this, this._parentWrap = this, this.#pendingRead = @undefined, this.#upgraded = !1, socket instanceof Socket2)\n      this.#socket = socket;\n    signal\?.once(\"abort\", () => this.destroy()), this.once(\"connect\", () => this.emit(\"ready\"));\n  }\n  address() {\n    return {\n      address: this.localAddress,\n      family: this.localFamily,\n      port: this.localPort\n    };\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  #attach(port, socket) {\n    if (this.remotePort = port, socket.data = this, socket.timeout(this.timeout), socket.ref(), this[bunSocketInternal] = socket, this.connecting = !1, !this.#upgraded)\n      this.emit(\"connect\", this);\n    Socket2.#Drain(socket);\n  }\n  connect(port, host, connectListener) {\n    var path, connection = this.#socket, _checkServerIdentity = @undefined;\n    if (typeof port === \"string\") {\n      if (path = port, port = @undefined, typeof host === \"function\")\n        connectListener = host, host = @undefined;\n    } else if (typeof host == \"function\") {\n      if (typeof port === \"string\")\n        path = port, port = @undefined;\n      connectListener = host, host = @undefined;\n    }\n    if (typeof port == \"object\") {\n      var {\n        port,\n        host,\n        path,\n        socket,\n        localAddress,\n        localPort,\n        family,\n        hints,\n        lookup,\n        noDelay,\n        keepAlive,\n        keepAliveInitialDelay,\n        requestCert,\n        rejectUnauthorized,\n        pauseOnConnect,\n        servername,\n        checkServerIdentity,\n        session\n      } = port;\n      if (_checkServerIdentity = checkServerIdentity, this.servername = servername, socket)\n        connection = socket;\n    }\n    if (!pauseOnConnect)\n      this.resume();\n    this.connecting = !0, this.remotePort = port;\n    const bunTLS = this[bunTlsSymbol];\n    var tls = @undefined;\n    if (typeof bunTLS === \"function\") {\n      if (tls = bunTLS.call(this, port, host, !0), this._requestCert = !0, this._rejectUnauthorized = rejectUnauthorized, tls) {\n        if (tls.rejectUnauthorized = rejectUnauthorized, tls.requestCert = !0, tls.session = session || tls.session, this.servername = tls.servername, tls.checkServerIdentity = _checkServerIdentity || tls.checkServerIdentity, this[bunTLSConnectOptions] = tls, !connection && tls.socket)\n          connection = tls.socket;\n      }\n      if (connection) {\n        if (typeof connection !== \"object\" || !(connection instanceof Socket2) || typeof connection[bunTlsSymbol] === \"function\")\n          @throwTypeError(\"socket must be an instance of net.Socket\");\n      }\n      if (this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, connectListener)\n        this.on(\"secureConnect\", connectListener);\n    } else if (connectListener)\n      this.on(\"connect\", connectListener);\n    try {\n      if (connection) {\n        const socket2 = connection[bunSocketInternal];\n        if (socket2) {\n          this.connecting = !0, this.#upgraded = !0;\n          const result = socket2.upgradeTLS({\n            data: this,\n            tls,\n            socket: Socket2.#Handlers\n          });\n          if (result) {\n            const [raw, tls2] = result;\n            connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n          } else\n            throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n        } else\n          connection.once(\"connect\", () => {\n            const socket3 = connection[bunSocketInternal];\n            if (!socket3)\n              return;\n            this.connecting = !0, this.#upgraded = !0;\n            const result = socket3.upgradeTLS({\n              data: this,\n              tls,\n              socket: Socket2.#Handlers\n            });\n            if (result) {\n              const [raw, tls2] = result;\n              connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n            } else\n              throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n          });\n      } else if (path)\n        bunConnect({\n          data: this,\n          unix: path,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n      else\n        bunConnect({\n          data: this,\n          hostname: host || \"localhost\",\n          port,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n    } catch (error) {\n      process.nextTick(emitErrorAndCloseNextTick, this, error);\n    }\n    return this;\n  }\n  _destroy(err, callback) {\n    const socket = this[bunSocketInternal];\n    socket && process.nextTick(endNT, socket, callback, err);\n  }\n  _final(callback) {\n    this[bunSocketInternal]\?.end(), callback();\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return this[bunSocketInternal]\?.localPort;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n    const queue = this.#readQueue;\n    let chunk;\n    while (chunk = queue.peek()) {\n      if (!this.push(chunk))\n        return;\n      queue.shift();\n    }\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n    this[bunSocketInternal]\?.ref();\n  }\n  get remoteAddress() {\n    return this[bunSocketInternal]\?.remoteAddress;\n  }\n  get remoteFamily() {\n    return \"IPv4\";\n  }\n  resetAndDestroy() {\n    this[bunSocketInternal]\?.end();\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n    return this;\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    if (this[bunSocketInternal]\?.timeout(timeout), this.timeout = timeout, callback)\n      this.once(\"timeout\", callback);\n    return this;\n  }\n  unref() {\n    this[bunSocketInternal]\?.unref();\n  }\n  _write(chunk, encoding, callback) {\n    if (typeof chunk == \"string\" && encoding !== \"ascii\")\n      chunk = @Buffer.from(chunk, encoding);\n    var written = this[bunSocketInternal]\?.write(chunk);\n    if (written == chunk.length)\n      callback();\n    else if (this.#writeCallback)\n      callback(new Error(\"overlapping _write()\"));\n    else {\n      if (written > 0)\n        if (typeof chunk == \"string\")\n          chunk = chunk.slice(written);\n        else\n          chunk = chunk.subarray(written);\n      this.#writeCallback = callback, this.#writeChunk = chunk;\n    }\n  }\n}), connect = createConnection;\n\nclass Server extends EventEmitter {\n  #server;\n  #listening = !1;\n  [bunSocketServerConnections] = 0;\n  [bunSocketServerOptions];\n  maxConnections = 0;\n  constructor(options, connectionListener) {\n    super();\n    if (typeof options === \"function\")\n      connectionListener = options, options = {};\n    else if (options == null || typeof options === \"object\")\n      options = { ...options };\n    else\n      throw new Error(\"bun-net-polyfill: invalid arguments\");\n    const { maxConnections } = options;\n    this.maxConnections = Number.isSafeInteger(maxConnections) && maxConnections > 0 \? maxConnections : 0, options.connectionListener = connectionListener, this[bunSocketServerOptions] = options;\n  }\n  ref() {\n    return this.#server\?.ref(), this;\n  }\n  unref() {\n    return this.#server\?.unref(), this;\n  }\n  close(callback) {\n    if (this.#server) {\n      if (this.#server.stop(!0), this.#server = null, this.#listening = !1, this[bunSocketServerConnections] = 0, this.emit(\"close\"), typeof callback === \"function\")\n        callback();\n      return this;\n    }\n    if (typeof callback === \"function\") {\n      const error = new Error(\"Server is not running\");\n      error.code = \"ERR_SERVER_NOT_RUNNING\", callback(error);\n    }\n    return this;\n  }\n  address() {\n    const server = this.#server;\n    if (server) {\n      const unix = server.unix;\n      if (unix)\n        return unix;\n      let address = server.hostname;\n      const type = isIP(address), port = server.port;\n      if (typeof port === \"number\")\n        return {\n          port,\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      if (type)\n        return {\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      return address;\n    }\n    return null;\n  }\n  getConnections(callback) {\n    if (typeof callback === \"function\")\n      callback(null, this.#server \? this[bunSocketServerConnections] : 0);\n    return this;\n  }\n  listen(port, hostname, onListen) {\n    let backlog, path, exclusive = !1;\n    if (typeof port === \"string\") {\n      if (Number.isSafeInteger(hostname)) {\n        if (hostname > 0)\n          backlog = hostname;\n      } else if (typeof hostname === \"function\")\n        onListen = hostname;\n      path = port, hostname = @undefined, port = @undefined;\n    } else {\n      if (typeof hostname === \"function\")\n        onListen = hostname, hostname = @undefined;\n      if (typeof port === \"function\")\n        onListen = port, port = 0;\n      else if (typeof port === \"object\") {\n        const options = port;\n        options.signal\?.addEventListener(\"abort\", () => this.close()), hostname = options.host, exclusive = options.exclusive === !0;\n        const path2 = options.path;\n        if (port = options.port, !Number.isSafeInteger(port) || port < 0)\n          if (path2)\n            hostname = path2, port = @undefined;\n          else {\n            let message = 'The argument \\'options\\' must have the property \"port\" or \"path\"';\n            try {\n              message = `${message}. Received ${JSON.stringify(options)}`;\n            } catch {\n            }\n            const error = @makeTypeError(message);\n            throw error.code = \"ERR_INVALID_ARG_VALUE\", error;\n          }\n        else if (!Number.isSafeInteger(port) || port < 0)\n          port = 0;\n        if (typeof port.callback === \"function\")\n          onListen = port\?.callback;\n      } else if (!Number.isSafeInteger(port) || port < 0)\n        port = 0;\n      hostname = hostname || \"::\";\n    }\n    try {\n      var tls = @undefined, TLSSocketClass = @undefined;\n      const bunTLS = this[bunTlsSymbol], options = this[bunSocketServerOptions];\n      if (typeof bunTLS === \"function\")\n        [tls, TLSSocketClass] = bunTLS.call(this, port, hostname, !1), options.servername = tls.serverName, options.InternalSocketClass = TLSSocketClass;\n      else\n        options.InternalSocketClass = SocketClass;\n      this.#server = Bun.listen(path \? {\n        exclusive,\n        unix: path,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      } : {\n        exclusive,\n        port,\n        hostname,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      }), this.#server.data = this, this.#listening = !0, setTimeout(emitListeningNextTick, 1, this, onListen);\n    } catch (err) {\n      this.#listening = !1, setTimeout(emitErrorNextTick, 1, this, err);\n    }\n    return this;\n  }\n}\n$ = {\n  createServer,\n  Server,\n  createConnection,\n  connect,\n  isIP,\n  isIPv4,\n  isIPv6,\n  Socket,\n  [Symbol.for(\"::bunternal::\")]: SocketClass\n};\nreturn $})\n"_s;
 //
 
 //
@@ -182,7 +182,7 @@ static constexpr ASCIILiteral NodeTimersPromisesCode = "(function (){\"use stric
 //
 
 //
-static constexpr ASCIILiteral NodeTLSCode = "(function (){\"use strict\";// src/js/out/tmp/node/tls.ts\nvar parseCertString = function() {\n  throwNotImplemented(\"Not implemented\");\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, unfqdn = function(host) {\n  return RegExpPrototypeSymbolReplace.call(/[.]$/, host, \"\");\n}, toLowerCase = function(c) {\n  return StringFromCharCode.call(32 + StringPrototypeCharCodeAt.call(c, 0));\n}, splitHost = function(host) {\n  return StringPrototypeSplit.call(RegExpPrototypeSymbolReplace.call(/[A-Z]/g, unfqdn(host), toLowerCase), \".\");\n}, check = function(hostParts, pattern, wildcards) {\n  if (!pattern)\n    return !1;\n  const patternParts = splitHost(pattern);\n  if (hostParts.length !== patternParts.length)\n    return !1;\n  if (ArrayPrototypeIncludes.call(patternParts, \"\"))\n    return !1;\n  const isBad = (s) => RegExpPrototypeExec.call(/[^\\u0021-\\u007F]/u, s) !== null;\n  if (ArrayPrototypeSome.call(patternParts, isBad))\n    return !1;\n  for (let i = hostParts.length - 1;i > 0; i -= 1)\n    if (hostParts[i] !== patternParts[i])\n      return !1;\n  const hostSubdomain = hostParts[0], patternSubdomain = patternParts[0], patternSubdomainParts = StringPrototypeSplit.call(patternSubdomain, \"*\");\n  if (patternSubdomainParts.length === 1 || StringPrototypeIncludes.call(patternSubdomain, \"xn--\"))\n    return hostSubdomain === patternSubdomain;\n  if (!wildcards)\n    return !1;\n  if (patternSubdomainParts.length > 2)\n    return !1;\n  if (patternParts.length <= 2)\n    return !1;\n  const { 0: prefix, 1: suffix } = patternSubdomainParts;\n  if (prefix.length + suffix.length > hostSubdomain.length)\n    return !1;\n  if (!StringPrototypeStartsWith.call(hostSubdomain, prefix))\n    return !1;\n  if (!StringPrototypeEndsWith.call(hostSubdomain, suffix))\n    return !1;\n  return !0;\n}, splitEscapedAltNames = function(altNames) {\n  const result = [];\n  let currentToken = \"\", offset = 0;\n  while (offset !== altNames.length) {\n    const nextSep = StringPrototypeIndexOf.call(altNames, \", \", offset), nextQuote = StringPrototypeIndexOf.call(altNames, '\"', offset);\n    if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) {\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextQuote);\n      const match = RegExpPrototypeExec.call(jsonStringPattern, StringPrototypeSubstring.call(altNames, nextQuote));\n      if (!match) {\n        let error = new SyntaxError(\"ERR_TLS_CERT_ALTNAME_FORMAT: Invalid subject alternative name string\");\n        throw error.name = ERR_TLS_CERT_ALTNAME_FORMAT, error;\n      }\n      currentToken += JSON.parse(match[0]), offset = nextQuote + match[0].length;\n    } else if (nextSep !== -1)\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextSep), ArrayPrototypePush.call(result, currentToken), currentToken = \"\", offset = nextSep + 2;\n    else\n      currentToken += StringPrototypeSubstring.call(altNames, offset), offset = altNames.length;\n  }\n  return ArrayPrototypePush.call(result, currentToken), result;\n}, checkServerIdentity = function(hostname, cert) {\n  const { subject, subjectaltname: altNames } = cert, dnsNames = [], ips = [];\n  if (hostname = \"\" + hostname, altNames) {\n    const splitAltNames = StringPrototypeIncludes.call(altNames, '\"') \? splitEscapedAltNames(altNames) : StringPrototypeSplit.call(altNames, \", \");\n    ArrayPrototypeForEach.call(splitAltNames, (name) => {\n      if (StringPrototypeStartsWith.call(name, \"DNS:\"))\n        ArrayPrototypePush.call(dnsNames, StringPrototypeSlice.call(name, 4));\n      else if (StringPrototypeStartsWith.call(name, \"IP Address:\"))\n        ArrayPrototypePush.call(ips, canonicalizeIP(StringPrototypeSlice.call(name, 11)));\n    });\n  }\n  let valid = !1, reason = \"Unknown reason\";\n  if (hostname = unfqdn(hostname), net.isIP(hostname)) {\n    if (valid = ArrayPrototypeIncludes.call(ips, canonicalizeIP(hostname)), !valid)\n      reason = `IP: ${hostname} is not in the cert's list: ` + ArrayPrototypeJoin.call(ips, \", \");\n  } else if (dnsNames.length > 0 || subject\?.CN) {\n    const hostParts = splitHost(hostname), wildcard = (pattern) => check(hostParts, pattern, !0);\n    if (dnsNames.length > 0) {\n      if (valid = ArrayPrototypeSome.call(dnsNames, wildcard), !valid)\n        reason = `Host: ${hostname}. is not in the cert's altnames: ${altNames}`;\n    } else {\n      const cn = subject.CN;\n      if (@Array.isArray(cn))\n        valid = ArrayPrototypeSome.call(cn, wildcard);\n      else if (cn)\n        valid = wildcard(cn);\n      if (!valid)\n        reason = `Host: ${hostname}. is not cert's CN: ${cn}`;\n    }\n  } else\n    reason = \"Cert does not contain a DNS name\";\n  if (!valid) {\n    let error = new Error(`ERR_TLS_CERT_ALTNAME_INVALID: Hostname/IP does not match certificate's altnames: ${reason}`);\n    return error.name = \"ERR_TLS_CERT_ALTNAME_INVALID\", error.reason = reason, error.host = hostname, error.cert = cert, error;\n  }\n}, SecureContext = function(options) {\n  return new InternalSecureContext(options);\n}, createSecureContext = function(options) {\n  return new SecureContext(options);\n}, translatePeerCertificate = function(c) {\n  if (!c)\n    return null;\n  if (c.issuerCertificate != null && c.issuerCertificate !== c)\n    c.issuerCertificate = translatePeerCertificate(c.issuerCertificate);\n  if (c.infoAccess != null) {\n    const info = c.infoAccess;\n    c.infoAccess = { __proto__: null }, RegExpPrototypeSymbolReplace.call(/([^\\n:]*):([^\\n]*)(\?:\\n|$)/g, info, (all, key, val) => {\n      if (val.charCodeAt(0) === 34)\n        val = JSONParse(val);\n      if (key in c.infoAccess)\n        ArrayPrototypePush.call(c.infoAccess[key], val);\n      else\n        c.infoAccess[key] = [val];\n    });\n  }\n  return c;\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, getCiphers = function() {\n  return DEFAULT_CIPHERS.split(\":\");\n}, convertProtocols = function(protocols) {\n  const lens = new @Array(protocols.length), buff = @Buffer.allocUnsafe(ArrayPrototypeReduce.call(protocols, (p, c, i) => {\n    const len = @Buffer.byteLength(c);\n    if (len > 255)\n      @throwRangeError(\"The byte length of the protocol at index \" + `${i} exceeds the maximum length.`, \"<= 255\", len, !0);\n    return lens[i] = len, p + 1 + len;\n  }, 0));\n  let offset = 0;\n  for (let i = 0, c = protocols.length;i < c; i++)\n    buff[offset++] = lens[i], buff.write(protocols[i], offset), offset += lens[i];\n  return buff;\n}, convertALPNProtocols = function(protocols, out) {\n  if (@Array.isArray(protocols))\n    out.ALPNProtocols = convertProtocols(protocols);\n  else if (isTypedArray(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols);\n  else if (isArrayBufferView(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols.buffer.slice(protocols.byteOffset, protocols.byteOffset + protocols.byteLength));\n  else if (@Buffer.isBuffer(protocols))\n    out.ALPNProtocols = protocols;\n}, $, { isArrayBufferView, isTypedArray } = @requireNativeModule(\"util/types\"), net = @getInternalField(@internalModuleRegistry, 27) || @createInternalModuleById(27), { Server: NetServer, [Symbol.for(\"::bunternal::\")]: InternalTCPSocket } = net, bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), { rootCertificates, canonicalizeIP } = @lazy(\"internal/tls\"), SymbolReplace = Symbol.replace, RegExpPrototypeSymbolReplace = @RegExp.prototype[SymbolReplace], RegExpPrototypeExec = @RegExp.prototype.exec, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeSlice = @String.prototype.slice, StringPrototypeIncludes = @String.prototype.includes, StringPrototypeSplit = @String.prototype.split, StringPrototypeIndexOf = @String.prototype.indexOf, StringPrototypeSubstring = @String.prototype.substring, StringPrototypeEndsWith = @String.prototype.endsWith, StringFromCharCode = @String.fromCharCode, StringPrototypeCharCodeAt = @String.prototype.charCodeAt, ArrayPrototypeIncludes = @Array.prototype.includes, ArrayPrototypeJoin = @Array.prototype.join, ArrayPrototypeForEach = @Array.prototype.forEach, ArrayPrototypePush = @Array.prototype.push, ArrayPrototypeSome = @Array.prototype.some, ArrayPrototypeReduce = @Array.prototype.reduce, jsonStringPattern = /^\"(\?:[^\"\\\\\\u0000-\\u001f]|\\\\(\?:[\"\\\\/bfnrt]|u[0-9a-fA-F]{4}))*\"/, InternalSecureContext = class SecureContext2 {\n  context;\n  constructor(options) {\n    const context = {};\n    if (options) {\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n    }\n    this.context = context;\n  }\n}, buntls = Symbol.for(\"::buntls::\"), SocketClass, TLSSocket = function(InternalTLSSocket) {\n  return SocketClass = InternalTLSSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"TLSSocket\",\n    enumerable: !1\n  }), Object.defineProperty(function Socket(options) {\n    return new InternalTLSSocket(options);\n  }, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalTLSSocket;\n    }\n  });\n}(class TLSSocket2 extends InternalTCPSocket {\n  #secureContext;\n  ALPNProtocols;\n  #socket;\n  #checkServerIdentity;\n  #session;\n  constructor(socket, options) {\n    super(socket instanceof InternalTCPSocket \? options : options || socket);\n    if (options = options || socket || {}, typeof options === \"object\") {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      if (socket instanceof InternalTCPSocket)\n        this.#socket = socket;\n    }\n    this.#secureContext = options.secureContext || createSecureContext(options), this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, this.#checkServerIdentity = options.checkServerIdentity || checkServerIdentity, this.#session = options.session || null;\n  }\n  _secureEstablished = !1;\n  _securePending = !0;\n  _newSessionPending;\n  _controlReleased;\n  secureConnecting = !1;\n  _SNICallback;\n  servername;\n  authorized = !1;\n  authorizationError;\n  #renegotiationDisabled = !1;\n  encrypted = !0;\n  _start() {\n    this.connect();\n  }\n  getSession() {\n    return this[bunSocketInternal]\?.getSession();\n  }\n  getEphemeralKeyInfo() {\n    return this[bunSocketInternal]\?.getEphemeralKeyInfo();\n  }\n  getCipher() {\n    return this[bunSocketInternal]\?.getCipher();\n  }\n  getSharedSigalgs() {\n    return this[bunSocketInternal]\?.getSharedSigalgs();\n  }\n  getProtocol() {\n    return this[bunSocketInternal]\?.getTLSVersion();\n  }\n  getFinished() {\n    return this[bunSocketInternal]\?.getTLSFinishedMessage() || @undefined;\n  }\n  getPeerFinished() {\n    return this[bunSocketInternal]\?.getTLSPeerFinishedMessage() || @undefined;\n  }\n  isSessionReused() {\n    return !!this.#session;\n  }\n  renegotiate() {\n    if (this.#renegotiationDisabled) {\n      const error = new Error(\"ERR_TLS_RENEGOTIATION_DISABLED: TLS session renegotiation disabled for this socket\");\n      throw error.name = \"ERR_TLS_RENEGOTIATION_DISABLED\", error;\n    }\n    throw Error(\"Not implented in Bun yet\");\n  }\n  disableRenegotiation() {\n    this.#renegotiationDisabled = !0;\n  }\n  getTLSTicket() {\n    return this[bunSocketInternal]\?.getTLSTicket();\n  }\n  exportKeyingMaterial(length, label, context) {\n    if (context)\n      return this[bunSocketInternal]\?.exportKeyingMaterial(length, label, context);\n    return this[bunSocketInternal]\?.exportKeyingMaterial(length, label);\n  }\n  setMaxSendFragment(size) {\n    return this[bunSocketInternal]\?.setMaxSendFragment(size) || !1;\n  }\n  enableTrace() {\n  }\n  setServername(name) {\n    if (this.isServer) {\n      let error = new Error(\"ERR_TLS_SNI_FROM_SERVER: Cannot issue SNI from a TLS server-side socket\");\n      throw error.name = \"ERR_TLS_SNI_FROM_SERVER\", error;\n    }\n    this.servername = name, this[bunSocketInternal]\?.setServername(name);\n  }\n  setSession(session) {\n    if (this.#session = session, typeof session === \"string\")\n      session = @Buffer.from(session, \"latin1\");\n    return this[bunSocketInternal]\?.setSession(session);\n  }\n  getPeerCertificate(abbreviated) {\n    const cert = arguments.length < 1 \? this[bunSocketInternal]\?.getPeerCertificate() : this[bunSocketInternal]\?.getPeerCertificate(abbreviated);\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getCertificate() {\n    const cert = this[bunSocketInternal]\?.getCertificate();\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getPeerX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  getX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  get alpnProtocol() {\n    return this[bunSocketInternal]\?.alpnProtocol;\n  }\n  [buntls](port, host) {\n    return {\n      socket: this.#socket,\n      ALPNProtocols: this.ALPNProtocols,\n      serverName: this.servername || host || \"localhost\",\n      checkServerIdentity: this.#checkServerIdentity,\n      session: this.#session,\n      ...this.#secureContext\n    };\n  }\n});\n\nclass Server extends NetServer {\n  key;\n  cert;\n  ca;\n  passphrase;\n  secureOptions;\n  _rejectUnauthorized;\n  _requestCert;\n  servername;\n  ALPNProtocols;\n  constructor(options, secureConnectionListener) {\n    super(options, secureConnectionListener);\n    this.setSecureContext(options);\n  }\n  setSecureContext(options) {\n    if (options instanceof InternalSecureContext)\n      options = options.context;\n    if (options) {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n      const requestCert = options.requestCert || !1;\n      if (requestCert)\n        this._requestCert = requestCert;\n      else\n        this._requestCert = @undefined;\n      const rejectUnauthorized = options.rejectUnauthorized || !1;\n      if (rejectUnauthorized)\n        this._rejectUnauthorized = rejectUnauthorized;\n      else\n        this._rejectUnauthorized = @undefined;\n    }\n  }\n  getTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  setTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  [buntls](port, host, isClient) {\n    return [\n      {\n        serverName: this.servername || host || \"localhost\",\n        key: this.key,\n        cert: this.cert,\n        ca: this.ca,\n        passphrase: this.passphrase,\n        secureOptions: this.secureOptions,\n        rejectUnauthorized: isClient \? !1 : this._rejectUnauthorized,\n        requestCert: isClient \? !1 : this._requestCert,\n        ALPNProtocols: this.ALPNProtocols\n      },\n      SocketClass\n    ];\n  }\n}\nvar CLIENT_RENEG_LIMIT = 3, CLIENT_RENEG_WINDOW = 600, DEFAULT_ECDH_CURVE = \"auto\", DEFAULT_CIPHERS = \"DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256\", DEFAULT_MIN_VERSION = \"TLSv1.2\", DEFAULT_MAX_VERSION = \"TLSv1.3\", createConnection = (port, host, connectListener) => {\n  if (typeof port === \"object\") {\n    port.checkServerIdentity;\n    const { ALPNProtocols } = port;\n    if (ALPNProtocols)\n      convertALPNProtocols(ALPNProtocols, port);\n    return new TLSSocket(port).connect(port, host, connectListener);\n  }\n  return new TLSSocket().connect(port, host, connectListener);\n}, connect = createConnection;\n$ = {\n  CLIENT_RENEG_LIMIT,\n  CLIENT_RENEG_WINDOW,\n  connect,\n  convertALPNProtocols,\n  createConnection,\n  createSecureContext,\n  createServer,\n  DEFAULT_CIPHERS,\n  DEFAULT_ECDH_CURVE,\n  DEFAULT_MAX_VERSION,\n  DEFAULT_MIN_VERSION,\n  getCiphers,\n  parseCertString,\n  SecureContext,\n  Server,\n  TLSSocket,\n  checkServerIdentity,\n  rootCertificates\n};\nreturn $})\n"_s;
+static constexpr ASCIILiteral NodeTLSCode = "(function (){\"use strict\";// src/js/out/tmp/node/tls.ts\nvar parseCertString = function() {\n  throwNotImplemented(\"Not implemented\");\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, unfqdn = function(host) {\n  return RegExpPrototypeSymbolReplace.call(/[.]$/, host, \"\");\n}, toLowerCase = function(c) {\n  return StringFromCharCode.call(32 + StringPrototypeCharCodeAt.call(c, 0));\n}, splitHost = function(host) {\n  return StringPrototypeSplit.call(RegExpPrototypeSymbolReplace.call(/[A-Z]/g, unfqdn(host), toLowerCase), \".\");\n}, check = function(hostParts, pattern, wildcards) {\n  if (!pattern)\n    return !1;\n  const patternParts = splitHost(pattern);\n  if (hostParts.length !== patternParts.length)\n    return !1;\n  if (ArrayPrototypeIncludes.call(patternParts, \"\"))\n    return !1;\n  const isBad = (s) => RegExpPrototypeExec.call(/[^\\u0021-\\u007F]/u, s) !== null;\n  if (ArrayPrototypeSome.call(patternParts, isBad))\n    return !1;\n  for (let i = hostParts.length - 1;i > 0; i -= 1)\n    if (hostParts[i] !== patternParts[i])\n      return !1;\n  const hostSubdomain = hostParts[0], patternSubdomain = patternParts[0], patternSubdomainParts = StringPrototypeSplit.call(patternSubdomain, \"*\");\n  if (patternSubdomainParts.length === 1 || StringPrototypeIncludes.call(patternSubdomain, \"xn--\"))\n    return hostSubdomain === patternSubdomain;\n  if (!wildcards)\n    return !1;\n  if (patternSubdomainParts.length > 2)\n    return !1;\n  if (patternParts.length <= 2)\n    return !1;\n  const { 0: prefix, 1: suffix } = patternSubdomainParts;\n  if (prefix.length + suffix.length > hostSubdomain.length)\n    return !1;\n  if (!StringPrototypeStartsWith.call(hostSubdomain, prefix))\n    return !1;\n  if (!StringPrototypeEndsWith.call(hostSubdomain, suffix))\n    return !1;\n  return !0;\n}, splitEscapedAltNames = function(altNames) {\n  const result = [];\n  let currentToken = \"\", offset = 0;\n  while (offset !== altNames.length) {\n    const nextSep = StringPrototypeIndexOf.call(altNames, \", \", offset), nextQuote = StringPrototypeIndexOf.call(altNames, '\"', offset);\n    if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) {\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextQuote);\n      const match = RegExpPrototypeExec.call(jsonStringPattern, StringPrototypeSubstring.call(altNames, nextQuote));\n      if (!match) {\n        let error = new SyntaxError(\"ERR_TLS_CERT_ALTNAME_FORMAT: Invalid subject alternative name string\");\n        throw error.name = ERR_TLS_CERT_ALTNAME_FORMAT, error;\n      }\n      currentToken += JSON.parse(match[0]), offset = nextQuote + match[0].length;\n    } else if (nextSep !== -1)\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextSep), ArrayPrototypePush.call(result, currentToken), currentToken = \"\", offset = nextSep + 2;\n    else\n      currentToken += StringPrototypeSubstring.call(altNames, offset), offset = altNames.length;\n  }\n  return ArrayPrototypePush.call(result, currentToken), result;\n}, checkServerIdentity = function(hostname, cert) {\n  const { subject, subjectaltname: altNames } = cert, dnsNames = [], ips = [];\n  if (hostname = \"\" + hostname, altNames) {\n    const splitAltNames = StringPrototypeIncludes.call(altNames, '\"') \? splitEscapedAltNames(altNames) : StringPrototypeSplit.call(altNames, \", \");\n    ArrayPrototypeForEach.call(splitAltNames, (name) => {\n      if (StringPrototypeStartsWith.call(name, \"DNS:\"))\n        ArrayPrototypePush.call(dnsNames, StringPrototypeSlice.call(name, 4));\n      else if (StringPrototypeStartsWith.call(name, \"IP Address:\"))\n        ArrayPrototypePush.call(ips, canonicalizeIP(StringPrototypeSlice.call(name, 11)));\n    });\n  }\n  let valid = !1, reason = \"Unknown reason\";\n  if (hostname = unfqdn(hostname), net.isIP(hostname)) {\n    if (valid = ArrayPrototypeIncludes.call(ips, canonicalizeIP(hostname)), !valid)\n      reason = `IP: ${hostname} is not in the cert's list: ` + ArrayPrototypeJoin.call(ips, \", \");\n  } else if (dnsNames.length > 0 || subject\?.CN) {\n    const hostParts = splitHost(hostname), wildcard = (pattern) => check(hostParts, pattern, !0);\n    if (dnsNames.length > 0) {\n      if (valid = ArrayPrototypeSome.call(dnsNames, wildcard), !valid)\n        reason = `Host: ${hostname}. is not in the cert's altnames: ${altNames}`;\n    } else {\n      const cn = subject.CN;\n      if (@Array.isArray(cn))\n        valid = ArrayPrototypeSome.call(cn, wildcard);\n      else if (cn)\n        valid = wildcard(cn);\n      if (!valid)\n        reason = `Host: ${hostname}. is not cert's CN: ${cn}`;\n    }\n  } else\n    reason = \"Cert does not contain a DNS name\";\n  if (!valid) {\n    let error = new Error(`ERR_TLS_CERT_ALTNAME_INVALID: Hostname/IP does not match certificate's altnames: ${reason}`);\n    return error.name = \"ERR_TLS_CERT_ALTNAME_INVALID\", error.reason = reason, error.host = hostname, error.cert = cert, error;\n  }\n}, SecureContext = function(options) {\n  return new InternalSecureContext(options);\n}, createSecureContext = function(options) {\n  return new SecureContext(options);\n}, translatePeerCertificate = function(c) {\n  if (!c)\n    return null;\n  if (c.issuerCertificate != null && c.issuerCertificate !== c)\n    c.issuerCertificate = translatePeerCertificate(c.issuerCertificate);\n  if (c.infoAccess != null) {\n    const info = c.infoAccess;\n    c.infoAccess = { __proto__: null }, RegExpPrototypeSymbolReplace.call(/([^\\n:]*):([^\\n]*)(\?:\\n|$)/g, info, (all, key, val) => {\n      if (val.charCodeAt(0) === 34)\n        val = JSONParse(val);\n      if (key in c.infoAccess)\n        ArrayPrototypePush.call(c.infoAccess[key], val);\n      else\n        c.infoAccess[key] = [val];\n    });\n  }\n  return c;\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, getCiphers = function() {\n  return DEFAULT_CIPHERS.split(\":\");\n}, convertProtocols = function(protocols) {\n  const lens = new @Array(protocols.length), buff = @Buffer.allocUnsafe(ArrayPrototypeReduce.call(protocols, (p, c, i) => {\n    const len = @Buffer.byteLength(c);\n    if (len > 255)\n      @throwRangeError(\"The byte length of the protocol at index \" + `${i} exceeds the maximum length.`, \"<= 255\", len, !0);\n    return lens[i] = len, p + 1 + len;\n  }, 0));\n  let offset = 0;\n  for (let i = 0, c = protocols.length;i < c; i++)\n    buff[offset++] = lens[i], buff.write(protocols[i], offset), offset += lens[i];\n  return buff;\n}, convertALPNProtocols = function(protocols, out) {\n  if (@Array.isArray(protocols))\n    out.ALPNProtocols = convertProtocols(protocols);\n  else if (isTypedArray(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols);\n  else if (isArrayBufferView(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols.buffer.slice(protocols.byteOffset, protocols.byteOffset + protocols.byteLength));\n  else if (@Buffer.isBuffer(protocols))\n    out.ALPNProtocols = protocols;\n}, $, { isArrayBufferView, isTypedArray } = @requireNativeModule(\"util/types\"), net = @getInternalField(@internalModuleRegistry, 27) || @createInternalModuleById(27), { Server: NetServer, [Symbol.for(\"::bunternal::\")]: InternalTCPSocket } = net, bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), { rootCertificates, canonicalizeIP } = @lazy(\"internal/tls\"), SymbolReplace = Symbol.replace, RegExpPrototypeSymbolReplace = @RegExp.prototype[SymbolReplace], RegExpPrototypeExec = @RegExp.prototype.exec, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeSlice = @String.prototype.slice, StringPrototypeIncludes = @String.prototype.includes, StringPrototypeSplit = @String.prototype.split, StringPrototypeIndexOf = @String.prototype.indexOf, StringPrototypeSubstring = @String.prototype.substring, StringPrototypeEndsWith = @String.prototype.endsWith, StringFromCharCode = @String.fromCharCode, StringPrototypeCharCodeAt = @String.prototype.charCodeAt, ArrayPrototypeIncludes = @Array.prototype.includes, ArrayPrototypeJoin = @Array.prototype.join, ArrayPrototypeForEach = @Array.prototype.forEach, ArrayPrototypePush = @Array.prototype.push, ArrayPrototypeSome = @Array.prototype.some, ArrayPrototypeReduce = @Array.prototype.reduce, jsonStringPattern = /^\"(\?:[^\"\\\\\\u0000-\\u001f]|\\\\(\?:[\"\\\\/bfnrt]|u[0-9a-fA-F]{4}))*\"/, InternalSecureContext = class SecureContext2 {\n  context;\n  constructor(options) {\n    const context = {};\n    if (options) {\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n    }\n    this.context = context;\n  }\n}, buntls = Symbol.for(\"::buntls::\"), SocketClass, TLSSocket = function(InternalTLSSocket) {\n  SocketClass = InternalTLSSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"TLSSocket\",\n    enumerable: !1\n  });\n  function Socket(options) {\n    return new InternalTLSSocket(options);\n  }\n  return Socket.prototype = InternalTLSSocket.prototype, Object.defineProperty(Socket, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalTLSSocket;\n    }\n  });\n}(class TLSSocket2 extends InternalTCPSocket {\n  #secureContext;\n  ALPNProtocols;\n  #socket;\n  #checkServerIdentity;\n  #session;\n  constructor(socket, options) {\n    super(socket instanceof InternalTCPSocket \? options : options || socket);\n    if (options = options || socket || {}, typeof options === \"object\") {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      if (socket instanceof InternalTCPSocket)\n        this.#socket = socket;\n    }\n    this.#secureContext = options.secureContext || createSecureContext(options), this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, this.#checkServerIdentity = options.checkServerIdentity || checkServerIdentity, this.#session = options.session || null;\n  }\n  _secureEstablished = !1;\n  _securePending = !0;\n  _newSessionPending;\n  _controlReleased;\n  secureConnecting = !1;\n  _SNICallback;\n  servername;\n  authorized = !1;\n  authorizationError;\n  #renegotiationDisabled = !1;\n  encrypted = !0;\n  _start() {\n    this.connect();\n  }\n  getSession() {\n    return this[bunSocketInternal]\?.getSession();\n  }\n  getEphemeralKeyInfo() {\n    return this[bunSocketInternal]\?.getEphemeralKeyInfo();\n  }\n  getCipher() {\n    return this[bunSocketInternal]\?.getCipher();\n  }\n  getSharedSigalgs() {\n    return this[bunSocketInternal]\?.getSharedSigalgs();\n  }\n  getProtocol() {\n    return this[bunSocketInternal]\?.getTLSVersion();\n  }\n  getFinished() {\n    return this[bunSocketInternal]\?.getTLSFinishedMessage() || @undefined;\n  }\n  getPeerFinished() {\n    return this[bunSocketInternal]\?.getTLSPeerFinishedMessage() || @undefined;\n  }\n  isSessionReused() {\n    return !!this.#session;\n  }\n  renegotiate() {\n    if (this.#renegotiationDisabled) {\n      const error = new Error(\"ERR_TLS_RENEGOTIATION_DISABLED: TLS session renegotiation disabled for this socket\");\n      throw error.name = \"ERR_TLS_RENEGOTIATION_DISABLED\", error;\n    }\n    throw Error(\"Not implented in Bun yet\");\n  }\n  disableRenegotiation() {\n    this.#renegotiationDisabled = !0;\n  }\n  getTLSTicket() {\n    return this[bunSocketInternal]\?.getTLSTicket();\n  }\n  exportKeyingMaterial(length, label, context) {\n    if (context)\n      return this[bunSocketInternal]\?.exportKeyingMaterial(length, label, context);\n    return this[bunSocketInternal]\?.exportKeyingMaterial(length, label);\n  }\n  setMaxSendFragment(size) {\n    return this[bunSocketInternal]\?.setMaxSendFragment(size) || !1;\n  }\n  enableTrace() {\n  }\n  setServername(name) {\n    if (this.isServer) {\n      let error = new Error(\"ERR_TLS_SNI_FROM_SERVER: Cannot issue SNI from a TLS server-side socket\");\n      throw error.name = \"ERR_TLS_SNI_FROM_SERVER\", error;\n    }\n    this.servername = name, this[bunSocketInternal]\?.setServername(name);\n  }\n  setSession(session) {\n    if (this.#session = session, typeof session === \"string\")\n      session = @Buffer.from(session, \"latin1\");\n    return this[bunSocketInternal]\?.setSession(session);\n  }\n  getPeerCertificate(abbreviated) {\n    const cert = arguments.length < 1 \? this[bunSocketInternal]\?.getPeerCertificate() : this[bunSocketInternal]\?.getPeerCertificate(abbreviated);\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getCertificate() {\n    const cert = this[bunSocketInternal]\?.getCertificate();\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getPeerX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  getX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  get alpnProtocol() {\n    return this[bunSocketInternal]\?.alpnProtocol;\n  }\n  [buntls](port, host) {\n    return {\n      socket: this.#socket,\n      ALPNProtocols: this.ALPNProtocols,\n      serverName: this.servername || host || \"localhost\",\n      checkServerIdentity: this.#checkServerIdentity,\n      session: this.#session,\n      ...this.#secureContext\n    };\n  }\n});\n\nclass Server extends NetServer {\n  key;\n  cert;\n  ca;\n  passphrase;\n  secureOptions;\n  _rejectUnauthorized;\n  _requestCert;\n  servername;\n  ALPNProtocols;\n  constructor(options, secureConnectionListener) {\n    super(options, secureConnectionListener);\n    this.setSecureContext(options);\n  }\n  setSecureContext(options) {\n    if (options instanceof InternalSecureContext)\n      options = options.context;\n    if (options) {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n      const requestCert = options.requestCert || !1;\n      if (requestCert)\n        this._requestCert = requestCert;\n      else\n        this._requestCert = @undefined;\n      const rejectUnauthorized = options.rejectUnauthorized || !1;\n      if (rejectUnauthorized)\n        this._rejectUnauthorized = rejectUnauthorized;\n      else\n        this._rejectUnauthorized = @undefined;\n    }\n  }\n  getTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  setTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  [buntls](port, host, isClient) {\n    return [\n      {\n        serverName: this.servername || host || \"localhost\",\n        key: this.key,\n        cert: this.cert,\n        ca: this.ca,\n        passphrase: this.passphrase,\n        secureOptions: this.secureOptions,\n        rejectUnauthorized: isClient \? !1 : this._rejectUnauthorized,\n        requestCert: isClient \? !1 : this._requestCert,\n        ALPNProtocols: this.ALPNProtocols\n      },\n      SocketClass\n    ];\n  }\n}\nvar CLIENT_RENEG_LIMIT = 3, CLIENT_RENEG_WINDOW = 600, DEFAULT_ECDH_CURVE = \"auto\", DEFAULT_CIPHERS = \"DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256\", DEFAULT_MIN_VERSION = \"TLSv1.2\", DEFAULT_MAX_VERSION = \"TLSv1.3\", createConnection = (port, host, connectListener) => {\n  if (typeof port === \"object\") {\n    port.checkServerIdentity;\n    const { ALPNProtocols } = port;\n    if (ALPNProtocols)\n      convertALPNProtocols(ALPNProtocols, port);\n    return new TLSSocket(port).connect(port, host, connectListener);\n  }\n  return new TLSSocket().connect(port, host, connectListener);\n}, connect = createConnection;\n$ = {\n  CLIENT_RENEG_LIMIT,\n  CLIENT_RENEG_WINDOW,\n  connect,\n  convertALPNProtocols,\n  createConnection,\n  createSecureContext,\n  createServer,\n  DEFAULT_CIPHERS,\n  DEFAULT_ECDH_CURVE,\n  DEFAULT_MAX_VERSION,\n  DEFAULT_MIN_VERSION,\n  getCiphers,\n  parseCertString,\n  SecureContext,\n  Server,\n  TLSSocket,\n  checkServerIdentity,\n  rootCertificates\n};\nreturn $})\n"_s;
 //
 
 //
@@ -347,7 +347,7 @@ static constexpr ASCIILiteral NodeFSPromisesCode = "(function (){\"use strict\";
 //
 
 //
-static constexpr ASCIILiteral NodeHttpCode = "(function (){\"use strict\";// src/js/out/tmp/node/http.ts\nvar checkInvalidHeaderChar = function(val) {\n  return RegExpPrototypeExec.call(headerCharRegex, val) !== null;\n}, isIPv6 = function(input) {\n  return new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\").test(input);\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, validateMsecs = function(numberlike, field) {\n  if (typeof numberlike !== \"number\" || numberlike < 0)\n    throw new ERR_INVALID_ARG_TYPE(field, \"number\", numberlike);\n  return numberlike;\n}, validateFunction = function(callable, field) {\n  if (typeof callable !== \"function\")\n    throw new ERR_INVALID_ARG_TYPE(field, \"Function\", callable);\n  return callable;\n}, createServer = function(options, callback) {\n  return new Server(options, callback);\n}, emitListeningNextTick = function(self, onListen, err, hostname, port) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen(err, hostname, port);\n    } catch (err2) {\n      self.emit(\"error\", err2);\n    }\n  if (self.listening = !err, err)\n    self.emit(\"error\", err);\n  else\n    self.emit(\"listening\", hostname, port);\n}, assignHeaders = function(object, req) {\n  var headers = req.headers.toJSON();\n  const rawHeaders = @newArrayWithSize(req.headers.count * 2);\n  var i = 0;\n  for (let key in headers)\n    rawHeaders[i++] = key, rawHeaders[i++] = headers[key];\n  object.headers = headers, object.rawHeaders = rawHeaders;\n};\nvar getDefaultHTTPSAgent = function() {\n  return _defaultHTTPSAgent \?\?= new Agent({ defaultPort: 443, protocol: \"https:\" });\n};\nvar urlToHttpOptions = function(url) {\n  var { protocol, hostname, hash, search, pathname, href, port, username, password } = url;\n  return {\n    protocol,\n    hostname: typeof hostname === \"string\" && StringPrototypeStartsWith.call(hostname, \"[\") \? StringPrototypeSlice.call(hostname, 1, -1) : hostname,\n    hash,\n    search,\n    pathname,\n    path: `${pathname || \"\"}${search || \"\"}`,\n    href,\n    port: port \? Number(port) : protocol === \"https:\" \? 443 : protocol === \"http:\" \? 80 : @undefined,\n    auth: username || password \? `${decodeURIComponent(username)}:${decodeURIComponent(password)}` : @undefined\n  };\n}, validateHost = function(host, name) {\n  if (host !== null && host !== @undefined && typeof host !== \"string\")\n    throw new Error(\"Invalid arg type in options\");\n  return host;\n}, checkIsHttpToken = function(val) {\n  return RegExpPrototypeExec.call(tokenRegExp, val) !== null;\n};\nvar _writeHead = function(statusCode, reason, obj, response) {\n  if (statusCode |= 0, statusCode < 100 || statusCode > 999)\n    throw new Error(\"status code must be between 100 and 999\");\n  if (typeof reason === \"string\")\n    response.statusMessage = reason;\n  else {\n    if (!response.statusMessage)\n      response.statusMessage = STATUS_CODES[statusCode] || \"unknown\";\n    obj = reason;\n  }\n  response.statusCode = statusCode;\n  {\n    let k;\n    if (@Array.isArray(obj)) {\n      if (obj.length % 2 !== 0)\n        throw new Error(\"raw headers must have an even number of elements\");\n      for (let n = 0;n < obj.length; n += 2)\n        if (k = obj[n + 0], k)\n          response.setHeader(k, obj[n + 1]);\n    } else if (obj) {\n      const keys = Object.keys(obj);\n      for (let i = 0;i < keys.length; i++)\n        if (k = keys[i], k)\n          response.setHeader(k, obj[k]);\n    }\n  }\n  if (statusCode === 204 || statusCode === 304 || statusCode >= 100 && statusCode <= 199)\n    response._hasBody = !1;\n}, request = function(url, options, cb) {\n  return new ClientRequest(url, options, cb);\n}, get = function(url, options, cb) {\n  const req = request(url, options, cb);\n  return req.end(), req;\n}, $, EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20), { isTypedArray } = @requireNativeModule(\"util/types\"), { Duplex, Readable, Writable } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), { getHeader, setHeader } = @lazy(\"http\"), headerCharRegex = /[^\\t\\x20-\\x7e\\x80-\\xff]/, validateHeaderName = (name, label) => {\n  if (typeof name !== \"string\" || !name || !checkIsHttpToken(name))\n    throw new Error(\"ERR_INVALID_HTTP_TOKEN\");\n}, validateHeaderValue = (name, value) => {\n  if (value === @undefined)\n    throw new Error(\"ERR_HTTP_INVALID_HEADER_VALUE\");\n  if (checkInvalidHeaderChar(value))\n    throw new Error(\"ERR_INVALID_CHAR\");\n}, { URL } = globalThis, globalReportError = globalThis.reportError, setTimeout = globalThis.setTimeout, fetch = Bun.fetch;\nvar kEmptyObject = Object.freeze(Object.create(null)), kOutHeaders = Symbol.for(\"kOutHeaders\"), kEndCalled = Symbol.for(\"kEndCalled\"), kAbortController = Symbol.for(\"kAbortController\"), kClearTimeout = Symbol(\"kClearTimeout\"), kCorked = Symbol.for(\"kCorked\"), searchParamsSymbol = Symbol.for(\"query\"), StringPrototypeSlice = @String.prototype.slice, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeToUpperCase = @String.prototype.toUpperCase, ArrayIsArray = @Array.isArray, RegExpPrototypeExec = @RegExp.prototype.exec, ObjectAssign = Object.assign, INVALID_PATH_REGEX = /[^\\u0021-\\u00ff]/;\nvar _defaultHTTPSAgent, kInternalRequest = Symbol(\"kInternalRequest\"), kInternalSocketData = Symbol.for(\"::bunternal::\"), kEmptyBuffer = @Buffer.alloc(0);\n\nclass ERR_INVALID_ARG_TYPE extends TypeError {\n  constructor(name, expected, actual) {\n    super(`The ${name} argument must be of type ${expected}. Received type ${typeof actual}`);\n    this.code = \"ERR_INVALID_ARG_TYPE\";\n  }\n}\nvar FakeSocket = class Socket extends Duplex {\n  [kInternalSocketData];\n  bytesRead = 0;\n  bytesWritten = 0;\n  connecting = !1;\n  timeout = 0;\n  isServer = !1;\n  #address;\n  address() {\n    var internalData;\n    return this.#address \?\?= (internalData = this[kInternalSocketData])[0].requestIP(internalData[2]);\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  connect(port, host, connectListener) {\n    return this;\n  }\n  _destroy(err, callback) {\n  }\n  _final(callback) {\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return 80;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n  }\n  get remoteAddress() {\n    return this.address()\?.address;\n  }\n  set remoteAddress(val) {\n    this.address().address = val;\n  }\n  get remotePort() {\n    return this.address()\?.port;\n  }\n  set remotePort(val) {\n    this.address().port = val;\n  }\n  get remoteFamily() {\n    return this.address()\?.family;\n  }\n  set remoteFamily(val) {\n    this.address().family = val;\n  }\n  resetAndDestroy() {\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    return this;\n  }\n  unref() {\n  }\n  _write(chunk, encoding, callback) {\n  }\n};\n\nclass Agent extends EventEmitter {\n  defaultPort = 80;\n  protocol = \"http:\";\n  options;\n  requests;\n  sockets;\n  freeSockets;\n  keepAliveMsecs;\n  keepAlive;\n  maxSockets;\n  maxFreeSockets;\n  scheduling;\n  maxTotalSockets;\n  totalSocketCount;\n  #fakeSocket;\n  static get globalAgent() {\n    return globalAgent;\n  }\n  static get defaultMaxSockets() {\n    return @Infinity;\n  }\n  constructor(options = kEmptyObject) {\n    super();\n    if (this.options = options = { ...options, path: null }, options.noDelay === @undefined)\n      options.noDelay = !0;\n    this.requests = kEmptyObject, this.sockets = kEmptyObject, this.freeSockets = kEmptyObject, this.keepAliveMsecs = options.keepAliveMsecs || 1000, this.keepAlive = options.keepAlive || !1, this.maxSockets = options.maxSockets || Agent.defaultMaxSockets, this.maxFreeSockets = options.maxFreeSockets || 256, this.scheduling = options.scheduling || \"lifo\", this.maxTotalSockets = options.maxTotalSockets, this.totalSocketCount = 0, this.defaultPort = options.defaultPort || 80, this.protocol = options.protocol || \"http:\";\n  }\n  createConnection() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  getName(options = kEmptyObject) {\n    let name = `http:${options.host || \"localhost\"}:`;\n    if (options.port)\n      name += options.port;\n    if (name += \":\", options.localAddress)\n      name += options.localAddress;\n    if (options.family === 4 || options.family === 6)\n      name += `:${options.family}`;\n    if (options.socketPath)\n      name += `:${options.socketPath}`;\n    return name;\n  }\n  addRequest() {\n  }\n  createSocket(req, options, cb) {\n    cb(null, this.#fakeSocket \?\?= new FakeSocket);\n  }\n  removeSocket() {\n  }\n  keepSocketAlive() {\n    return !0;\n  }\n  reuseSocket() {\n  }\n  destroy() {\n  }\n}\n\nclass Server extends EventEmitter {\n  #server;\n  #options;\n  #tls;\n  #is_tls = !1;\n  listening = !1;\n  serverName;\n  constructor(options, callback) {\n    super();\n    if (typeof options === \"function\")\n      callback = options, options = {};\n    else if (options == null || typeof options === \"object\") {\n      options = { ...options }, this.#tls = null;\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      let serverName = options.servername;\n      if (serverName && typeof serverName !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      if (this.#is_tls)\n        this.#tls = {\n          serverName,\n          key,\n          cert,\n          ca,\n          passphrase,\n          secureOptions\n        };\n      else\n        this.#tls = null;\n    } else\n      throw new Error(\"bun-http-polyfill: invalid arguments\");\n    if (this.#options = options, callback)\n      this.on(\"request\", callback);\n  }\n  closeAllConnections() {\n    const server = this.#server;\n    if (!server)\n      return;\n    this.#server = @undefined, server.stop(!0), this.emit(\"close\");\n  }\n  closeIdleConnections() {\n  }\n  close(optionalCallback) {\n    const server = this.#server;\n    if (!server) {\n      if (typeof optionalCallback === \"function\")\n        process.nextTick(optionalCallback, new Error(\"Server is not running\"));\n      return;\n    }\n    if (this.#server = @undefined, typeof optionalCallback === \"function\")\n      this.once(\"close\", optionalCallback);\n    server.stop(), this.emit(\"close\");\n  }\n  address() {\n    if (!this.#server)\n      return null;\n    const address = this.#server.hostname;\n    return {\n      address,\n      family: isIPv6(address) \? \"IPv6\" : \"IPv4\",\n      port: this.#server.port\n    };\n  }\n  listen(port, host, backlog, onListen) {\n    const server = this;\n    let socketPath;\n    if (typeof port == \"string\" && !Number.isSafeInteger(Number(port)))\n      socketPath = port;\n    if (typeof host === \"function\")\n      onListen = host, host = @undefined;\n    if (typeof port === \"function\")\n      onListen = port;\n    else if (typeof port === \"object\") {\n      if (port\?.signal\?.addEventListener(\"abort\", () => {\n        this.close();\n      }), host = port\?.host, port = port\?.port, typeof port\?.callback === \"function\")\n        onListen = port\?.callback;\n    }\n    if (typeof backlog === \"function\")\n      onListen = backlog;\n    const ResponseClass = this.#options.ServerResponse || ServerResponse, RequestClass = this.#options.IncomingMessage || IncomingMessage;\n    try {\n      const tls = this.#tls;\n      if (tls)\n        this.serverName = tls.serverName || host || \"localhost\";\n      this.#server = Bun.serve({\n        tls,\n        port,\n        hostname: host,\n        unix: socketPath,\n        websocket: {\n          open(ws) {\n            ws.data.open(ws);\n          },\n          message(ws, message) {\n            ws.data.message(ws, message);\n          },\n          close(ws, code, reason) {\n            ws.data.close(ws, code, reason);\n          },\n          drain(ws) {\n            ws.data.drain(ws);\n          }\n        },\n        fetch(req, _server) {\n          var pendingResponse, pendingError, rejectFunction, resolveFunction, reject = (err) => {\n            if (pendingError)\n              return;\n            if (pendingError = err, rejectFunction)\n              rejectFunction(err);\n          }, reply = function(resp) {\n            if (pendingResponse)\n              return;\n            if (pendingResponse = resp, resolveFunction)\n              resolveFunction(resp);\n          };\n          const http_req = new RequestClass(req), http_res = new ResponseClass({ reply, req: http_req });\n          if (http_req.socket[kInternalSocketData] = [_server, http_res, req], http_req.once(\"error\", (err) => reject(err)), http_res.once(\"error\", (err) => reject(err)), req.headers.get(\"upgrade\"))\n            server.emit(\"upgrade\", http_req, http_req.socket, kEmptyBuffer);\n          else\n            server.emit(\"request\", http_req, http_res);\n          if (pendingError)\n            throw pendingError;\n          if (pendingResponse)\n            return pendingResponse;\n          return new @Promise((resolve, reject2) => {\n            resolveFunction = resolve, rejectFunction = reject2;\n          });\n        }\n      }), setTimeout(emitListeningNextTick, 1, this, onListen, null, this.#server.hostname, this.#server.port);\n    } catch (err) {\n      server.emit(\"error\", err);\n    }\n    return this;\n  }\n  setTimeout(msecs, callback) {\n  }\n}\nclass IncomingMessage extends Readable {\n  method;\n  complete;\n  constructor(req, defaultIncomingOpts) {\n    const method = req.method;\n    super();\n    const url = new URL(req.url);\n    var { type = \"request\", [kInternalRequest]: nodeReq } = defaultIncomingOpts || {};\n    this.#noBody = type === \"request\" \? method === \"GET\" || method === \"HEAD\" || method === \"TRACE\" || method === \"CONNECT\" || method === \"OPTIONS\" || (parseInt(req.headers.get(\"Content-Length\") || \"\") || 0) === 0 : !1, this.#req = req, this.method = method, this.#type = type, this.complete = !!this.#noBody, this.#bodyStream = @undefined;\n    const socket = new FakeSocket;\n    if (url.protocol === \"https:\")\n      socket.encrypted = !0;\n    this.#fakeSocket = socket, this.url = url.pathname + url.search, this.req = nodeReq, assignHeaders(this, req);\n  }\n  headers;\n  rawHeaders;\n  _consuming = !1;\n  _dumped = !1;\n  #bodyStream;\n  #fakeSocket;\n  #noBody = !1;\n  #aborted = !1;\n  #req;\n  url;\n  #type;\n  _construct(callback) {\n    if (this.#type === \"response\" || this.#noBody) {\n      callback();\n      return;\n    }\n    const contentLength = this.#req.headers.get(\"content-length\");\n    if ((contentLength \? parseInt(contentLength, 10) : 0) === 0) {\n      this.#noBody = !0, callback();\n      return;\n    }\n    callback();\n  }\n  async#consumeStream(reader) {\n    while (!0) {\n      var { done, value } = await reader.readMany();\n      if (this.#aborted)\n        return;\n      if (done) {\n        this.push(null), this.destroy();\n        break;\n      }\n      for (var v of value)\n        this.push(v);\n    }\n  }\n  _read(size) {\n    if (this.#noBody)\n      this.push(null), this.complete = !0;\n    else if (this.#bodyStream == null) {\n      const reader = this.#req.body\?.getReader();\n      if (!reader) {\n        this.push(null);\n        return;\n      }\n      this.#bodyStream = reader, this.#consumeStream(reader);\n    }\n  }\n  get aborted() {\n    return this.#aborted;\n  }\n  #abort() {\n    if (this.#aborted)\n      return;\n    this.#aborted = !0;\n    var bodyStream = this.#bodyStream;\n    if (!bodyStream)\n      return;\n    bodyStream.cancel(), this.complete = !0, this.#bodyStream = @undefined, this.push(null);\n  }\n  get connection() {\n    return this.#fakeSocket;\n  }\n  get statusCode() {\n    return this.#req.status;\n  }\n  get statusMessage() {\n    return STATUS_CODES[this.#req.status];\n  }\n  get httpVersion() {\n    return \"1.1\";\n  }\n  get rawTrailers() {\n    return [];\n  }\n  get httpVersionMajor() {\n    return 1;\n  }\n  get httpVersionMinor() {\n    return 1;\n  }\n  get trailers() {\n    return kEmptyObject;\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n}\n\nclass OutgoingMessage extends Writable {\n  constructor() {\n    super(...arguments);\n  }\n  #headers;\n  headersSent = !1;\n  sendDate = !0;\n  req;\n  timeout;\n  #finished = !1;\n  [kEndCalled] = !1;\n  #fakeSocket;\n  #timeoutTimer;\n  [kAbortController] = null;\n  _implicitHeader() {\n  }\n  get headers() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  get connection() {\n    return this.socket;\n  }\n  get finished() {\n    return this.#finished;\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return headers.set(name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.removeAllListeners(\"timeout\"), this.#timeoutTimer = @undefined;\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar OriginalWriteHeadFn, OriginalImplicitHeadFn;\n\nclass ServerResponse extends Writable {\n  constructor(c) {\n    super();\n    if (!c)\n      c = {};\n    var req = c.req || {}, reply = c.reply;\n    if (this.req = req, this._reply = reply, this.sendDate = !0, this.statusCode = 200, this.headersSent = !1, this.statusMessage = @undefined, this.#controller = @undefined, this.#firstWrite = @undefined, this._writableState.decodeStrings = !1, this.#deferred = @undefined, req.method === \"HEAD\")\n      this._hasBody = !1;\n  }\n  req;\n  _reply;\n  sendDate;\n  statusCode;\n  #headers;\n  headersSent = !1;\n  statusMessage;\n  #controller;\n  #firstWrite;\n  _sent100 = !1;\n  _defaultKeepAlive = !1;\n  _removedConnection = !1;\n  _removedContLen = !1;\n  _hasBody = !0;\n  #deferred = @undefined;\n  #finished = !1;\n  _implicitHeader() {\n    this.writeHead(this.statusCode);\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#firstWrite && !this.headersSent) {\n      this.#firstWrite = chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      controller.write(chunk), callback();\n    });\n  }\n  _writev(chunks, callback) {\n    if (chunks.length === 1 && !this.headersSent && !this.#firstWrite) {\n      this.#firstWrite = chunks[0].chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      for (let chunk of chunks)\n        controller.write(chunk.chunk);\n      callback();\n    });\n  }\n  #ensureReadableStreamController(run) {\n    var thisController = this.#controller;\n    if (thisController)\n      return run(thisController);\n    this.headersSent = !0;\n    var firstWrite = this.#firstWrite;\n    this.#firstWrite = @undefined, this._reply(new Response(new @ReadableStream({\n      type: \"direct\",\n      pull: (controller) => {\n        if (this.#controller = controller, firstWrite)\n          controller.write(firstWrite);\n        if (firstWrite = @undefined, run(controller), !this.#finished)\n          return new @Promise((resolve) => {\n            this.#deferred = resolve;\n          });\n      }\n    }), {\n      headers: this.#headers,\n      status: this.statusCode,\n      statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n    }));\n  }\n  #drainHeadersIfObservable() {\n    if (this._implicitHeader === OriginalImplicitHeadFn && this.writeHead === OriginalWriteHeadFn)\n      return;\n    this._implicitHeader();\n  }\n  _final(callback) {\n    if (!this.headersSent) {\n      var data = this.#firstWrite || \"\";\n      this.#firstWrite = @undefined, this.#finished = !0, this.#drainHeadersIfObservable(), this._reply(new Response(data, {\n        headers: this.#headers,\n        status: this.statusCode,\n        statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n      })), callback && callback();\n      return;\n    }\n    this.#finished = !0, this.#ensureReadableStreamController((controller) => {\n      controller.end(), callback();\n      var deferred = this.#deferred;\n      if (deferred)\n        this.#deferred = @undefined, deferred();\n    });\n  }\n  writeProcessing() {\n    throw new Error(\"not implemented\");\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  assignSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  detachSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  writeContinue(callback) {\n    throw new Error(\"not implemented\");\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    var headers = this.#headers;\n    if (!headers)\n      return kEmptyObject;\n    return headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return setHeader(headers, name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  writeHead(statusCode, statusMessage, headers) {\n    return _writeHead(statusCode, statusMessage, headers, this), this;\n  }\n}\nOriginalWriteHeadFn = ServerResponse.prototype.writeHead;\nOriginalImplicitHeadFn = ServerResponse.prototype._implicitHeader;\n\nclass ClientRequest extends OutgoingMessage {\n  #timeout;\n  #res = null;\n  #upgradeOrConnect = !1;\n  #parser = null;\n  #maxHeadersCount = null;\n  #reusedSocket = !1;\n  #host;\n  #protocol;\n  #method;\n  #port;\n  #useDefaultPort;\n  #joinDuplicateHeaders;\n  #maxHeaderSize;\n  #agent = globalAgent;\n  #path;\n  #socketPath;\n  #bodyChunks = null;\n  #fetchRequest;\n  #signal = null;\n  [kAbortController] = null;\n  #timeoutTimer = @undefined;\n  #options;\n  #finished;\n  get path() {\n    return this.#path;\n  }\n  get port() {\n    return this.#port;\n  }\n  get method() {\n    return this.#method;\n  }\n  get host() {\n    return this.#host;\n  }\n  get protocol() {\n    return this.#protocol;\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = [chunk], callback();\n      return;\n    }\n    this.#bodyChunks.push(chunk), callback();\n  }\n  _writev(chunks, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = chunks, callback();\n      return;\n    }\n    this.#bodyChunks.push(...chunks), callback();\n  }\n  _final(callback) {\n    if (this.#finished = !0, this[kAbortController] = new AbortController, this[kAbortController].signal.addEventListener(\"abort\", () => {\n      this[kClearTimeout]();\n    }), this.#signal\?.aborted)\n      this[kAbortController].abort();\n    var method = this.#method, body = this.#bodyChunks\?.length === 1 \? this.#bodyChunks[0] : @Buffer.concat(this.#bodyChunks || []);\n    let url, proxy;\n    if (this.#path.startsWith(\"http://\") || this.#path.startsWith(\"https://\"))\n      url = this.#path, proxy = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}`;\n    else\n      url = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}${this.#path}`;\n    try {\n      this.#fetchRequest = fetch(url, {\n        method,\n        headers: this.getHeaders(),\n        body: body && method !== \"GET\" && method !== \"HEAD\" && method !== \"OPTIONS\" \? body : @undefined,\n        redirect: \"manual\",\n        verbose: !1,\n        signal: this[kAbortController].signal,\n        proxy,\n        timeout: !1,\n        decompress: !1\n      }).then((response) => {\n        var res = this.#res = new IncomingMessage(response, {\n          type: \"response\",\n          [kInternalRequest]: this\n        });\n        this.emit(\"response\", res);\n      }).catch((err) => {\n        this.emit(\"error\", err);\n      }).finally(() => {\n        this.#fetchRequest = null, this[kClearTimeout]();\n      });\n    } catch (err) {\n      this.emit(\"error\", err);\n    } finally {\n      callback();\n    }\n  }\n  get aborted() {\n    return this.#signal\?.aborted || !!this[kAbortController]\?.signal.aborted;\n  }\n  abort() {\n    if (this.aborted)\n      return;\n    this[kAbortController].abort();\n  }\n  constructor(input, options, cb) {\n    super();\n    if (typeof input === \"string\") {\n      const urlStr = input;\n      try {\n        var urlObject = new URL(urlStr);\n      } catch (e) {\n        @throwTypeError(`Invalid URL: ${urlStr}`);\n      }\n      input = urlToHttpOptions(urlObject);\n    } else if (input && typeof input === \"object\" && input instanceof URL)\n      input = urlToHttpOptions(input);\n    else\n      cb = options, options = input, input = null;\n    if (typeof options === \"function\")\n      cb = options, options = input || kEmptyObject;\n    else\n      options = ObjectAssign(input || {}, options);\n    var defaultAgent = options._defaultAgent || Agent.globalAgent;\n    let protocol = options.protocol;\n    if (!protocol)\n      if (options.port === 443)\n        protocol = \"https:\";\n      else\n        protocol = defaultAgent.protocol || \"http:\";\n    switch (this.#protocol = protocol, this.#agent\?.protocol) {\n      case @undefined:\n        break;\n      case \"http:\":\n        if (protocol === \"https:\") {\n          defaultAgent = this.#agent = getDefaultHTTPSAgent();\n          break;\n        }\n      case \"https:\":\n        if (protocol === \"https\") {\n          defaultAgent = this.#agent = Agent.globalAgent;\n          break;\n        }\n      default:\n        break;\n    }\n    if (options.path) {\n      const path = @String(options.path);\n      if (RegExpPrototypeExec.call(INVALID_PATH_REGEX, path) !== null)\n        throw new Error(\"Path contains unescaped characters\");\n    }\n    if (protocol !== \"http:\" && protocol !== \"https:\" && protocol) {\n      const expectedProtocol = defaultAgent\?.protocol \?\? \"http:\";\n      throw new Error(`Protocol mismatch. Expected: ${expectedProtocol}. Got: ${protocol}`);\n    }\n    const defaultPort = protocol === \"https:\" \? 443 : 80;\n    this.#port = options.port || options.defaultPort || this.#agent\?.defaultPort || defaultPort, this.#useDefaultPort = this.#port === defaultPort;\n    const host = this.#host = options.host = validateHost(options.hostname, \"hostname\") || validateHost(options.host, \"host\") || \"localhost\";\n    this.#socketPath = options.socketPath;\n    const signal = options.signal;\n    if (signal)\n      signal.addEventListener(\"abort\", () => {\n        this[kAbortController]\?.abort();\n      }), this.#signal = signal;\n    let method = options.method;\n    const methodIsString = typeof method === \"string\";\n    if (method !== null && method !== @undefined && !methodIsString)\n      throw new Error(\"ERR_INVALID_ARG_TYPE: options.method\");\n    if (methodIsString && method) {\n      if (!checkIsHttpToken(method))\n        throw new Error(\"ERR_INVALID_HTTP_TOKEN: Method\");\n      method = this.#method = StringPrototypeToUpperCase.call(method);\n    } else\n      method = this.#method = \"GET\";\n    const _maxHeaderSize = options.maxHeaderSize;\n    this.#maxHeaderSize = _maxHeaderSize;\n    var _joinDuplicateHeaders = options.joinDuplicateHeaders;\n    if (this.#joinDuplicateHeaders = _joinDuplicateHeaders, this.#path = options.path || \"/\", cb)\n      this.once(\"response\", cb);\n    this.#finished = !1, this.#res = null, this.#upgradeOrConnect = !1, this.#parser = null, this.#maxHeadersCount = null, this.#reusedSocket = !1, this.#host = host, this.#protocol = protocol;\n    var timeout = options.timeout;\n    if (timeout !== @undefined && timeout !== 0)\n      this.setTimeout(timeout, @undefined);\n    if (!ArrayIsArray(headers)) {\n      var headers = options.headers;\n      if (headers)\n        for (let key in headers)\n          this.setHeader(key, headers[key]);\n      var auth = options.auth;\n      if (auth && !this.getHeader(\"Authorization\"))\n        this.setHeader(\"Authorization\", \"Basic \" + @Buffer.from(auth).toString(\"base64\"));\n    }\n    var { signal: _signal, ...optsWithoutSignal } = options;\n    this.#options = optsWithoutSignal;\n  }\n  setSocketKeepAlive(enable = !0, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.#timeoutTimer = @undefined, this.removeAllListeners(\"timeout\");\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar tokenRegExp = /^[\\^_`a-zA-Z\\-0-9!#$%&'*+.|~]+$/, METHODS = [\n  \"ACL\",\n  \"BIND\",\n  \"CHECKOUT\",\n  \"CONNECT\",\n  \"COPY\",\n  \"DELETE\",\n  \"GET\",\n  \"HEAD\",\n  \"LINK\",\n  \"LOCK\",\n  \"M-SEARCH\",\n  \"MERGE\",\n  \"MKACTIVITY\",\n  \"MKCALENDAR\",\n  \"MKCOL\",\n  \"MOVE\",\n  \"NOTIFY\",\n  \"OPTIONS\",\n  \"PATCH\",\n  \"POST\",\n  \"PROPFIND\",\n  \"PROPPATCH\",\n  \"PURGE\",\n  \"PUT\",\n  \"REBIND\",\n  \"REPORT\",\n  \"SEARCH\",\n  \"SOURCE\",\n  \"SUBSCRIBE\",\n  \"TRACE\",\n  \"UNBIND\",\n  \"UNLINK\",\n  \"UNLOCK\",\n  \"UNSUBSCRIBE\"\n], STATUS_CODES = {\n  100: \"Continue\",\n  101: \"Switching Protocols\",\n  102: \"Processing\",\n  103: \"Early Hints\",\n  200: \"OK\",\n  201: \"Created\",\n  202: \"Accepted\",\n  203: \"Non-Authoritative Information\",\n  204: \"No Content\",\n  205: \"Reset Content\",\n  206: \"Partial Content\",\n  207: \"Multi-Status\",\n  208: \"Already Reported\",\n  226: \"IM Used\",\n  300: \"Multiple Choices\",\n  301: \"Moved Permanently\",\n  302: \"Found\",\n  303: \"See Other\",\n  304: \"Not Modified\",\n  305: \"Use Proxy\",\n  307: \"Temporary Redirect\",\n  308: \"Permanent Redirect\",\n  400: \"Bad Request\",\n  401: \"Unauthorized\",\n  402: \"Payment Required\",\n  403: \"Forbidden\",\n  404: \"Not Found\",\n  405: \"Method Not Allowed\",\n  406: \"Not Acceptable\",\n  407: \"Proxy Authentication Required\",\n  408: \"Request Timeout\",\n  409: \"Conflict\",\n  410: \"Gone\",\n  411: \"Length Required\",\n  412: \"Precondition Failed\",\n  413: \"Payload Too Large\",\n  414: \"URI Too Long\",\n  415: \"Unsupported Media Type\",\n  416: \"Range Not Satisfiable\",\n  417: \"Expectation Failed\",\n  418: \"I'm a Teapot\",\n  421: \"Misdirected Request\",\n  422: \"Unprocessable Entity\",\n  423: \"Locked\",\n  424: \"Failed Dependency\",\n  425: \"Too Early\",\n  426: \"Upgrade Required\",\n  428: \"Precondition Required\",\n  429: \"Too Many Requests\",\n  431: \"Request Header Fields Too Large\",\n  451: \"Unavailable For Legal Reasons\",\n  500: \"Internal Server Error\",\n  501: \"Not Implemented\",\n  502: \"Bad Gateway\",\n  503: \"Service Unavailable\",\n  504: \"Gateway Timeout\",\n  505: \"HTTP Version Not Supported\",\n  506: \"Variant Also Negotiates\",\n  507: \"Insufficient Storage\",\n  508: \"Loop Detected\",\n  509: \"Bandwidth Limit Exceeded\",\n  510: \"Not Extended\",\n  511: \"Network Authentication Required\"\n}, globalAgent = new Agent;\n$ = {\n  Agent,\n  Server,\n  METHODS,\n  STATUS_CODES,\n  createServer,\n  ServerResponse,\n  IncomingMessage,\n  request,\n  get,\n  maxHeaderSize: 16384,\n  validateHeaderName,\n  validateHeaderValue,\n  setMaxIdleHTTPParsers(max) {\n  },\n  globalAgent,\n  ClientRequest,\n  OutgoingMessage\n};\nreturn $})\n"_s;
+static constexpr ASCIILiteral NodeHttpCode = "(function (){\"use strict\";// src/js/out/tmp/node/http.ts\nvar checkInvalidHeaderChar = function(val) {\n  return RegExpPrototypeExec.call(headerCharRegex, val) !== null;\n}, isIPv6 = function(input) {\n  return new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\").test(input);\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, validateMsecs = function(numberlike, field) {\n  if (typeof numberlike !== \"number\" || numberlike < 0)\n    throw new ERR_INVALID_ARG_TYPE(field, \"number\", numberlike);\n  return numberlike;\n}, validateFunction = function(callable, field) {\n  if (typeof callable !== \"function\")\n    throw new ERR_INVALID_ARG_TYPE(field, \"Function\", callable);\n  return callable;\n}, createServer = function(options, callback) {\n  return new Server(options, callback);\n}, emitListeningNextTick = function(self, onListen, err, hostname, port) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen(err, hostname, port);\n    } catch (err2) {\n      self.emit(\"error\", err2);\n    }\n  if (self.listening = !err, err)\n    self.emit(\"error\", err);\n  else\n    self.emit(\"listening\", hostname, port);\n}, assignHeaders = function(object, req) {\n  var headers = req.headers.toJSON();\n  const rawHeaders = @newArrayWithSize(req.headers.count * 2);\n  var i = 0;\n  for (let key in headers)\n    rawHeaders[i++] = key, rawHeaders[i++] = headers[key];\n  object.headers = headers, object.rawHeaders = rawHeaders;\n};\nvar getDefaultHTTPSAgent = function() {\n  return _defaultHTTPSAgent \?\?= new Agent({ defaultPort: 443, protocol: \"https:\" });\n};\nvar urlToHttpOptions = function(url) {\n  var { protocol, hostname, hash, search, pathname, href, port, username, password } = url;\n  return {\n    protocol,\n    hostname: typeof hostname === \"string\" && StringPrototypeStartsWith.call(hostname, \"[\") \? StringPrototypeSlice.call(hostname, 1, -1) : hostname,\n    hash,\n    search,\n    pathname,\n    path: `${pathname || \"\"}${search || \"\"}`,\n    href,\n    port: port \? Number(port) : protocol === \"https:\" \? 443 : protocol === \"http:\" \? 80 : @undefined,\n    auth: username || password \? `${decodeURIComponent(username)}:${decodeURIComponent(password)}` : @undefined\n  };\n}, validateHost = function(host, name) {\n  if (host !== null && host !== @undefined && typeof host !== \"string\")\n    throw new Error(\"Invalid arg type in options\");\n  return host;\n}, checkIsHttpToken = function(val) {\n  return RegExpPrototypeExec.call(tokenRegExp, val) !== null;\n};\nvar _writeHead = function(statusCode, reason, obj, response) {\n  if (statusCode |= 0, statusCode < 100 || statusCode > 999)\n    throw new Error(\"status code must be between 100 and 999\");\n  if (typeof reason === \"string\")\n    response.statusMessage = reason;\n  else {\n    if (!response.statusMessage)\n      response.statusMessage = STATUS_CODES[statusCode] || \"unknown\";\n    obj = reason;\n  }\n  response.statusCode = statusCode;\n  {\n    let k;\n    if (@Array.isArray(obj)) {\n      if (obj.length % 2 !== 0)\n        throw new Error(\"raw headers must have an even number of elements\");\n      for (let n = 0;n < obj.length; n += 2)\n        if (k = obj[n + 0], k)\n          response.setHeader(k, obj[n + 1]);\n    } else if (obj) {\n      const keys = Object.keys(obj);\n      for (let i = 0;i < keys.length; i++)\n        if (k = keys[i], k)\n          response.setHeader(k, obj[k]);\n    }\n  }\n  if (statusCode === 204 || statusCode === 304 || statusCode >= 100 && statusCode <= 199)\n    response._hasBody = !1;\n}, request = function(url, options, cb) {\n  return new ClientRequest(url, options, cb);\n}, get = function(url, options, cb) {\n  const req = request(url, options, cb);\n  return req.end(), req;\n}, $, EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20), { isTypedArray } = @requireNativeModule(\"util/types\"), { Duplex, Readable, Writable } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), { getHeader, setHeader } = @lazy(\"http\"), headerCharRegex = /[^\\t\\x20-\\x7e\\x80-\\xff]/, validateHeaderName = (name, label) => {\n  if (typeof name !== \"string\" || !name || !checkIsHttpToken(name))\n    throw new Error(\"ERR_INVALID_HTTP_TOKEN\");\n}, validateHeaderValue = (name, value) => {\n  if (value === @undefined)\n    throw new Error(\"ERR_HTTP_INVALID_HEADER_VALUE\");\n  if (checkInvalidHeaderChar(value))\n    throw new Error(\"ERR_INVALID_CHAR\");\n}, { URL } = globalThis, globalReportError = globalThis.reportError, setTimeout = globalThis.setTimeout, fetch = Bun.fetch;\nvar kEmptyObject = Object.freeze(Object.create(null)), kOutHeaders = Symbol.for(\"kOutHeaders\"), kEndCalled = Symbol.for(\"kEndCalled\"), kAbortController = Symbol.for(\"kAbortController\"), kClearTimeout = Symbol(\"kClearTimeout\"), kCorked = Symbol.for(\"kCorked\"), searchParamsSymbol = Symbol.for(\"query\"), StringPrototypeSlice = @String.prototype.slice, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeToUpperCase = @String.prototype.toUpperCase, ArrayIsArray = @Array.isArray, RegExpPrototypeExec = @RegExp.prototype.exec, ObjectAssign = Object.assign, INVALID_PATH_REGEX = /[^\\u0021-\\u00ff]/;\nvar _defaultHTTPSAgent, kInternalRequest = Symbol(\"kInternalRequest\"), kInternalSocketData = Symbol.for(\"::bunternal::\"), kEmptyBuffer = @Buffer.alloc(0);\n\nclass ERR_INVALID_ARG_TYPE extends TypeError {\n  constructor(name, expected, actual) {\n    super(`The ${name} argument must be of type ${expected}. Received type ${typeof actual}`);\n    this.code = \"ERR_INVALID_ARG_TYPE\";\n  }\n}\nvar FakeSocket = class Socket extends Duplex {\n  [kInternalSocketData];\n  bytesRead = 0;\n  bytesWritten = 0;\n  connecting = !1;\n  timeout = 0;\n  isServer = !1;\n  #address;\n  address() {\n    var internalData;\n    return this.#address \?\?= (internalData = this[kInternalSocketData])[0].requestIP(internalData[2]) \?\? {};\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  connect(port, host, connectListener) {\n    return this;\n  }\n  _destroy(err, callback) {\n  }\n  _final(callback) {\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return 80;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n  }\n  get remoteAddress() {\n    return this.address()\?.address;\n  }\n  set remoteAddress(val) {\n    this.address().address = val;\n  }\n  get remotePort() {\n    return this.address()\?.port;\n  }\n  set remotePort(val) {\n    this.address().port = val;\n  }\n  get remoteFamily() {\n    return this.address()\?.family;\n  }\n  set remoteFamily(val) {\n    this.address().family = val;\n  }\n  resetAndDestroy() {\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    return this;\n  }\n  unref() {\n  }\n  _write(chunk, encoding, callback) {\n  }\n};\n\nclass Agent extends EventEmitter {\n  defaultPort = 80;\n  protocol = \"http:\";\n  options;\n  requests;\n  sockets;\n  freeSockets;\n  keepAliveMsecs;\n  keepAlive;\n  maxSockets;\n  maxFreeSockets;\n  scheduling;\n  maxTotalSockets;\n  totalSocketCount;\n  #fakeSocket;\n  static get globalAgent() {\n    return globalAgent;\n  }\n  static get defaultMaxSockets() {\n    return @Infinity;\n  }\n  constructor(options = kEmptyObject) {\n    super();\n    if (this.options = options = { ...options, path: null }, options.noDelay === @undefined)\n      options.noDelay = !0;\n    this.requests = kEmptyObject, this.sockets = kEmptyObject, this.freeSockets = kEmptyObject, this.keepAliveMsecs = options.keepAliveMsecs || 1000, this.keepAlive = options.keepAlive || !1, this.maxSockets = options.maxSockets || Agent.defaultMaxSockets, this.maxFreeSockets = options.maxFreeSockets || 256, this.scheduling = options.scheduling || \"lifo\", this.maxTotalSockets = options.maxTotalSockets, this.totalSocketCount = 0, this.defaultPort = options.defaultPort || 80, this.protocol = options.protocol || \"http:\";\n  }\n  createConnection() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  getName(options = kEmptyObject) {\n    let name = `http:${options.host || \"localhost\"}:`;\n    if (options.port)\n      name += options.port;\n    if (name += \":\", options.localAddress)\n      name += options.localAddress;\n    if (options.family === 4 || options.family === 6)\n      name += `:${options.family}`;\n    if (options.socketPath)\n      name += `:${options.socketPath}`;\n    return name;\n  }\n  addRequest() {\n  }\n  createSocket(req, options, cb) {\n    cb(null, this.#fakeSocket \?\?= new FakeSocket);\n  }\n  removeSocket() {\n  }\n  keepSocketAlive() {\n    return !0;\n  }\n  reuseSocket() {\n  }\n  destroy() {\n  }\n}\n\nclass Server extends EventEmitter {\n  #server;\n  #options;\n  #tls;\n  #is_tls = !1;\n  listening = !1;\n  serverName;\n  constructor(options, callback) {\n    super();\n    if (typeof options === \"function\")\n      callback = options, options = {};\n    else if (options == null || typeof options === \"object\") {\n      options = { ...options }, this.#tls = null;\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      let serverName = options.servername;\n      if (serverName && typeof serverName !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      if (this.#is_tls)\n        this.#tls = {\n          serverName,\n          key,\n          cert,\n          ca,\n          passphrase,\n          secureOptions\n        };\n      else\n        this.#tls = null;\n    } else\n      throw new Error(\"bun-http-polyfill: invalid arguments\");\n    if (this.#options = options, callback)\n      this.on(\"request\", callback);\n  }\n  closeAllConnections() {\n    const server = this.#server;\n    if (!server)\n      return;\n    this.#server = @undefined, server.stop(!0), this.emit(\"close\");\n  }\n  closeIdleConnections() {\n  }\n  close(optionalCallback) {\n    const server = this.#server;\n    if (!server) {\n      if (typeof optionalCallback === \"function\")\n        process.nextTick(optionalCallback, new Error(\"Server is not running\"));\n      return;\n    }\n    if (this.#server = @undefined, typeof optionalCallback === \"function\")\n      this.once(\"close\", optionalCallback);\n    server.stop(), this.emit(\"close\");\n  }\n  address() {\n    if (!this.#server)\n      return null;\n    const address = this.#server.hostname;\n    return {\n      address,\n      family: isIPv6(address) \? \"IPv6\" : \"IPv4\",\n      port: this.#server.port\n    };\n  }\n  listen(port, host, backlog, onListen) {\n    const server = this;\n    let socketPath;\n    if (typeof port == \"string\" && !Number.isSafeInteger(Number(port)))\n      socketPath = port;\n    if (typeof host === \"function\")\n      onListen = host, host = @undefined;\n    if (typeof port === \"function\")\n      onListen = port;\n    else if (typeof port === \"object\") {\n      if (port\?.signal\?.addEventListener(\"abort\", () => {\n        this.close();\n      }), host = port\?.host, port = port\?.port, typeof port\?.callback === \"function\")\n        onListen = port\?.callback;\n    }\n    if (typeof backlog === \"function\")\n      onListen = backlog;\n    const ResponseClass = this.#options.ServerResponse || ServerResponse, RequestClass = this.#options.IncomingMessage || IncomingMessage;\n    try {\n      const tls = this.#tls;\n      if (tls)\n        this.serverName = tls.serverName || host || \"localhost\";\n      this.#server = Bun.serve({\n        tls,\n        port,\n        hostname: host,\n        unix: socketPath,\n        websocket: {\n          open(ws) {\n            ws.data.open(ws);\n          },\n          message(ws, message) {\n            ws.data.message(ws, message);\n          },\n          close(ws, code, reason) {\n            ws.data.close(ws, code, reason);\n          },\n          drain(ws) {\n            ws.data.drain(ws);\n          }\n        },\n        fetch(req, _server) {\n          var pendingResponse, pendingError, rejectFunction, resolveFunction, reject = (err) => {\n            if (pendingError)\n              return;\n            if (pendingError = err, rejectFunction)\n              rejectFunction(err);\n          }, reply = function(resp) {\n            if (pendingResponse)\n              return;\n            if (pendingResponse = resp, resolveFunction)\n              resolveFunction(resp);\n          };\n          const http_req = new RequestClass(req), http_res = new ResponseClass({ reply, req: http_req });\n          if (http_req.socket[kInternalSocketData] = [_server, http_res, req], http_req.once(\"error\", (err) => reject(err)), http_res.once(\"error\", (err) => reject(err)), req.headers.get(\"upgrade\"))\n            server.emit(\"upgrade\", http_req, http_req.socket, kEmptyBuffer);\n          else\n            server.emit(\"request\", http_req, http_res);\n          if (pendingError)\n            throw pendingError;\n          if (pendingResponse)\n            return pendingResponse;\n          return new @Promise((resolve, reject2) => {\n            resolveFunction = resolve, rejectFunction = reject2;\n          });\n        }\n      }), setTimeout(emitListeningNextTick, 1, this, onListen, null, this.#server.hostname, this.#server.port);\n    } catch (err) {\n      server.emit(\"error\", err);\n    }\n    return this;\n  }\n  setTimeout(msecs, callback) {\n  }\n}\nclass IncomingMessage extends Readable {\n  method;\n  complete;\n  constructor(req, defaultIncomingOpts) {\n    const method = req.method;\n    super();\n    const url = new URL(req.url);\n    var { type = \"request\", [kInternalRequest]: nodeReq } = defaultIncomingOpts || {};\n    this.#noBody = type === \"request\" \? method === \"GET\" || method === \"HEAD\" || method === \"TRACE\" || method === \"CONNECT\" || method === \"OPTIONS\" || (parseInt(req.headers.get(\"Content-Length\") || \"\") || 0) === 0 : !1, this.#req = req, this.method = method, this.#type = type, this.complete = !!this.#noBody, this.#bodyStream = @undefined;\n    const socket = new FakeSocket;\n    if (url.protocol === \"https:\")\n      socket.encrypted = !0;\n    this.#fakeSocket = socket, this.url = url.pathname + url.search, this.req = nodeReq, assignHeaders(this, req);\n  }\n  headers;\n  rawHeaders;\n  _consuming = !1;\n  _dumped = !1;\n  #bodyStream;\n  #fakeSocket;\n  #noBody = !1;\n  #aborted = !1;\n  #req;\n  url;\n  #type;\n  _construct(callback) {\n    if (this.#type === \"response\" || this.#noBody) {\n      callback();\n      return;\n    }\n    const contentLength = this.#req.headers.get(\"content-length\");\n    if ((contentLength \? parseInt(contentLength, 10) : 0) === 0) {\n      this.#noBody = !0, callback();\n      return;\n    }\n    callback();\n  }\n  async#consumeStream(reader) {\n    while (!0) {\n      var { done, value } = await reader.readMany();\n      if (this.#aborted)\n        return;\n      if (done) {\n        this.push(null), this.destroy();\n        break;\n      }\n      for (var v of value)\n        this.push(v);\n    }\n  }\n  _read(size) {\n    if (this.#noBody)\n      this.push(null), this.complete = !0;\n    else if (this.#bodyStream == null) {\n      const reader = this.#req.body\?.getReader();\n      if (!reader) {\n        this.push(null);\n        return;\n      }\n      this.#bodyStream = reader, this.#consumeStream(reader);\n    }\n  }\n  get aborted() {\n    return this.#aborted;\n  }\n  #abort() {\n    if (this.#aborted)\n      return;\n    this.#aborted = !0;\n    var bodyStream = this.#bodyStream;\n    if (!bodyStream)\n      return;\n    bodyStream.cancel(), this.complete = !0, this.#bodyStream = @undefined, this.push(null);\n  }\n  get connection() {\n    return this.#fakeSocket;\n  }\n  get statusCode() {\n    return this.#req.status;\n  }\n  get statusMessage() {\n    return STATUS_CODES[this.#req.status];\n  }\n  get httpVersion() {\n    return \"1.1\";\n  }\n  get rawTrailers() {\n    return [];\n  }\n  get httpVersionMajor() {\n    return 1;\n  }\n  get httpVersionMinor() {\n    return 1;\n  }\n  get trailers() {\n    return kEmptyObject;\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n}\n\nclass OutgoingMessage extends Writable {\n  constructor() {\n    super(...arguments);\n  }\n  #headers;\n  headersSent = !1;\n  sendDate = !0;\n  req;\n  timeout;\n  #finished = !1;\n  [kEndCalled] = !1;\n  #fakeSocket;\n  #timeoutTimer;\n  [kAbortController] = null;\n  _implicitHeader() {\n  }\n  get headers() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  get connection() {\n    return this.socket;\n  }\n  get finished() {\n    return this.#finished;\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return headers.set(name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.removeAllListeners(\"timeout\"), this.#timeoutTimer = @undefined;\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar OriginalWriteHeadFn, OriginalImplicitHeadFn;\n\nclass ServerResponse extends Writable {\n  constructor(c) {\n    super();\n    if (!c)\n      c = {};\n    var req = c.req || {}, reply = c.reply;\n    if (this.req = req, this._reply = reply, this.sendDate = !0, this.statusCode = 200, this.headersSent = !1, this.statusMessage = @undefined, this.#controller = @undefined, this.#firstWrite = @undefined, this._writableState.decodeStrings = !1, this.#deferred = @undefined, req.method === \"HEAD\")\n      this._hasBody = !1;\n  }\n  req;\n  _reply;\n  sendDate;\n  statusCode;\n  #headers;\n  headersSent = !1;\n  statusMessage;\n  #controller;\n  #firstWrite;\n  _sent100 = !1;\n  _defaultKeepAlive = !1;\n  _removedConnection = !1;\n  _removedContLen = !1;\n  _hasBody = !0;\n  #deferred = @undefined;\n  #finished = !1;\n  _implicitHeader() {\n    this.writeHead(this.statusCode);\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#firstWrite && !this.headersSent) {\n      this.#firstWrite = chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      controller.write(chunk), callback();\n    });\n  }\n  _writev(chunks, callback) {\n    if (chunks.length === 1 && !this.headersSent && !this.#firstWrite) {\n      this.#firstWrite = chunks[0].chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      for (let chunk of chunks)\n        controller.write(chunk.chunk);\n      callback();\n    });\n  }\n  #ensureReadableStreamController(run) {\n    var thisController = this.#controller;\n    if (thisController)\n      return run(thisController);\n    this.headersSent = !0;\n    var firstWrite = this.#firstWrite;\n    this.#firstWrite = @undefined, this._reply(new Response(new @ReadableStream({\n      type: \"direct\",\n      pull: (controller) => {\n        if (this.#controller = controller, firstWrite)\n          controller.write(firstWrite);\n        if (firstWrite = @undefined, run(controller), !this.#finished)\n          return new @Promise((resolve) => {\n            this.#deferred = resolve;\n          });\n      }\n    }), {\n      headers: this.#headers,\n      status: this.statusCode,\n      statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n    }));\n  }\n  #drainHeadersIfObservable() {\n    if (this._implicitHeader === OriginalImplicitHeadFn && this.writeHead === OriginalWriteHeadFn)\n      return;\n    this._implicitHeader();\n  }\n  _final(callback) {\n    if (!this.headersSent) {\n      var data = this.#firstWrite || \"\";\n      this.#firstWrite = @undefined, this.#finished = !0, this.#drainHeadersIfObservable(), this._reply(new Response(data, {\n        headers: this.#headers,\n        status: this.statusCode,\n        statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n      })), callback && callback();\n      return;\n    }\n    this.#finished = !0, this.#ensureReadableStreamController((controller) => {\n      controller.end(), callback();\n      var deferred = this.#deferred;\n      if (deferred)\n        this.#deferred = @undefined, deferred();\n    });\n  }\n  writeProcessing() {\n    throw new Error(\"not implemented\");\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  assignSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  detachSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  writeContinue(callback) {\n    throw new Error(\"not implemented\");\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    var headers = this.#headers;\n    if (!headers)\n      return kEmptyObject;\n    return headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return setHeader(headers, name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  writeHead(statusCode, statusMessage, headers) {\n    return _writeHead(statusCode, statusMessage, headers, this), this;\n  }\n}\nOriginalWriteHeadFn = ServerResponse.prototype.writeHead;\nOriginalImplicitHeadFn = ServerResponse.prototype._implicitHeader;\n\nclass ClientRequest extends OutgoingMessage {\n  #timeout;\n  #res = null;\n  #upgradeOrConnect = !1;\n  #parser = null;\n  #maxHeadersCount = null;\n  #reusedSocket = !1;\n  #host;\n  #protocol;\n  #method;\n  #port;\n  #useDefaultPort;\n  #joinDuplicateHeaders;\n  #maxHeaderSize;\n  #agent = globalAgent;\n  #path;\n  #socketPath;\n  #bodyChunks = null;\n  #fetchRequest;\n  #signal = null;\n  [kAbortController] = null;\n  #timeoutTimer = @undefined;\n  #options;\n  #finished;\n  get path() {\n    return this.#path;\n  }\n  get port() {\n    return this.#port;\n  }\n  get method() {\n    return this.#method;\n  }\n  get host() {\n    return this.#host;\n  }\n  get protocol() {\n    return this.#protocol;\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = [chunk], callback();\n      return;\n    }\n    this.#bodyChunks.push(chunk), callback();\n  }\n  _writev(chunks, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = chunks, callback();\n      return;\n    }\n    this.#bodyChunks.push(...chunks), callback();\n  }\n  _final(callback) {\n    if (this.#finished = !0, this[kAbortController] = new AbortController, this[kAbortController].signal.addEventListener(\"abort\", () => {\n      this[kClearTimeout]();\n    }), this.#signal\?.aborted)\n      this[kAbortController].abort();\n    var method = this.#method, body = this.#bodyChunks\?.length === 1 \? this.#bodyChunks[0] : @Buffer.concat(this.#bodyChunks || []);\n    let url, proxy;\n    if (this.#path.startsWith(\"http://\") || this.#path.startsWith(\"https://\"))\n      url = this.#path, proxy = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}`;\n    else\n      url = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}${this.#path}`;\n    try {\n      this.#fetchRequest = fetch(url, {\n        method,\n        headers: this.getHeaders(),\n        body: body && method !== \"GET\" && method !== \"HEAD\" && method !== \"OPTIONS\" \? body : @undefined,\n        redirect: \"manual\",\n        verbose: !1,\n        signal: this[kAbortController].signal,\n        proxy,\n        timeout: !1,\n        decompress: !1\n      }).then((response) => {\n        var res = this.#res = new IncomingMessage(response, {\n          type: \"response\",\n          [kInternalRequest]: this\n        });\n        this.emit(\"response\", res);\n      }).catch((err) => {\n        this.emit(\"error\", err);\n      }).finally(() => {\n        this.#fetchRequest = null, this[kClearTimeout]();\n      });\n    } catch (err) {\n      this.emit(\"error\", err);\n    } finally {\n      callback();\n    }\n  }\n  get aborted() {\n    return this.#signal\?.aborted || !!this[kAbortController]\?.signal.aborted;\n  }\n  abort() {\n    if (this.aborted)\n      return;\n    this[kAbortController].abort();\n  }\n  constructor(input, options, cb) {\n    super();\n    if (typeof input === \"string\") {\n      const urlStr = input;\n      try {\n        var urlObject = new URL(urlStr);\n      } catch (e) {\n        @throwTypeError(`Invalid URL: ${urlStr}`);\n      }\n      input = urlToHttpOptions(urlObject);\n    } else if (input && typeof input === \"object\" && input instanceof URL)\n      input = urlToHttpOptions(input);\n    else\n      cb = options, options = input, input = null;\n    if (typeof options === \"function\")\n      cb = options, options = input || kEmptyObject;\n    else\n      options = ObjectAssign(input || {}, options);\n    var defaultAgent = options._defaultAgent || Agent.globalAgent;\n    let protocol = options.protocol;\n    if (!protocol)\n      if (options.port === 443)\n        protocol = \"https:\";\n      else\n        protocol = defaultAgent.protocol || \"http:\";\n    switch (this.#protocol = protocol, this.#agent\?.protocol) {\n      case @undefined:\n        break;\n      case \"http:\":\n        if (protocol === \"https:\") {\n          defaultAgent = this.#agent = getDefaultHTTPSAgent();\n          break;\n        }\n      case \"https:\":\n        if (protocol === \"https\") {\n          defaultAgent = this.#agent = Agent.globalAgent;\n          break;\n        }\n      default:\n        break;\n    }\n    if (options.path) {\n      const path = @String(options.path);\n      if (RegExpPrototypeExec.call(INVALID_PATH_REGEX, path) !== null)\n        throw new Error(\"Path contains unescaped characters\");\n    }\n    if (protocol !== \"http:\" && protocol !== \"https:\" && protocol) {\n      const expectedProtocol = defaultAgent\?.protocol \?\? \"http:\";\n      throw new Error(`Protocol mismatch. Expected: ${expectedProtocol}. Got: ${protocol}`);\n    }\n    const defaultPort = protocol === \"https:\" \? 443 : 80;\n    this.#port = options.port || options.defaultPort || this.#agent\?.defaultPort || defaultPort, this.#useDefaultPort = this.#port === defaultPort;\n    const host = this.#host = options.host = validateHost(options.hostname, \"hostname\") || validateHost(options.host, \"host\") || \"localhost\";\n    this.#socketPath = options.socketPath;\n    const signal = options.signal;\n    if (signal)\n      signal.addEventListener(\"abort\", () => {\n        this[kAbortController]\?.abort();\n      }), this.#signal = signal;\n    let method = options.method;\n    const methodIsString = typeof method === \"string\";\n    if (method !== null && method !== @undefined && !methodIsString)\n      throw new Error(\"ERR_INVALID_ARG_TYPE: options.method\");\n    if (methodIsString && method) {\n      if (!checkIsHttpToken(method))\n        throw new Error(\"ERR_INVALID_HTTP_TOKEN: Method\");\n      method = this.#method = StringPrototypeToUpperCase.call(method);\n    } else\n      method = this.#method = \"GET\";\n    const _maxHeaderSize = options.maxHeaderSize;\n    this.#maxHeaderSize = _maxHeaderSize;\n    var _joinDuplicateHeaders = options.joinDuplicateHeaders;\n    if (this.#joinDuplicateHeaders = _joinDuplicateHeaders, this.#path = options.path || \"/\", cb)\n      this.once(\"response\", cb);\n    this.#finished = !1, this.#res = null, this.#upgradeOrConnect = !1, this.#parser = null, this.#maxHeadersCount = null, this.#reusedSocket = !1, this.#host = host, this.#protocol = protocol;\n    var timeout = options.timeout;\n    if (timeout !== @undefined && timeout !== 0)\n      this.setTimeout(timeout, @undefined);\n    if (!ArrayIsArray(headers)) {\n      var headers = options.headers;\n      if (headers)\n        for (let key in headers)\n          this.setHeader(key, headers[key]);\n      var auth = options.auth;\n      if (auth && !this.getHeader(\"Authorization\"))\n        this.setHeader(\"Authorization\", \"Basic \" + @Buffer.from(auth).toString(\"base64\"));\n    }\n    var { signal: _signal, ...optsWithoutSignal } = options;\n    this.#options = optsWithoutSignal;\n  }\n  setSocketKeepAlive(enable = !0, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.#timeoutTimer = @undefined, this.removeAllListeners(\"timeout\");\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar tokenRegExp = /^[\\^_`a-zA-Z\\-0-9!#$%&'*+.|~]+$/, METHODS = [\n  \"ACL\",\n  \"BIND\",\n  \"CHECKOUT\",\n  \"CONNECT\",\n  \"COPY\",\n  \"DELETE\",\n  \"GET\",\n  \"HEAD\",\n  \"LINK\",\n  \"LOCK\",\n  \"M-SEARCH\",\n  \"MERGE\",\n  \"MKACTIVITY\",\n  \"MKCALENDAR\",\n  \"MKCOL\",\n  \"MOVE\",\n  \"NOTIFY\",\n  \"OPTIONS\",\n  \"PATCH\",\n  \"POST\",\n  \"PROPFIND\",\n  \"PROPPATCH\",\n  \"PURGE\",\n  \"PUT\",\n  \"REBIND\",\n  \"REPORT\",\n  \"SEARCH\",\n  \"SOURCE\",\n  \"SUBSCRIBE\",\n  \"TRACE\",\n  \"UNBIND\",\n  \"UNLINK\",\n  \"UNLOCK\",\n  \"UNSUBSCRIBE\"\n], STATUS_CODES = {\n  100: \"Continue\",\n  101: \"Switching Protocols\",\n  102: \"Processing\",\n  103: \"Early Hints\",\n  200: \"OK\",\n  201: \"Created\",\n  202: \"Accepted\",\n  203: \"Non-Authoritative Information\",\n  204: \"No Content\",\n  205: \"Reset Content\",\n  206: \"Partial Content\",\n  207: \"Multi-Status\",\n  208: \"Already Reported\",\n  226: \"IM Used\",\n  300: \"Multiple Choices\",\n  301: \"Moved Permanently\",\n  302: \"Found\",\n  303: \"See Other\",\n  304: \"Not Modified\",\n  305: \"Use Proxy\",\n  307: \"Temporary Redirect\",\n  308: \"Permanent Redirect\",\n  400: \"Bad Request\",\n  401: \"Unauthorized\",\n  402: \"Payment Required\",\n  403: \"Forbidden\",\n  404: \"Not Found\",\n  405: \"Method Not Allowed\",\n  406: \"Not Acceptable\",\n  407: \"Proxy Authentication Required\",\n  408: \"Request Timeout\",\n  409: \"Conflict\",\n  410: \"Gone\",\n  411: \"Length Required\",\n  412: \"Precondition Failed\",\n  413: \"Payload Too Large\",\n  414: \"URI Too Long\",\n  415: \"Unsupported Media Type\",\n  416: \"Range Not Satisfiable\",\n  417: \"Expectation Failed\",\n  418: \"I'm a Teapot\",\n  421: \"Misdirected Request\",\n  422: \"Unprocessable Entity\",\n  423: \"Locked\",\n  424: \"Failed Dependency\",\n  425: \"Too Early\",\n  426: \"Upgrade Required\",\n  428: \"Precondition Required\",\n  429: \"Too Many Requests\",\n  431: \"Request Header Fields Too Large\",\n  451: \"Unavailable For Legal Reasons\",\n  500: \"Internal Server Error\",\n  501: \"Not Implemented\",\n  502: \"Bad Gateway\",\n  503: \"Service Unavailable\",\n  504: \"Gateway Timeout\",\n  505: \"HTTP Version Not Supported\",\n  506: \"Variant Also Negotiates\",\n  507: \"Insufficient Storage\",\n  508: \"Loop Detected\",\n  509: \"Bandwidth Limit Exceeded\",\n  510: \"Not Extended\",\n  511: \"Network Authentication Required\"\n}, globalAgent = new Agent;\n$ = {\n  Agent,\n  Server,\n  METHODS,\n  STATUS_CODES,\n  createServer,\n  ServerResponse,\n  IncomingMessage,\n  request,\n  get,\n  maxHeaderSize: 16384,\n  validateHeaderName,\n  validateHeaderValue,\n  setMaxIdleHTTPParsers(max) {\n  },\n  globalAgent,\n  ClientRequest,\n  OutgoingMessage\n};\nreturn $})\n"_s;
 //
 
 //
@@ -363,7 +363,7 @@ static constexpr ASCIILiteral NodeInspectorCode = "(function (){\"use strict\";/
 //
 
 //
-static constexpr ASCIILiteral NodeNetCode = "(function (){\"use strict\";// src/js/out/tmp/node/net.ts\nvar isIPv4 = function(s) {\n  return IPv4Reg.test(s);\n}, isIPv6 = function(s) {\n  return IPv6Reg.test(s);\n}, isIP = function(s) {\n  if (isIPv4(s))\n    return 4;\n  if (isIPv6(s))\n    return 6;\n  return 0;\n}, endNT = function(socket, callback, err) {\n  socket.end(), callback(err);\n}, createConnection = function(port, host, connectListener) {\n  if (typeof port === \"object\")\n    return new Socket(port).connect(port, host, connectListener);\n  return new Socket().connect(port, host, connectListener);\n}, emitErrorNextTick = function(self, error) {\n  self.emit(\"error\", error);\n}, emitErrorAndCloseNextTick = function(self, error) {\n  self.emit(\"error\", error), self.emit(\"close\");\n}, emitListeningNextTick = function(self, onListen) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen();\n    } catch (err) {\n      self.emit(\"error\", err);\n    }\n  self.emit(\"listening\");\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, $, { Duplex } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20);\nvar IPv4Reg = new @RegExp(\"^((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$\");\nvar IPv6Reg = new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\"), { connect: bunConnect } = Bun, { setTimeout } = globalThis, bunTlsSymbol = Symbol.for(\"::buntls::\"), bunSocketServerHandlers = Symbol.for(\"::bunsocket_serverhandlers::\"), bunSocketServerConnections = Symbol.for(\"::bunnetserverconnections::\"), bunSocketServerOptions = Symbol.for(\"::bunnetserveroptions::\"), bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), bunTLSConnectOptions = Symbol.for(\"::buntlsconnectoptions::\"), SocketClass, Socket = function(InternalSocket) {\n  return SocketClass = InternalSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"Socket\",\n    enumerable: !1\n  }), Object.defineProperty(function Socket(options) {\n    return new InternalSocket(options);\n  }, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalSocket;\n    }\n  });\n}(class Socket2 extends Duplex {\n  static #Handlers = {\n    close: Socket2.#Close,\n    data({ data: self }, buffer) {\n      self.bytesRead += buffer.length;\n      const queue = self.#readQueue;\n      if (queue.isEmpty()) {\n        if (self.push(buffer))\n          return;\n      }\n      queue.push(buffer);\n    },\n    drain: Socket2.#Drain,\n    end: Socket2.#Close,\n    error(socket, error) {\n      const self = socket.data, callback = self.#writeCallback;\n      if (callback)\n        self.#writeCallback = null, callback(error);\n      self.emit(\"error\", error);\n    },\n    open(socket) {\n      const self = socket.data;\n      socket.timeout(self.timeout), socket.ref(), self[bunSocketInternal] = socket, self.connecting = !1;\n      const options = self[bunTLSConnectOptions];\n      if (options) {\n        const { session } = options;\n        if (session)\n          self.setSession(session);\n      }\n      if (!self.#upgraded)\n        self.emit(\"connect\", self);\n      Socket2.#Drain(socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self.emit(\"secure\", self);\n      const { checkServerIdentity } = self[bunTLSConnectOptions];\n      if (!verifyError && typeof checkServerIdentity === \"function\" && self.servername) {\n        const cert = self.getPeerCertificate(!0);\n        verifyError = checkServerIdentity(self.servername, cert);\n      }\n      if (self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnect\", verifyError);\n    },\n    timeout(socket) {\n      const self = socket.data;\n      self.emit(\"timeout\", self);\n    },\n    binaryType: \"buffer\"\n  };\n  static #Close(socket) {\n    const self = socket.data;\n    if (self.#closed)\n      return;\n    self.#closed = !0, self[bunSocketInternal] = null;\n    const queue = self.#readQueue;\n    if (queue.isEmpty()) {\n      if (self.push(null))\n        return;\n    }\n    queue.push(null);\n  }\n  static #Drain(socket) {\n    const self = socket.data, callback = self.#writeCallback;\n    if (callback) {\n      const chunk = self.#writeChunk, written = socket.write(chunk);\n      if (self.bytesWritten += written, written < chunk.length)\n        self.#writeChunk = chunk.slice(written);\n      else\n        self.#writeCallback = null, self.#writeChunk = null, callback(null);\n    }\n  }\n  static [bunSocketServerHandlers] = {\n    data: Socket2.#Handlers.data,\n    close(socket) {\n      Socket2.#Handlers.close(socket), this.data[bunSocketServerConnections]--;\n    },\n    end(socket) {\n      Socket2.#Handlers.end(socket), this.data[bunSocketServerConnections]--;\n    },\n    open(socket) {\n      const self = this.data, options = self[bunSocketServerOptions], { pauseOnConnect, connectionListener, InternalSocketClass, requestCert, rejectUnauthorized } = options, _socket = new InternalSocketClass({});\n      if (_socket.isServer = !0, _socket._requestCert = requestCert, _socket._rejectUnauthorized = rejectUnauthorized, _socket.#attach(this.localPort, socket), self.maxConnections && self[bunSocketServerConnections] >= self.maxConnections) {\n        const data = {\n          localAddress: _socket.localAddress,\n          localPort: _socket.localPort,\n          localFamily: _socket.localFamily,\n          remoteAddress: _socket.remoteAddress,\n          remotePort: _socket.remotePort,\n          remoteFamily: _socket.remoteFamily || \"IPv4\"\n        };\n        socket.end(), self.emit(\"drop\", data);\n        return;\n      }\n      if (!pauseOnConnect)\n        _socket.resume();\n      if (self[bunSocketServerConnections]++, typeof connectionListener == \"function\")\n        if (InternalSocketClass.name === \"TLSSocket\")\n          self.once(\"secureConnection\", () => connectionListener(_socket));\n        else\n          connectionListener(_socket);\n      self.emit(\"connection\", _socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      if (self.emit(\"secure\", self), self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnection\", verifyError);\n    },\n    error(socket, error) {\n      Socket2.#Handlers.error(socket, error), this.data.emit(\"error\", error);\n    },\n    timeout: Socket2.#Handlers.timeout,\n    connectError: Socket2.#Handlers.connectError,\n    drain: Socket2.#Handlers.drain,\n    binaryType: \"buffer\"\n  };\n  bytesRead = 0;\n  bytesWritten = 0;\n  #closed = !1;\n  connecting = !1;\n  localAddress = \"127.0.0.1\";\n  #readQueue = @createFIFO();\n  remotePort;\n  [bunSocketInternal] = null;\n  [bunTLSConnectOptions] = null;\n  timeout = 0;\n  #writeCallback;\n  #writeChunk;\n  #pendingRead;\n  isServer = !1;\n  _handle;\n  _parent;\n  _parentWrap;\n  #socket;\n  #upgraded;\n  constructor(options) {\n    const { socket, signal, write, read, allowHalfOpen = !1, ...opts } = options || {};\n    super({\n      ...opts,\n      allowHalfOpen,\n      readable: !0,\n      writable: !0\n    });\n    if (this._handle = this, this._parent = this, this._parentWrap = this, this.#pendingRead = @undefined, this.#upgraded = !1, socket instanceof Socket2)\n      this.#socket = socket;\n    signal\?.once(\"abort\", () => this.destroy()), this.once(\"connect\", () => this.emit(\"ready\"));\n  }\n  address() {\n    return {\n      address: this.localAddress,\n      family: this.localFamily,\n      port: this.localPort\n    };\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  #attach(port, socket) {\n    if (this.remotePort = port, socket.data = this, socket.timeout(this.timeout), socket.ref(), this[bunSocketInternal] = socket, this.connecting = !1, !this.#upgraded)\n      this.emit(\"connect\", this);\n    Socket2.#Drain(socket);\n  }\n  connect(port, host, connectListener) {\n    var path, connection = this.#socket, _checkServerIdentity = @undefined;\n    if (typeof port === \"string\") {\n      if (path = port, port = @undefined, typeof host === \"function\")\n        connectListener = host, host = @undefined;\n    } else if (typeof host == \"function\") {\n      if (typeof port === \"string\")\n        path = port, port = @undefined;\n      connectListener = host, host = @undefined;\n    }\n    if (typeof port == \"object\") {\n      var {\n        port,\n        host,\n        path,\n        socket,\n        localAddress,\n        localPort,\n        family,\n        hints,\n        lookup,\n        noDelay,\n        keepAlive,\n        keepAliveInitialDelay,\n        requestCert,\n        rejectUnauthorized,\n        pauseOnConnect,\n        servername,\n        checkServerIdentity,\n        session\n      } = port;\n      if (_checkServerIdentity = checkServerIdentity, this.servername = servername, socket)\n        connection = socket;\n    }\n    if (!pauseOnConnect)\n      this.resume();\n    this.connecting = !0, this.remotePort = port;\n    const bunTLS = this[bunTlsSymbol];\n    var tls = @undefined;\n    if (typeof bunTLS === \"function\") {\n      if (tls = bunTLS.call(this, port, host, !0), this._requestCert = !0, this._rejectUnauthorized = rejectUnauthorized, tls) {\n        if (tls.rejectUnauthorized = rejectUnauthorized, tls.requestCert = !0, tls.session = session || tls.session, this.servername = tls.servername, tls.checkServerIdentity = _checkServerIdentity || tls.checkServerIdentity, this[bunTLSConnectOptions] = tls, !connection && tls.socket)\n          connection = tls.socket;\n      }\n      if (connection) {\n        if (typeof connection !== \"object\" || !(connection instanceof Socket2) || typeof connection[bunTlsSymbol] === \"function\")\n          @throwTypeError(\"socket must be an instance of net.Socket\");\n      }\n      if (this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, connectListener)\n        this.on(\"secureConnect\", connectListener);\n    } else if (connectListener)\n      this.on(\"connect\", connectListener);\n    try {\n      if (connection) {\n        const socket2 = connection[bunSocketInternal];\n        if (socket2) {\n          this.connecting = !0, this.#upgraded = !0;\n          const result = socket2.upgradeTLS({\n            data: this,\n            tls,\n            socket: Socket2.#Handlers\n          });\n          if (result) {\n            const [raw, tls2] = result;\n            connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n          } else\n            throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n        } else\n          connection.once(\"connect\", () => {\n            const socket3 = connection[bunSocketInternal];\n            if (!socket3)\n              return;\n            this.connecting = !0, this.#upgraded = !0;\n            const result = socket3.upgradeTLS({\n              data: this,\n              tls,\n              socket: Socket2.#Handlers\n            });\n            if (result) {\n              const [raw, tls2] = result;\n              connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n            } else\n              throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n          });\n      } else if (path)\n        bunConnect({\n          data: this,\n          unix: path,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n      else\n        bunConnect({\n          data: this,\n          hostname: host || \"localhost\",\n          port,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n    } catch (error) {\n      process.nextTick(emitErrorAndCloseNextTick, this, error);\n    }\n    return this;\n  }\n  _destroy(err, callback) {\n    const socket = this[bunSocketInternal];\n    socket && process.nextTick(endNT, socket, callback, err);\n  }\n  _final(callback) {\n    this[bunSocketInternal]\?.end(), callback();\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return this[bunSocketInternal]\?.localPort;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n    const queue = this.#readQueue;\n    let chunk;\n    while (chunk = queue.peek()) {\n      if (!this.push(chunk))\n        return;\n      queue.shift();\n    }\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n    this[bunSocketInternal]\?.ref();\n  }\n  get remoteAddress() {\n    return this[bunSocketInternal]\?.remoteAddress;\n  }\n  get remoteFamily() {\n    return \"IPv4\";\n  }\n  resetAndDestroy() {\n    this[bunSocketInternal]\?.end();\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n    return this;\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    if (this[bunSocketInternal]\?.timeout(timeout), this.timeout = timeout, callback)\n      this.once(\"timeout\", callback);\n    return this;\n  }\n  unref() {\n    this[bunSocketInternal]\?.unref();\n  }\n  _write(chunk, encoding, callback) {\n    if (typeof chunk == \"string\" && encoding !== \"ascii\")\n      chunk = @Buffer.from(chunk, encoding);\n    var written = this[bunSocketInternal]\?.write(chunk);\n    if (written == chunk.length)\n      callback();\n    else if (this.#writeCallback)\n      callback(new Error(\"overlapping _write()\"));\n    else {\n      if (written > 0)\n        if (typeof chunk == \"string\")\n          chunk = chunk.slice(written);\n        else\n          chunk = chunk.subarray(written);\n      this.#writeCallback = callback, this.#writeChunk = chunk;\n    }\n  }\n}), connect = createConnection;\n\nclass Server extends EventEmitter {\n  #server;\n  #listening = !1;\n  [bunSocketServerConnections] = 0;\n  [bunSocketServerOptions];\n  maxConnections = 0;\n  constructor(options, connectionListener) {\n    super();\n    if (typeof options === \"function\")\n      connectionListener = options, options = {};\n    else if (options == null || typeof options === \"object\")\n      options = { ...options };\n    else\n      throw new Error(\"bun-net-polyfill: invalid arguments\");\n    const { maxConnections } = options;\n    this.maxConnections = Number.isSafeInteger(maxConnections) && maxConnections > 0 \? maxConnections : 0, options.connectionListener = connectionListener, this[bunSocketServerOptions] = options;\n  }\n  ref() {\n    return this.#server\?.ref(), this;\n  }\n  unref() {\n    return this.#server\?.unref(), this;\n  }\n  close(callback) {\n    if (this.#server) {\n      if (this.#server.stop(!0), this.#server = null, this.#listening = !1, this[bunSocketServerConnections] = 0, this.emit(\"close\"), typeof callback === \"function\")\n        callback();\n      return this;\n    }\n    if (typeof callback === \"function\") {\n      const error = new Error(\"Server is not running\");\n      error.code = \"ERR_SERVER_NOT_RUNNING\", callback(error);\n    }\n    return this;\n  }\n  address() {\n    const server = this.#server;\n    if (server) {\n      const unix = server.unix;\n      if (unix)\n        return unix;\n      let address = server.hostname;\n      const type = isIP(address), port = server.port;\n      if (typeof port === \"number\")\n        return {\n          port,\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      if (type)\n        return {\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      return address;\n    }\n    return null;\n  }\n  getConnections(callback) {\n    if (typeof callback === \"function\")\n      callback(null, this.#server \? this[bunSocketServerConnections] : 0);\n    return this;\n  }\n  listen(port, hostname, onListen) {\n    let backlog, path, exclusive = !1;\n    if (typeof port === \"string\") {\n      if (Number.isSafeInteger(hostname)) {\n        if (hostname > 0)\n          backlog = hostname;\n      } else if (typeof hostname === \"function\")\n        onListen = hostname;\n      path = port, hostname = @undefined, port = @undefined;\n    } else {\n      if (typeof hostname === \"function\")\n        onListen = hostname, hostname = @undefined;\n      if (typeof port === \"function\")\n        onListen = port, port = 0;\n      else if (typeof port === \"object\") {\n        const options = port;\n        options.signal\?.addEventListener(\"abort\", () => this.close()), hostname = options.host, exclusive = options.exclusive === !0;\n        const path2 = options.path;\n        if (port = options.port, !Number.isSafeInteger(port) || port < 0)\n          if (path2)\n            hostname = path2, port = @undefined;\n          else {\n            let message = 'The argument \\'options\\' must have the property \"port\" or \"path\"';\n            try {\n              message = `${message}. Received ${JSON.stringify(options)}`;\n            } catch {\n            }\n            const error = @makeTypeError(message);\n            throw error.code = \"ERR_INVALID_ARG_VALUE\", error;\n          }\n        else if (!Number.isSafeInteger(port) || port < 0)\n          port = 0;\n        if (typeof port.callback === \"function\")\n          onListen = port\?.callback;\n      } else if (!Number.isSafeInteger(port) || port < 0)\n        port = 0;\n      hostname = hostname || \"::\";\n    }\n    try {\n      var tls = @undefined, TLSSocketClass = @undefined;\n      const bunTLS = this[bunTlsSymbol], options = this[bunSocketServerOptions];\n      if (typeof bunTLS === \"function\")\n        [tls, TLSSocketClass] = bunTLS.call(this, port, hostname, !1), options.servername = tls.serverName, options.InternalSocketClass = TLSSocketClass;\n      else\n        options.InternalSocketClass = SocketClass;\n      this.#server = Bun.listen(path \? {\n        exclusive,\n        unix: path,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      } : {\n        exclusive,\n        port,\n        hostname,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      }), this.#server.data = this, this.#listening = !0, setTimeout(emitListeningNextTick, 1, this, onListen);\n    } catch (err) {\n      this.#listening = !1, setTimeout(emitErrorNextTick, 1, this, err);\n    }\n    return this;\n  }\n}\n$ = {\n  createServer,\n  Server,\n  createConnection,\n  connect,\n  isIP,\n  isIPv4,\n  isIPv6,\n  Socket,\n  [Symbol.for(\"::bunternal::\")]: SocketClass\n};\nreturn $})\n"_s;
+static constexpr ASCIILiteral NodeNetCode = "(function (){\"use strict\";// src/js/out/tmp/node/net.ts\nvar isIPv4 = function(s) {\n  return IPv4Reg.test(s);\n}, isIPv6 = function(s) {\n  return IPv6Reg.test(s);\n}, isIP = function(s) {\n  if (isIPv4(s))\n    return 4;\n  if (isIPv6(s))\n    return 6;\n  return 0;\n}, endNT = function(socket, callback, err) {\n  socket.end(), callback(err);\n}, createConnection = function(port, host, connectListener) {\n  if (typeof port === \"object\")\n    return new Socket(port).connect(port, host, connectListener);\n  return new Socket().connect(port, host, connectListener);\n}, emitErrorNextTick = function(self, error) {\n  self.emit(\"error\", error);\n}, emitErrorAndCloseNextTick = function(self, error) {\n  self.emit(\"error\", error), self.emit(\"close\");\n}, emitListeningNextTick = function(self, onListen) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen();\n    } catch (err) {\n      self.emit(\"error\", err);\n    }\n  self.emit(\"listening\");\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, $, { Duplex } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20);\nvar IPv4Reg = new @RegExp(\"^((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$\");\nvar IPv6Reg = new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\"), { connect: bunConnect } = Bun, { setTimeout } = globalThis, bunTlsSymbol = Symbol.for(\"::buntls::\"), bunSocketServerHandlers = Symbol.for(\"::bunsocket_serverhandlers::\"), bunSocketServerConnections = Symbol.for(\"::bunnetserverconnections::\"), bunSocketServerOptions = Symbol.for(\"::bunnetserveroptions::\"), bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), bunTLSConnectOptions = Symbol.for(\"::buntlsconnectoptions::\"), SocketClass, Socket = function(InternalSocket) {\n  SocketClass = InternalSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"Socket\",\n    enumerable: !1\n  });\n  function Socket3(options) {\n    return new InternalSocket(options);\n  }\n  return Socket3.prototype = InternalSocket.prototype, Object.defineProperty(Socket3, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalSocket;\n    }\n  });\n}(class Socket2 extends Duplex {\n  static #Handlers = {\n    close: Socket2.#Close,\n    data({ data: self }, buffer) {\n      self.bytesRead += buffer.length;\n      const queue = self.#readQueue;\n      if (queue.isEmpty()) {\n        if (self.push(buffer))\n          return;\n      }\n      queue.push(buffer);\n    },\n    drain: Socket2.#Drain,\n    end: Socket2.#Close,\n    error(socket, error) {\n      const self = socket.data, callback = self.#writeCallback;\n      if (callback)\n        self.#writeCallback = null, callback(error);\n      self.emit(\"error\", error);\n    },\n    open(socket) {\n      const self = socket.data;\n      socket.timeout(self.timeout), socket.ref(), self[bunSocketInternal] = socket, self.connecting = !1;\n      const options = self[bunTLSConnectOptions];\n      if (options) {\n        const { session } = options;\n        if (session)\n          self.setSession(session);\n      }\n      if (!self.#upgraded)\n        self.emit(\"connect\", self);\n      Socket2.#Drain(socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self.emit(\"secure\", self);\n      const { checkServerIdentity } = self[bunTLSConnectOptions];\n      if (!verifyError && typeof checkServerIdentity === \"function\" && self.servername) {\n        const cert = self.getPeerCertificate(!0);\n        verifyError = checkServerIdentity(self.servername, cert);\n      }\n      if (self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnect\", verifyError);\n    },\n    timeout(socket) {\n      const self = socket.data;\n      self.emit(\"timeout\", self);\n    },\n    binaryType: \"buffer\"\n  };\n  static #Close(socket) {\n    const self = socket.data;\n    if (self.#closed)\n      return;\n    self.#closed = !0, self[bunSocketInternal] = null;\n    const queue = self.#readQueue;\n    if (queue.isEmpty()) {\n      if (self.push(null))\n        return;\n    }\n    queue.push(null);\n  }\n  static #Drain(socket) {\n    const self = socket.data, callback = self.#writeCallback;\n    if (callback) {\n      const chunk = self.#writeChunk, written = socket.write(chunk);\n      if (self.bytesWritten += written, written < chunk.length)\n        self.#writeChunk = chunk.slice(written);\n      else\n        self.#writeCallback = null, self.#writeChunk = null, callback(null);\n    }\n  }\n  static [bunSocketServerHandlers] = {\n    data: Socket2.#Handlers.data,\n    close(socket) {\n      Socket2.#Handlers.close(socket), this.data[bunSocketServerConnections]--;\n    },\n    end(socket) {\n      Socket2.#Handlers.end(socket), this.data[bunSocketServerConnections]--;\n    },\n    open(socket) {\n      const self = this.data, options = self[bunSocketServerOptions], { pauseOnConnect, connectionListener, InternalSocketClass, requestCert, rejectUnauthorized } = options, _socket = new InternalSocketClass({});\n      if (_socket.isServer = !0, _socket._requestCert = requestCert, _socket._rejectUnauthorized = rejectUnauthorized, _socket.#attach(this.localPort, socket), self.maxConnections && self[bunSocketServerConnections] >= self.maxConnections) {\n        const data = {\n          localAddress: _socket.localAddress,\n          localPort: _socket.localPort,\n          localFamily: _socket.localFamily,\n          remoteAddress: _socket.remoteAddress,\n          remotePort: _socket.remotePort,\n          remoteFamily: _socket.remoteFamily || \"IPv4\"\n        };\n        socket.end(), self.emit(\"drop\", data);\n        return;\n      }\n      if (!pauseOnConnect)\n        _socket.resume();\n      if (self[bunSocketServerConnections]++, typeof connectionListener == \"function\")\n        if (InternalSocketClass.name === \"TLSSocket\")\n          self.once(\"secureConnection\", () => connectionListener(_socket));\n        else\n          connectionListener(_socket);\n      self.emit(\"connection\", _socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      if (self.emit(\"secure\", self), self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnection\", verifyError);\n    },\n    error(socket, error) {\n      Socket2.#Handlers.error(socket, error), this.data.emit(\"error\", error);\n    },\n    timeout: Socket2.#Handlers.timeout,\n    connectError: Socket2.#Handlers.connectError,\n    drain: Socket2.#Handlers.drain,\n    binaryType: \"buffer\"\n  };\n  bytesRead = 0;\n  bytesWritten = 0;\n  #closed = !1;\n  connecting = !1;\n  localAddress = \"127.0.0.1\";\n  #readQueue = @createFIFO();\n  remotePort;\n  [bunSocketInternal] = null;\n  [bunTLSConnectOptions] = null;\n  timeout = 0;\n  #writeCallback;\n  #writeChunk;\n  #pendingRead;\n  isServer = !1;\n  _handle;\n  _parent;\n  _parentWrap;\n  #socket;\n  #upgraded;\n  constructor(options) {\n    const { socket, signal, write, read, allowHalfOpen = !1, ...opts } = options || {};\n    super({\n      ...opts,\n      allowHalfOpen,\n      readable: !0,\n      writable: !0\n    });\n    if (this._handle = this, this._parent = this, this._parentWrap = this, this.#pendingRead = @undefined, this.#upgraded = !1, socket instanceof Socket2)\n      this.#socket = socket;\n    signal\?.once(\"abort\", () => this.destroy()), this.once(\"connect\", () => this.emit(\"ready\"));\n  }\n  address() {\n    return {\n      address: this.localAddress,\n      family: this.localFamily,\n      port: this.localPort\n    };\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  #attach(port, socket) {\n    if (this.remotePort = port, socket.data = this, socket.timeout(this.timeout), socket.ref(), this[bunSocketInternal] = socket, this.connecting = !1, !this.#upgraded)\n      this.emit(\"connect\", this);\n    Socket2.#Drain(socket);\n  }\n  connect(port, host, connectListener) {\n    var path, connection = this.#socket, _checkServerIdentity = @undefined;\n    if (typeof port === \"string\") {\n      if (path = port, port = @undefined, typeof host === \"function\")\n        connectListener = host, host = @undefined;\n    } else if (typeof host == \"function\") {\n      if (typeof port === \"string\")\n        path = port, port = @undefined;\n      connectListener = host, host = @undefined;\n    }\n    if (typeof port == \"object\") {\n      var {\n        port,\n        host,\n        path,\n        socket,\n        localAddress,\n        localPort,\n        family,\n        hints,\n        lookup,\n        noDelay,\n        keepAlive,\n        keepAliveInitialDelay,\n        requestCert,\n        rejectUnauthorized,\n        pauseOnConnect,\n        servername,\n        checkServerIdentity,\n        session\n      } = port;\n      if (_checkServerIdentity = checkServerIdentity, this.servername = servername, socket)\n        connection = socket;\n    }\n    if (!pauseOnConnect)\n      this.resume();\n    this.connecting = !0, this.remotePort = port;\n    const bunTLS = this[bunTlsSymbol];\n    var tls = @undefined;\n    if (typeof bunTLS === \"function\") {\n      if (tls = bunTLS.call(this, port, host, !0), this._requestCert = !0, this._rejectUnauthorized = rejectUnauthorized, tls) {\n        if (tls.rejectUnauthorized = rejectUnauthorized, tls.requestCert = !0, tls.session = session || tls.session, this.servername = tls.servername, tls.checkServerIdentity = _checkServerIdentity || tls.checkServerIdentity, this[bunTLSConnectOptions] = tls, !connection && tls.socket)\n          connection = tls.socket;\n      }\n      if (connection) {\n        if (typeof connection !== \"object\" || !(connection instanceof Socket2) || typeof connection[bunTlsSymbol] === \"function\")\n          @throwTypeError(\"socket must be an instance of net.Socket\");\n      }\n      if (this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, connectListener)\n        this.on(\"secureConnect\", connectListener);\n    } else if (connectListener)\n      this.on(\"connect\", connectListener);\n    try {\n      if (connection) {\n        const socket2 = connection[bunSocketInternal];\n        if (socket2) {\n          this.connecting = !0, this.#upgraded = !0;\n          const result = socket2.upgradeTLS({\n            data: this,\n            tls,\n            socket: Socket2.#Handlers\n          });\n          if (result) {\n            const [raw, tls2] = result;\n            connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n          } else\n            throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n        } else\n          connection.once(\"connect\", () => {\n            const socket3 = connection[bunSocketInternal];\n            if (!socket3)\n              return;\n            this.connecting = !0, this.#upgraded = !0;\n            const result = socket3.upgradeTLS({\n              data: this,\n              tls,\n              socket: Socket2.#Handlers\n            });\n            if (result) {\n              const [raw, tls2] = result;\n              connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n            } else\n              throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n          });\n      } else if (path)\n        bunConnect({\n          data: this,\n          unix: path,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n      else\n        bunConnect({\n          data: this,\n          hostname: host || \"localhost\",\n          port,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n    } catch (error) {\n      process.nextTick(emitErrorAndCloseNextTick, this, error);\n    }\n    return this;\n  }\n  _destroy(err, callback) {\n    const socket = this[bunSocketInternal];\n    socket && process.nextTick(endNT, socket, callback, err);\n  }\n  _final(callback) {\n    this[bunSocketInternal]\?.end(), callback();\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return this[bunSocketInternal]\?.localPort;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n    const queue = this.#readQueue;\n    let chunk;\n    while (chunk = queue.peek()) {\n      if (!this.push(chunk))\n        return;\n      queue.shift();\n    }\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n    this[bunSocketInternal]\?.ref();\n  }\n  get remoteAddress() {\n    return this[bunSocketInternal]\?.remoteAddress;\n  }\n  get remoteFamily() {\n    return \"IPv4\";\n  }\n  resetAndDestroy() {\n    this[bunSocketInternal]\?.end();\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n    return this;\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    if (this[bunSocketInternal]\?.timeout(timeout), this.timeout = timeout, callback)\n      this.once(\"timeout\", callback);\n    return this;\n  }\n  unref() {\n    this[bunSocketInternal]\?.unref();\n  }\n  _write(chunk, encoding, callback) {\n    if (typeof chunk == \"string\" && encoding !== \"ascii\")\n      chunk = @Buffer.from(chunk, encoding);\n    var written = this[bunSocketInternal]\?.write(chunk);\n    if (written == chunk.length)\n      callback();\n    else if (this.#writeCallback)\n      callback(new Error(\"overlapping _write()\"));\n    else {\n      if (written > 0)\n        if (typeof chunk == \"string\")\n          chunk = chunk.slice(written);\n        else\n          chunk = chunk.subarray(written);\n      this.#writeCallback = callback, this.#writeChunk = chunk;\n    }\n  }\n}), connect = createConnection;\n\nclass Server extends EventEmitter {\n  #server;\n  #listening = !1;\n  [bunSocketServerConnections] = 0;\n  [bunSocketServerOptions];\n  maxConnections = 0;\n  constructor(options, connectionListener) {\n    super();\n    if (typeof options === \"function\")\n      connectionListener = options, options = {};\n    else if (options == null || typeof options === \"object\")\n      options = { ...options };\n    else\n      throw new Error(\"bun-net-polyfill: invalid arguments\");\n    const { maxConnections } = options;\n    this.maxConnections = Number.isSafeInteger(maxConnections) && maxConnections > 0 \? maxConnections : 0, options.connectionListener = connectionListener, this[bunSocketServerOptions] = options;\n  }\n  ref() {\n    return this.#server\?.ref(), this;\n  }\n  unref() {\n    return this.#server\?.unref(), this;\n  }\n  close(callback) {\n    if (this.#server) {\n      if (this.#server.stop(!0), this.#server = null, this.#listening = !1, this[bunSocketServerConnections] = 0, this.emit(\"close\"), typeof callback === \"function\")\n        callback();\n      return this;\n    }\n    if (typeof callback === \"function\") {\n      const error = new Error(\"Server is not running\");\n      error.code = \"ERR_SERVER_NOT_RUNNING\", callback(error);\n    }\n    return this;\n  }\n  address() {\n    const server = this.#server;\n    if (server) {\n      const unix = server.unix;\n      if (unix)\n        return unix;\n      let address = server.hostname;\n      const type = isIP(address), port = server.port;\n      if (typeof port === \"number\")\n        return {\n          port,\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      if (type)\n        return {\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      return address;\n    }\n    return null;\n  }\n  getConnections(callback) {\n    if (typeof callback === \"function\")\n      callback(null, this.#server \? this[bunSocketServerConnections] : 0);\n    return this;\n  }\n  listen(port, hostname, onListen) {\n    let backlog, path, exclusive = !1;\n    if (typeof port === \"string\") {\n      if (Number.isSafeInteger(hostname)) {\n        if (hostname > 0)\n          backlog = hostname;\n      } else if (typeof hostname === \"function\")\n        onListen = hostname;\n      path = port, hostname = @undefined, port = @undefined;\n    } else {\n      if (typeof hostname === \"function\")\n        onListen = hostname, hostname = @undefined;\n      if (typeof port === \"function\")\n        onListen = port, port = 0;\n      else if (typeof port === \"object\") {\n        const options = port;\n        options.signal\?.addEventListener(\"abort\", () => this.close()), hostname = options.host, exclusive = options.exclusive === !0;\n        const path2 = options.path;\n        if (port = options.port, !Number.isSafeInteger(port) || port < 0)\n          if (path2)\n            hostname = path2, port = @undefined;\n          else {\n            let message = 'The argument \\'options\\' must have the property \"port\" or \"path\"';\n            try {\n              message = `${message}. Received ${JSON.stringify(options)}`;\n            } catch {\n            }\n            const error = @makeTypeError(message);\n            throw error.code = \"ERR_INVALID_ARG_VALUE\", error;\n          }\n        else if (!Number.isSafeInteger(port) || port < 0)\n          port = 0;\n        if (typeof port.callback === \"function\")\n          onListen = port\?.callback;\n      } else if (!Number.isSafeInteger(port) || port < 0)\n        port = 0;\n      hostname = hostname || \"::\";\n    }\n    try {\n      var tls = @undefined, TLSSocketClass = @undefined;\n      const bunTLS = this[bunTlsSymbol], options = this[bunSocketServerOptions];\n      if (typeof bunTLS === \"function\")\n        [tls, TLSSocketClass] = bunTLS.call(this, port, hostname, !1), options.servername = tls.serverName, options.InternalSocketClass = TLSSocketClass;\n      else\n        options.InternalSocketClass = SocketClass;\n      this.#server = Bun.listen(path \? {\n        exclusive,\n        unix: path,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      } : {\n        exclusive,\n        port,\n        hostname,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      }), this.#server.data = this, this.#listening = !0, setTimeout(emitListeningNextTick, 1, this, onListen);\n    } catch (err) {\n      this.#listening = !1, setTimeout(emitErrorNextTick, 1, this, err);\n    }\n    return this;\n  }\n}\n$ = {\n  createServer,\n  Server,\n  createConnection,\n  connect,\n  isIP,\n  isIPv4,\n  isIPv6,\n  Socket,\n  [Symbol.for(\"::bunternal::\")]: SocketClass\n};\nreturn $})\n"_s;
 //
 
 //
@@ -431,7 +431,7 @@ static constexpr ASCIILiteral NodeTimersPromisesCode = "(function (){\"use stric
 //
 
 //
-static constexpr ASCIILiteral NodeTLSCode = "(function (){\"use strict\";// src/js/out/tmp/node/tls.ts\nvar parseCertString = function() {\n  throwNotImplemented(\"Not implemented\");\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, unfqdn = function(host) {\n  return RegExpPrototypeSymbolReplace.call(/[.]$/, host, \"\");\n}, toLowerCase = function(c) {\n  return StringFromCharCode.call(32 + StringPrototypeCharCodeAt.call(c, 0));\n}, splitHost = function(host) {\n  return StringPrototypeSplit.call(RegExpPrototypeSymbolReplace.call(/[A-Z]/g, unfqdn(host), toLowerCase), \".\");\n}, check = function(hostParts, pattern, wildcards) {\n  if (!pattern)\n    return !1;\n  const patternParts = splitHost(pattern);\n  if (hostParts.length !== patternParts.length)\n    return !1;\n  if (ArrayPrototypeIncludes.call(patternParts, \"\"))\n    return !1;\n  const isBad = (s) => RegExpPrototypeExec.call(/[^\\u0021-\\u007F]/u, s) !== null;\n  if (ArrayPrototypeSome.call(patternParts, isBad))\n    return !1;\n  for (let i = hostParts.length - 1;i > 0; i -= 1)\n    if (hostParts[i] !== patternParts[i])\n      return !1;\n  const hostSubdomain = hostParts[0], patternSubdomain = patternParts[0], patternSubdomainParts = StringPrototypeSplit.call(patternSubdomain, \"*\");\n  if (patternSubdomainParts.length === 1 || StringPrototypeIncludes.call(patternSubdomain, \"xn--\"))\n    return hostSubdomain === patternSubdomain;\n  if (!wildcards)\n    return !1;\n  if (patternSubdomainParts.length > 2)\n    return !1;\n  if (patternParts.length <= 2)\n    return !1;\n  const { 0: prefix, 1: suffix } = patternSubdomainParts;\n  if (prefix.length + suffix.length > hostSubdomain.length)\n    return !1;\n  if (!StringPrototypeStartsWith.call(hostSubdomain, prefix))\n    return !1;\n  if (!StringPrototypeEndsWith.call(hostSubdomain, suffix))\n    return !1;\n  return !0;\n}, splitEscapedAltNames = function(altNames) {\n  const result = [];\n  let currentToken = \"\", offset = 0;\n  while (offset !== altNames.length) {\n    const nextSep = StringPrototypeIndexOf.call(altNames, \", \", offset), nextQuote = StringPrototypeIndexOf.call(altNames, '\"', offset);\n    if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) {\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextQuote);\n      const match = RegExpPrototypeExec.call(jsonStringPattern, StringPrototypeSubstring.call(altNames, nextQuote));\n      if (!match) {\n        let error = new SyntaxError(\"ERR_TLS_CERT_ALTNAME_FORMAT: Invalid subject alternative name string\");\n        throw error.name = ERR_TLS_CERT_ALTNAME_FORMAT, error;\n      }\n      currentToken += JSON.parse(match[0]), offset = nextQuote + match[0].length;\n    } else if (nextSep !== -1)\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextSep), ArrayPrototypePush.call(result, currentToken), currentToken = \"\", offset = nextSep + 2;\n    else\n      currentToken += StringPrototypeSubstring.call(altNames, offset), offset = altNames.length;\n  }\n  return ArrayPrototypePush.call(result, currentToken), result;\n}, checkServerIdentity = function(hostname, cert) {\n  const { subject, subjectaltname: altNames } = cert, dnsNames = [], ips = [];\n  if (hostname = \"\" + hostname, altNames) {\n    const splitAltNames = StringPrototypeIncludes.call(altNames, '\"') \? splitEscapedAltNames(altNames) : StringPrototypeSplit.call(altNames, \", \");\n    ArrayPrototypeForEach.call(splitAltNames, (name) => {\n      if (StringPrototypeStartsWith.call(name, \"DNS:\"))\n        ArrayPrototypePush.call(dnsNames, StringPrototypeSlice.call(name, 4));\n      else if (StringPrototypeStartsWith.call(name, \"IP Address:\"))\n        ArrayPrototypePush.call(ips, canonicalizeIP(StringPrototypeSlice.call(name, 11)));\n    });\n  }\n  let valid = !1, reason = \"Unknown reason\";\n  if (hostname = unfqdn(hostname), net.isIP(hostname)) {\n    if (valid = ArrayPrototypeIncludes.call(ips, canonicalizeIP(hostname)), !valid)\n      reason = `IP: ${hostname} is not in the cert's list: ` + ArrayPrototypeJoin.call(ips, \", \");\n  } else if (dnsNames.length > 0 || subject\?.CN) {\n    const hostParts = splitHost(hostname), wildcard = (pattern) => check(hostParts, pattern, !0);\n    if (dnsNames.length > 0) {\n      if (valid = ArrayPrototypeSome.call(dnsNames, wildcard), !valid)\n        reason = `Host: ${hostname}. is not in the cert's altnames: ${altNames}`;\n    } else {\n      const cn = subject.CN;\n      if (@Array.isArray(cn))\n        valid = ArrayPrototypeSome.call(cn, wildcard);\n      else if (cn)\n        valid = wildcard(cn);\n      if (!valid)\n        reason = `Host: ${hostname}. is not cert's CN: ${cn}`;\n    }\n  } else\n    reason = \"Cert does not contain a DNS name\";\n  if (!valid) {\n    let error = new Error(`ERR_TLS_CERT_ALTNAME_INVALID: Hostname/IP does not match certificate's altnames: ${reason}`);\n    return error.name = \"ERR_TLS_CERT_ALTNAME_INVALID\", error.reason = reason, error.host = hostname, error.cert = cert, error;\n  }\n}, SecureContext = function(options) {\n  return new InternalSecureContext(options);\n}, createSecureContext = function(options) {\n  return new SecureContext(options);\n}, translatePeerCertificate = function(c) {\n  if (!c)\n    return null;\n  if (c.issuerCertificate != null && c.issuerCertificate !== c)\n    c.issuerCertificate = translatePeerCertificate(c.issuerCertificate);\n  if (c.infoAccess != null) {\n    const info = c.infoAccess;\n    c.infoAccess = { __proto__: null }, RegExpPrototypeSymbolReplace.call(/([^\\n:]*):([^\\n]*)(\?:\\n|$)/g, info, (all, key, val) => {\n      if (val.charCodeAt(0) === 34)\n        val = JSONParse(val);\n      if (key in c.infoAccess)\n        ArrayPrototypePush.call(c.infoAccess[key], val);\n      else\n        c.infoAccess[key] = [val];\n    });\n  }\n  return c;\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, getCiphers = function() {\n  return DEFAULT_CIPHERS.split(\":\");\n}, convertProtocols = function(protocols) {\n  const lens = new @Array(protocols.length), buff = @Buffer.allocUnsafe(ArrayPrototypeReduce.call(protocols, (p, c, i) => {\n    const len = @Buffer.byteLength(c);\n    if (len > 255)\n      @throwRangeError(\"The byte length of the protocol at index \" + `${i} exceeds the maximum length.`, \"<= 255\", len, !0);\n    return lens[i] = len, p + 1 + len;\n  }, 0));\n  let offset = 0;\n  for (let i = 0, c = protocols.length;i < c; i++)\n    buff[offset++] = lens[i], buff.write(protocols[i], offset), offset += lens[i];\n  return buff;\n}, convertALPNProtocols = function(protocols, out) {\n  if (@Array.isArray(protocols))\n    out.ALPNProtocols = convertProtocols(protocols);\n  else if (isTypedArray(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols);\n  else if (isArrayBufferView(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols.buffer.slice(protocols.byteOffset, protocols.byteOffset + protocols.byteLength));\n  else if (@Buffer.isBuffer(protocols))\n    out.ALPNProtocols = protocols;\n}, $, { isArrayBufferView, isTypedArray } = @requireNativeModule(\"util/types\"), net = @getInternalField(@internalModuleRegistry, 27) || @createInternalModuleById(27), { Server: NetServer, [Symbol.for(\"::bunternal::\")]: InternalTCPSocket } = net, bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), { rootCertificates, canonicalizeIP } = @lazy(\"internal/tls\"), SymbolReplace = Symbol.replace, RegExpPrototypeSymbolReplace = @RegExp.prototype[SymbolReplace], RegExpPrototypeExec = @RegExp.prototype.exec, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeSlice = @String.prototype.slice, StringPrototypeIncludes = @String.prototype.includes, StringPrototypeSplit = @String.prototype.split, StringPrototypeIndexOf = @String.prototype.indexOf, StringPrototypeSubstring = @String.prototype.substring, StringPrototypeEndsWith = @String.prototype.endsWith, StringFromCharCode = @String.fromCharCode, StringPrototypeCharCodeAt = @String.prototype.charCodeAt, ArrayPrototypeIncludes = @Array.prototype.includes, ArrayPrototypeJoin = @Array.prototype.join, ArrayPrototypeForEach = @Array.prototype.forEach, ArrayPrototypePush = @Array.prototype.push, ArrayPrototypeSome = @Array.prototype.some, ArrayPrototypeReduce = @Array.prototype.reduce, jsonStringPattern = /^\"(\?:[^\"\\\\\\u0000-\\u001f]|\\\\(\?:[\"\\\\/bfnrt]|u[0-9a-fA-F]{4}))*\"/, InternalSecureContext = class SecureContext2 {\n  context;\n  constructor(options) {\n    const context = {};\n    if (options) {\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n    }\n    this.context = context;\n  }\n}, buntls = Symbol.for(\"::buntls::\"), SocketClass, TLSSocket = function(InternalTLSSocket) {\n  return SocketClass = InternalTLSSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"TLSSocket\",\n    enumerable: !1\n  }), Object.defineProperty(function Socket(options) {\n    return new InternalTLSSocket(options);\n  }, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalTLSSocket;\n    }\n  });\n}(class TLSSocket2 extends InternalTCPSocket {\n  #secureContext;\n  ALPNProtocols;\n  #socket;\n  #checkServerIdentity;\n  #session;\n  constructor(socket, options) {\n    super(socket instanceof InternalTCPSocket \? options : options || socket);\n    if (options = options || socket || {}, typeof options === \"object\") {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      if (socket instanceof InternalTCPSocket)\n        this.#socket = socket;\n    }\n    this.#secureContext = options.secureContext || createSecureContext(options), this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, this.#checkServerIdentity = options.checkServerIdentity || checkServerIdentity, this.#session = options.session || null;\n  }\n  _secureEstablished = !1;\n  _securePending = !0;\n  _newSessionPending;\n  _controlReleased;\n  secureConnecting = !1;\n  _SNICallback;\n  servername;\n  authorized = !1;\n  authorizationError;\n  #renegotiationDisabled = !1;\n  encrypted = !0;\n  _start() {\n    this.connect();\n  }\n  getSession() {\n    return this[bunSocketInternal]\?.getSession();\n  }\n  getEphemeralKeyInfo() {\n    return this[bunSocketInternal]\?.getEphemeralKeyInfo();\n  }\n  getCipher() {\n    return this[bunSocketInternal]\?.getCipher();\n  }\n  getSharedSigalgs() {\n    return this[bunSocketInternal]\?.getSharedSigalgs();\n  }\n  getProtocol() {\n    return this[bunSocketInternal]\?.getTLSVersion();\n  }\n  getFinished() {\n    return this[bunSocketInternal]\?.getTLSFinishedMessage() || @undefined;\n  }\n  getPeerFinished() {\n    return this[bunSocketInternal]\?.getTLSPeerFinishedMessage() || @undefined;\n  }\n  isSessionReused() {\n    return !!this.#session;\n  }\n  renegotiate() {\n    if (this.#renegotiationDisabled) {\n      const error = new Error(\"ERR_TLS_RENEGOTIATION_DISABLED: TLS session renegotiation disabled for this socket\");\n      throw error.name = \"ERR_TLS_RENEGOTIATION_DISABLED\", error;\n    }\n    throw Error(\"Not implented in Bun yet\");\n  }\n  disableRenegotiation() {\n    this.#renegotiationDisabled = !0;\n  }\n  getTLSTicket() {\n    return this[bunSocketInternal]\?.getTLSTicket();\n  }\n  exportKeyingMaterial(length, label, context) {\n    if (context)\n      return this[bunSocketInternal]\?.exportKeyingMaterial(length, label, context);\n    return this[bunSocketInternal]\?.exportKeyingMaterial(length, label);\n  }\n  setMaxSendFragment(size) {\n    return this[bunSocketInternal]\?.setMaxSendFragment(size) || !1;\n  }\n  enableTrace() {\n  }\n  setServername(name) {\n    if (this.isServer) {\n      let error = new Error(\"ERR_TLS_SNI_FROM_SERVER: Cannot issue SNI from a TLS server-side socket\");\n      throw error.name = \"ERR_TLS_SNI_FROM_SERVER\", error;\n    }\n    this.servername = name, this[bunSocketInternal]\?.setServername(name);\n  }\n  setSession(session) {\n    if (this.#session = session, typeof session === \"string\")\n      session = @Buffer.from(session, \"latin1\");\n    return this[bunSocketInternal]\?.setSession(session);\n  }\n  getPeerCertificate(abbreviated) {\n    const cert = arguments.length < 1 \? this[bunSocketInternal]\?.getPeerCertificate() : this[bunSocketInternal]\?.getPeerCertificate(abbreviated);\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getCertificate() {\n    const cert = this[bunSocketInternal]\?.getCertificate();\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getPeerX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  getX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  get alpnProtocol() {\n    return this[bunSocketInternal]\?.alpnProtocol;\n  }\n  [buntls](port, host) {\n    return {\n      socket: this.#socket,\n      ALPNProtocols: this.ALPNProtocols,\n      serverName: this.servername || host || \"localhost\",\n      checkServerIdentity: this.#checkServerIdentity,\n      session: this.#session,\n      ...this.#secureContext\n    };\n  }\n});\n\nclass Server extends NetServer {\n  key;\n  cert;\n  ca;\n  passphrase;\n  secureOptions;\n  _rejectUnauthorized;\n  _requestCert;\n  servername;\n  ALPNProtocols;\n  constructor(options, secureConnectionListener) {\n    super(options, secureConnectionListener);\n    this.setSecureContext(options);\n  }\n  setSecureContext(options) {\n    if (options instanceof InternalSecureContext)\n      options = options.context;\n    if (options) {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n      const requestCert = options.requestCert || !1;\n      if (requestCert)\n        this._requestCert = requestCert;\n      else\n        this._requestCert = @undefined;\n      const rejectUnauthorized = options.rejectUnauthorized || !1;\n      if (rejectUnauthorized)\n        this._rejectUnauthorized = rejectUnauthorized;\n      else\n        this._rejectUnauthorized = @undefined;\n    }\n  }\n  getTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  setTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  [buntls](port, host, isClient) {\n    return [\n      {\n        serverName: this.servername || host || \"localhost\",\n        key: this.key,\n        cert: this.cert,\n        ca: this.ca,\n        passphrase: this.passphrase,\n        secureOptions: this.secureOptions,\n        rejectUnauthorized: isClient \? !1 : this._rejectUnauthorized,\n        requestCert: isClient \? !1 : this._requestCert,\n        ALPNProtocols: this.ALPNProtocols\n      },\n      SocketClass\n    ];\n  }\n}\nvar CLIENT_RENEG_LIMIT = 3, CLIENT_RENEG_WINDOW = 600, DEFAULT_ECDH_CURVE = \"auto\", DEFAULT_CIPHERS = \"DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256\", DEFAULT_MIN_VERSION = \"TLSv1.2\", DEFAULT_MAX_VERSION = \"TLSv1.3\", createConnection = (port, host, connectListener) => {\n  if (typeof port === \"object\") {\n    port.checkServerIdentity;\n    const { ALPNProtocols } = port;\n    if (ALPNProtocols)\n      convertALPNProtocols(ALPNProtocols, port);\n    return new TLSSocket(port).connect(port, host, connectListener);\n  }\n  return new TLSSocket().connect(port, host, connectListener);\n}, connect = createConnection;\n$ = {\n  CLIENT_RENEG_LIMIT,\n  CLIENT_RENEG_WINDOW,\n  connect,\n  convertALPNProtocols,\n  createConnection,\n  createSecureContext,\n  createServer,\n  DEFAULT_CIPHERS,\n  DEFAULT_ECDH_CURVE,\n  DEFAULT_MAX_VERSION,\n  DEFAULT_MIN_VERSION,\n  getCiphers,\n  parseCertString,\n  SecureContext,\n  Server,\n  TLSSocket,\n  checkServerIdentity,\n  rootCertificates\n};\nreturn $})\n"_s;
+static constexpr ASCIILiteral NodeTLSCode = "(function (){\"use strict\";// src/js/out/tmp/node/tls.ts\nvar parseCertString = function() {\n  throwNotImplemented(\"Not implemented\");\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, unfqdn = function(host) {\n  return RegExpPrototypeSymbolReplace.call(/[.]$/, host, \"\");\n}, toLowerCase = function(c) {\n  return StringFromCharCode.call(32 + StringPrototypeCharCodeAt.call(c, 0));\n}, splitHost = function(host) {\n  return StringPrototypeSplit.call(RegExpPrototypeSymbolReplace.call(/[A-Z]/g, unfqdn(host), toLowerCase), \".\");\n}, check = function(hostParts, pattern, wildcards) {\n  if (!pattern)\n    return !1;\n  const patternParts = splitHost(pattern);\n  if (hostParts.length !== patternParts.length)\n    return !1;\n  if (ArrayPrototypeIncludes.call(patternParts, \"\"))\n    return !1;\n  const isBad = (s) => RegExpPrototypeExec.call(/[^\\u0021-\\u007F]/u, s) !== null;\n  if (ArrayPrototypeSome.call(patternParts, isBad))\n    return !1;\n  for (let i = hostParts.length - 1;i > 0; i -= 1)\n    if (hostParts[i] !== patternParts[i])\n      return !1;\n  const hostSubdomain = hostParts[0], patternSubdomain = patternParts[0], patternSubdomainParts = StringPrototypeSplit.call(patternSubdomain, \"*\");\n  if (patternSubdomainParts.length === 1 || StringPrototypeIncludes.call(patternSubdomain, \"xn--\"))\n    return hostSubdomain === patternSubdomain;\n  if (!wildcards)\n    return !1;\n  if (patternSubdomainParts.length > 2)\n    return !1;\n  if (patternParts.length <= 2)\n    return !1;\n  const { 0: prefix, 1: suffix } = patternSubdomainParts;\n  if (prefix.length + suffix.length > hostSubdomain.length)\n    return !1;\n  if (!StringPrototypeStartsWith.call(hostSubdomain, prefix))\n    return !1;\n  if (!StringPrototypeEndsWith.call(hostSubdomain, suffix))\n    return !1;\n  return !0;\n}, splitEscapedAltNames = function(altNames) {\n  const result = [];\n  let currentToken = \"\", offset = 0;\n  while (offset !== altNames.length) {\n    const nextSep = StringPrototypeIndexOf.call(altNames, \", \", offset), nextQuote = StringPrototypeIndexOf.call(altNames, '\"', offset);\n    if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) {\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextQuote);\n      const match = RegExpPrototypeExec.call(jsonStringPattern, StringPrototypeSubstring.call(altNames, nextQuote));\n      if (!match) {\n        let error = new SyntaxError(\"ERR_TLS_CERT_ALTNAME_FORMAT: Invalid subject alternative name string\");\n        throw error.name = ERR_TLS_CERT_ALTNAME_FORMAT, error;\n      }\n      currentToken += JSON.parse(match[0]), offset = nextQuote + match[0].length;\n    } else if (nextSep !== -1)\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextSep), ArrayPrototypePush.call(result, currentToken), currentToken = \"\", offset = nextSep + 2;\n    else\n      currentToken += StringPrototypeSubstring.call(altNames, offset), offset = altNames.length;\n  }\n  return ArrayPrototypePush.call(result, currentToken), result;\n}, checkServerIdentity = function(hostname, cert) {\n  const { subject, subjectaltname: altNames } = cert, dnsNames = [], ips = [];\n  if (hostname = \"\" + hostname, altNames) {\n    const splitAltNames = StringPrototypeIncludes.call(altNames, '\"') \? splitEscapedAltNames(altNames) : StringPrototypeSplit.call(altNames, \", \");\n    ArrayPrototypeForEach.call(splitAltNames, (name) => {\n      if (StringPrototypeStartsWith.call(name, \"DNS:\"))\n        ArrayPrototypePush.call(dnsNames, StringPrototypeSlice.call(name, 4));\n      else if (StringPrototypeStartsWith.call(name, \"IP Address:\"))\n        ArrayPrototypePush.call(ips, canonicalizeIP(StringPrototypeSlice.call(name, 11)));\n    });\n  }\n  let valid = !1, reason = \"Unknown reason\";\n  if (hostname = unfqdn(hostname), net.isIP(hostname)) {\n    if (valid = ArrayPrototypeIncludes.call(ips, canonicalizeIP(hostname)), !valid)\n      reason = `IP: ${hostname} is not in the cert's list: ` + ArrayPrototypeJoin.call(ips, \", \");\n  } else if (dnsNames.length > 0 || subject\?.CN) {\n    const hostParts = splitHost(hostname), wildcard = (pattern) => check(hostParts, pattern, !0);\n    if (dnsNames.length > 0) {\n      if (valid = ArrayPrototypeSome.call(dnsNames, wildcard), !valid)\n        reason = `Host: ${hostname}. is not in the cert's altnames: ${altNames}`;\n    } else {\n      const cn = subject.CN;\n      if (@Array.isArray(cn))\n        valid = ArrayPrototypeSome.call(cn, wildcard);\n      else if (cn)\n        valid = wildcard(cn);\n      if (!valid)\n        reason = `Host: ${hostname}. is not cert's CN: ${cn}`;\n    }\n  } else\n    reason = \"Cert does not contain a DNS name\";\n  if (!valid) {\n    let error = new Error(`ERR_TLS_CERT_ALTNAME_INVALID: Hostname/IP does not match certificate's altnames: ${reason}`);\n    return error.name = \"ERR_TLS_CERT_ALTNAME_INVALID\", error.reason = reason, error.host = hostname, error.cert = cert, error;\n  }\n}, SecureContext = function(options) {\n  return new InternalSecureContext(options);\n}, createSecureContext = function(options) {\n  return new SecureContext(options);\n}, translatePeerCertificate = function(c) {\n  if (!c)\n    return null;\n  if (c.issuerCertificate != null && c.issuerCertificate !== c)\n    c.issuerCertificate = translatePeerCertificate(c.issuerCertificate);\n  if (c.infoAccess != null) {\n    const info = c.infoAccess;\n    c.infoAccess = { __proto__: null }, RegExpPrototypeSymbolReplace.call(/([^\\n:]*):([^\\n]*)(\?:\\n|$)/g, info, (all, key, val) => {\n      if (val.charCodeAt(0) === 34)\n        val = JSONParse(val);\n      if (key in c.infoAccess)\n        ArrayPrototypePush.call(c.infoAccess[key], val);\n      else\n        c.infoAccess[key] = [val];\n    });\n  }\n  return c;\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, getCiphers = function() {\n  return DEFAULT_CIPHERS.split(\":\");\n}, convertProtocols = function(protocols) {\n  const lens = new @Array(protocols.length), buff = @Buffer.allocUnsafe(ArrayPrototypeReduce.call(protocols, (p, c, i) => {\n    const len = @Buffer.byteLength(c);\n    if (len > 255)\n      @throwRangeError(\"The byte length of the protocol at index \" + `${i} exceeds the maximum length.`, \"<= 255\", len, !0);\n    return lens[i] = len, p + 1 + len;\n  }, 0));\n  let offset = 0;\n  for (let i = 0, c = protocols.length;i < c; i++)\n    buff[offset++] = lens[i], buff.write(protocols[i], offset), offset += lens[i];\n  return buff;\n}, convertALPNProtocols = function(protocols, out) {\n  if (@Array.isArray(protocols))\n    out.ALPNProtocols = convertProtocols(protocols);\n  else if (isTypedArray(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols);\n  else if (isArrayBufferView(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols.buffer.slice(protocols.byteOffset, protocols.byteOffset + protocols.byteLength));\n  else if (@Buffer.isBuffer(protocols))\n    out.ALPNProtocols = protocols;\n}, $, { isArrayBufferView, isTypedArray } = @requireNativeModule(\"util/types\"), net = @getInternalField(@internalModuleRegistry, 27) || @createInternalModuleById(27), { Server: NetServer, [Symbol.for(\"::bunternal::\")]: InternalTCPSocket } = net, bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), { rootCertificates, canonicalizeIP } = @lazy(\"internal/tls\"), SymbolReplace = Symbol.replace, RegExpPrototypeSymbolReplace = @RegExp.prototype[SymbolReplace], RegExpPrototypeExec = @RegExp.prototype.exec, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeSlice = @String.prototype.slice, StringPrototypeIncludes = @String.prototype.includes, StringPrototypeSplit = @String.prototype.split, StringPrototypeIndexOf = @String.prototype.indexOf, StringPrototypeSubstring = @String.prototype.substring, StringPrototypeEndsWith = @String.prototype.endsWith, StringFromCharCode = @String.fromCharCode, StringPrototypeCharCodeAt = @String.prototype.charCodeAt, ArrayPrototypeIncludes = @Array.prototype.includes, ArrayPrototypeJoin = @Array.prototype.join, ArrayPrototypeForEach = @Array.prototype.forEach, ArrayPrototypePush = @Array.prototype.push, ArrayPrototypeSome = @Array.prototype.some, ArrayPrototypeReduce = @Array.prototype.reduce, jsonStringPattern = /^\"(\?:[^\"\\\\\\u0000-\\u001f]|\\\\(\?:[\"\\\\/bfnrt]|u[0-9a-fA-F]{4}))*\"/, InternalSecureContext = class SecureContext2 {\n  context;\n  constructor(options) {\n    const context = {};\n    if (options) {\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n    }\n    this.context = context;\n  }\n}, buntls = Symbol.for(\"::buntls::\"), SocketClass, TLSSocket = function(InternalTLSSocket) {\n  SocketClass = InternalTLSSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"TLSSocket\",\n    enumerable: !1\n  });\n  function Socket(options) {\n    return new InternalTLSSocket(options);\n  }\n  return Socket.prototype = InternalTLSSocket.prototype, Object.defineProperty(Socket, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalTLSSocket;\n    }\n  });\n}(class TLSSocket2 extends InternalTCPSocket {\n  #secureContext;\n  ALPNProtocols;\n  #socket;\n  #checkServerIdentity;\n  #session;\n  constructor(socket, options) {\n    super(socket instanceof InternalTCPSocket \? options : options || socket);\n    if (options = options || socket || {}, typeof options === \"object\") {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      if (socket instanceof InternalTCPSocket)\n        this.#socket = socket;\n    }\n    this.#secureContext = options.secureContext || createSecureContext(options), this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, this.#checkServerIdentity = options.checkServerIdentity || checkServerIdentity, this.#session = options.session || null;\n  }\n  _secureEstablished = !1;\n  _securePending = !0;\n  _newSessionPending;\n  _controlReleased;\n  secureConnecting = !1;\n  _SNICallback;\n  servername;\n  authorized = !1;\n  authorizationError;\n  #renegotiationDisabled = !1;\n  encrypted = !0;\n  _start() {\n    this.connect();\n  }\n  getSession() {\n    return this[bunSocketInternal]\?.getSession();\n  }\n  getEphemeralKeyInfo() {\n    return this[bunSocketInternal]\?.getEphemeralKeyInfo();\n  }\n  getCipher() {\n    return this[bunSocketInternal]\?.getCipher();\n  }\n  getSharedSigalgs() {\n    return this[bunSocketInternal]\?.getSharedSigalgs();\n  }\n  getProtocol() {\n    return this[bunSocketInternal]\?.getTLSVersion();\n  }\n  getFinished() {\n    return this[bunSocketInternal]\?.getTLSFinishedMessage() || @undefined;\n  }\n  getPeerFinished() {\n    return this[bunSocketInternal]\?.getTLSPeerFinishedMessage() || @undefined;\n  }\n  isSessionReused() {\n    return !!this.#session;\n  }\n  renegotiate() {\n    if (this.#renegotiationDisabled) {\n      const error = new Error(\"ERR_TLS_RENEGOTIATION_DISABLED: TLS session renegotiation disabled for this socket\");\n      throw error.name = \"ERR_TLS_RENEGOTIATION_DISABLED\", error;\n    }\n    throw Error(\"Not implented in Bun yet\");\n  }\n  disableRenegotiation() {\n    this.#renegotiationDisabled = !0;\n  }\n  getTLSTicket() {\n    return this[bunSocketInternal]\?.getTLSTicket();\n  }\n  exportKeyingMaterial(length, label, context) {\n    if (context)\n      return this[bunSocketInternal]\?.exportKeyingMaterial(length, label, context);\n    return this[bunSocketInternal]\?.exportKeyingMaterial(length, label);\n  }\n  setMaxSendFragment(size) {\n    return this[bunSocketInternal]\?.setMaxSendFragment(size) || !1;\n  }\n  enableTrace() {\n  }\n  setServername(name) {\n    if (this.isServer) {\n      let error = new Error(\"ERR_TLS_SNI_FROM_SERVER: Cannot issue SNI from a TLS server-side socket\");\n      throw error.name = \"ERR_TLS_SNI_FROM_SERVER\", error;\n    }\n    this.servername = name, this[bunSocketInternal]\?.setServername(name);\n  }\n  setSession(session) {\n    if (this.#session = session, typeof session === \"string\")\n      session = @Buffer.from(session, \"latin1\");\n    return this[bunSocketInternal]\?.setSession(session);\n  }\n  getPeerCertificate(abbreviated) {\n    const cert = arguments.length < 1 \? this[bunSocketInternal]\?.getPeerCertificate() : this[bunSocketInternal]\?.getPeerCertificate(abbreviated);\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getCertificate() {\n    const cert = this[bunSocketInternal]\?.getCertificate();\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getPeerX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  getX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  get alpnProtocol() {\n    return this[bunSocketInternal]\?.alpnProtocol;\n  }\n  [buntls](port, host) {\n    return {\n      socket: this.#socket,\n      ALPNProtocols: this.ALPNProtocols,\n      serverName: this.servername || host || \"localhost\",\n      checkServerIdentity: this.#checkServerIdentity,\n      session: this.#session,\n      ...this.#secureContext\n    };\n  }\n});\n\nclass Server extends NetServer {\n  key;\n  cert;\n  ca;\n  passphrase;\n  secureOptions;\n  _rejectUnauthorized;\n  _requestCert;\n  servername;\n  ALPNProtocols;\n  constructor(options, secureConnectionListener) {\n    super(options, secureConnectionListener);\n    this.setSecureContext(options);\n  }\n  setSecureContext(options) {\n    if (options instanceof InternalSecureContext)\n      options = options.context;\n    if (options) {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n      const requestCert = options.requestCert || !1;\n      if (requestCert)\n        this._requestCert = requestCert;\n      else\n        this._requestCert = @undefined;\n      const rejectUnauthorized = options.rejectUnauthorized || !1;\n      if (rejectUnauthorized)\n        this._rejectUnauthorized = rejectUnauthorized;\n      else\n        this._rejectUnauthorized = @undefined;\n    }\n  }\n  getTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  setTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  [buntls](port, host, isClient) {\n    return [\n      {\n        serverName: this.servername || host || \"localhost\",\n        key: this.key,\n        cert: this.cert,\n        ca: this.ca,\n        passphrase: this.passphrase,\n        secureOptions: this.secureOptions,\n        rejectUnauthorized: isClient \? !1 : this._rejectUnauthorized,\n        requestCert: isClient \? !1 : this._requestCert,\n        ALPNProtocols: this.ALPNProtocols\n      },\n      SocketClass\n    ];\n  }\n}\nvar CLIENT_RENEG_LIMIT = 3, CLIENT_RENEG_WINDOW = 600, DEFAULT_ECDH_CURVE = \"auto\", DEFAULT_CIPHERS = \"DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256\", DEFAULT_MIN_VERSION = \"TLSv1.2\", DEFAULT_MAX_VERSION = \"TLSv1.3\", createConnection = (port, host, connectListener) => {\n  if (typeof port === \"object\") {\n    port.checkServerIdentity;\n    const { ALPNProtocols } = port;\n    if (ALPNProtocols)\n      convertALPNProtocols(ALPNProtocols, port);\n    return new TLSSocket(port).connect(port, host, connectListener);\n  }\n  return new TLSSocket().connect(port, host, connectListener);\n}, connect = createConnection;\n$ = {\n  CLIENT_RENEG_LIMIT,\n  CLIENT_RENEG_WINDOW,\n  connect,\n  convertALPNProtocols,\n  createConnection,\n  createSecureContext,\n  createServer,\n  DEFAULT_CIPHERS,\n  DEFAULT_ECDH_CURVE,\n  DEFAULT_MAX_VERSION,\n  DEFAULT_MIN_VERSION,\n  getCiphers,\n  parseCertString,\n  SecureContext,\n  Server,\n  TLSSocket,\n  checkServerIdentity,\n  rootCertificates\n};\nreturn $})\n"_s;
 //
 
 //
@@ -597,7 +597,7 @@ static constexpr ASCIILiteral NodeFSPromisesCode = "(function (){\"use strict\";
 //
 
 //
-static constexpr ASCIILiteral NodeHttpCode = "(function (){\"use strict\";// src/js/out/tmp/node/http.ts\nvar checkInvalidHeaderChar = function(val) {\n  return RegExpPrototypeExec.call(headerCharRegex, val) !== null;\n}, isIPv6 = function(input) {\n  return new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\").test(input);\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, validateMsecs = function(numberlike, field) {\n  if (typeof numberlike !== \"number\" || numberlike < 0)\n    throw new ERR_INVALID_ARG_TYPE(field, \"number\", numberlike);\n  return numberlike;\n}, validateFunction = function(callable, field) {\n  if (typeof callable !== \"function\")\n    throw new ERR_INVALID_ARG_TYPE(field, \"Function\", callable);\n  return callable;\n}, createServer = function(options, callback) {\n  return new Server(options, callback);\n}, emitListeningNextTick = function(self, onListen, err, hostname, port) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen(err, hostname, port);\n    } catch (err2) {\n      self.emit(\"error\", err2);\n    }\n  if (self.listening = !err, err)\n    self.emit(\"error\", err);\n  else\n    self.emit(\"listening\", hostname, port);\n}, assignHeaders = function(object, req) {\n  var headers = req.headers.toJSON();\n  const rawHeaders = @newArrayWithSize(req.headers.count * 2);\n  var i = 0;\n  for (let key in headers)\n    rawHeaders[i++] = key, rawHeaders[i++] = headers[key];\n  object.headers = headers, object.rawHeaders = rawHeaders;\n};\nvar getDefaultHTTPSAgent = function() {\n  return _defaultHTTPSAgent \?\?= new Agent({ defaultPort: 443, protocol: \"https:\" });\n};\nvar urlToHttpOptions = function(url) {\n  var { protocol, hostname, hash, search, pathname, href, port, username, password } = url;\n  return {\n    protocol,\n    hostname: typeof hostname === \"string\" && StringPrototypeStartsWith.call(hostname, \"[\") \? StringPrototypeSlice.call(hostname, 1, -1) : hostname,\n    hash,\n    search,\n    pathname,\n    path: `${pathname || \"\"}${search || \"\"}`,\n    href,\n    port: port \? Number(port) : protocol === \"https:\" \? 443 : protocol === \"http:\" \? 80 : @undefined,\n    auth: username || password \? `${decodeURIComponent(username)}:${decodeURIComponent(password)}` : @undefined\n  };\n}, validateHost = function(host, name) {\n  if (host !== null && host !== @undefined && typeof host !== \"string\")\n    throw new Error(\"Invalid arg type in options\");\n  return host;\n}, checkIsHttpToken = function(val) {\n  return RegExpPrototypeExec.call(tokenRegExp, val) !== null;\n};\nvar _writeHead = function(statusCode, reason, obj, response) {\n  if (statusCode |= 0, statusCode < 100 || statusCode > 999)\n    throw new Error(\"status code must be between 100 and 999\");\n  if (typeof reason === \"string\")\n    response.statusMessage = reason;\n  else {\n    if (!response.statusMessage)\n      response.statusMessage = STATUS_CODES[statusCode] || \"unknown\";\n    obj = reason;\n  }\n  response.statusCode = statusCode;\n  {\n    let k;\n    if (@Array.isArray(obj)) {\n      if (obj.length % 2 !== 0)\n        throw new Error(\"raw headers must have an even number of elements\");\n      for (let n = 0;n < obj.length; n += 2)\n        if (k = obj[n + 0], k)\n          response.setHeader(k, obj[n + 1]);\n    } else if (obj) {\n      const keys = Object.keys(obj);\n      for (let i = 0;i < keys.length; i++)\n        if (k = keys[i], k)\n          response.setHeader(k, obj[k]);\n    }\n  }\n  if (statusCode === 204 || statusCode === 304 || statusCode >= 100 && statusCode <= 199)\n    response._hasBody = !1;\n}, request = function(url, options, cb) {\n  return new ClientRequest(url, options, cb);\n}, get = function(url, options, cb) {\n  const req = request(url, options, cb);\n  return req.end(), req;\n}, $, EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20), { isTypedArray } = @requireNativeModule(\"util/types\"), { Duplex, Readable, Writable } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), { getHeader, setHeader } = @lazy(\"http\"), headerCharRegex = /[^\\t\\x20-\\x7e\\x80-\\xff]/, validateHeaderName = (name, label) => {\n  if (typeof name !== \"string\" || !name || !checkIsHttpToken(name))\n    throw new Error(\"ERR_INVALID_HTTP_TOKEN\");\n}, validateHeaderValue = (name, value) => {\n  if (value === @undefined)\n    throw new Error(\"ERR_HTTP_INVALID_HEADER_VALUE\");\n  if (checkInvalidHeaderChar(value))\n    throw new Error(\"ERR_INVALID_CHAR\");\n}, { URL } = globalThis, globalReportError = globalThis.reportError, setTimeout = globalThis.setTimeout, fetch = Bun.fetch;\nvar kEmptyObject = Object.freeze(Object.create(null)), kOutHeaders = Symbol.for(\"kOutHeaders\"), kEndCalled = Symbol.for(\"kEndCalled\"), kAbortController = Symbol.for(\"kAbortController\"), kClearTimeout = Symbol(\"kClearTimeout\"), kCorked = Symbol.for(\"kCorked\"), searchParamsSymbol = Symbol.for(\"query\"), StringPrototypeSlice = @String.prototype.slice, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeToUpperCase = @String.prototype.toUpperCase, ArrayIsArray = @Array.isArray, RegExpPrototypeExec = @RegExp.prototype.exec, ObjectAssign = Object.assign, INVALID_PATH_REGEX = /[^\\u0021-\\u00ff]/;\nvar _defaultHTTPSAgent, kInternalRequest = Symbol(\"kInternalRequest\"), kInternalSocketData = Symbol.for(\"::bunternal::\"), kEmptyBuffer = @Buffer.alloc(0);\n\nclass ERR_INVALID_ARG_TYPE extends TypeError {\n  constructor(name, expected, actual) {\n    super(`The ${name} argument must be of type ${expected}. Received type ${typeof actual}`);\n    this.code = \"ERR_INVALID_ARG_TYPE\";\n  }\n}\nvar FakeSocket = class Socket extends Duplex {\n  [kInternalSocketData];\n  bytesRead = 0;\n  bytesWritten = 0;\n  connecting = !1;\n  timeout = 0;\n  isServer = !1;\n  #address;\n  address() {\n    var internalData;\n    return this.#address \?\?= (internalData = this[kInternalSocketData])[0].requestIP(internalData[2]);\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  connect(port, host, connectListener) {\n    return this;\n  }\n  _destroy(err, callback) {\n  }\n  _final(callback) {\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return 80;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n  }\n  get remoteAddress() {\n    return this.address()\?.address;\n  }\n  set remoteAddress(val) {\n    this.address().address = val;\n  }\n  get remotePort() {\n    return this.address()\?.port;\n  }\n  set remotePort(val) {\n    this.address().port = val;\n  }\n  get remoteFamily() {\n    return this.address()\?.family;\n  }\n  set remoteFamily(val) {\n    this.address().family = val;\n  }\n  resetAndDestroy() {\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    return this;\n  }\n  unref() {\n  }\n  _write(chunk, encoding, callback) {\n  }\n};\n\nclass Agent extends EventEmitter {\n  defaultPort = 80;\n  protocol = \"http:\";\n  options;\n  requests;\n  sockets;\n  freeSockets;\n  keepAliveMsecs;\n  keepAlive;\n  maxSockets;\n  maxFreeSockets;\n  scheduling;\n  maxTotalSockets;\n  totalSocketCount;\n  #fakeSocket;\n  static get globalAgent() {\n    return globalAgent;\n  }\n  static get defaultMaxSockets() {\n    return @Infinity;\n  }\n  constructor(options = kEmptyObject) {\n    super();\n    if (this.options = options = { ...options, path: null }, options.noDelay === @undefined)\n      options.noDelay = !0;\n    this.requests = kEmptyObject, this.sockets = kEmptyObject, this.freeSockets = kEmptyObject, this.keepAliveMsecs = options.keepAliveMsecs || 1000, this.keepAlive = options.keepAlive || !1, this.maxSockets = options.maxSockets || Agent.defaultMaxSockets, this.maxFreeSockets = options.maxFreeSockets || 256, this.scheduling = options.scheduling || \"lifo\", this.maxTotalSockets = options.maxTotalSockets, this.totalSocketCount = 0, this.defaultPort = options.defaultPort || 80, this.protocol = options.protocol || \"http:\";\n  }\n  createConnection() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  getName(options = kEmptyObject) {\n    let name = `http:${options.host || \"localhost\"}:`;\n    if (options.port)\n      name += options.port;\n    if (name += \":\", options.localAddress)\n      name += options.localAddress;\n    if (options.family === 4 || options.family === 6)\n      name += `:${options.family}`;\n    if (options.socketPath)\n      name += `:${options.socketPath}`;\n    return name;\n  }\n  addRequest() {\n  }\n  createSocket(req, options, cb) {\n    cb(null, this.#fakeSocket \?\?= new FakeSocket);\n  }\n  removeSocket() {\n  }\n  keepSocketAlive() {\n    return !0;\n  }\n  reuseSocket() {\n  }\n  destroy() {\n  }\n}\n\nclass Server extends EventEmitter {\n  #server;\n  #options;\n  #tls;\n  #is_tls = !1;\n  listening = !1;\n  serverName;\n  constructor(options, callback) {\n    super();\n    if (typeof options === \"function\")\n      callback = options, options = {};\n    else if (options == null || typeof options === \"object\") {\n      options = { ...options }, this.#tls = null;\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      let serverName = options.servername;\n      if (serverName && typeof serverName !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      if (this.#is_tls)\n        this.#tls = {\n          serverName,\n          key,\n          cert,\n          ca,\n          passphrase,\n          secureOptions\n        };\n      else\n        this.#tls = null;\n    } else\n      throw new Error(\"bun-http-polyfill: invalid arguments\");\n    if (this.#options = options, callback)\n      this.on(\"request\", callback);\n  }\n  closeAllConnections() {\n    const server = this.#server;\n    if (!server)\n      return;\n    this.#server = @undefined, server.stop(!0), this.emit(\"close\");\n  }\n  closeIdleConnections() {\n  }\n  close(optionalCallback) {\n    const server = this.#server;\n    if (!server) {\n      if (typeof optionalCallback === \"function\")\n        process.nextTick(optionalCallback, new Error(\"Server is not running\"));\n      return;\n    }\n    if (this.#server = @undefined, typeof optionalCallback === \"function\")\n      this.once(\"close\", optionalCallback);\n    server.stop(), this.emit(\"close\");\n  }\n  address() {\n    if (!this.#server)\n      return null;\n    const address = this.#server.hostname;\n    return {\n      address,\n      family: isIPv6(address) \? \"IPv6\" : \"IPv4\",\n      port: this.#server.port\n    };\n  }\n  listen(port, host, backlog, onListen) {\n    const server = this;\n    let socketPath;\n    if (typeof port == \"string\" && !Number.isSafeInteger(Number(port)))\n      socketPath = port;\n    if (typeof host === \"function\")\n      onListen = host, host = @undefined;\n    if (typeof port === \"function\")\n      onListen = port;\n    else if (typeof port === \"object\") {\n      if (port\?.signal\?.addEventListener(\"abort\", () => {\n        this.close();\n      }), host = port\?.host, port = port\?.port, typeof port\?.callback === \"function\")\n        onListen = port\?.callback;\n    }\n    if (typeof backlog === \"function\")\n      onListen = backlog;\n    const ResponseClass = this.#options.ServerResponse || ServerResponse, RequestClass = this.#options.IncomingMessage || IncomingMessage;\n    try {\n      const tls = this.#tls;\n      if (tls)\n        this.serverName = tls.serverName || host || \"localhost\";\n      this.#server = Bun.serve({\n        tls,\n        port,\n        hostname: host,\n        unix: socketPath,\n        websocket: {\n          open(ws) {\n            ws.data.open(ws);\n          },\n          message(ws, message) {\n            ws.data.message(ws, message);\n          },\n          close(ws, code, reason) {\n            ws.data.close(ws, code, reason);\n          },\n          drain(ws) {\n            ws.data.drain(ws);\n          }\n        },\n        fetch(req, _server) {\n          var pendingResponse, pendingError, rejectFunction, resolveFunction, reject = (err) => {\n            if (pendingError)\n              return;\n            if (pendingError = err, rejectFunction)\n              rejectFunction(err);\n          }, reply = function(resp) {\n            if (pendingResponse)\n              return;\n            if (pendingResponse = resp, resolveFunction)\n              resolveFunction(resp);\n          };\n          const http_req = new RequestClass(req), http_res = new ResponseClass({ reply, req: http_req });\n          if (http_req.socket[kInternalSocketData] = [_server, http_res, req], http_req.once(\"error\", (err) => reject(err)), http_res.once(\"error\", (err) => reject(err)), req.headers.get(\"upgrade\"))\n            server.emit(\"upgrade\", http_req, http_req.socket, kEmptyBuffer);\n          else\n            server.emit(\"request\", http_req, http_res);\n          if (pendingError)\n            throw pendingError;\n          if (pendingResponse)\n            return pendingResponse;\n          return new @Promise((resolve, reject2) => {\n            resolveFunction = resolve, rejectFunction = reject2;\n          });\n        }\n      }), setTimeout(emitListeningNextTick, 1, this, onListen, null, this.#server.hostname, this.#server.port);\n    } catch (err) {\n      server.emit(\"error\", err);\n    }\n    return this;\n  }\n  setTimeout(msecs, callback) {\n  }\n}\nclass IncomingMessage extends Readable {\n  method;\n  complete;\n  constructor(req, defaultIncomingOpts) {\n    const method = req.method;\n    super();\n    const url = new URL(req.url);\n    var { type = \"request\", [kInternalRequest]: nodeReq } = defaultIncomingOpts || {};\n    this.#noBody = type === \"request\" \? method === \"GET\" || method === \"HEAD\" || method === \"TRACE\" || method === \"CONNECT\" || method === \"OPTIONS\" || (parseInt(req.headers.get(\"Content-Length\") || \"\") || 0) === 0 : !1, this.#req = req, this.method = method, this.#type = type, this.complete = !!this.#noBody, this.#bodyStream = @undefined;\n    const socket = new FakeSocket;\n    if (url.protocol === \"https:\")\n      socket.encrypted = !0;\n    this.#fakeSocket = socket, this.url = url.pathname + url.search, this.req = nodeReq, assignHeaders(this, req);\n  }\n  headers;\n  rawHeaders;\n  _consuming = !1;\n  _dumped = !1;\n  #bodyStream;\n  #fakeSocket;\n  #noBody = !1;\n  #aborted = !1;\n  #req;\n  url;\n  #type;\n  _construct(callback) {\n    if (this.#type === \"response\" || this.#noBody) {\n      callback();\n      return;\n    }\n    const contentLength = this.#req.headers.get(\"content-length\");\n    if ((contentLength \? parseInt(contentLength, 10) : 0) === 0) {\n      this.#noBody = !0, callback();\n      return;\n    }\n    callback();\n  }\n  async#consumeStream(reader) {\n    while (!0) {\n      var { done, value } = await reader.readMany();\n      if (this.#aborted)\n        return;\n      if (done) {\n        this.push(null), this.destroy();\n        break;\n      }\n      for (var v of value)\n        this.push(v);\n    }\n  }\n  _read(size) {\n    if (this.#noBody)\n      this.push(null), this.complete = !0;\n    else if (this.#bodyStream == null) {\n      const reader = this.#req.body\?.getReader();\n      if (!reader) {\n        this.push(null);\n        return;\n      }\n      this.#bodyStream = reader, this.#consumeStream(reader);\n    }\n  }\n  get aborted() {\n    return this.#aborted;\n  }\n  #abort() {\n    if (this.#aborted)\n      return;\n    this.#aborted = !0;\n    var bodyStream = this.#bodyStream;\n    if (!bodyStream)\n      return;\n    bodyStream.cancel(), this.complete = !0, this.#bodyStream = @undefined, this.push(null);\n  }\n  get connection() {\n    return this.#fakeSocket;\n  }\n  get statusCode() {\n    return this.#req.status;\n  }\n  get statusMessage() {\n    return STATUS_CODES[this.#req.status];\n  }\n  get httpVersion() {\n    return \"1.1\";\n  }\n  get rawTrailers() {\n    return [];\n  }\n  get httpVersionMajor() {\n    return 1;\n  }\n  get httpVersionMinor() {\n    return 1;\n  }\n  get trailers() {\n    return kEmptyObject;\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n}\n\nclass OutgoingMessage extends Writable {\n  constructor() {\n    super(...arguments);\n  }\n  #headers;\n  headersSent = !1;\n  sendDate = !0;\n  req;\n  timeout;\n  #finished = !1;\n  [kEndCalled] = !1;\n  #fakeSocket;\n  #timeoutTimer;\n  [kAbortController] = null;\n  _implicitHeader() {\n  }\n  get headers() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  get connection() {\n    return this.socket;\n  }\n  get finished() {\n    return this.#finished;\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return headers.set(name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.removeAllListeners(\"timeout\"), this.#timeoutTimer = @undefined;\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar OriginalWriteHeadFn, OriginalImplicitHeadFn;\n\nclass ServerResponse extends Writable {\n  constructor(c) {\n    super();\n    if (!c)\n      c = {};\n    var req = c.req || {}, reply = c.reply;\n    if (this.req = req, this._reply = reply, this.sendDate = !0, this.statusCode = 200, this.headersSent = !1, this.statusMessage = @undefined, this.#controller = @undefined, this.#firstWrite = @undefined, this._writableState.decodeStrings = !1, this.#deferred = @undefined, req.method === \"HEAD\")\n      this._hasBody = !1;\n  }\n  req;\n  _reply;\n  sendDate;\n  statusCode;\n  #headers;\n  headersSent = !1;\n  statusMessage;\n  #controller;\n  #firstWrite;\n  _sent100 = !1;\n  _defaultKeepAlive = !1;\n  _removedConnection = !1;\n  _removedContLen = !1;\n  _hasBody = !0;\n  #deferred = @undefined;\n  #finished = !1;\n  _implicitHeader() {\n    this.writeHead(this.statusCode);\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#firstWrite && !this.headersSent) {\n      this.#firstWrite = chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      controller.write(chunk), callback();\n    });\n  }\n  _writev(chunks, callback) {\n    if (chunks.length === 1 && !this.headersSent && !this.#firstWrite) {\n      this.#firstWrite = chunks[0].chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      for (let chunk of chunks)\n        controller.write(chunk.chunk);\n      callback();\n    });\n  }\n  #ensureReadableStreamController(run) {\n    var thisController = this.#controller;\n    if (thisController)\n      return run(thisController);\n    this.headersSent = !0;\n    var firstWrite = this.#firstWrite;\n    this.#firstWrite = @undefined, this._reply(new Response(new @ReadableStream({\n      type: \"direct\",\n      pull: (controller) => {\n        if (this.#controller = controller, firstWrite)\n          controller.write(firstWrite);\n        if (firstWrite = @undefined, run(controller), !this.#finished)\n          return new @Promise((resolve) => {\n            this.#deferred = resolve;\n          });\n      }\n    }), {\n      headers: this.#headers,\n      status: this.statusCode,\n      statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n    }));\n  }\n  #drainHeadersIfObservable() {\n    if (this._implicitHeader === OriginalImplicitHeadFn && this.writeHead === OriginalWriteHeadFn)\n      return;\n    this._implicitHeader();\n  }\n  _final(callback) {\n    if (!this.headersSent) {\n      var data = this.#firstWrite || \"\";\n      this.#firstWrite = @undefined, this.#finished = !0, this.#drainHeadersIfObservable(), this._reply(new Response(data, {\n        headers: this.#headers,\n        status: this.statusCode,\n        statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n      })), callback && callback();\n      return;\n    }\n    this.#finished = !0, this.#ensureReadableStreamController((controller) => {\n      controller.end(), callback();\n      var deferred = this.#deferred;\n      if (deferred)\n        this.#deferred = @undefined, deferred();\n    });\n  }\n  writeProcessing() {\n    throw new Error(\"not implemented\");\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  assignSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  detachSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  writeContinue(callback) {\n    throw new Error(\"not implemented\");\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    var headers = this.#headers;\n    if (!headers)\n      return kEmptyObject;\n    return headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return setHeader(headers, name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  writeHead(statusCode, statusMessage, headers) {\n    return _writeHead(statusCode, statusMessage, headers, this), this;\n  }\n}\nOriginalWriteHeadFn = ServerResponse.prototype.writeHead;\nOriginalImplicitHeadFn = ServerResponse.prototype._implicitHeader;\n\nclass ClientRequest extends OutgoingMessage {\n  #timeout;\n  #res = null;\n  #upgradeOrConnect = !1;\n  #parser = null;\n  #maxHeadersCount = null;\n  #reusedSocket = !1;\n  #host;\n  #protocol;\n  #method;\n  #port;\n  #useDefaultPort;\n  #joinDuplicateHeaders;\n  #maxHeaderSize;\n  #agent = globalAgent;\n  #path;\n  #socketPath;\n  #bodyChunks = null;\n  #fetchRequest;\n  #signal = null;\n  [kAbortController] = null;\n  #timeoutTimer = @undefined;\n  #options;\n  #finished;\n  get path() {\n    return this.#path;\n  }\n  get port() {\n    return this.#port;\n  }\n  get method() {\n    return this.#method;\n  }\n  get host() {\n    return this.#host;\n  }\n  get protocol() {\n    return this.#protocol;\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = [chunk], callback();\n      return;\n    }\n    this.#bodyChunks.push(chunk), callback();\n  }\n  _writev(chunks, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = chunks, callback();\n      return;\n    }\n    this.#bodyChunks.push(...chunks), callback();\n  }\n  _final(callback) {\n    if (this.#finished = !0, this[kAbortController] = new AbortController, this[kAbortController].signal.addEventListener(\"abort\", () => {\n      this[kClearTimeout]();\n    }), this.#signal\?.aborted)\n      this[kAbortController].abort();\n    var method = this.#method, body = this.#bodyChunks\?.length === 1 \? this.#bodyChunks[0] : @Buffer.concat(this.#bodyChunks || []);\n    let url, proxy;\n    if (this.#path.startsWith(\"http://\") || this.#path.startsWith(\"https://\"))\n      url = this.#path, proxy = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}`;\n    else\n      url = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}${this.#path}`;\n    try {\n      this.#fetchRequest = fetch(url, {\n        method,\n        headers: this.getHeaders(),\n        body: body && method !== \"GET\" && method !== \"HEAD\" && method !== \"OPTIONS\" \? body : @undefined,\n        redirect: \"manual\",\n        verbose: !1,\n        signal: this[kAbortController].signal,\n        proxy,\n        timeout: !1,\n        decompress: !1\n      }).then((response) => {\n        var res = this.#res = new IncomingMessage(response, {\n          type: \"response\",\n          [kInternalRequest]: this\n        });\n        this.emit(\"response\", res);\n      }).catch((err) => {\n        this.emit(\"error\", err);\n      }).finally(() => {\n        this.#fetchRequest = null, this[kClearTimeout]();\n      });\n    } catch (err) {\n      this.emit(\"error\", err);\n    } finally {\n      callback();\n    }\n  }\n  get aborted() {\n    return this.#signal\?.aborted || !!this[kAbortController]\?.signal.aborted;\n  }\n  abort() {\n    if (this.aborted)\n      return;\n    this[kAbortController].abort();\n  }\n  constructor(input, options, cb) {\n    super();\n    if (typeof input === \"string\") {\n      const urlStr = input;\n      try {\n        var urlObject = new URL(urlStr);\n      } catch (e) {\n        @throwTypeError(`Invalid URL: ${urlStr}`);\n      }\n      input = urlToHttpOptions(urlObject);\n    } else if (input && typeof input === \"object\" && input instanceof URL)\n      input = urlToHttpOptions(input);\n    else\n      cb = options, options = input, input = null;\n    if (typeof options === \"function\")\n      cb = options, options = input || kEmptyObject;\n    else\n      options = ObjectAssign(input || {}, options);\n    var defaultAgent = options._defaultAgent || Agent.globalAgent;\n    let protocol = options.protocol;\n    if (!protocol)\n      if (options.port === 443)\n        protocol = \"https:\";\n      else\n        protocol = defaultAgent.protocol || \"http:\";\n    switch (this.#protocol = protocol, this.#agent\?.protocol) {\n      case @undefined:\n        break;\n      case \"http:\":\n        if (protocol === \"https:\") {\n          defaultAgent = this.#agent = getDefaultHTTPSAgent();\n          break;\n        }\n      case \"https:\":\n        if (protocol === \"https\") {\n          defaultAgent = this.#agent = Agent.globalAgent;\n          break;\n        }\n      default:\n        break;\n    }\n    if (options.path) {\n      const path = @String(options.path);\n      if (RegExpPrototypeExec.call(INVALID_PATH_REGEX, path) !== null)\n        throw new Error(\"Path contains unescaped characters\");\n    }\n    if (protocol !== \"http:\" && protocol !== \"https:\" && protocol) {\n      const expectedProtocol = defaultAgent\?.protocol \?\? \"http:\";\n      throw new Error(`Protocol mismatch. Expected: ${expectedProtocol}. Got: ${protocol}`);\n    }\n    const defaultPort = protocol === \"https:\" \? 443 : 80;\n    this.#port = options.port || options.defaultPort || this.#agent\?.defaultPort || defaultPort, this.#useDefaultPort = this.#port === defaultPort;\n    const host = this.#host = options.host = validateHost(options.hostname, \"hostname\") || validateHost(options.host, \"host\") || \"localhost\";\n    this.#socketPath = options.socketPath;\n    const signal = options.signal;\n    if (signal)\n      signal.addEventListener(\"abort\", () => {\n        this[kAbortController]\?.abort();\n      }), this.#signal = signal;\n    let method = options.method;\n    const methodIsString = typeof method === \"string\";\n    if (method !== null && method !== @undefined && !methodIsString)\n      throw new Error(\"ERR_INVALID_ARG_TYPE: options.method\");\n    if (methodIsString && method) {\n      if (!checkIsHttpToken(method))\n        throw new Error(\"ERR_INVALID_HTTP_TOKEN: Method\");\n      method = this.#method = StringPrototypeToUpperCase.call(method);\n    } else\n      method = this.#method = \"GET\";\n    const _maxHeaderSize = options.maxHeaderSize;\n    this.#maxHeaderSize = _maxHeaderSize;\n    var _joinDuplicateHeaders = options.joinDuplicateHeaders;\n    if (this.#joinDuplicateHeaders = _joinDuplicateHeaders, this.#path = options.path || \"/\", cb)\n      this.once(\"response\", cb);\n    this.#finished = !1, this.#res = null, this.#upgradeOrConnect = !1, this.#parser = null, this.#maxHeadersCount = null, this.#reusedSocket = !1, this.#host = host, this.#protocol = protocol;\n    var timeout = options.timeout;\n    if (timeout !== @undefined && timeout !== 0)\n      this.setTimeout(timeout, @undefined);\n    if (!ArrayIsArray(headers)) {\n      var headers = options.headers;\n      if (headers)\n        for (let key in headers)\n          this.setHeader(key, headers[key]);\n      var auth = options.auth;\n      if (auth && !this.getHeader(\"Authorization\"))\n        this.setHeader(\"Authorization\", \"Basic \" + @Buffer.from(auth).toString(\"base64\"));\n    }\n    var { signal: _signal, ...optsWithoutSignal } = options;\n    this.#options = optsWithoutSignal;\n  }\n  setSocketKeepAlive(enable = !0, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.#timeoutTimer = @undefined, this.removeAllListeners(\"timeout\");\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar tokenRegExp = /^[\\^_`a-zA-Z\\-0-9!#$%&'*+.|~]+$/, METHODS = [\n  \"ACL\",\n  \"BIND\",\n  \"CHECKOUT\",\n  \"CONNECT\",\n  \"COPY\",\n  \"DELETE\",\n  \"GET\",\n  \"HEAD\",\n  \"LINK\",\n  \"LOCK\",\n  \"M-SEARCH\",\n  \"MERGE\",\n  \"MKACTIVITY\",\n  \"MKCALENDAR\",\n  \"MKCOL\",\n  \"MOVE\",\n  \"NOTIFY\",\n  \"OPTIONS\",\n  \"PATCH\",\n  \"POST\",\n  \"PROPFIND\",\n  \"PROPPATCH\",\n  \"PURGE\",\n  \"PUT\",\n  \"REBIND\",\n  \"REPORT\",\n  \"SEARCH\",\n  \"SOURCE\",\n  \"SUBSCRIBE\",\n  \"TRACE\",\n  \"UNBIND\",\n  \"UNLINK\",\n  \"UNLOCK\",\n  \"UNSUBSCRIBE\"\n], STATUS_CODES = {\n  100: \"Continue\",\n  101: \"Switching Protocols\",\n  102: \"Processing\",\n  103: \"Early Hints\",\n  200: \"OK\",\n  201: \"Created\",\n  202: \"Accepted\",\n  203: \"Non-Authoritative Information\",\n  204: \"No Content\",\n  205: \"Reset Content\",\n  206: \"Partial Content\",\n  207: \"Multi-Status\",\n  208: \"Already Reported\",\n  226: \"IM Used\",\n  300: \"Multiple Choices\",\n  301: \"Moved Permanently\",\n  302: \"Found\",\n  303: \"See Other\",\n  304: \"Not Modified\",\n  305: \"Use Proxy\",\n  307: \"Temporary Redirect\",\n  308: \"Permanent Redirect\",\n  400: \"Bad Request\",\n  401: \"Unauthorized\",\n  402: \"Payment Required\",\n  403: \"Forbidden\",\n  404: \"Not Found\",\n  405: \"Method Not Allowed\",\n  406: \"Not Acceptable\",\n  407: \"Proxy Authentication Required\",\n  408: \"Request Timeout\",\n  409: \"Conflict\",\n  410: \"Gone\",\n  411: \"Length Required\",\n  412: \"Precondition Failed\",\n  413: \"Payload Too Large\",\n  414: \"URI Too Long\",\n  415: \"Unsupported Media Type\",\n  416: \"Range Not Satisfiable\",\n  417: \"Expectation Failed\",\n  418: \"I'm a Teapot\",\n  421: \"Misdirected Request\",\n  422: \"Unprocessable Entity\",\n  423: \"Locked\",\n  424: \"Failed Dependency\",\n  425: \"Too Early\",\n  426: \"Upgrade Required\",\n  428: \"Precondition Required\",\n  429: \"Too Many Requests\",\n  431: \"Request Header Fields Too Large\",\n  451: \"Unavailable For Legal Reasons\",\n  500: \"Internal Server Error\",\n  501: \"Not Implemented\",\n  502: \"Bad Gateway\",\n  503: \"Service Unavailable\",\n  504: \"Gateway Timeout\",\n  505: \"HTTP Version Not Supported\",\n  506: \"Variant Also Negotiates\",\n  507: \"Insufficient Storage\",\n  508: \"Loop Detected\",\n  509: \"Bandwidth Limit Exceeded\",\n  510: \"Not Extended\",\n  511: \"Network Authentication Required\"\n}, globalAgent = new Agent;\n$ = {\n  Agent,\n  Server,\n  METHODS,\n  STATUS_CODES,\n  createServer,\n  ServerResponse,\n  IncomingMessage,\n  request,\n  get,\n  maxHeaderSize: 16384,\n  validateHeaderName,\n  validateHeaderValue,\n  setMaxIdleHTTPParsers(max) {\n  },\n  globalAgent,\n  ClientRequest,\n  OutgoingMessage\n};\nreturn $})\n"_s;
+static constexpr ASCIILiteral NodeHttpCode = "(function (){\"use strict\";// src/js/out/tmp/node/http.ts\nvar checkInvalidHeaderChar = function(val) {\n  return RegExpPrototypeExec.call(headerCharRegex, val) !== null;\n}, isIPv6 = function(input) {\n  return new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\").test(input);\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, validateMsecs = function(numberlike, field) {\n  if (typeof numberlike !== \"number\" || numberlike < 0)\n    throw new ERR_INVALID_ARG_TYPE(field, \"number\", numberlike);\n  return numberlike;\n}, validateFunction = function(callable, field) {\n  if (typeof callable !== \"function\")\n    throw new ERR_INVALID_ARG_TYPE(field, \"Function\", callable);\n  return callable;\n}, createServer = function(options, callback) {\n  return new Server(options, callback);\n}, emitListeningNextTick = function(self, onListen, err, hostname, port) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen(err, hostname, port);\n    } catch (err2) {\n      self.emit(\"error\", err2);\n    }\n  if (self.listening = !err, err)\n    self.emit(\"error\", err);\n  else\n    self.emit(\"listening\", hostname, port);\n}, assignHeaders = function(object, req) {\n  var headers = req.headers.toJSON();\n  const rawHeaders = @newArrayWithSize(req.headers.count * 2);\n  var i = 0;\n  for (let key in headers)\n    rawHeaders[i++] = key, rawHeaders[i++] = headers[key];\n  object.headers = headers, object.rawHeaders = rawHeaders;\n};\nvar getDefaultHTTPSAgent = function() {\n  return _defaultHTTPSAgent \?\?= new Agent({ defaultPort: 443, protocol: \"https:\" });\n};\nvar urlToHttpOptions = function(url) {\n  var { protocol, hostname, hash, search, pathname, href, port, username, password } = url;\n  return {\n    protocol,\n    hostname: typeof hostname === \"string\" && StringPrototypeStartsWith.call(hostname, \"[\") \? StringPrototypeSlice.call(hostname, 1, -1) : hostname,\n    hash,\n    search,\n    pathname,\n    path: `${pathname || \"\"}${search || \"\"}`,\n    href,\n    port: port \? Number(port) : protocol === \"https:\" \? 443 : protocol === \"http:\" \? 80 : @undefined,\n    auth: username || password \? `${decodeURIComponent(username)}:${decodeURIComponent(password)}` : @undefined\n  };\n}, validateHost = function(host, name) {\n  if (host !== null && host !== @undefined && typeof host !== \"string\")\n    throw new Error(\"Invalid arg type in options\");\n  return host;\n}, checkIsHttpToken = function(val) {\n  return RegExpPrototypeExec.call(tokenRegExp, val) !== null;\n};\nvar _writeHead = function(statusCode, reason, obj, response) {\n  if (statusCode |= 0, statusCode < 100 || statusCode > 999)\n    throw new Error(\"status code must be between 100 and 999\");\n  if (typeof reason === \"string\")\n    response.statusMessage = reason;\n  else {\n    if (!response.statusMessage)\n      response.statusMessage = STATUS_CODES[statusCode] || \"unknown\";\n    obj = reason;\n  }\n  response.statusCode = statusCode;\n  {\n    let k;\n    if (@Array.isArray(obj)) {\n      if (obj.length % 2 !== 0)\n        throw new Error(\"raw headers must have an even number of elements\");\n      for (let n = 0;n < obj.length; n += 2)\n        if (k = obj[n + 0], k)\n          response.setHeader(k, obj[n + 1]);\n    } else if (obj) {\n      const keys = Object.keys(obj);\n      for (let i = 0;i < keys.length; i++)\n        if (k = keys[i], k)\n          response.setHeader(k, obj[k]);\n    }\n  }\n  if (statusCode === 204 || statusCode === 304 || statusCode >= 100 && statusCode <= 199)\n    response._hasBody = !1;\n}, request = function(url, options, cb) {\n  return new ClientRequest(url, options, cb);\n}, get = function(url, options, cb) {\n  const req = request(url, options, cb);\n  return req.end(), req;\n}, $, EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20), { isTypedArray } = @requireNativeModule(\"util/types\"), { Duplex, Readable, Writable } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), { getHeader, setHeader } = @lazy(\"http\"), headerCharRegex = /[^\\t\\x20-\\x7e\\x80-\\xff]/, validateHeaderName = (name, label) => {\n  if (typeof name !== \"string\" || !name || !checkIsHttpToken(name))\n    throw new Error(\"ERR_INVALID_HTTP_TOKEN\");\n}, validateHeaderValue = (name, value) => {\n  if (value === @undefined)\n    throw new Error(\"ERR_HTTP_INVALID_HEADER_VALUE\");\n  if (checkInvalidHeaderChar(value))\n    throw new Error(\"ERR_INVALID_CHAR\");\n}, { URL } = globalThis, globalReportError = globalThis.reportError, setTimeout = globalThis.setTimeout, fetch = Bun.fetch;\nvar kEmptyObject = Object.freeze(Object.create(null)), kOutHeaders = Symbol.for(\"kOutHeaders\"), kEndCalled = Symbol.for(\"kEndCalled\"), kAbortController = Symbol.for(\"kAbortController\"), kClearTimeout = Symbol(\"kClearTimeout\"), kCorked = Symbol.for(\"kCorked\"), searchParamsSymbol = Symbol.for(\"query\"), StringPrototypeSlice = @String.prototype.slice, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeToUpperCase = @String.prototype.toUpperCase, ArrayIsArray = @Array.isArray, RegExpPrototypeExec = @RegExp.prototype.exec, ObjectAssign = Object.assign, INVALID_PATH_REGEX = /[^\\u0021-\\u00ff]/;\nvar _defaultHTTPSAgent, kInternalRequest = Symbol(\"kInternalRequest\"), kInternalSocketData = Symbol.for(\"::bunternal::\"), kEmptyBuffer = @Buffer.alloc(0);\n\nclass ERR_INVALID_ARG_TYPE extends TypeError {\n  constructor(name, expected, actual) {\n    super(`The ${name} argument must be of type ${expected}. Received type ${typeof actual}`);\n    this.code = \"ERR_INVALID_ARG_TYPE\";\n  }\n}\nvar FakeSocket = class Socket extends Duplex {\n  [kInternalSocketData];\n  bytesRead = 0;\n  bytesWritten = 0;\n  connecting = !1;\n  timeout = 0;\n  isServer = !1;\n  #address;\n  address() {\n    var internalData;\n    return this.#address \?\?= (internalData = this[kInternalSocketData])[0].requestIP(internalData[2]) \?\? {};\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  connect(port, host, connectListener) {\n    return this;\n  }\n  _destroy(err, callback) {\n  }\n  _final(callback) {\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return 80;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n  }\n  get remoteAddress() {\n    return this.address()\?.address;\n  }\n  set remoteAddress(val) {\n    this.address().address = val;\n  }\n  get remotePort() {\n    return this.address()\?.port;\n  }\n  set remotePort(val) {\n    this.address().port = val;\n  }\n  get remoteFamily() {\n    return this.address()\?.family;\n  }\n  set remoteFamily(val) {\n    this.address().family = val;\n  }\n  resetAndDestroy() {\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    return this;\n  }\n  unref() {\n  }\n  _write(chunk, encoding, callback) {\n  }\n};\n\nclass Agent extends EventEmitter {\n  defaultPort = 80;\n  protocol = \"http:\";\n  options;\n  requests;\n  sockets;\n  freeSockets;\n  keepAliveMsecs;\n  keepAlive;\n  maxSockets;\n  maxFreeSockets;\n  scheduling;\n  maxTotalSockets;\n  totalSocketCount;\n  #fakeSocket;\n  static get globalAgent() {\n    return globalAgent;\n  }\n  static get defaultMaxSockets() {\n    return @Infinity;\n  }\n  constructor(options = kEmptyObject) {\n    super();\n    if (this.options = options = { ...options, path: null }, options.noDelay === @undefined)\n      options.noDelay = !0;\n    this.requests = kEmptyObject, this.sockets = kEmptyObject, this.freeSockets = kEmptyObject, this.keepAliveMsecs = options.keepAliveMsecs || 1000, this.keepAlive = options.keepAlive || !1, this.maxSockets = options.maxSockets || Agent.defaultMaxSockets, this.maxFreeSockets = options.maxFreeSockets || 256, this.scheduling = options.scheduling || \"lifo\", this.maxTotalSockets = options.maxTotalSockets, this.totalSocketCount = 0, this.defaultPort = options.defaultPort || 80, this.protocol = options.protocol || \"http:\";\n  }\n  createConnection() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  getName(options = kEmptyObject) {\n    let name = `http:${options.host || \"localhost\"}:`;\n    if (options.port)\n      name += options.port;\n    if (name += \":\", options.localAddress)\n      name += options.localAddress;\n    if (options.family === 4 || options.family === 6)\n      name += `:${options.family}`;\n    if (options.socketPath)\n      name += `:${options.socketPath}`;\n    return name;\n  }\n  addRequest() {\n  }\n  createSocket(req, options, cb) {\n    cb(null, this.#fakeSocket \?\?= new FakeSocket);\n  }\n  removeSocket() {\n  }\n  keepSocketAlive() {\n    return !0;\n  }\n  reuseSocket() {\n  }\n  destroy() {\n  }\n}\n\nclass Server extends EventEmitter {\n  #server;\n  #options;\n  #tls;\n  #is_tls = !1;\n  listening = !1;\n  serverName;\n  constructor(options, callback) {\n    super();\n    if (typeof options === \"function\")\n      callback = options, options = {};\n    else if (options == null || typeof options === \"object\") {\n      options = { ...options }, this.#tls = null;\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.#is_tls = !0;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      let serverName = options.servername;\n      if (serverName && typeof serverName !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      if (this.#is_tls)\n        this.#tls = {\n          serverName,\n          key,\n          cert,\n          ca,\n          passphrase,\n          secureOptions\n        };\n      else\n        this.#tls = null;\n    } else\n      throw new Error(\"bun-http-polyfill: invalid arguments\");\n    if (this.#options = options, callback)\n      this.on(\"request\", callback);\n  }\n  closeAllConnections() {\n    const server = this.#server;\n    if (!server)\n      return;\n    this.#server = @undefined, server.stop(!0), this.emit(\"close\");\n  }\n  closeIdleConnections() {\n  }\n  close(optionalCallback) {\n    const server = this.#server;\n    if (!server) {\n      if (typeof optionalCallback === \"function\")\n        process.nextTick(optionalCallback, new Error(\"Server is not running\"));\n      return;\n    }\n    if (this.#server = @undefined, typeof optionalCallback === \"function\")\n      this.once(\"close\", optionalCallback);\n    server.stop(), this.emit(\"close\");\n  }\n  address() {\n    if (!this.#server)\n      return null;\n    const address = this.#server.hostname;\n    return {\n      address,\n      family: isIPv6(address) \? \"IPv6\" : \"IPv4\",\n      port: this.#server.port\n    };\n  }\n  listen(port, host, backlog, onListen) {\n    const server = this;\n    let socketPath;\n    if (typeof port == \"string\" && !Number.isSafeInteger(Number(port)))\n      socketPath = port;\n    if (typeof host === \"function\")\n      onListen = host, host = @undefined;\n    if (typeof port === \"function\")\n      onListen = port;\n    else if (typeof port === \"object\") {\n      if (port\?.signal\?.addEventListener(\"abort\", () => {\n        this.close();\n      }), host = port\?.host, port = port\?.port, typeof port\?.callback === \"function\")\n        onListen = port\?.callback;\n    }\n    if (typeof backlog === \"function\")\n      onListen = backlog;\n    const ResponseClass = this.#options.ServerResponse || ServerResponse, RequestClass = this.#options.IncomingMessage || IncomingMessage;\n    try {\n      const tls = this.#tls;\n      if (tls)\n        this.serverName = tls.serverName || host || \"localhost\";\n      this.#server = Bun.serve({\n        tls,\n        port,\n        hostname: host,\n        unix: socketPath,\n        websocket: {\n          open(ws) {\n            ws.data.open(ws);\n          },\n          message(ws, message) {\n            ws.data.message(ws, message);\n          },\n          close(ws, code, reason) {\n            ws.data.close(ws, code, reason);\n          },\n          drain(ws) {\n            ws.data.drain(ws);\n          }\n        },\n        fetch(req, _server) {\n          var pendingResponse, pendingError, rejectFunction, resolveFunction, reject = (err) => {\n            if (pendingError)\n              return;\n            if (pendingError = err, rejectFunction)\n              rejectFunction(err);\n          }, reply = function(resp) {\n            if (pendingResponse)\n              return;\n            if (pendingResponse = resp, resolveFunction)\n              resolveFunction(resp);\n          };\n          const http_req = new RequestClass(req), http_res = new ResponseClass({ reply, req: http_req });\n          if (http_req.socket[kInternalSocketData] = [_server, http_res, req], http_req.once(\"error\", (err) => reject(err)), http_res.once(\"error\", (err) => reject(err)), req.headers.get(\"upgrade\"))\n            server.emit(\"upgrade\", http_req, http_req.socket, kEmptyBuffer);\n          else\n            server.emit(\"request\", http_req, http_res);\n          if (pendingError)\n            throw pendingError;\n          if (pendingResponse)\n            return pendingResponse;\n          return new @Promise((resolve, reject2) => {\n            resolveFunction = resolve, rejectFunction = reject2;\n          });\n        }\n      }), setTimeout(emitListeningNextTick, 1, this, onListen, null, this.#server.hostname, this.#server.port);\n    } catch (err) {\n      server.emit(\"error\", err);\n    }\n    return this;\n  }\n  setTimeout(msecs, callback) {\n  }\n}\nclass IncomingMessage extends Readable {\n  method;\n  complete;\n  constructor(req, defaultIncomingOpts) {\n    const method = req.method;\n    super();\n    const url = new URL(req.url);\n    var { type = \"request\", [kInternalRequest]: nodeReq } = defaultIncomingOpts || {};\n    this.#noBody = type === \"request\" \? method === \"GET\" || method === \"HEAD\" || method === \"TRACE\" || method === \"CONNECT\" || method === \"OPTIONS\" || (parseInt(req.headers.get(\"Content-Length\") || \"\") || 0) === 0 : !1, this.#req = req, this.method = method, this.#type = type, this.complete = !!this.#noBody, this.#bodyStream = @undefined;\n    const socket = new FakeSocket;\n    if (url.protocol === \"https:\")\n      socket.encrypted = !0;\n    this.#fakeSocket = socket, this.url = url.pathname + url.search, this.req = nodeReq, assignHeaders(this, req);\n  }\n  headers;\n  rawHeaders;\n  _consuming = !1;\n  _dumped = !1;\n  #bodyStream;\n  #fakeSocket;\n  #noBody = !1;\n  #aborted = !1;\n  #req;\n  url;\n  #type;\n  _construct(callback) {\n    if (this.#type === \"response\" || this.#noBody) {\n      callback();\n      return;\n    }\n    const contentLength = this.#req.headers.get(\"content-length\");\n    if ((contentLength \? parseInt(contentLength, 10) : 0) === 0) {\n      this.#noBody = !0, callback();\n      return;\n    }\n    callback();\n  }\n  async#consumeStream(reader) {\n    while (!0) {\n      var { done, value } = await reader.readMany();\n      if (this.#aborted)\n        return;\n      if (done) {\n        this.push(null), this.destroy();\n        break;\n      }\n      for (var v of value)\n        this.push(v);\n    }\n  }\n  _read(size) {\n    if (this.#noBody)\n      this.push(null), this.complete = !0;\n    else if (this.#bodyStream == null) {\n      const reader = this.#req.body\?.getReader();\n      if (!reader) {\n        this.push(null);\n        return;\n      }\n      this.#bodyStream = reader, this.#consumeStream(reader);\n    }\n  }\n  get aborted() {\n    return this.#aborted;\n  }\n  #abort() {\n    if (this.#aborted)\n      return;\n    this.#aborted = !0;\n    var bodyStream = this.#bodyStream;\n    if (!bodyStream)\n      return;\n    bodyStream.cancel(), this.complete = !0, this.#bodyStream = @undefined, this.push(null);\n  }\n  get connection() {\n    return this.#fakeSocket;\n  }\n  get statusCode() {\n    return this.#req.status;\n  }\n  get statusMessage() {\n    return STATUS_CODES[this.#req.status];\n  }\n  get httpVersion() {\n    return \"1.1\";\n  }\n  get rawTrailers() {\n    return [];\n  }\n  get httpVersionMajor() {\n    return 1;\n  }\n  get httpVersionMinor() {\n    return 1;\n  }\n  get trailers() {\n    return kEmptyObject;\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n}\n\nclass OutgoingMessage extends Writable {\n  constructor() {\n    super(...arguments);\n  }\n  #headers;\n  headersSent = !1;\n  sendDate = !0;\n  req;\n  timeout;\n  #finished = !1;\n  [kEndCalled] = !1;\n  #fakeSocket;\n  #timeoutTimer;\n  [kAbortController] = null;\n  _implicitHeader() {\n  }\n  get headers() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  get socket() {\n    return this.#fakeSocket \?\?= new FakeSocket;\n  }\n  set socket(val) {\n    this.#fakeSocket = val;\n  }\n  get connection() {\n    return this.socket;\n  }\n  get finished() {\n    return this.#finished;\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    if (!this.#headers)\n      return kEmptyObject;\n    return this.#headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return headers.set(name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.removeAllListeners(\"timeout\"), this.#timeoutTimer = @undefined;\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar OriginalWriteHeadFn, OriginalImplicitHeadFn;\n\nclass ServerResponse extends Writable {\n  constructor(c) {\n    super();\n    if (!c)\n      c = {};\n    var req = c.req || {}, reply = c.reply;\n    if (this.req = req, this._reply = reply, this.sendDate = !0, this.statusCode = 200, this.headersSent = !1, this.statusMessage = @undefined, this.#controller = @undefined, this.#firstWrite = @undefined, this._writableState.decodeStrings = !1, this.#deferred = @undefined, req.method === \"HEAD\")\n      this._hasBody = !1;\n  }\n  req;\n  _reply;\n  sendDate;\n  statusCode;\n  #headers;\n  headersSent = !1;\n  statusMessage;\n  #controller;\n  #firstWrite;\n  _sent100 = !1;\n  _defaultKeepAlive = !1;\n  _removedConnection = !1;\n  _removedContLen = !1;\n  _hasBody = !0;\n  #deferred = @undefined;\n  #finished = !1;\n  _implicitHeader() {\n    this.writeHead(this.statusCode);\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#firstWrite && !this.headersSent) {\n      this.#firstWrite = chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      controller.write(chunk), callback();\n    });\n  }\n  _writev(chunks, callback) {\n    if (chunks.length === 1 && !this.headersSent && !this.#firstWrite) {\n      this.#firstWrite = chunks[0].chunk, callback();\n      return;\n    }\n    this.#ensureReadableStreamController((controller) => {\n      for (let chunk of chunks)\n        controller.write(chunk.chunk);\n      callback();\n    });\n  }\n  #ensureReadableStreamController(run) {\n    var thisController = this.#controller;\n    if (thisController)\n      return run(thisController);\n    this.headersSent = !0;\n    var firstWrite = this.#firstWrite;\n    this.#firstWrite = @undefined, this._reply(new Response(new @ReadableStream({\n      type: \"direct\",\n      pull: (controller) => {\n        if (this.#controller = controller, firstWrite)\n          controller.write(firstWrite);\n        if (firstWrite = @undefined, run(controller), !this.#finished)\n          return new @Promise((resolve) => {\n            this.#deferred = resolve;\n          });\n      }\n    }), {\n      headers: this.#headers,\n      status: this.statusCode,\n      statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n    }));\n  }\n  #drainHeadersIfObservable() {\n    if (this._implicitHeader === OriginalImplicitHeadFn && this.writeHead === OriginalWriteHeadFn)\n      return;\n    this._implicitHeader();\n  }\n  _final(callback) {\n    if (!this.headersSent) {\n      var data = this.#firstWrite || \"\";\n      this.#firstWrite = @undefined, this.#finished = !0, this.#drainHeadersIfObservable(), this._reply(new Response(data, {\n        headers: this.#headers,\n        status: this.statusCode,\n        statusText: this.statusMessage \?\? STATUS_CODES[this.statusCode]\n      })), callback && callback();\n      return;\n    }\n    this.#finished = !0, this.#ensureReadableStreamController((controller) => {\n      controller.end(), callback();\n      var deferred = this.#deferred;\n      if (deferred)\n        this.#deferred = @undefined, deferred();\n    });\n  }\n  writeProcessing() {\n    throw new Error(\"not implemented\");\n  }\n  addTrailers(headers) {\n    throw new Error(\"not implemented\");\n  }\n  assignSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  detachSocket(socket) {\n    throw new Error(\"not implemented\");\n  }\n  writeContinue(callback) {\n    throw new Error(\"not implemented\");\n  }\n  setTimeout(msecs, callback) {\n    throw new Error(\"not implemented\");\n  }\n  get shouldKeepAlive() {\n    return !0;\n  }\n  get chunkedEncoding() {\n    return !1;\n  }\n  set chunkedEncoding(value) {\n  }\n  set shouldKeepAlive(value) {\n  }\n  get useChunkedEncodingByDefault() {\n    return !0;\n  }\n  set useChunkedEncodingByDefault(value) {\n  }\n  appendHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    headers.append(name, value);\n  }\n  flushHeaders() {\n  }\n  getHeader(name) {\n    return getHeader(this.#headers, name);\n  }\n  getHeaders() {\n    var headers = this.#headers;\n    if (!headers)\n      return kEmptyObject;\n    return headers.toJSON();\n  }\n  getHeaderNames() {\n    var headers = this.#headers;\n    if (!headers)\n      return [];\n    return @Array.from(headers.keys());\n  }\n  removeHeader(name) {\n    if (!this.#headers)\n      return;\n    this.#headers.delete(name);\n  }\n  setHeader(name, value) {\n    var headers = this.#headers \?\?= new Headers;\n    return setHeader(headers, name, value), this;\n  }\n  hasHeader(name) {\n    if (!this.#headers)\n      return !1;\n    return this.#headers.has(name);\n  }\n  writeHead(statusCode, statusMessage, headers) {\n    return _writeHead(statusCode, statusMessage, headers, this), this;\n  }\n}\nOriginalWriteHeadFn = ServerResponse.prototype.writeHead;\nOriginalImplicitHeadFn = ServerResponse.prototype._implicitHeader;\n\nclass ClientRequest extends OutgoingMessage {\n  #timeout;\n  #res = null;\n  #upgradeOrConnect = !1;\n  #parser = null;\n  #maxHeadersCount = null;\n  #reusedSocket = !1;\n  #host;\n  #protocol;\n  #method;\n  #port;\n  #useDefaultPort;\n  #joinDuplicateHeaders;\n  #maxHeaderSize;\n  #agent = globalAgent;\n  #path;\n  #socketPath;\n  #bodyChunks = null;\n  #fetchRequest;\n  #signal = null;\n  [kAbortController] = null;\n  #timeoutTimer = @undefined;\n  #options;\n  #finished;\n  get path() {\n    return this.#path;\n  }\n  get port() {\n    return this.#port;\n  }\n  get method() {\n    return this.#method;\n  }\n  get host() {\n    return this.#host;\n  }\n  get protocol() {\n    return this.#protocol;\n  }\n  _write(chunk, encoding, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = [chunk], callback();\n      return;\n    }\n    this.#bodyChunks.push(chunk), callback();\n  }\n  _writev(chunks, callback) {\n    if (!this.#bodyChunks) {\n      this.#bodyChunks = chunks, callback();\n      return;\n    }\n    this.#bodyChunks.push(...chunks), callback();\n  }\n  _final(callback) {\n    if (this.#finished = !0, this[kAbortController] = new AbortController, this[kAbortController].signal.addEventListener(\"abort\", () => {\n      this[kClearTimeout]();\n    }), this.#signal\?.aborted)\n      this[kAbortController].abort();\n    var method = this.#method, body = this.#bodyChunks\?.length === 1 \? this.#bodyChunks[0] : @Buffer.concat(this.#bodyChunks || []);\n    let url, proxy;\n    if (this.#path.startsWith(\"http://\") || this.#path.startsWith(\"https://\"))\n      url = this.#path, proxy = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}`;\n    else\n      url = `${this.#protocol}//${this.#host}${this.#useDefaultPort \? \"\" : \":\" + this.#port}${this.#path}`;\n    try {\n      this.#fetchRequest = fetch(url, {\n        method,\n        headers: this.getHeaders(),\n        body: body && method !== \"GET\" && method !== \"HEAD\" && method !== \"OPTIONS\" \? body : @undefined,\n        redirect: \"manual\",\n        verbose: !1,\n        signal: this[kAbortController].signal,\n        proxy,\n        timeout: !1,\n        decompress: !1\n      }).then((response) => {\n        var res = this.#res = new IncomingMessage(response, {\n          type: \"response\",\n          [kInternalRequest]: this\n        });\n        this.emit(\"response\", res);\n      }).catch((err) => {\n        this.emit(\"error\", err);\n      }).finally(() => {\n        this.#fetchRequest = null, this[kClearTimeout]();\n      });\n    } catch (err) {\n      this.emit(\"error\", err);\n    } finally {\n      callback();\n    }\n  }\n  get aborted() {\n    return this.#signal\?.aborted || !!this[kAbortController]\?.signal.aborted;\n  }\n  abort() {\n    if (this.aborted)\n      return;\n    this[kAbortController].abort();\n  }\n  constructor(input, options, cb) {\n    super();\n    if (typeof input === \"string\") {\n      const urlStr = input;\n      try {\n        var urlObject = new URL(urlStr);\n      } catch (e) {\n        @throwTypeError(`Invalid URL: ${urlStr}`);\n      }\n      input = urlToHttpOptions(urlObject);\n    } else if (input && typeof input === \"object\" && input instanceof URL)\n      input = urlToHttpOptions(input);\n    else\n      cb = options, options = input, input = null;\n    if (typeof options === \"function\")\n      cb = options, options = input || kEmptyObject;\n    else\n      options = ObjectAssign(input || {}, options);\n    var defaultAgent = options._defaultAgent || Agent.globalAgent;\n    let protocol = options.protocol;\n    if (!protocol)\n      if (options.port === 443)\n        protocol = \"https:\";\n      else\n        protocol = defaultAgent.protocol || \"http:\";\n    switch (this.#protocol = protocol, this.#agent\?.protocol) {\n      case @undefined:\n        break;\n      case \"http:\":\n        if (protocol === \"https:\") {\n          defaultAgent = this.#agent = getDefaultHTTPSAgent();\n          break;\n        }\n      case \"https:\":\n        if (protocol === \"https\") {\n          defaultAgent = this.#agent = Agent.globalAgent;\n          break;\n        }\n      default:\n        break;\n    }\n    if (options.path) {\n      const path = @String(options.path);\n      if (RegExpPrototypeExec.call(INVALID_PATH_REGEX, path) !== null)\n        throw new Error(\"Path contains unescaped characters\");\n    }\n    if (protocol !== \"http:\" && protocol !== \"https:\" && protocol) {\n      const expectedProtocol = defaultAgent\?.protocol \?\? \"http:\";\n      throw new Error(`Protocol mismatch. Expected: ${expectedProtocol}. Got: ${protocol}`);\n    }\n    const defaultPort = protocol === \"https:\" \? 443 : 80;\n    this.#port = options.port || options.defaultPort || this.#agent\?.defaultPort || defaultPort, this.#useDefaultPort = this.#port === defaultPort;\n    const host = this.#host = options.host = validateHost(options.hostname, \"hostname\") || validateHost(options.host, \"host\") || \"localhost\";\n    this.#socketPath = options.socketPath;\n    const signal = options.signal;\n    if (signal)\n      signal.addEventListener(\"abort\", () => {\n        this[kAbortController]\?.abort();\n      }), this.#signal = signal;\n    let method = options.method;\n    const methodIsString = typeof method === \"string\";\n    if (method !== null && method !== @undefined && !methodIsString)\n      throw new Error(\"ERR_INVALID_ARG_TYPE: options.method\");\n    if (methodIsString && method) {\n      if (!checkIsHttpToken(method))\n        throw new Error(\"ERR_INVALID_HTTP_TOKEN: Method\");\n      method = this.#method = StringPrototypeToUpperCase.call(method);\n    } else\n      method = this.#method = \"GET\";\n    const _maxHeaderSize = options.maxHeaderSize;\n    this.#maxHeaderSize = _maxHeaderSize;\n    var _joinDuplicateHeaders = options.joinDuplicateHeaders;\n    if (this.#joinDuplicateHeaders = _joinDuplicateHeaders, this.#path = options.path || \"/\", cb)\n      this.once(\"response\", cb);\n    this.#finished = !1, this.#res = null, this.#upgradeOrConnect = !1, this.#parser = null, this.#maxHeadersCount = null, this.#reusedSocket = !1, this.#host = host, this.#protocol = protocol;\n    var timeout = options.timeout;\n    if (timeout !== @undefined && timeout !== 0)\n      this.setTimeout(timeout, @undefined);\n    if (!ArrayIsArray(headers)) {\n      var headers = options.headers;\n      if (headers)\n        for (let key in headers)\n          this.setHeader(key, headers[key]);\n      var auth = options.auth;\n      if (auth && !this.getHeader(\"Authorization\"))\n        this.setHeader(\"Authorization\", \"Basic \" + @Buffer.from(auth).toString(\"base64\"));\n    }\n    var { signal: _signal, ...optsWithoutSignal } = options;\n    this.#options = optsWithoutSignal;\n  }\n  setSocketKeepAlive(enable = !0, initialDelay = 0) {\n  }\n  setNoDelay(noDelay = !0) {\n  }\n  [kClearTimeout]() {\n    if (this.#timeoutTimer)\n      clearTimeout(this.#timeoutTimer), this.#timeoutTimer = @undefined, this.removeAllListeners(\"timeout\");\n  }\n  #onTimeout() {\n    this.#timeoutTimer = @undefined, this[kAbortController]\?.abort(), this.emit(\"timeout\");\n  }\n  setTimeout(msecs, callback) {\n    if (this.destroyed)\n      return this;\n    if (this.timeout = msecs = validateMsecs(msecs, \"msecs\"), clearTimeout(this.#timeoutTimer), msecs === 0) {\n      if (callback !== @undefined)\n        validateFunction(callback, \"callback\"), this.removeListener(\"timeout\", callback);\n      this.#timeoutTimer = @undefined;\n    } else if (this.#timeoutTimer = setTimeout(this.#onTimeout.bind(this), msecs).unref(), callback !== @undefined)\n      validateFunction(callback, \"callback\"), this.once(\"timeout\", callback);\n    return this;\n  }\n}\nvar tokenRegExp = /^[\\^_`a-zA-Z\\-0-9!#$%&'*+.|~]+$/, METHODS = [\n  \"ACL\",\n  \"BIND\",\n  \"CHECKOUT\",\n  \"CONNECT\",\n  \"COPY\",\n  \"DELETE\",\n  \"GET\",\n  \"HEAD\",\n  \"LINK\",\n  \"LOCK\",\n  \"M-SEARCH\",\n  \"MERGE\",\n  \"MKACTIVITY\",\n  \"MKCALENDAR\",\n  \"MKCOL\",\n  \"MOVE\",\n  \"NOTIFY\",\n  \"OPTIONS\",\n  \"PATCH\",\n  \"POST\",\n  \"PROPFIND\",\n  \"PROPPATCH\",\n  \"PURGE\",\n  \"PUT\",\n  \"REBIND\",\n  \"REPORT\",\n  \"SEARCH\",\n  \"SOURCE\",\n  \"SUBSCRIBE\",\n  \"TRACE\",\n  \"UNBIND\",\n  \"UNLINK\",\n  \"UNLOCK\",\n  \"UNSUBSCRIBE\"\n], STATUS_CODES = {\n  100: \"Continue\",\n  101: \"Switching Protocols\",\n  102: \"Processing\",\n  103: \"Early Hints\",\n  200: \"OK\",\n  201: \"Created\",\n  202: \"Accepted\",\n  203: \"Non-Authoritative Information\",\n  204: \"No Content\",\n  205: \"Reset Content\",\n  206: \"Partial Content\",\n  207: \"Multi-Status\",\n  208: \"Already Reported\",\n  226: \"IM Used\",\n  300: \"Multiple Choices\",\n  301: \"Moved Permanently\",\n  302: \"Found\",\n  303: \"See Other\",\n  304: \"Not Modified\",\n  305: \"Use Proxy\",\n  307: \"Temporary Redirect\",\n  308: \"Permanent Redirect\",\n  400: \"Bad Request\",\n  401: \"Unauthorized\",\n  402: \"Payment Required\",\n  403: \"Forbidden\",\n  404: \"Not Found\",\n  405: \"Method Not Allowed\",\n  406: \"Not Acceptable\",\n  407: \"Proxy Authentication Required\",\n  408: \"Request Timeout\",\n  409: \"Conflict\",\n  410: \"Gone\",\n  411: \"Length Required\",\n  412: \"Precondition Failed\",\n  413: \"Payload Too Large\",\n  414: \"URI Too Long\",\n  415: \"Unsupported Media Type\",\n  416: \"Range Not Satisfiable\",\n  417: \"Expectation Failed\",\n  418: \"I'm a Teapot\",\n  421: \"Misdirected Request\",\n  422: \"Unprocessable Entity\",\n  423: \"Locked\",\n  424: \"Failed Dependency\",\n  425: \"Too Early\",\n  426: \"Upgrade Required\",\n  428: \"Precondition Required\",\n  429: \"Too Many Requests\",\n  431: \"Request Header Fields Too Large\",\n  451: \"Unavailable For Legal Reasons\",\n  500: \"Internal Server Error\",\n  501: \"Not Implemented\",\n  502: \"Bad Gateway\",\n  503: \"Service Unavailable\",\n  504: \"Gateway Timeout\",\n  505: \"HTTP Version Not Supported\",\n  506: \"Variant Also Negotiates\",\n  507: \"Insufficient Storage\",\n  508: \"Loop Detected\",\n  509: \"Bandwidth Limit Exceeded\",\n  510: \"Not Extended\",\n  511: \"Network Authentication Required\"\n}, globalAgent = new Agent;\n$ = {\n  Agent,\n  Server,\n  METHODS,\n  STATUS_CODES,\n  createServer,\n  ServerResponse,\n  IncomingMessage,\n  request,\n  get,\n  maxHeaderSize: 16384,\n  validateHeaderName,\n  validateHeaderValue,\n  setMaxIdleHTTPParsers(max) {\n  },\n  globalAgent,\n  ClientRequest,\n  OutgoingMessage\n};\nreturn $})\n"_s;
 //
 
 //
@@ -613,7 +613,7 @@ static constexpr ASCIILiteral NodeInspectorCode = "(function (){\"use strict\";/
 //
 
 //
-static constexpr ASCIILiteral NodeNetCode = "(function (){\"use strict\";// src/js/out/tmp/node/net.ts\nvar isIPv4 = function(s) {\n  return IPv4Reg.test(s);\n}, isIPv6 = function(s) {\n  return IPv6Reg.test(s);\n}, isIP = function(s) {\n  if (isIPv4(s))\n    return 4;\n  if (isIPv6(s))\n    return 6;\n  return 0;\n}, endNT = function(socket, callback, err) {\n  socket.end(), callback(err);\n}, createConnection = function(port, host, connectListener) {\n  if (typeof port === \"object\")\n    return new Socket(port).connect(port, host, connectListener);\n  return new Socket().connect(port, host, connectListener);\n}, emitErrorNextTick = function(self, error) {\n  self.emit(\"error\", error);\n}, emitErrorAndCloseNextTick = function(self, error) {\n  self.emit(\"error\", error), self.emit(\"close\");\n}, emitListeningNextTick = function(self, onListen) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen();\n    } catch (err) {\n      self.emit(\"error\", err);\n    }\n  self.emit(\"listening\");\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, $, { Duplex } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20);\nvar IPv4Reg = new @RegExp(\"^((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$\");\nvar IPv6Reg = new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\"), { connect: bunConnect } = Bun, { setTimeout } = globalThis, bunTlsSymbol = Symbol.for(\"::buntls::\"), bunSocketServerHandlers = Symbol.for(\"::bunsocket_serverhandlers::\"), bunSocketServerConnections = Symbol.for(\"::bunnetserverconnections::\"), bunSocketServerOptions = Symbol.for(\"::bunnetserveroptions::\"), bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), bunTLSConnectOptions = Symbol.for(\"::buntlsconnectoptions::\"), SocketClass, Socket = function(InternalSocket) {\n  return SocketClass = InternalSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"Socket\",\n    enumerable: !1\n  }), Object.defineProperty(function Socket(options) {\n    return new InternalSocket(options);\n  }, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalSocket;\n    }\n  });\n}(class Socket2 extends Duplex {\n  static #Handlers = {\n    close: Socket2.#Close,\n    data({ data: self }, buffer) {\n      self.bytesRead += buffer.length;\n      const queue = self.#readQueue;\n      if (queue.isEmpty()) {\n        if (self.push(buffer))\n          return;\n      }\n      queue.push(buffer);\n    },\n    drain: Socket2.#Drain,\n    end: Socket2.#Close,\n    error(socket, error) {\n      const self = socket.data, callback = self.#writeCallback;\n      if (callback)\n        self.#writeCallback = null, callback(error);\n      self.emit(\"error\", error);\n    },\n    open(socket) {\n      const self = socket.data;\n      socket.timeout(self.timeout), socket.ref(), self[bunSocketInternal] = socket, self.connecting = !1;\n      const options = self[bunTLSConnectOptions];\n      if (options) {\n        const { session } = options;\n        if (session)\n          self.setSession(session);\n      }\n      if (!self.#upgraded)\n        self.emit(\"connect\", self);\n      Socket2.#Drain(socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self.emit(\"secure\", self);\n      const { checkServerIdentity } = self[bunTLSConnectOptions];\n      if (!verifyError && typeof checkServerIdentity === \"function\" && self.servername) {\n        const cert = self.getPeerCertificate(!0);\n        verifyError = checkServerIdentity(self.servername, cert);\n      }\n      if (self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnect\", verifyError);\n    },\n    timeout(socket) {\n      const self = socket.data;\n      self.emit(\"timeout\", self);\n    },\n    binaryType: \"buffer\"\n  };\n  static #Close(socket) {\n    const self = socket.data;\n    if (self.#closed)\n      return;\n    self.#closed = !0, self[bunSocketInternal] = null;\n    const queue = self.#readQueue;\n    if (queue.isEmpty()) {\n      if (self.push(null))\n        return;\n    }\n    queue.push(null);\n  }\n  static #Drain(socket) {\n    const self = socket.data, callback = self.#writeCallback;\n    if (callback) {\n      const chunk = self.#writeChunk, written = socket.write(chunk);\n      if (self.bytesWritten += written, written < chunk.length)\n        self.#writeChunk = chunk.slice(written);\n      else\n        self.#writeCallback = null, self.#writeChunk = null, callback(null);\n    }\n  }\n  static [bunSocketServerHandlers] = {\n    data: Socket2.#Handlers.data,\n    close(socket) {\n      Socket2.#Handlers.close(socket), this.data[bunSocketServerConnections]--;\n    },\n    end(socket) {\n      Socket2.#Handlers.end(socket), this.data[bunSocketServerConnections]--;\n    },\n    open(socket) {\n      const self = this.data, options = self[bunSocketServerOptions], { pauseOnConnect, connectionListener, InternalSocketClass, requestCert, rejectUnauthorized } = options, _socket = new InternalSocketClass({});\n      if (_socket.isServer = !0, _socket._requestCert = requestCert, _socket._rejectUnauthorized = rejectUnauthorized, _socket.#attach(this.localPort, socket), self.maxConnections && self[bunSocketServerConnections] >= self.maxConnections) {\n        const data = {\n          localAddress: _socket.localAddress,\n          localPort: _socket.localPort,\n          localFamily: _socket.localFamily,\n          remoteAddress: _socket.remoteAddress,\n          remotePort: _socket.remotePort,\n          remoteFamily: _socket.remoteFamily || \"IPv4\"\n        };\n        socket.end(), self.emit(\"drop\", data);\n        return;\n      }\n      if (!pauseOnConnect)\n        _socket.resume();\n      if (self[bunSocketServerConnections]++, typeof connectionListener == \"function\")\n        if (InternalSocketClass.name === \"TLSSocket\")\n          self.once(\"secureConnection\", () => connectionListener(_socket));\n        else\n          connectionListener(_socket);\n      self.emit(\"connection\", _socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      if (self.emit(\"secure\", self), self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnection\", verifyError);\n    },\n    error(socket, error) {\n      Socket2.#Handlers.error(socket, error), this.data.emit(\"error\", error);\n    },\n    timeout: Socket2.#Handlers.timeout,\n    connectError: Socket2.#Handlers.connectError,\n    drain: Socket2.#Handlers.drain,\n    binaryType: \"buffer\"\n  };\n  bytesRead = 0;\n  bytesWritten = 0;\n  #closed = !1;\n  connecting = !1;\n  localAddress = \"127.0.0.1\";\n  #readQueue = @createFIFO();\n  remotePort;\n  [bunSocketInternal] = null;\n  [bunTLSConnectOptions] = null;\n  timeout = 0;\n  #writeCallback;\n  #writeChunk;\n  #pendingRead;\n  isServer = !1;\n  _handle;\n  _parent;\n  _parentWrap;\n  #socket;\n  #upgraded;\n  constructor(options) {\n    const { socket, signal, write, read, allowHalfOpen = !1, ...opts } = options || {};\n    super({\n      ...opts,\n      allowHalfOpen,\n      readable: !0,\n      writable: !0\n    });\n    if (this._handle = this, this._parent = this, this._parentWrap = this, this.#pendingRead = @undefined, this.#upgraded = !1, socket instanceof Socket2)\n      this.#socket = socket;\n    signal\?.once(\"abort\", () => this.destroy()), this.once(\"connect\", () => this.emit(\"ready\"));\n  }\n  address() {\n    return {\n      address: this.localAddress,\n      family: this.localFamily,\n      port: this.localPort\n    };\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  #attach(port, socket) {\n    if (this.remotePort = port, socket.data = this, socket.timeout(this.timeout), socket.ref(), this[bunSocketInternal] = socket, this.connecting = !1, !this.#upgraded)\n      this.emit(\"connect\", this);\n    Socket2.#Drain(socket);\n  }\n  connect(port, host, connectListener) {\n    var path, connection = this.#socket, _checkServerIdentity = @undefined;\n    if (typeof port === \"string\") {\n      if (path = port, port = @undefined, typeof host === \"function\")\n        connectListener = host, host = @undefined;\n    } else if (typeof host == \"function\") {\n      if (typeof port === \"string\")\n        path = port, port = @undefined;\n      connectListener = host, host = @undefined;\n    }\n    if (typeof port == \"object\") {\n      var {\n        port,\n        host,\n        path,\n        socket,\n        localAddress,\n        localPort,\n        family,\n        hints,\n        lookup,\n        noDelay,\n        keepAlive,\n        keepAliveInitialDelay,\n        requestCert,\n        rejectUnauthorized,\n        pauseOnConnect,\n        servername,\n        checkServerIdentity,\n        session\n      } = port;\n      if (_checkServerIdentity = checkServerIdentity, this.servername = servername, socket)\n        connection = socket;\n    }\n    if (!pauseOnConnect)\n      this.resume();\n    this.connecting = !0, this.remotePort = port;\n    const bunTLS = this[bunTlsSymbol];\n    var tls = @undefined;\n    if (typeof bunTLS === \"function\") {\n      if (tls = bunTLS.call(this, port, host, !0), this._requestCert = !0, this._rejectUnauthorized = rejectUnauthorized, tls) {\n        if (tls.rejectUnauthorized = rejectUnauthorized, tls.requestCert = !0, tls.session = session || tls.session, this.servername = tls.servername, tls.checkServerIdentity = _checkServerIdentity || tls.checkServerIdentity, this[bunTLSConnectOptions] = tls, !connection && tls.socket)\n          connection = tls.socket;\n      }\n      if (connection) {\n        if (typeof connection !== \"object\" || !(connection instanceof Socket2) || typeof connection[bunTlsSymbol] === \"function\")\n          @throwTypeError(\"socket must be an instance of net.Socket\");\n      }\n      if (this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, connectListener)\n        this.on(\"secureConnect\", connectListener);\n    } else if (connectListener)\n      this.on(\"connect\", connectListener);\n    try {\n      if (connection) {\n        const socket2 = connection[bunSocketInternal];\n        if (socket2) {\n          this.connecting = !0, this.#upgraded = !0;\n          const result = socket2.upgradeTLS({\n            data: this,\n            tls,\n            socket: Socket2.#Handlers\n          });\n          if (result) {\n            const [raw, tls2] = result;\n            connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n          } else\n            throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n        } else\n          connection.once(\"connect\", () => {\n            const socket3 = connection[bunSocketInternal];\n            if (!socket3)\n              return;\n            this.connecting = !0, this.#upgraded = !0;\n            const result = socket3.upgradeTLS({\n              data: this,\n              tls,\n              socket: Socket2.#Handlers\n            });\n            if (result) {\n              const [raw, tls2] = result;\n              connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n            } else\n              throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n          });\n      } else if (path)\n        bunConnect({\n          data: this,\n          unix: path,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n      else\n        bunConnect({\n          data: this,\n          hostname: host || \"localhost\",\n          port,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n    } catch (error) {\n      process.nextTick(emitErrorAndCloseNextTick, this, error);\n    }\n    return this;\n  }\n  _destroy(err, callback) {\n    const socket = this[bunSocketInternal];\n    socket && process.nextTick(endNT, socket, callback, err);\n  }\n  _final(callback) {\n    this[bunSocketInternal]\?.end(), callback();\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return this[bunSocketInternal]\?.localPort;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n    const queue = this.#readQueue;\n    let chunk;\n    while (chunk = queue.peek()) {\n      if (!this.push(chunk))\n        return;\n      queue.shift();\n    }\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n    this[bunSocketInternal]\?.ref();\n  }\n  get remoteAddress() {\n    return this[bunSocketInternal]\?.remoteAddress;\n  }\n  get remoteFamily() {\n    return \"IPv4\";\n  }\n  resetAndDestroy() {\n    this[bunSocketInternal]\?.end();\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n    return this;\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    if (this[bunSocketInternal]\?.timeout(timeout), this.timeout = timeout, callback)\n      this.once(\"timeout\", callback);\n    return this;\n  }\n  unref() {\n    this[bunSocketInternal]\?.unref();\n  }\n  _write(chunk, encoding, callback) {\n    if (typeof chunk == \"string\" && encoding !== \"ascii\")\n      chunk = @Buffer.from(chunk, encoding);\n    var written = this[bunSocketInternal]\?.write(chunk);\n    if (written == chunk.length)\n      callback();\n    else if (this.#writeCallback)\n      callback(new Error(\"overlapping _write()\"));\n    else {\n      if (written > 0)\n        if (typeof chunk == \"string\")\n          chunk = chunk.slice(written);\n        else\n          chunk = chunk.subarray(written);\n      this.#writeCallback = callback, this.#writeChunk = chunk;\n    }\n  }\n}), connect = createConnection;\n\nclass Server extends EventEmitter {\n  #server;\n  #listening = !1;\n  [bunSocketServerConnections] = 0;\n  [bunSocketServerOptions];\n  maxConnections = 0;\n  constructor(options, connectionListener) {\n    super();\n    if (typeof options === \"function\")\n      connectionListener = options, options = {};\n    else if (options == null || typeof options === \"object\")\n      options = { ...options };\n    else\n      throw new Error(\"bun-net-polyfill: invalid arguments\");\n    const { maxConnections } = options;\n    this.maxConnections = Number.isSafeInteger(maxConnections) && maxConnections > 0 \? maxConnections : 0, options.connectionListener = connectionListener, this[bunSocketServerOptions] = options;\n  }\n  ref() {\n    return this.#server\?.ref(), this;\n  }\n  unref() {\n    return this.#server\?.unref(), this;\n  }\n  close(callback) {\n    if (this.#server) {\n      if (this.#server.stop(!0), this.#server = null, this.#listening = !1, this[bunSocketServerConnections] = 0, this.emit(\"close\"), typeof callback === \"function\")\n        callback();\n      return this;\n    }\n    if (typeof callback === \"function\") {\n      const error = new Error(\"Server is not running\");\n      error.code = \"ERR_SERVER_NOT_RUNNING\", callback(error);\n    }\n    return this;\n  }\n  address() {\n    const server = this.#server;\n    if (server) {\n      const unix = server.unix;\n      if (unix)\n        return unix;\n      let address = server.hostname;\n      const type = isIP(address), port = server.port;\n      if (typeof port === \"number\")\n        return {\n          port,\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      if (type)\n        return {\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      return address;\n    }\n    return null;\n  }\n  getConnections(callback) {\n    if (typeof callback === \"function\")\n      callback(null, this.#server \? this[bunSocketServerConnections] : 0);\n    return this;\n  }\n  listen(port, hostname, onListen) {\n    let backlog, path, exclusive = !1;\n    if (typeof port === \"string\") {\n      if (Number.isSafeInteger(hostname)) {\n        if (hostname > 0)\n          backlog = hostname;\n      } else if (typeof hostname === \"function\")\n        onListen = hostname;\n      path = port, hostname = @undefined, port = @undefined;\n    } else {\n      if (typeof hostname === \"function\")\n        onListen = hostname, hostname = @undefined;\n      if (typeof port === \"function\")\n        onListen = port, port = 0;\n      else if (typeof port === \"object\") {\n        const options = port;\n        options.signal\?.addEventListener(\"abort\", () => this.close()), hostname = options.host, exclusive = options.exclusive === !0;\n        const path2 = options.path;\n        if (port = options.port, !Number.isSafeInteger(port) || port < 0)\n          if (path2)\n            hostname = path2, port = @undefined;\n          else {\n            let message = 'The argument \\'options\\' must have the property \"port\" or \"path\"';\n            try {\n              message = `${message}. Received ${JSON.stringify(options)}`;\n            } catch {\n            }\n            const error = @makeTypeError(message);\n            throw error.code = \"ERR_INVALID_ARG_VALUE\", error;\n          }\n        else if (!Number.isSafeInteger(port) || port < 0)\n          port = 0;\n        if (typeof port.callback === \"function\")\n          onListen = port\?.callback;\n      } else if (!Number.isSafeInteger(port) || port < 0)\n        port = 0;\n      hostname = hostname || \"::\";\n    }\n    try {\n      var tls = @undefined, TLSSocketClass = @undefined;\n      const bunTLS = this[bunTlsSymbol], options = this[bunSocketServerOptions];\n      if (typeof bunTLS === \"function\")\n        [tls, TLSSocketClass] = bunTLS.call(this, port, hostname, !1), options.servername = tls.serverName, options.InternalSocketClass = TLSSocketClass;\n      else\n        options.InternalSocketClass = SocketClass;\n      this.#server = Bun.listen(path \? {\n        exclusive,\n        unix: path,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      } : {\n        exclusive,\n        port,\n        hostname,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      }), this.#server.data = this, this.#listening = !0, setTimeout(emitListeningNextTick, 1, this, onListen);\n    } catch (err) {\n      this.#listening = !1, setTimeout(emitErrorNextTick, 1, this, err);\n    }\n    return this;\n  }\n}\n$ = {\n  createServer,\n  Server,\n  createConnection,\n  connect,\n  isIP,\n  isIPv4,\n  isIPv6,\n  Socket,\n  [Symbol.for(\"::bunternal::\")]: SocketClass\n};\nreturn $})\n"_s;
+static constexpr ASCIILiteral NodeNetCode = "(function (){\"use strict\";// src/js/out/tmp/node/net.ts\nvar isIPv4 = function(s) {\n  return IPv4Reg.test(s);\n}, isIPv6 = function(s) {\n  return IPv6Reg.test(s);\n}, isIP = function(s) {\n  if (isIPv4(s))\n    return 4;\n  if (isIPv6(s))\n    return 6;\n  return 0;\n}, endNT = function(socket, callback, err) {\n  socket.end(), callback(err);\n}, createConnection = function(port, host, connectListener) {\n  if (typeof port === \"object\")\n    return new Socket(port).connect(port, host, connectListener);\n  return new Socket().connect(port, host, connectListener);\n}, emitErrorNextTick = function(self, error) {\n  self.emit(\"error\", error);\n}, emitErrorAndCloseNextTick = function(self, error) {\n  self.emit(\"error\", error), self.emit(\"close\");\n}, emitListeningNextTick = function(self, onListen) {\n  if (typeof onListen === \"function\")\n    try {\n      onListen();\n    } catch (err) {\n      self.emit(\"error\", err);\n    }\n  self.emit(\"listening\");\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, $, { Duplex } = @getInternalField(@internalModuleRegistry, 39) || @createInternalModuleById(39), EventEmitter = @getInternalField(@internalModuleRegistry, 20) || @createInternalModuleById(20);\nvar IPv4Reg = new @RegExp(\"^((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$\");\nvar IPv6Reg = new @RegExp(\"^((\?:(\?:[0-9a-fA-F]{1,4}):){7}(\?:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){6}(\?:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|:(\?:[0-9a-fA-F]{1,4})|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){5}(\?::((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,2}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){4}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,1}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,3}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){3}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,2}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,4}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){2}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,3}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,5}|:)|(\?:(\?:[0-9a-fA-F]{1,4}):){1}(\?:(:(\?:[0-9a-fA-F]{1,4})){0,4}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(:(\?:[0-9a-fA-F]{1,4})){1,6}|:)|(\?::((\?::(\?:[0-9a-fA-F]{1,4})){0,5}:((\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])[.]){3}(\?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])|(\?::(\?:[0-9a-fA-F]{1,4})){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})\?$\"), { connect: bunConnect } = Bun, { setTimeout } = globalThis, bunTlsSymbol = Symbol.for(\"::buntls::\"), bunSocketServerHandlers = Symbol.for(\"::bunsocket_serverhandlers::\"), bunSocketServerConnections = Symbol.for(\"::bunnetserverconnections::\"), bunSocketServerOptions = Symbol.for(\"::bunnetserveroptions::\"), bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), bunTLSConnectOptions = Symbol.for(\"::buntlsconnectoptions::\"), SocketClass, Socket = function(InternalSocket) {\n  SocketClass = InternalSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"Socket\",\n    enumerable: !1\n  });\n  function Socket3(options) {\n    return new InternalSocket(options);\n  }\n  return Socket3.prototype = InternalSocket.prototype, Object.defineProperty(Socket3, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalSocket;\n    }\n  });\n}(class Socket2 extends Duplex {\n  static #Handlers = {\n    close: Socket2.#Close,\n    data({ data: self }, buffer) {\n      self.bytesRead += buffer.length;\n      const queue = self.#readQueue;\n      if (queue.isEmpty()) {\n        if (self.push(buffer))\n          return;\n      }\n      queue.push(buffer);\n    },\n    drain: Socket2.#Drain,\n    end: Socket2.#Close,\n    error(socket, error) {\n      const self = socket.data, callback = self.#writeCallback;\n      if (callback)\n        self.#writeCallback = null, callback(error);\n      self.emit(\"error\", error);\n    },\n    open(socket) {\n      const self = socket.data;\n      socket.timeout(self.timeout), socket.ref(), self[bunSocketInternal] = socket, self.connecting = !1;\n      const options = self[bunTLSConnectOptions];\n      if (options) {\n        const { session } = options;\n        if (session)\n          self.setSession(session);\n      }\n      if (!self.#upgraded)\n        self.emit(\"connect\", self);\n      Socket2.#Drain(socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self.emit(\"secure\", self);\n      const { checkServerIdentity } = self[bunTLSConnectOptions];\n      if (!verifyError && typeof checkServerIdentity === \"function\" && self.servername) {\n        const cert = self.getPeerCertificate(!0);\n        verifyError = checkServerIdentity(self.servername, cert);\n      }\n      if (self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnect\", verifyError);\n    },\n    timeout(socket) {\n      const self = socket.data;\n      self.emit(\"timeout\", self);\n    },\n    binaryType: \"buffer\"\n  };\n  static #Close(socket) {\n    const self = socket.data;\n    if (self.#closed)\n      return;\n    self.#closed = !0, self[bunSocketInternal] = null;\n    const queue = self.#readQueue;\n    if (queue.isEmpty()) {\n      if (self.push(null))\n        return;\n    }\n    queue.push(null);\n  }\n  static #Drain(socket) {\n    const self = socket.data, callback = self.#writeCallback;\n    if (callback) {\n      const chunk = self.#writeChunk, written = socket.write(chunk);\n      if (self.bytesWritten += written, written < chunk.length)\n        self.#writeChunk = chunk.slice(written);\n      else\n        self.#writeCallback = null, self.#writeChunk = null, callback(null);\n    }\n  }\n  static [bunSocketServerHandlers] = {\n    data: Socket2.#Handlers.data,\n    close(socket) {\n      Socket2.#Handlers.close(socket), this.data[bunSocketServerConnections]--;\n    },\n    end(socket) {\n      Socket2.#Handlers.end(socket), this.data[bunSocketServerConnections]--;\n    },\n    open(socket) {\n      const self = this.data, options = self[bunSocketServerOptions], { pauseOnConnect, connectionListener, InternalSocketClass, requestCert, rejectUnauthorized } = options, _socket = new InternalSocketClass({});\n      if (_socket.isServer = !0, _socket._requestCert = requestCert, _socket._rejectUnauthorized = rejectUnauthorized, _socket.#attach(this.localPort, socket), self.maxConnections && self[bunSocketServerConnections] >= self.maxConnections) {\n        const data = {\n          localAddress: _socket.localAddress,\n          localPort: _socket.localPort,\n          localFamily: _socket.localFamily,\n          remoteAddress: _socket.remoteAddress,\n          remotePort: _socket.remotePort,\n          remoteFamily: _socket.remoteFamily || \"IPv4\"\n        };\n        socket.end(), self.emit(\"drop\", data);\n        return;\n      }\n      if (!pauseOnConnect)\n        _socket.resume();\n      if (self[bunSocketServerConnections]++, typeof connectionListener == \"function\")\n        if (InternalSocketClass.name === \"TLSSocket\")\n          self.once(\"secureConnection\", () => connectionListener(_socket));\n        else\n          connectionListener(_socket);\n      self.emit(\"connection\", _socket);\n    },\n    handshake(socket, success, verifyError) {\n      const { data: self } = socket;\n      if (self.emit(\"secure\", self), self._securePending = !1, self.secureConnecting = !1, self._secureEstablished = !!success, self._requestCert || self._rejectUnauthorized) {\n        if (verifyError) {\n          if (self.authorized = !1, self.authorizationError = verifyError.code || verifyError.message, self._rejectUnauthorized) {\n            self.destroy(verifyError);\n            return;\n          }\n        }\n      } else\n        self.authorized = !0;\n      self.emit(\"secureConnection\", verifyError);\n    },\n    error(socket, error) {\n      Socket2.#Handlers.error(socket, error), this.data.emit(\"error\", error);\n    },\n    timeout: Socket2.#Handlers.timeout,\n    connectError: Socket2.#Handlers.connectError,\n    drain: Socket2.#Handlers.drain,\n    binaryType: \"buffer\"\n  };\n  bytesRead = 0;\n  bytesWritten = 0;\n  #closed = !1;\n  connecting = !1;\n  localAddress = \"127.0.0.1\";\n  #readQueue = @createFIFO();\n  remotePort;\n  [bunSocketInternal] = null;\n  [bunTLSConnectOptions] = null;\n  timeout = 0;\n  #writeCallback;\n  #writeChunk;\n  #pendingRead;\n  isServer = !1;\n  _handle;\n  _parent;\n  _parentWrap;\n  #socket;\n  #upgraded;\n  constructor(options) {\n    const { socket, signal, write, read, allowHalfOpen = !1, ...opts } = options || {};\n    super({\n      ...opts,\n      allowHalfOpen,\n      readable: !0,\n      writable: !0\n    });\n    if (this._handle = this, this._parent = this, this._parentWrap = this, this.#pendingRead = @undefined, this.#upgraded = !1, socket instanceof Socket2)\n      this.#socket = socket;\n    signal\?.once(\"abort\", () => this.destroy()), this.once(\"connect\", () => this.emit(\"ready\"));\n  }\n  address() {\n    return {\n      address: this.localAddress,\n      family: this.localFamily,\n      port: this.localPort\n    };\n  }\n  get bufferSize() {\n    return this.writableLength;\n  }\n  #attach(port, socket) {\n    if (this.remotePort = port, socket.data = this, socket.timeout(this.timeout), socket.ref(), this[bunSocketInternal] = socket, this.connecting = !1, !this.#upgraded)\n      this.emit(\"connect\", this);\n    Socket2.#Drain(socket);\n  }\n  connect(port, host, connectListener) {\n    var path, connection = this.#socket, _checkServerIdentity = @undefined;\n    if (typeof port === \"string\") {\n      if (path = port, port = @undefined, typeof host === \"function\")\n        connectListener = host, host = @undefined;\n    } else if (typeof host == \"function\") {\n      if (typeof port === \"string\")\n        path = port, port = @undefined;\n      connectListener = host, host = @undefined;\n    }\n    if (typeof port == \"object\") {\n      var {\n        port,\n        host,\n        path,\n        socket,\n        localAddress,\n        localPort,\n        family,\n        hints,\n        lookup,\n        noDelay,\n        keepAlive,\n        keepAliveInitialDelay,\n        requestCert,\n        rejectUnauthorized,\n        pauseOnConnect,\n        servername,\n        checkServerIdentity,\n        session\n      } = port;\n      if (_checkServerIdentity = checkServerIdentity, this.servername = servername, socket)\n        connection = socket;\n    }\n    if (!pauseOnConnect)\n      this.resume();\n    this.connecting = !0, this.remotePort = port;\n    const bunTLS = this[bunTlsSymbol];\n    var tls = @undefined;\n    if (typeof bunTLS === \"function\") {\n      if (tls = bunTLS.call(this, port, host, !0), this._requestCert = !0, this._rejectUnauthorized = rejectUnauthorized, tls) {\n        if (tls.rejectUnauthorized = rejectUnauthorized, tls.requestCert = !0, tls.session = session || tls.session, this.servername = tls.servername, tls.checkServerIdentity = _checkServerIdentity || tls.checkServerIdentity, this[bunTLSConnectOptions] = tls, !connection && tls.socket)\n          connection = tls.socket;\n      }\n      if (connection) {\n        if (typeof connection !== \"object\" || !(connection instanceof Socket2) || typeof connection[bunTlsSymbol] === \"function\")\n          @throwTypeError(\"socket must be an instance of net.Socket\");\n      }\n      if (this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, connectListener)\n        this.on(\"secureConnect\", connectListener);\n    } else if (connectListener)\n      this.on(\"connect\", connectListener);\n    try {\n      if (connection) {\n        const socket2 = connection[bunSocketInternal];\n        if (socket2) {\n          this.connecting = !0, this.#upgraded = !0;\n          const result = socket2.upgradeTLS({\n            data: this,\n            tls,\n            socket: Socket2.#Handlers\n          });\n          if (result) {\n            const [raw, tls2] = result;\n            connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n          } else\n            throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n        } else\n          connection.once(\"connect\", () => {\n            const socket3 = connection[bunSocketInternal];\n            if (!socket3)\n              return;\n            this.connecting = !0, this.#upgraded = !0;\n            const result = socket3.upgradeTLS({\n              data: this,\n              tls,\n              socket: Socket2.#Handlers\n            });\n            if (result) {\n              const [raw, tls2] = result;\n              connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2;\n            } else\n              throw this[bunSocketInternal] = null, new Error(\"Invalid socket\");\n          });\n      } else if (path)\n        bunConnect({\n          data: this,\n          unix: path,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n      else\n        bunConnect({\n          data: this,\n          hostname: host || \"localhost\",\n          port,\n          socket: Socket2.#Handlers,\n          tls\n        }).catch((error) => {\n          this.emit(\"error\", error), this.emit(\"close\");\n        });\n    } catch (error) {\n      process.nextTick(emitErrorAndCloseNextTick, this, error);\n    }\n    return this;\n  }\n  _destroy(err, callback) {\n    const socket = this[bunSocketInternal];\n    socket && process.nextTick(endNT, socket, callback, err);\n  }\n  _final(callback) {\n    this[bunSocketInternal]\?.end(), callback();\n  }\n  get localAddress() {\n    return \"127.0.0.1\";\n  }\n  get localFamily() {\n    return \"IPv4\";\n  }\n  get localPort() {\n    return this[bunSocketInternal]\?.localPort;\n  }\n  get pending() {\n    return this.connecting;\n  }\n  _read(size) {\n    const queue = this.#readQueue;\n    let chunk;\n    while (chunk = queue.peek()) {\n      if (!this.push(chunk))\n        return;\n      queue.shift();\n    }\n  }\n  get readyState() {\n    if (this.connecting)\n      return \"opening\";\n    if (this.readable)\n      return this.writable \? \"open\" : \"readOnly\";\n    else\n      return this.writable \? \"writeOnly\" : \"closed\";\n  }\n  ref() {\n    this[bunSocketInternal]\?.ref();\n  }\n  get remoteAddress() {\n    return this[bunSocketInternal]\?.remoteAddress;\n  }\n  get remoteFamily() {\n    return \"IPv4\";\n  }\n  resetAndDestroy() {\n    this[bunSocketInternal]\?.end();\n  }\n  setKeepAlive(enable = !1, initialDelay = 0) {\n    return this;\n  }\n  setNoDelay(noDelay = !0) {\n    return this;\n  }\n  setTimeout(timeout, callback) {\n    if (this[bunSocketInternal]\?.timeout(timeout), this.timeout = timeout, callback)\n      this.once(\"timeout\", callback);\n    return this;\n  }\n  unref() {\n    this[bunSocketInternal]\?.unref();\n  }\n  _write(chunk, encoding, callback) {\n    if (typeof chunk == \"string\" && encoding !== \"ascii\")\n      chunk = @Buffer.from(chunk, encoding);\n    var written = this[bunSocketInternal]\?.write(chunk);\n    if (written == chunk.length)\n      callback();\n    else if (this.#writeCallback)\n      callback(new Error(\"overlapping _write()\"));\n    else {\n      if (written > 0)\n        if (typeof chunk == \"string\")\n          chunk = chunk.slice(written);\n        else\n          chunk = chunk.subarray(written);\n      this.#writeCallback = callback, this.#writeChunk = chunk;\n    }\n  }\n}), connect = createConnection;\n\nclass Server extends EventEmitter {\n  #server;\n  #listening = !1;\n  [bunSocketServerConnections] = 0;\n  [bunSocketServerOptions];\n  maxConnections = 0;\n  constructor(options, connectionListener) {\n    super();\n    if (typeof options === \"function\")\n      connectionListener = options, options = {};\n    else if (options == null || typeof options === \"object\")\n      options = { ...options };\n    else\n      throw new Error(\"bun-net-polyfill: invalid arguments\");\n    const { maxConnections } = options;\n    this.maxConnections = Number.isSafeInteger(maxConnections) && maxConnections > 0 \? maxConnections : 0, options.connectionListener = connectionListener, this[bunSocketServerOptions] = options;\n  }\n  ref() {\n    return this.#server\?.ref(), this;\n  }\n  unref() {\n    return this.#server\?.unref(), this;\n  }\n  close(callback) {\n    if (this.#server) {\n      if (this.#server.stop(!0), this.#server = null, this.#listening = !1, this[bunSocketServerConnections] = 0, this.emit(\"close\"), typeof callback === \"function\")\n        callback();\n      return this;\n    }\n    if (typeof callback === \"function\") {\n      const error = new Error(\"Server is not running\");\n      error.code = \"ERR_SERVER_NOT_RUNNING\", callback(error);\n    }\n    return this;\n  }\n  address() {\n    const server = this.#server;\n    if (server) {\n      const unix = server.unix;\n      if (unix)\n        return unix;\n      let address = server.hostname;\n      const type = isIP(address), port = server.port;\n      if (typeof port === \"number\")\n        return {\n          port,\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      if (type)\n        return {\n          address,\n          family: type \? `IPv${type}` : @undefined\n        };\n      return address;\n    }\n    return null;\n  }\n  getConnections(callback) {\n    if (typeof callback === \"function\")\n      callback(null, this.#server \? this[bunSocketServerConnections] : 0);\n    return this;\n  }\n  listen(port, hostname, onListen) {\n    let backlog, path, exclusive = !1;\n    if (typeof port === \"string\") {\n      if (Number.isSafeInteger(hostname)) {\n        if (hostname > 0)\n          backlog = hostname;\n      } else if (typeof hostname === \"function\")\n        onListen = hostname;\n      path = port, hostname = @undefined, port = @undefined;\n    } else {\n      if (typeof hostname === \"function\")\n        onListen = hostname, hostname = @undefined;\n      if (typeof port === \"function\")\n        onListen = port, port = 0;\n      else if (typeof port === \"object\") {\n        const options = port;\n        options.signal\?.addEventListener(\"abort\", () => this.close()), hostname = options.host, exclusive = options.exclusive === !0;\n        const path2 = options.path;\n        if (port = options.port, !Number.isSafeInteger(port) || port < 0)\n          if (path2)\n            hostname = path2, port = @undefined;\n          else {\n            let message = 'The argument \\'options\\' must have the property \"port\" or \"path\"';\n            try {\n              message = `${message}. Received ${JSON.stringify(options)}`;\n            } catch {\n            }\n            const error = @makeTypeError(message);\n            throw error.code = \"ERR_INVALID_ARG_VALUE\", error;\n          }\n        else if (!Number.isSafeInteger(port) || port < 0)\n          port = 0;\n        if (typeof port.callback === \"function\")\n          onListen = port\?.callback;\n      } else if (!Number.isSafeInteger(port) || port < 0)\n        port = 0;\n      hostname = hostname || \"::\";\n    }\n    try {\n      var tls = @undefined, TLSSocketClass = @undefined;\n      const bunTLS = this[bunTlsSymbol], options = this[bunSocketServerOptions];\n      if (typeof bunTLS === \"function\")\n        [tls, TLSSocketClass] = bunTLS.call(this, port, hostname, !1), options.servername = tls.serverName, options.InternalSocketClass = TLSSocketClass;\n      else\n        options.InternalSocketClass = SocketClass;\n      this.#server = Bun.listen(path \? {\n        exclusive,\n        unix: path,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      } : {\n        exclusive,\n        port,\n        hostname,\n        tls,\n        socket: SocketClass[bunSocketServerHandlers]\n      }), this.#server.data = this, this.#listening = !0, setTimeout(emitListeningNextTick, 1, this, onListen);\n    } catch (err) {\n      this.#listening = !1, setTimeout(emitErrorNextTick, 1, this, err);\n    }\n    return this;\n  }\n}\n$ = {\n  createServer,\n  Server,\n  createConnection,\n  connect,\n  isIP,\n  isIPv4,\n  isIPv6,\n  Socket,\n  [Symbol.for(\"::bunternal::\")]: SocketClass\n};\nreturn $})\n"_s;
 //
 
 //
@@ -681,7 +681,7 @@ static constexpr ASCIILiteral NodeTimersPromisesCode = "(function (){\"use stric
 //
 
 //
-static constexpr ASCIILiteral NodeTLSCode = "(function (){\"use strict\";// src/js/out/tmp/node/tls.ts\nvar parseCertString = function() {\n  throwNotImplemented(\"Not implemented\");\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, unfqdn = function(host) {\n  return RegExpPrototypeSymbolReplace.call(/[.]$/, host, \"\");\n}, toLowerCase = function(c) {\n  return StringFromCharCode.call(32 + StringPrototypeCharCodeAt.call(c, 0));\n}, splitHost = function(host) {\n  return StringPrototypeSplit.call(RegExpPrototypeSymbolReplace.call(/[A-Z]/g, unfqdn(host), toLowerCase), \".\");\n}, check = function(hostParts, pattern, wildcards) {\n  if (!pattern)\n    return !1;\n  const patternParts = splitHost(pattern);\n  if (hostParts.length !== patternParts.length)\n    return !1;\n  if (ArrayPrototypeIncludes.call(patternParts, \"\"))\n    return !1;\n  const isBad = (s) => RegExpPrototypeExec.call(/[^\\u0021-\\u007F]/u, s) !== null;\n  if (ArrayPrototypeSome.call(patternParts, isBad))\n    return !1;\n  for (let i = hostParts.length - 1;i > 0; i -= 1)\n    if (hostParts[i] !== patternParts[i])\n      return !1;\n  const hostSubdomain = hostParts[0], patternSubdomain = patternParts[0], patternSubdomainParts = StringPrototypeSplit.call(patternSubdomain, \"*\");\n  if (patternSubdomainParts.length === 1 || StringPrototypeIncludes.call(patternSubdomain, \"xn--\"))\n    return hostSubdomain === patternSubdomain;\n  if (!wildcards)\n    return !1;\n  if (patternSubdomainParts.length > 2)\n    return !1;\n  if (patternParts.length <= 2)\n    return !1;\n  const { 0: prefix, 1: suffix } = patternSubdomainParts;\n  if (prefix.length + suffix.length > hostSubdomain.length)\n    return !1;\n  if (!StringPrototypeStartsWith.call(hostSubdomain, prefix))\n    return !1;\n  if (!StringPrototypeEndsWith.call(hostSubdomain, suffix))\n    return !1;\n  return !0;\n}, splitEscapedAltNames = function(altNames) {\n  const result = [];\n  let currentToken = \"\", offset = 0;\n  while (offset !== altNames.length) {\n    const nextSep = StringPrototypeIndexOf.call(altNames, \", \", offset), nextQuote = StringPrototypeIndexOf.call(altNames, '\"', offset);\n    if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) {\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextQuote);\n      const match = RegExpPrototypeExec.call(jsonStringPattern, StringPrototypeSubstring.call(altNames, nextQuote));\n      if (!match) {\n        let error = new SyntaxError(\"ERR_TLS_CERT_ALTNAME_FORMAT: Invalid subject alternative name string\");\n        throw error.name = ERR_TLS_CERT_ALTNAME_FORMAT, error;\n      }\n      currentToken += JSON.parse(match[0]), offset = nextQuote + match[0].length;\n    } else if (nextSep !== -1)\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextSep), ArrayPrototypePush.call(result, currentToken), currentToken = \"\", offset = nextSep + 2;\n    else\n      currentToken += StringPrototypeSubstring.call(altNames, offset), offset = altNames.length;\n  }\n  return ArrayPrototypePush.call(result, currentToken), result;\n}, checkServerIdentity = function(hostname, cert) {\n  const { subject, subjectaltname: altNames } = cert, dnsNames = [], ips = [];\n  if (hostname = \"\" + hostname, altNames) {\n    const splitAltNames = StringPrototypeIncludes.call(altNames, '\"') \? splitEscapedAltNames(altNames) : StringPrototypeSplit.call(altNames, \", \");\n    ArrayPrototypeForEach.call(splitAltNames, (name) => {\n      if (StringPrototypeStartsWith.call(name, \"DNS:\"))\n        ArrayPrototypePush.call(dnsNames, StringPrototypeSlice.call(name, 4));\n      else if (StringPrototypeStartsWith.call(name, \"IP Address:\"))\n        ArrayPrototypePush.call(ips, canonicalizeIP(StringPrototypeSlice.call(name, 11)));\n    });\n  }\n  let valid = !1, reason = \"Unknown reason\";\n  if (hostname = unfqdn(hostname), net.isIP(hostname)) {\n    if (valid = ArrayPrototypeIncludes.call(ips, canonicalizeIP(hostname)), !valid)\n      reason = `IP: ${hostname} is not in the cert's list: ` + ArrayPrototypeJoin.call(ips, \", \");\n  } else if (dnsNames.length > 0 || subject\?.CN) {\n    const hostParts = splitHost(hostname), wildcard = (pattern) => check(hostParts, pattern, !0);\n    if (dnsNames.length > 0) {\n      if (valid = ArrayPrototypeSome.call(dnsNames, wildcard), !valid)\n        reason = `Host: ${hostname}. is not in the cert's altnames: ${altNames}`;\n    } else {\n      const cn = subject.CN;\n      if (@Array.isArray(cn))\n        valid = ArrayPrototypeSome.call(cn, wildcard);\n      else if (cn)\n        valid = wildcard(cn);\n      if (!valid)\n        reason = `Host: ${hostname}. is not cert's CN: ${cn}`;\n    }\n  } else\n    reason = \"Cert does not contain a DNS name\";\n  if (!valid) {\n    let error = new Error(`ERR_TLS_CERT_ALTNAME_INVALID: Hostname/IP does not match certificate's altnames: ${reason}`);\n    return error.name = \"ERR_TLS_CERT_ALTNAME_INVALID\", error.reason = reason, error.host = hostname, error.cert = cert, error;\n  }\n}, SecureContext = function(options) {\n  return new InternalSecureContext(options);\n}, createSecureContext = function(options) {\n  return new SecureContext(options);\n}, translatePeerCertificate = function(c) {\n  if (!c)\n    return null;\n  if (c.issuerCertificate != null && c.issuerCertificate !== c)\n    c.issuerCertificate = translatePeerCertificate(c.issuerCertificate);\n  if (c.infoAccess != null) {\n    const info = c.infoAccess;\n    c.infoAccess = { __proto__: null }, RegExpPrototypeSymbolReplace.call(/([^\\n:]*):([^\\n]*)(\?:\\n|$)/g, info, (all, key, val) => {\n      if (val.charCodeAt(0) === 34)\n        val = JSONParse(val);\n      if (key in c.infoAccess)\n        ArrayPrototypePush.call(c.infoAccess[key], val);\n      else\n        c.infoAccess[key] = [val];\n    });\n  }\n  return c;\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, getCiphers = function() {\n  return DEFAULT_CIPHERS.split(\":\");\n}, convertProtocols = function(protocols) {\n  const lens = new @Array(protocols.length), buff = @Buffer.allocUnsafe(ArrayPrototypeReduce.call(protocols, (p, c, i) => {\n    const len = @Buffer.byteLength(c);\n    if (len > 255)\n      @throwRangeError(\"The byte length of the protocol at index \" + `${i} exceeds the maximum length.`, \"<= 255\", len, !0);\n    return lens[i] = len, p + 1 + len;\n  }, 0));\n  let offset = 0;\n  for (let i = 0, c = protocols.length;i < c; i++)\n    buff[offset++] = lens[i], buff.write(protocols[i], offset), offset += lens[i];\n  return buff;\n}, convertALPNProtocols = function(protocols, out) {\n  if (@Array.isArray(protocols))\n    out.ALPNProtocols = convertProtocols(protocols);\n  else if (isTypedArray(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols);\n  else if (isArrayBufferView(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols.buffer.slice(protocols.byteOffset, protocols.byteOffset + protocols.byteLength));\n  else if (@Buffer.isBuffer(protocols))\n    out.ALPNProtocols = protocols;\n}, $, { isArrayBufferView, isTypedArray } = @requireNativeModule(\"util/types\"), net = @getInternalField(@internalModuleRegistry, 27) || @createInternalModuleById(27), { Server: NetServer, [Symbol.for(\"::bunternal::\")]: InternalTCPSocket } = net, bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), { rootCertificates, canonicalizeIP } = @lazy(\"internal/tls\"), SymbolReplace = Symbol.replace, RegExpPrototypeSymbolReplace = @RegExp.prototype[SymbolReplace], RegExpPrototypeExec = @RegExp.prototype.exec, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeSlice = @String.prototype.slice, StringPrototypeIncludes = @String.prototype.includes, StringPrototypeSplit = @String.prototype.split, StringPrototypeIndexOf = @String.prototype.indexOf, StringPrototypeSubstring = @String.prototype.substring, StringPrototypeEndsWith = @String.prototype.endsWith, StringFromCharCode = @String.fromCharCode, StringPrototypeCharCodeAt = @String.prototype.charCodeAt, ArrayPrototypeIncludes = @Array.prototype.includes, ArrayPrototypeJoin = @Array.prototype.join, ArrayPrototypeForEach = @Array.prototype.forEach, ArrayPrototypePush = @Array.prototype.push, ArrayPrototypeSome = @Array.prototype.some, ArrayPrototypeReduce = @Array.prototype.reduce, jsonStringPattern = /^\"(\?:[^\"\\\\\\u0000-\\u001f]|\\\\(\?:[\"\\\\/bfnrt]|u[0-9a-fA-F]{4}))*\"/, InternalSecureContext = class SecureContext2 {\n  context;\n  constructor(options) {\n    const context = {};\n    if (options) {\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n    }\n    this.context = context;\n  }\n}, buntls = Symbol.for(\"::buntls::\"), SocketClass, TLSSocket = function(InternalTLSSocket) {\n  return SocketClass = InternalTLSSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"TLSSocket\",\n    enumerable: !1\n  }), Object.defineProperty(function Socket(options) {\n    return new InternalTLSSocket(options);\n  }, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalTLSSocket;\n    }\n  });\n}(class TLSSocket2 extends InternalTCPSocket {\n  #secureContext;\n  ALPNProtocols;\n  #socket;\n  #checkServerIdentity;\n  #session;\n  constructor(socket, options) {\n    super(socket instanceof InternalTCPSocket \? options : options || socket);\n    if (options = options || socket || {}, typeof options === \"object\") {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      if (socket instanceof InternalTCPSocket)\n        this.#socket = socket;\n    }\n    this.#secureContext = options.secureContext || createSecureContext(options), this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, this.#checkServerIdentity = options.checkServerIdentity || checkServerIdentity, this.#session = options.session || null;\n  }\n  _secureEstablished = !1;\n  _securePending = !0;\n  _newSessionPending;\n  _controlReleased;\n  secureConnecting = !1;\n  _SNICallback;\n  servername;\n  authorized = !1;\n  authorizationError;\n  #renegotiationDisabled = !1;\n  encrypted = !0;\n  _start() {\n    this.connect();\n  }\n  getSession() {\n    return this[bunSocketInternal]\?.getSession();\n  }\n  getEphemeralKeyInfo() {\n    return this[bunSocketInternal]\?.getEphemeralKeyInfo();\n  }\n  getCipher() {\n    return this[bunSocketInternal]\?.getCipher();\n  }\n  getSharedSigalgs() {\n    return this[bunSocketInternal]\?.getSharedSigalgs();\n  }\n  getProtocol() {\n    return this[bunSocketInternal]\?.getTLSVersion();\n  }\n  getFinished() {\n    return this[bunSocketInternal]\?.getTLSFinishedMessage() || @undefined;\n  }\n  getPeerFinished() {\n    return this[bunSocketInternal]\?.getTLSPeerFinishedMessage() || @undefined;\n  }\n  isSessionReused() {\n    return !!this.#session;\n  }\n  renegotiate() {\n    if (this.#renegotiationDisabled) {\n      const error = new Error(\"ERR_TLS_RENEGOTIATION_DISABLED: TLS session renegotiation disabled for this socket\");\n      throw error.name = \"ERR_TLS_RENEGOTIATION_DISABLED\", error;\n    }\n    throw Error(\"Not implented in Bun yet\");\n  }\n  disableRenegotiation() {\n    this.#renegotiationDisabled = !0;\n  }\n  getTLSTicket() {\n    return this[bunSocketInternal]\?.getTLSTicket();\n  }\n  exportKeyingMaterial(length, label, context) {\n    if (context)\n      return this[bunSocketInternal]\?.exportKeyingMaterial(length, label, context);\n    return this[bunSocketInternal]\?.exportKeyingMaterial(length, label);\n  }\n  setMaxSendFragment(size) {\n    return this[bunSocketInternal]\?.setMaxSendFragment(size) || !1;\n  }\n  enableTrace() {\n  }\n  setServername(name) {\n    if (this.isServer) {\n      let error = new Error(\"ERR_TLS_SNI_FROM_SERVER: Cannot issue SNI from a TLS server-side socket\");\n      throw error.name = \"ERR_TLS_SNI_FROM_SERVER\", error;\n    }\n    this.servername = name, this[bunSocketInternal]\?.setServername(name);\n  }\n  setSession(session) {\n    if (this.#session = session, typeof session === \"string\")\n      session = @Buffer.from(session, \"latin1\");\n    return this[bunSocketInternal]\?.setSession(session);\n  }\n  getPeerCertificate(abbreviated) {\n    const cert = arguments.length < 1 \? this[bunSocketInternal]\?.getPeerCertificate() : this[bunSocketInternal]\?.getPeerCertificate(abbreviated);\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getCertificate() {\n    const cert = this[bunSocketInternal]\?.getCertificate();\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getPeerX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  getX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  get alpnProtocol() {\n    return this[bunSocketInternal]\?.alpnProtocol;\n  }\n  [buntls](port, host) {\n    return {\n      socket: this.#socket,\n      ALPNProtocols: this.ALPNProtocols,\n      serverName: this.servername || host || \"localhost\",\n      checkServerIdentity: this.#checkServerIdentity,\n      session: this.#session,\n      ...this.#secureContext\n    };\n  }\n});\n\nclass Server extends NetServer {\n  key;\n  cert;\n  ca;\n  passphrase;\n  secureOptions;\n  _rejectUnauthorized;\n  _requestCert;\n  servername;\n  ALPNProtocols;\n  constructor(options, secureConnectionListener) {\n    super(options, secureConnectionListener);\n    this.setSecureContext(options);\n  }\n  setSecureContext(options) {\n    if (options instanceof InternalSecureContext)\n      options = options.context;\n    if (options) {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n      const requestCert = options.requestCert || !1;\n      if (requestCert)\n        this._requestCert = requestCert;\n      else\n        this._requestCert = @undefined;\n      const rejectUnauthorized = options.rejectUnauthorized || !1;\n      if (rejectUnauthorized)\n        this._rejectUnauthorized = rejectUnauthorized;\n      else\n        this._rejectUnauthorized = @undefined;\n    }\n  }\n  getTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  setTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  [buntls](port, host, isClient) {\n    return [\n      {\n        serverName: this.servername || host || \"localhost\",\n        key: this.key,\n        cert: this.cert,\n        ca: this.ca,\n        passphrase: this.passphrase,\n        secureOptions: this.secureOptions,\n        rejectUnauthorized: isClient \? !1 : this._rejectUnauthorized,\n        requestCert: isClient \? !1 : this._requestCert,\n        ALPNProtocols: this.ALPNProtocols\n      },\n      SocketClass\n    ];\n  }\n}\nvar CLIENT_RENEG_LIMIT = 3, CLIENT_RENEG_WINDOW = 600, DEFAULT_ECDH_CURVE = \"auto\", DEFAULT_CIPHERS = \"DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256\", DEFAULT_MIN_VERSION = \"TLSv1.2\", DEFAULT_MAX_VERSION = \"TLSv1.3\", createConnection = (port, host, connectListener) => {\n  if (typeof port === \"object\") {\n    port.checkServerIdentity;\n    const { ALPNProtocols } = port;\n    if (ALPNProtocols)\n      convertALPNProtocols(ALPNProtocols, port);\n    return new TLSSocket(port).connect(port, host, connectListener);\n  }\n  return new TLSSocket().connect(port, host, connectListener);\n}, connect = createConnection;\n$ = {\n  CLIENT_RENEG_LIMIT,\n  CLIENT_RENEG_WINDOW,\n  connect,\n  convertALPNProtocols,\n  createConnection,\n  createSecureContext,\n  createServer,\n  DEFAULT_CIPHERS,\n  DEFAULT_ECDH_CURVE,\n  DEFAULT_MAX_VERSION,\n  DEFAULT_MIN_VERSION,\n  getCiphers,\n  parseCertString,\n  SecureContext,\n  Server,\n  TLSSocket,\n  checkServerIdentity,\n  rootCertificates\n};\nreturn $})\n"_s;
+static constexpr ASCIILiteral NodeTLSCode = "(function (){\"use strict\";// src/js/out/tmp/node/tls.ts\nvar parseCertString = function() {\n  throwNotImplemented(\"Not implemented\");\n}, isValidTLSArray = function(obj) {\n  if (typeof obj === \"string\" || isTypedArray(obj) || obj instanceof @ArrayBuffer || obj instanceof Blob)\n    return !0;\n  if (@Array.isArray(obj)) {\n    for (var i = 0;i < obj.length; i++)\n      if (typeof obj !== \"string\" && !isTypedArray(obj) && !(obj instanceof @ArrayBuffer) && !(obj instanceof Blob))\n        return !1;\n    return !0;\n  }\n}, unfqdn = function(host) {\n  return RegExpPrototypeSymbolReplace.call(/[.]$/, host, \"\");\n}, toLowerCase = function(c) {\n  return StringFromCharCode.call(32 + StringPrototypeCharCodeAt.call(c, 0));\n}, splitHost = function(host) {\n  return StringPrototypeSplit.call(RegExpPrototypeSymbolReplace.call(/[A-Z]/g, unfqdn(host), toLowerCase), \".\");\n}, check = function(hostParts, pattern, wildcards) {\n  if (!pattern)\n    return !1;\n  const patternParts = splitHost(pattern);\n  if (hostParts.length !== patternParts.length)\n    return !1;\n  if (ArrayPrototypeIncludes.call(patternParts, \"\"))\n    return !1;\n  const isBad = (s) => RegExpPrototypeExec.call(/[^\\u0021-\\u007F]/u, s) !== null;\n  if (ArrayPrototypeSome.call(patternParts, isBad))\n    return !1;\n  for (let i = hostParts.length - 1;i > 0; i -= 1)\n    if (hostParts[i] !== patternParts[i])\n      return !1;\n  const hostSubdomain = hostParts[0], patternSubdomain = patternParts[0], patternSubdomainParts = StringPrototypeSplit.call(patternSubdomain, \"*\");\n  if (patternSubdomainParts.length === 1 || StringPrototypeIncludes.call(patternSubdomain, \"xn--\"))\n    return hostSubdomain === patternSubdomain;\n  if (!wildcards)\n    return !1;\n  if (patternSubdomainParts.length > 2)\n    return !1;\n  if (patternParts.length <= 2)\n    return !1;\n  const { 0: prefix, 1: suffix } = patternSubdomainParts;\n  if (prefix.length + suffix.length > hostSubdomain.length)\n    return !1;\n  if (!StringPrototypeStartsWith.call(hostSubdomain, prefix))\n    return !1;\n  if (!StringPrototypeEndsWith.call(hostSubdomain, suffix))\n    return !1;\n  return !0;\n}, splitEscapedAltNames = function(altNames) {\n  const result = [];\n  let currentToken = \"\", offset = 0;\n  while (offset !== altNames.length) {\n    const nextSep = StringPrototypeIndexOf.call(altNames, \", \", offset), nextQuote = StringPrototypeIndexOf.call(altNames, '\"', offset);\n    if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) {\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextQuote);\n      const match = RegExpPrototypeExec.call(jsonStringPattern, StringPrototypeSubstring.call(altNames, nextQuote));\n      if (!match) {\n        let error = new SyntaxError(\"ERR_TLS_CERT_ALTNAME_FORMAT: Invalid subject alternative name string\");\n        throw error.name = ERR_TLS_CERT_ALTNAME_FORMAT, error;\n      }\n      currentToken += JSON.parse(match[0]), offset = nextQuote + match[0].length;\n    } else if (nextSep !== -1)\n      currentToken += StringPrototypeSubstring.call(altNames, offset, nextSep), ArrayPrototypePush.call(result, currentToken), currentToken = \"\", offset = nextSep + 2;\n    else\n      currentToken += StringPrototypeSubstring.call(altNames, offset), offset = altNames.length;\n  }\n  return ArrayPrototypePush.call(result, currentToken), result;\n}, checkServerIdentity = function(hostname, cert) {\n  const { subject, subjectaltname: altNames } = cert, dnsNames = [], ips = [];\n  if (hostname = \"\" + hostname, altNames) {\n    const splitAltNames = StringPrototypeIncludes.call(altNames, '\"') \? splitEscapedAltNames(altNames) : StringPrototypeSplit.call(altNames, \", \");\n    ArrayPrototypeForEach.call(splitAltNames, (name) => {\n      if (StringPrototypeStartsWith.call(name, \"DNS:\"))\n        ArrayPrototypePush.call(dnsNames, StringPrototypeSlice.call(name, 4));\n      else if (StringPrototypeStartsWith.call(name, \"IP Address:\"))\n        ArrayPrototypePush.call(ips, canonicalizeIP(StringPrototypeSlice.call(name, 11)));\n    });\n  }\n  let valid = !1, reason = \"Unknown reason\";\n  if (hostname = unfqdn(hostname), net.isIP(hostname)) {\n    if (valid = ArrayPrototypeIncludes.call(ips, canonicalizeIP(hostname)), !valid)\n      reason = `IP: ${hostname} is not in the cert's list: ` + ArrayPrototypeJoin.call(ips, \", \");\n  } else if (dnsNames.length > 0 || subject\?.CN) {\n    const hostParts = splitHost(hostname), wildcard = (pattern) => check(hostParts, pattern, !0);\n    if (dnsNames.length > 0) {\n      if (valid = ArrayPrototypeSome.call(dnsNames, wildcard), !valid)\n        reason = `Host: ${hostname}. is not in the cert's altnames: ${altNames}`;\n    } else {\n      const cn = subject.CN;\n      if (@Array.isArray(cn))\n        valid = ArrayPrototypeSome.call(cn, wildcard);\n      else if (cn)\n        valid = wildcard(cn);\n      if (!valid)\n        reason = `Host: ${hostname}. is not cert's CN: ${cn}`;\n    }\n  } else\n    reason = \"Cert does not contain a DNS name\";\n  if (!valid) {\n    let error = new Error(`ERR_TLS_CERT_ALTNAME_INVALID: Hostname/IP does not match certificate's altnames: ${reason}`);\n    return error.name = \"ERR_TLS_CERT_ALTNAME_INVALID\", error.reason = reason, error.host = hostname, error.cert = cert, error;\n  }\n}, SecureContext = function(options) {\n  return new InternalSecureContext(options);\n}, createSecureContext = function(options) {\n  return new SecureContext(options);\n}, translatePeerCertificate = function(c) {\n  if (!c)\n    return null;\n  if (c.issuerCertificate != null && c.issuerCertificate !== c)\n    c.issuerCertificate = translatePeerCertificate(c.issuerCertificate);\n  if (c.infoAccess != null) {\n    const info = c.infoAccess;\n    c.infoAccess = { __proto__: null }, RegExpPrototypeSymbolReplace.call(/([^\\n:]*):([^\\n]*)(\?:\\n|$)/g, info, (all, key, val) => {\n      if (val.charCodeAt(0) === 34)\n        val = JSONParse(val);\n      if (key in c.infoAccess)\n        ArrayPrototypePush.call(c.infoAccess[key], val);\n      else\n        c.infoAccess[key] = [val];\n    });\n  }\n  return c;\n}, createServer = function(options, connectionListener) {\n  return new Server(options, connectionListener);\n}, getCiphers = function() {\n  return DEFAULT_CIPHERS.split(\":\");\n}, convertProtocols = function(protocols) {\n  const lens = new @Array(protocols.length), buff = @Buffer.allocUnsafe(ArrayPrototypeReduce.call(protocols, (p, c, i) => {\n    const len = @Buffer.byteLength(c);\n    if (len > 255)\n      @throwRangeError(\"The byte length of the protocol at index \" + `${i} exceeds the maximum length.`, \"<= 255\", len, !0);\n    return lens[i] = len, p + 1 + len;\n  }, 0));\n  let offset = 0;\n  for (let i = 0, c = protocols.length;i < c; i++)\n    buff[offset++] = lens[i], buff.write(protocols[i], offset), offset += lens[i];\n  return buff;\n}, convertALPNProtocols = function(protocols, out) {\n  if (@Array.isArray(protocols))\n    out.ALPNProtocols = convertProtocols(protocols);\n  else if (isTypedArray(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols);\n  else if (isArrayBufferView(protocols))\n    out.ALPNProtocols = @Buffer.from(protocols.buffer.slice(protocols.byteOffset, protocols.byteOffset + protocols.byteLength));\n  else if (@Buffer.isBuffer(protocols))\n    out.ALPNProtocols = protocols;\n}, $, { isArrayBufferView, isTypedArray } = @requireNativeModule(\"util/types\"), net = @getInternalField(@internalModuleRegistry, 27) || @createInternalModuleById(27), { Server: NetServer, [Symbol.for(\"::bunternal::\")]: InternalTCPSocket } = net, bunSocketInternal = Symbol.for(\"::bunnetsocketinternal::\"), { rootCertificates, canonicalizeIP } = @lazy(\"internal/tls\"), SymbolReplace = Symbol.replace, RegExpPrototypeSymbolReplace = @RegExp.prototype[SymbolReplace], RegExpPrototypeExec = @RegExp.prototype.exec, StringPrototypeStartsWith = @String.prototype.startsWith, StringPrototypeSlice = @String.prototype.slice, StringPrototypeIncludes = @String.prototype.includes, StringPrototypeSplit = @String.prototype.split, StringPrototypeIndexOf = @String.prototype.indexOf, StringPrototypeSubstring = @String.prototype.substring, StringPrototypeEndsWith = @String.prototype.endsWith, StringFromCharCode = @String.fromCharCode, StringPrototypeCharCodeAt = @String.prototype.charCodeAt, ArrayPrototypeIncludes = @Array.prototype.includes, ArrayPrototypeJoin = @Array.prototype.join, ArrayPrototypeForEach = @Array.prototype.forEach, ArrayPrototypePush = @Array.prototype.push, ArrayPrototypeSome = @Array.prototype.some, ArrayPrototypeReduce = @Array.prototype.reduce, jsonStringPattern = /^\"(\?:[^\"\\\\\\u0000-\\u001f]|\\\\(\?:[\"\\\\/bfnrt]|u[0-9a-fA-F]{4}))*\"/, InternalSecureContext = class SecureContext2 {\n  context;\n  constructor(options) {\n    const context = {};\n    if (options) {\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n    }\n    this.context = context;\n  }\n}, buntls = Symbol.for(\"::buntls::\"), SocketClass, TLSSocket = function(InternalTLSSocket) {\n  SocketClass = InternalTLSSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {\n    value: \"TLSSocket\",\n    enumerable: !1\n  });\n  function Socket(options) {\n    return new InternalTLSSocket(options);\n  }\n  return Socket.prototype = InternalTLSSocket.prototype, Object.defineProperty(Socket, Symbol.hasInstance, {\n    value(instance) {\n      return instance instanceof InternalTLSSocket;\n    }\n  });\n}(class TLSSocket2 extends InternalTCPSocket {\n  #secureContext;\n  ALPNProtocols;\n  #socket;\n  #checkServerIdentity;\n  #session;\n  constructor(socket, options) {\n    super(socket instanceof InternalTCPSocket \? options : options || socket);\n    if (options = options || socket || {}, typeof options === \"object\") {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      if (socket instanceof InternalTCPSocket)\n        this.#socket = socket;\n    }\n    this.#secureContext = options.secureContext || createSecureContext(options), this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, this.#checkServerIdentity = options.checkServerIdentity || checkServerIdentity, this.#session = options.session || null;\n  }\n  _secureEstablished = !1;\n  _securePending = !0;\n  _newSessionPending;\n  _controlReleased;\n  secureConnecting = !1;\n  _SNICallback;\n  servername;\n  authorized = !1;\n  authorizationError;\n  #renegotiationDisabled = !1;\n  encrypted = !0;\n  _start() {\n    this.connect();\n  }\n  getSession() {\n    return this[bunSocketInternal]\?.getSession();\n  }\n  getEphemeralKeyInfo() {\n    return this[bunSocketInternal]\?.getEphemeralKeyInfo();\n  }\n  getCipher() {\n    return this[bunSocketInternal]\?.getCipher();\n  }\n  getSharedSigalgs() {\n    return this[bunSocketInternal]\?.getSharedSigalgs();\n  }\n  getProtocol() {\n    return this[bunSocketInternal]\?.getTLSVersion();\n  }\n  getFinished() {\n    return this[bunSocketInternal]\?.getTLSFinishedMessage() || @undefined;\n  }\n  getPeerFinished() {\n    return this[bunSocketInternal]\?.getTLSPeerFinishedMessage() || @undefined;\n  }\n  isSessionReused() {\n    return !!this.#session;\n  }\n  renegotiate() {\n    if (this.#renegotiationDisabled) {\n      const error = new Error(\"ERR_TLS_RENEGOTIATION_DISABLED: TLS session renegotiation disabled for this socket\");\n      throw error.name = \"ERR_TLS_RENEGOTIATION_DISABLED\", error;\n    }\n    throw Error(\"Not implented in Bun yet\");\n  }\n  disableRenegotiation() {\n    this.#renegotiationDisabled = !0;\n  }\n  getTLSTicket() {\n    return this[bunSocketInternal]\?.getTLSTicket();\n  }\n  exportKeyingMaterial(length, label, context) {\n    if (context)\n      return this[bunSocketInternal]\?.exportKeyingMaterial(length, label, context);\n    return this[bunSocketInternal]\?.exportKeyingMaterial(length, label);\n  }\n  setMaxSendFragment(size) {\n    return this[bunSocketInternal]\?.setMaxSendFragment(size) || !1;\n  }\n  enableTrace() {\n  }\n  setServername(name) {\n    if (this.isServer) {\n      let error = new Error(\"ERR_TLS_SNI_FROM_SERVER: Cannot issue SNI from a TLS server-side socket\");\n      throw error.name = \"ERR_TLS_SNI_FROM_SERVER\", error;\n    }\n    this.servername = name, this[bunSocketInternal]\?.setServername(name);\n  }\n  setSession(session) {\n    if (this.#session = session, typeof session === \"string\")\n      session = @Buffer.from(session, \"latin1\");\n    return this[bunSocketInternal]\?.setSession(session);\n  }\n  getPeerCertificate(abbreviated) {\n    const cert = arguments.length < 1 \? this[bunSocketInternal]\?.getPeerCertificate() : this[bunSocketInternal]\?.getPeerCertificate(abbreviated);\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getCertificate() {\n    const cert = this[bunSocketInternal]\?.getCertificate();\n    if (cert)\n      return translatePeerCertificate(cert);\n  }\n  getPeerX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  getX509Certificate() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  get alpnProtocol() {\n    return this[bunSocketInternal]\?.alpnProtocol;\n  }\n  [buntls](port, host) {\n    return {\n      socket: this.#socket,\n      ALPNProtocols: this.ALPNProtocols,\n      serverName: this.servername || host || \"localhost\",\n      checkServerIdentity: this.#checkServerIdentity,\n      session: this.#session,\n      ...this.#secureContext\n    };\n  }\n});\n\nclass Server extends NetServer {\n  key;\n  cert;\n  ca;\n  passphrase;\n  secureOptions;\n  _rejectUnauthorized;\n  _requestCert;\n  servername;\n  ALPNProtocols;\n  constructor(options, secureConnectionListener) {\n    super(options, secureConnectionListener);\n    this.setSecureContext(options);\n  }\n  setSecureContext(options) {\n    if (options instanceof InternalSecureContext)\n      options = options.context;\n    if (options) {\n      const { ALPNProtocols } = options;\n      if (ALPNProtocols)\n        convertALPNProtocols(ALPNProtocols, this);\n      let key = options.key;\n      if (key) {\n        if (!isValidTLSArray(key))\n          @throwTypeError(\"key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.key = key;\n      }\n      let cert = options.cert;\n      if (cert) {\n        if (!isValidTLSArray(cert))\n          @throwTypeError(\"cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.cert = cert;\n      }\n      let ca = options.ca;\n      if (ca) {\n        if (!isValidTLSArray(ca))\n          @throwTypeError(\"ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile\");\n        this.ca = ca;\n      }\n      let passphrase = options.passphrase;\n      if (passphrase && typeof passphrase !== \"string\")\n        @throwTypeError(\"passphrase argument must be an string\");\n      this.passphrase = passphrase;\n      let servername = options.servername;\n      if (servername && typeof servername !== \"string\")\n        @throwTypeError(\"servername argument must be an string\");\n      this.servername = servername;\n      let secureOptions = options.secureOptions || 0;\n      if (secureOptions && typeof secureOptions !== \"number\")\n        @throwTypeError(\"secureOptions argument must be an number\");\n      this.secureOptions = secureOptions;\n      const requestCert = options.requestCert || !1;\n      if (requestCert)\n        this._requestCert = requestCert;\n      else\n        this._requestCert = @undefined;\n      const rejectUnauthorized = options.rejectUnauthorized || !1;\n      if (rejectUnauthorized)\n        this._rejectUnauthorized = rejectUnauthorized;\n      else\n        this._rejectUnauthorized = @undefined;\n    }\n  }\n  getTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  setTicketKeys() {\n    throw Error(\"Not implented in Bun yet\");\n  }\n  [buntls](port, host, isClient) {\n    return [\n      {\n        serverName: this.servername || host || \"localhost\",\n        key: this.key,\n        cert: this.cert,\n        ca: this.ca,\n        passphrase: this.passphrase,\n        secureOptions: this.secureOptions,\n        rejectUnauthorized: isClient \? !1 : this._rejectUnauthorized,\n        requestCert: isClient \? !1 : this._requestCert,\n        ALPNProtocols: this.ALPNProtocols\n      },\n      SocketClass\n    ];\n  }\n}\nvar CLIENT_RENEG_LIMIT = 3, CLIENT_RENEG_WINDOW = 600, DEFAULT_ECDH_CURVE = \"auto\", DEFAULT_CIPHERS = \"DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256\", DEFAULT_MIN_VERSION = \"TLSv1.2\", DEFAULT_MAX_VERSION = \"TLSv1.3\", createConnection = (port, host, connectListener) => {\n  if (typeof port === \"object\") {\n    port.checkServerIdentity;\n    const { ALPNProtocols } = port;\n    if (ALPNProtocols)\n      convertALPNProtocols(ALPNProtocols, port);\n    return new TLSSocket(port).connect(port, host, connectListener);\n  }\n  return new TLSSocket().connect(port, host, connectListener);\n}, connect = createConnection;\n$ = {\n  CLIENT_RENEG_LIMIT,\n  CLIENT_RENEG_WINDOW,\n  connect,\n  convertALPNProtocols,\n  createConnection,\n  createSecureContext,\n  createServer,\n  DEFAULT_CIPHERS,\n  DEFAULT_ECDH_CURVE,\n  DEFAULT_MAX_VERSION,\n  DEFAULT_MIN_VERSION,\n  getCiphers,\n  parseCertString,\n  SecureContext,\n  Server,\n  TLSSocket,\n  checkServerIdentity,\n  rootCertificates\n};\nreturn $})\n"_s;
 //
 
 //
diff --git a/src/js/out/WebCoreJSBuiltins.cpp b/src/js/out/WebCoreJSBuiltins.cpp
index a60dfc281..31246276b 100644
--- a/src/js/out/WebCoreJSBuiltins.cpp
+++ b/src/js/out/WebCoreJSBuiltins.cpp
@@ -30,9 +30,9 @@ const char* const s_bundlerPluginRunOnResolvePluginsCode = "(function (specifier
 const JSC::ConstructAbility s_bundlerPluginRunSetupFunctionCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_bundlerPluginRunSetupFunctionCodeConstructorKind = JSC::ConstructorKind::None;
 const JSC::ImplementationVisibility s_bundlerPluginRunSetupFunctionCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
-const int s_bundlerPluginRunSetupFunctionCodeLength = 4001;
+const int s_bundlerPluginRunSetupFunctionCodeLength = 4133;
 static const JSC::Intrinsic s_bundlerPluginRunSetupFunctionCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_bundlerPluginRunSetupFunctionCode = "(function (setup, config) {\"use strict\";\n  var onLoadPlugins = new Map, onResolvePlugins = new Map;\n  function validate(filterObject, callback, map) {\n    if (!filterObject || !@isObject(filterObject))\n      @throwTypeError('Expected an object with \"filter\" RegExp');\n    if (!callback || !@isCallable(callback))\n      @throwTypeError(\"callback must be a function\");\n    var { filter, namespace = \"file\" } = filterObject;\n    if (!filter)\n      @throwTypeError('Expected an object with \"filter\" RegExp');\n    if (!@isRegExpObject(filter))\n      @throwTypeError(\"filter must be a RegExp\");\n    if (namespace && typeof namespace !== \"string\")\n      @throwTypeError(\"namespace must be a string\");\n    if ((namespace\?.length \?\? 0) === 0)\n      namespace = \"file\";\n    if (!/^([/@a-zA-Z0-9_\\\\-]+)$/.test(namespace))\n      @throwTypeError(\"namespace can only contain $a-zA-Z0-9_\\\\-\");\n    var callbacks = map.@get(namespace);\n    if (!callbacks)\n      map.@set(namespace, [[filter, callback]]);\n    else\n      @arrayPush(callbacks, [filter, callback]);\n  }\n  function onLoad(filterObject, callback) {\n    validate(filterObject, callback, onLoadPlugins);\n  }\n  function onResolve(filterObject, callback) {\n    validate(filterObject, callback, onResolvePlugins);\n  }\n  const processSetupResult = () => {\n    var anyOnLoad = !1, anyOnResolve = !1;\n    for (var [namespace, callbacks] of onLoadPlugins.entries())\n      for (var [filter] of callbacks)\n        this.addFilter(filter, namespace, 1), anyOnLoad = !0;\n    for (var [namespace, callbacks] of onResolvePlugins.entries())\n      for (var [filter] of callbacks)\n        this.addFilter(filter, namespace, 0), anyOnResolve = !0;\n    if (anyOnResolve) {\n      var onResolveObject = this.onResolve;\n      if (!onResolveObject)\n        this.onResolve = onResolvePlugins;\n      else\n        for (var [namespace, callbacks] of onResolvePlugins.entries()) {\n          var existing = onResolveObject.@get(namespace);\n          if (!existing)\n            onResolveObject.@set(namespace, callbacks);\n          else\n            onResolveObject.@set(namespace, existing.concat(callbacks));\n        }\n    }\n    if (anyOnLoad) {\n      var onLoadObject = this.onLoad;\n      if (!onLoadObject)\n        this.onLoad = onLoadPlugins;\n      else\n        for (var [namespace, callbacks] of onLoadPlugins.entries()) {\n          var existing = onLoadObject.@get(namespace);\n          if (!existing)\n            onLoadObject.@set(namespace, callbacks);\n          else\n            onLoadObject.@set(namespace, existing.concat(callbacks));\n        }\n    }\n    return anyOnLoad || anyOnResolve;\n  };\n  var setupResult = setup({\n    config,\n    onDispose: () => @throwTypeError(\"@{@2} is not implemented yet. See https://github.com/oven-sh/bun/issues/@1\"),\n    onEnd: () => @throwTypeError(\"@{@2} is not implemented yet. See https://github.com/oven-sh/bun/issues/@1\"),\n    onLoad,\n    onResolve,\n    onStart: () => @throwTypeError(\"@{@2} is not implemented yet. See https://github.com/oven-sh/bun/issues/@1\"),\n    resolve: () => @throwTypeError(\"@{@2} is not implemented yet. See https://github.com/oven-sh/bun/issues/@1\"),\n    initialOptions: {\n      ...config,\n      bundle: !0,\n      entryPoints: config.entrypoints \?\? config.entryPoints \?\? [],\n      minify: typeof config.minify === \"boolean\" \? config.minify : !1,\n      minifyIdentifiers: config.minify === !0 || config.minify\?.identifiers,\n      minifyWhitespace: config.minify === !0 || config.minify\?.whitespace,\n      minifySyntax: config.minify === !0 || config.minify\?.syntax,\n      outbase: config.root,\n      platform: config.target === \"bun\" \? \"node\" : config.target\n    },\n    esbuild: {}\n  });\n  if (setupResult && @isPromise(setupResult))\n    if (@getPromiseInternalField(setupResult, @promiseFieldFlags) & @promiseStateFulfilled)\n      setupResult = @getPromiseInternalField(setupResult, @promiseFieldReactionsOrResult);\n    else\n      return setupResult.@then(processSetupResult);\n  return processSetupResult();\n})\n";
+const char* const s_bundlerPluginRunSetupFunctionCode = "(function (setup, config) {\"use strict\";\n  var onLoadPlugins = new Map, onResolvePlugins = new Map;\n  function validate(filterObject, callback, map) {\n    if (!filterObject || !@isObject(filterObject))\n      @throwTypeError('Expected an object with \"filter\" RegExp');\n    if (!callback || !@isCallable(callback))\n      @throwTypeError(\"callback must be a function\");\n    var { filter, namespace = \"file\" } = filterObject;\n    if (!filter)\n      @throwTypeError('Expected an object with \"filter\" RegExp');\n    if (!@isRegExpObject(filter))\n      @throwTypeError(\"filter must be a RegExp\");\n    if (namespace && typeof namespace !== \"string\")\n      @throwTypeError(\"namespace must be a string\");\n    if ((namespace\?.length \?\? 0) === 0)\n      namespace = \"file\";\n    if (!/^([/@a-zA-Z0-9_\\\\-]+)$/.test(namespace))\n      @throwTypeError(\"namespace can only contain $a-zA-Z0-9_\\\\-\");\n    var callbacks = map.@get(namespace);\n    if (!callbacks)\n      map.@set(namespace, [[filter, callback]]);\n    else\n      @arrayPush(callbacks, [filter, callback]);\n  }\n  function onLoad(filterObject, callback) {\n    validate(filterObject, callback, onLoadPlugins);\n  }\n  function onResolve(filterObject, callback) {\n    validate(filterObject, callback, onResolvePlugins);\n  }\n  const processSetupResult = () => {\n    var anyOnLoad = !1, anyOnResolve = !1;\n    for (var [namespace, callbacks] of onLoadPlugins.entries())\n      for (var [filter] of callbacks)\n        this.addFilter(filter, namespace, 1), anyOnLoad = !0;\n    for (var [namespace, callbacks] of onResolvePlugins.entries())\n      for (var [filter] of callbacks)\n        this.addFilter(filter, namespace, 0), anyOnResolve = !0;\n    if (anyOnResolve) {\n      var onResolveObject = this.onResolve;\n      if (!onResolveObject)\n        this.onResolve = onResolvePlugins;\n      else\n        for (var [namespace, callbacks] of onResolvePlugins.entries()) {\n          var existing = onResolveObject.@get(namespace);\n          if (!existing)\n            onResolveObject.@set(namespace, callbacks);\n          else\n            onResolveObject.@set(namespace, existing.concat(callbacks));\n        }\n    }\n    if (anyOnLoad) {\n      var onLoadObject = this.onLoad;\n      if (!onLoadObject)\n        this.onLoad = onLoadPlugins;\n      else\n        for (var [namespace, callbacks] of onLoadPlugins.entries()) {\n          var existing = onLoadObject.@get(namespace);\n          if (!existing)\n            onLoadObject.@set(namespace, callbacks);\n          else\n            onLoadObject.@set(namespace, existing.concat(callbacks));\n        }\n    }\n    return anyOnLoad || anyOnResolve;\n  };\n  var setupResult = setup({\n    config,\n    onDispose: () => @throwTypeError(\"@{@2} is not implemented yet. See https://github.com/oven-sh/bun/issues/@1\"),\n    onEnd: () => @throwTypeError(\"@{@2} is not implemented yet. See https://github.com/oven-sh/bun/issues/@1\"),\n    onLoad,\n    onResolve,\n    onStart: () => @throwTypeError(\"@{@2} is not implemented yet. See https://github.com/oven-sh/bun/issues/@1\"),\n    resolve: () => @throwTypeError(\"@{@2} is not implemented yet. See https://github.com/oven-sh/bun/issues/@1\"),\n    module: () => {\n      @throwTypeError(\"module() is not supported in Bun.build() yet. Only via Bun.plugin() at runtime\");\n    },\n    initialOptions: {\n      ...config,\n      bundle: !0,\n      entryPoints: config.entrypoints \?\? config.entryPoints \?\? [],\n      minify: typeof config.minify === \"boolean\" \? config.minify : !1,\n      minifyIdentifiers: config.minify === !0 || config.minify\?.identifiers,\n      minifyWhitespace: config.minify === !0 || config.minify\?.whitespace,\n      minifySyntax: config.minify === !0 || config.minify\?.syntax,\n      outbase: config.root,\n      platform: config.target === \"bun\" \? \"node\" : config.target\n    },\n    esbuild: {}\n  });\n  if (setupResult && @isPromise(setupResult))\n    if (@getPromiseInternalField(setupResult, @promiseFieldFlags) & @promiseStateFulfilled)\n      setupResult = @getPromiseInternalField(setupResult, @promiseFieldReactionsOrResult);\n    else\n      return setupResult.@then(processSetupResult);\n  return processSetupResult();\n})\n";
 
 #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, overriddenName, argumentCount) \
 JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
diff --git a/src/libarchive/libarchive.zig b/src/libarchive/libarchive.zig
index c6276b1cc..ff514d72d 100644
--- a/src/libarchive/libarchive.zig
+++ b/src/libarchive/libarchive.zig
@@ -543,13 +543,13 @@ pub const Archive = struct {
                             if (comptime Environment.isWindows) {
                                 std.os.mkdirat(dir_fd, pathname, @as(u32, @intCast(mode))) catch |err| {
                                     if (err == error.PathAlreadyExists or err == error.NotDir) break;
-                                    try dir.makePath(std.fs.path.dirname(slice) orelse return err);
+                                    try bun.makePath(dir, std.fs.path.dirname(slice) orelse return err);
                                     try std.os.mkdirat(dir_fd, pathname, 0o777);
                                 };
                             } else {
                                 std.os.mkdiratZ(dir_fd, pathname, @as(u32, @intCast(mode))) catch |err| {
                                     if (err == error.PathAlreadyExists or err == error.NotDir) break;
-                                    try dir.makePath(std.fs.path.dirname(slice) orelse return err);
+                                    try bun.makePath(dir, std.fs.path.dirname(slice) orelse return err);
                                     try std.os.mkdiratZ(dir_fd, pathname, 0o777);
                                 };
                             }
diff --git a/src/resolver/resolver.zig b/src/resolver/resolver.zig
index 4ddd97dca..8835e57ce 100644
--- a/src/resolver/resolver.zig
+++ b/src/resolver/resolver.zig
@@ -1139,41 +1139,6 @@ pub const Resolver = struct {
             return .{ .not_found = {} };
         }
 
-        if (strings.hasPrefixComptime(import_path, "file:///")) {
-            const path = import_path[7..];
-
-            if (r.opts.external.abs_paths.count() > 0 and r.opts.external.abs_paths.contains(path)) {
-                // If the string literal in the source text is an absolute path and has
-                // been marked as an external module, mark it as *not* an absolute path.
-                // That way we preserve the literal text in the output and don't generate
-                // a relative path from the output directory to that path.
-                if (r.debug_logs) |*debug| {
-                    debug.addNoteFmt("The path \"{s}\" is marked as external by the user", .{path});
-                }
-
-                return .{
-                    .success = Result{
-                        .path_pair = .{ .primary = Path.init(import_path) },
-                        .is_external = true,
-                    },
-                };
-            }
-
-            if (r.loadAsFile(path, r.extension_order)) |file| {
-                return .{
-                    .success = Result{
-                        .dirname_fd = file.dirname_fd,
-                        .path_pair = .{ .primary = Path.init(file.path) },
-                        .diff_case = file.diff_case,
-                        .file_fd = file.file_fd,
-                        .jsx = r.opts.jsx,
-                    },
-                };
-            }
-
-            return .{ .not_found = {} };
-        }
-
         // Check both relative and package paths for CSS URL tokens, with relative
         // paths taking precedence over package paths to match Webpack behavior.
         const is_package_path = isPackagePath(import_path);
diff --git a/src/sys.zig b/src/sys.zig
index 14bb9ddf9..b7542b44f 100644
--- a/src/sys.zig
+++ b/src/sys.zig
@@ -819,6 +819,19 @@ pub fn readlink(in: [:0]const u8, buf: []u8) Maybe(usize) {
     unreachable;
 }
 
+pub fn readlinkat(fd: bun.FileDescriptor, in: [:0]const u8, buf: []u8) Maybe(usize) {
+    while (true) {
+        const rc = sys.readlinkat(fd, in, buf.ptr, buf.len);
+
+        if (Maybe(usize).errnoSys(rc, .readlink)) |err| {
+            if (err.getErrno() == .INTR) continue;
+            return err;
+        }
+        return Maybe(usize){ .result = @as(usize, @intCast(rc)) };
+    }
+    unreachable;
+}
+
 pub fn ftruncate(fd: fd_t, size: isize) Maybe(void) {
     if (comptime Environment.isWindows) {
         if (kernel32.SetFileValidData(bun.fdcast(fd), size) == 0) {
diff --git a/test/bundler/bun-build-api.test.ts b/test/bundler/bun-build-api.test.ts
index 3c2308d94..d1f1a10b8 100644
--- a/test/bundler/bun-build-api.test.ts
+++ b/test/bundler/bun-build-api.test.ts
@@ -290,4 +290,27 @@ describe("Bun.build", () => {
     // depends on the ws package in the test/node_modules.
     expect(content).toContain("var websocket = __toESM(require_websocket(), 1);");
   });
+
+  test("module() throws error", async () => {
+    expect(() =>
+      Bun.build({
+        entrypoints: [join(import.meta.dir, "./fixtures/trivial/bundle-ws.ts")],
+        plugins: [
+          {
+            name: "test",
+            setup: b => {
+              b.module("ad", () => {
+                return {
+                  exports: {
+                    hello: "world",
+                  },
+                  loader: "object",
+                };
+              });
+            },
+          },
+        ],
+      }),
+    ).toThrow();
+  });
 });
diff --git a/test/js/bun/http/serve.test.ts b/test/js/bun/http/serve.test.ts
index be271cf33..67b7614b2 100644
--- a/test/js/bun/http/serve.test.ts
+++ b/test/js/bun/http/serve.test.ts
@@ -1237,14 +1237,42 @@ it("server.requestIP (v6)", async () => {
     fetch(req, server) {
       return Response.json(server.requestIP(req));
     },
-    hostname: "0000:0000:0000:0000:0000:0000:0000:0001",
+    hostname: "::1",
   });
 
   const response = await fetch(`http://localhost:${server.port}`).then(x => x.json());
   expect(response).toEqual({
-    address: "0000:0000:0000:0000:0000:0000:0000:0001",
+    address: "::1",
     family: "IPv6",
     port: expect.any(Number),
   });
   server.stop(true);
 });
+
+it("server.requestIP (unix)", async () => {
+  const unix = "/tmp/bun-serve.sock";
+  const server = Bun.serve({
+    unix,
+    fetch(req, server) {
+      return Response.json(server.requestIP(req));
+    },
+  });
+  const requestText = `GET / HTTP/1.1\r\nHost: localhost\r\n\r\n`;
+  const received: Buffer[] = [];
+  const { resolve, promise } = Promise.withResolvers<void>();
+  const connection = await Bun.connect({
+    unix,
+    socket: {
+      data(socket, data) {
+        received.push(data);
+        resolve();
+      },
+    },
+  });
+  connection.write(requestText);
+  connection.flush();
+  await promise;
+  expect(Buffer.concat(received).toString()).toEndWith("\r\n\r\nnull");
+  connection.end();
+  server.stop(true);
+});
diff --git a/test/js/bun/plugin/module-plugins.ts b/test/js/bun/plugin/module-plugins.ts
new file mode 100644
index 000000000..d6034c5df
--- /dev/null
+++ b/test/js/bun/plugin/module-plugins.ts
@@ -0,0 +1,38 @@
+import { plugin } from "bun";
+plugin({
+  name: "i am virtual!",
+  setup(builder) {
+    builder.module("my-virtual-module-async", async () => {
+      // check
+      await Bun.sleep(1);
+      return {
+        exports: {
+          hello: "world",
+        },
+        loader: "object",
+      };
+    });
+
+    builder.module("my-virtual-module-sync", () => {
+      return {
+        exports: {
+          hello: "world",
+        },
+        loader: "object",
+      };
+    });
+
+    builder.onLoad({ filter: /.*/, namespace: "rejected-promise" }, async ({ path }) => {
+      throw new Error("Rejected Promise");
+    });
+
+    builder.onResolve({ filter: /.*/, namespace: "rejected-promise2" }, ({ path }) => ({
+      namespace: "rejected-promise2",
+      path,
+    }));
+
+    builder.onLoad({ filter: /.*/, namespace: "rejected-promise2" }, ({ path }) => {
+      return Promise.reject(new Error("Rejected Promise"));
+    });
+  },
+});
diff --git a/test/js/bun/plugin/plugins.test.ts b/test/js/bun/plugin/plugins.test.ts
index c2827f600..2d3cfa1fa 100644
--- a/test/js/bun/plugin/plugins.test.ts
+++ b/test/js/bun/plugin/plugins.test.ts
@@ -185,6 +185,7 @@ plugin({
 
 // This is to test that it works when imported from a separate file
 import "../../third_party/svelte";
+import "./module-plugins";
 
 describe("require", () => {
   it("SSRs `<h1>Hello world!</h1>` with Svelte", () => {
@@ -210,6 +211,83 @@ describe("require", () => {
   });
 });
 
+describe("module", () => {
+  it("throws with require()", () => {
+    expect(() => require("my-virtual-module-async")).toThrow();
+  });
+
+  it("async module works with async import", async () => {
+    // @ts-expect-error
+    const { hello } = await import("my-virtual-module-async");
+
+    expect(hello).toBe("world");
+    delete require.cache["my-virtual-module-async"];
+  });
+
+  it("sync module module works with require()", async () => {
+    const { hello } = require("my-virtual-module-sync");
+
+    expect(hello).toBe("world");
+    delete require.cache["my-virtual-module-sync"];
+  });
+
+  it("sync module module works with require.resolve()", async () => {
+    expect(require.resolve("my-virtual-module-sync")).toBe("my-virtual-module-sync");
+    delete require.cache["my-virtual-module-sync"];
+  });
+
+  it("sync module module works with import", async () => {
+    // @ts-expect-error
+    const { hello } = await import("my-virtual-module-sync");
+
+    expect(hello).toBe("world");
+    delete require.cache["my-virtual-module-sync"];
+  });
+
+  it("modules are overridable", async () => {
+    // @ts-expect-error
+    let { hello, there } = await import("my-virtual-module-sync");
+    expect(there).toBeUndefined();
+    expect(hello).toBe("world");
+
+    Bun.plugin({
+      setup(builder) {
+        builder.module("my-virtual-module-sync", () => ({
+          exports: {
+            there: true,
+          },
+          loader: "object",
+        }));
+      },
+    });
+
+    {
+      const { there, hello } = require("my-virtual-module-sync");
+      expect(there).toBe(true);
+      expect(hello).toBeUndefined();
+    }
+
+    Bun.plugin({
+      setup(builder) {
+        builder.module("my-virtual-module-sync", () => ({
+          exports: {
+            yo: true,
+          },
+          loader: "object",
+        }));
+      },
+    });
+
+    {
+      // @ts-expect-error
+      const { there, hello, yo } = await import("my-virtual-module-sync");
+      expect(yo).toBe(true);
+      expect(hello).toBeUndefined();
+      expect(there).toBeUndefined();
+    }
+  });
+});
+
 describe("dynamic import", () => {
   it("SSRs `<h1>Hello world!</h1>` with Svelte", async () => {
     const { default: App }: any = await import("./hello.svelte");
diff --git a/test/js/bun/resolve/import-meta.test.js b/test/js/bun/resolve/import-meta.test.js
index a940d0c87..e0e3bb11e 100644
--- a/test/js/bun/resolve/import-meta.test.js
+++ b/test/js/bun/resolve/import-meta.test.js
@@ -102,7 +102,7 @@ it("Module.createRequire(file://url).resolve(file://url)", () => {
 
   const createdRequire = Module.createRequire(import.meta.url);
   const result1 = createdRequire.resolve("./require-json.json");
-  const result2 = createdRequire.resolve("file://./require-json.json");
+  const result2 = createdRequire.resolve(`file://${expected}`);
   expect(result1).toBe(expected);
   expect(result2).toBe(expected);
 });
diff --git a/test/js/bun/resolve/png/test-png-import.test.js b/test/js/bun/resolve/png/test-png-import.test.js
index f4a809e7a..ca2d0b9ce 100644
--- a/test/js/bun/resolve/png/test-png-import.test.js
+++ b/test/js/bun/resolve/png/test-png-import.test.js
@@ -1,7 +1,7 @@
 import { expect, test } from "bun:test";
 import { resolve } from "path";
-// import MyPNG from "./test-png.png";
+import MyPNG from "./test-png.png";
 
-test.todo("png import", () => {
+test("png import", () => {
   expect(MyPNG).toBe(resolve(__dirname, "./test-png.png"));
 });
diff --git a/test/js/bun/resolve/resolve.test.ts b/test/js/bun/resolve/resolve.test.ts
index a9272fb3f..217d3dc81 100644
--- a/test/js/bun/resolve/resolve.test.ts
+++ b/test/js/bun/resolve/resolve.test.ts
@@ -92,7 +92,6 @@ it("file url in import resolves", async () => {
   });
   writeFileSync(`${dir}/test.js`, `import {foo} from 'file://${dir}/index.js';\nconsole.log(foo);`);
 
-  console.log("dir", dir);
   const { exitCode, stdout } = Bun.spawnSync({
     cmd: [bunExe(), `${dir}/test.js`],
     env: bunEnv,
@@ -102,13 +101,97 @@ it("file url in import resolves", async () => {
   expect(stdout.toString("utf8")).toBe("1\n");
 });
 
+it("invalid file url in import throws error", async () => {
+  const dir = tempDirWithFiles("fileurl", {});
+  writeFileSync(`${dir}/test.js`, `import {foo} from 'file://\0invalid url';\nconsole.log(foo);`);
+
+  const { exitCode, stdout, stderr } = Bun.spawnSync({
+    cmd: [bunExe(), `${dir}/test.js`],
+    env: bunEnv,
+    cwd: import.meta.dir,
+  });
+  expect(exitCode).not.toBe(0);
+  expect(stderr.toString("utf8")).toContain("file://\0invalid url");
+});
+
 it("file url in await import resolves", async () => {
   const dir = tempDirWithFiles("fileurl", {
     "index.js": "export const foo = 1;",
   });
   writeFileSync(`${dir}/test.js`, `const {foo} = await import('file://${dir}/index.js');\nconsole.log(foo);`);
 
-  console.log("dir", dir);
+  const { exitCode, stdout } = Bun.spawnSync({
+    cmd: [bunExe(), `${dir}/test.js`],
+    env: bunEnv,
+    cwd: import.meta.dir,
+  });
+  expect(exitCode).toBe(0);
+  expect(stdout.toString("utf8")).toBe("1\n");
+});
+
+it("file url with special characters in await import resolves", async () => {
+  const filename = "🅱️ndex.js";
+  const dir = tempDirWithFiles("file url", {
+    [filename]: "export const foo = 1;",
+  });
+  writeFileSync(
+    `${dir}/test.js`,
+    `const {foo} = await import('file://${dir.replace(/ /g, "%20")}/${encodeURIComponent(
+      filename,
+    )}');\nconsole.log(foo);`,
+  );
+
+  const { exitCode, stdout } = Bun.spawnSync({
+    cmd: [bunExe(), `${dir}/test.js`],
+    env: bunEnv,
+    cwd: import.meta.dir,
+  });
+  expect(exitCode).toBe(0);
+  expect(stdout.toString("utf8")).toBe("1\n");
+});
+
+it("file url with special characters not encoded in await import resolves", async () => {
+  const filename = "🅱️ndex.js";
+  const dir = tempDirWithFiles("file url", {
+    [filename]: "export const foo = 1;",
+  });
+  writeFileSync(`${dir}/test.js`, `const {foo} = await import('file://${dir}/${filename}');\nconsole.log(foo);`);
+
+  const { exitCode, stdout } = Bun.spawnSync({
+    cmd: [bunExe(), `${dir}/test.js`],
+    env: bunEnv,
+    cwd: import.meta.dir,
+  });
+  expect(exitCode).toBe(0);
+  expect(stdout.toString("utf8")).toBe("1\n");
+});
+
+it("file url with special characters in import statement resolves", async () => {
+  const filename = "🅱️ndex.js";
+  const dir = tempDirWithFiles("file url", {
+    [filename]: "export const foo = 1;",
+  });
+  writeFileSync(
+    `${dir}/test.js`,
+    `import {foo} from 'file://${dir.replace(/ /g, "%20")}/${encodeURIComponent(filename)}';\nconsole.log(foo);`,
+  );
+
+  const { exitCode, stdout } = Bun.spawnSync({
+    cmd: [bunExe(), `${dir}/test.js`],
+    env: bunEnv,
+    cwd: import.meta.dir,
+  });
+  expect(exitCode).toBe(0);
+  expect(stdout.toString("utf8")).toBe("1\n");
+});
+
+it("file url with special characters not encoded in import statement resolves", async () => {
+  const filename = "🅱️ndex.js";
+  const dir = tempDirWithFiles("file url", {
+    [filename]: "export const foo = 1;",
+  });
+  writeFileSync(`${dir}/test.js`, `import {foo} from 'file://${dir}/${filename}';\nconsole.log(foo);`);
+
   const { exitCode, stdout } = Bun.spawnSync({
     cmd: [bunExe(), `${dir}/test.js`],
     env: bunEnv,
@@ -124,7 +207,6 @@ it("file url in require resolves", async () => {
   });
   writeFileSync(`${dir}/test.js`, `const {foo} = require('file://${dir}/index.js');\nconsole.log(foo);`);
 
-  console.log("dir", dir);
   const { exitCode, stdout } = Bun.spawnSync({
     cmd: [bunExe(), `${dir}/test.js`],
     env: bunEnv,
@@ -134,6 +216,61 @@ it("file url in require resolves", async () => {
   expect(stdout.toString("utf8")).toBe("1\n");
 });
 
+it("file url with special characters in require resolves", async () => {
+  const filename = "🅱️ndex.js";
+  const dir = tempDirWithFiles("file url", {
+    [filename]: "export const foo = 1;",
+  });
+  writeFileSync(
+    `${dir}/test.js`,
+    `const {foo} = require('file://${dir.replace(/ /g, "%20")}/${encodeURIComponent(filename)}');\nconsole.log(foo);`,
+  );
+
+  const { exitCode, stdout } = Bun.spawnSync({
+    cmd: [bunExe(), `${dir}/test.js`],
+    env: bunEnv,
+    cwd: import.meta.dir,
+  });
+  expect(exitCode).toBe(0);
+  expect(stdout.toString("utf8")).toBe("1\n");
+});
+
+it("file url in require.resolve resolves", async () => {
+  const dir = tempDirWithFiles("fileurl", {
+    "index.js": "export const foo = 1;",
+  });
+  writeFileSync(`${dir}/test.js`, `const to = require.resolve('file://${dir}/index.js');\nconsole.log(to);`);
+
+  const { exitCode, stdout } = Bun.spawnSync({
+    cmd: [bunExe(), `${dir}/test.js`],
+    env: bunEnv,
+    cwd: import.meta.dir,
+  });
+  expect(exitCode).toBe(0);
+  expect(stdout.toString("utf8")).toBe(`${dir}/index.js\n`);
+});
+
+it("file url with special characters in require resolves", async () => {
+  const filename = "🅱️ndex.js";
+  const dir = tempDirWithFiles("file url", {
+    [filename]: "export const foo = 1;",
+  });
+  writeFileSync(
+    `${dir}/test.js`,
+    `const to = require.resolve('file://${dir.replace(/ /g, "%20")}/${encodeURIComponent(
+      filename,
+    )}');\nconsole.log(to);`,
+  );
+
+  const { exitCode, stdout } = Bun.spawnSync({
+    cmd: [bunExe(), `${dir}/test.js`],
+    env: bunEnv,
+    cwd: import.meta.dir,
+  });
+  expect(exitCode).toBe(0);
+  expect(stdout.toString("utf8")).toBe(`${dir}/${filename}\n`);
+});
+
 it("import long string should not segfault", async () => {
   try {
     await import("a".repeat(10000));
diff --git a/test/js/node/net/node-net.test.ts b/test/js/node/net/node-net.test.ts
index 109391af5..a16ac6db1 100644
--- a/test/js/node/net/node-net.test.ts
+++ b/test/js/node/net/node-net.test.ts
@@ -411,3 +411,10 @@ it("should handle connection error (unix)", done => {
     done();
   });
 });
+
+it("Socket has a prototype", () => {
+  function Connection() {}
+  function Connection2() {}
+  require("util").inherits(Connection, Socket);
+  require("util").inherits(Connection2, require("tls").TLSSocket);
+});
diff --git a/test/js/node/process/process.test.js b/test/js/node/process/process.test.js
index a4a8862a2..4fb678dce 100644
--- a/test/js/node/process/process.test.js
+++ b/test/js/node/process/process.test.js
@@ -407,7 +407,8 @@ describe("signal", () => {
       stdout: "pipe",
     });
     const prom = child.exited;
-    process.kill(child.pid, "SIGTERM");
+    const ret = process.kill(child.pid, "SIGTERM");
+    expect(ret).toBe(true);
     await prom;
     expect(child.signalCode).toBe("SIGTERM");
   });
@@ -418,7 +419,8 @@ describe("signal", () => {
       stdout: "pipe",
     });
     const prom = child.exited;
-    process.kill(child.pid, 9);
+    const ret = process.kill(child.pid, 9);
+    expect(ret).toBe(true);
     await prom;
     expect(child.signalCode).toBe("SIGKILL");
   });
diff --git a/test/js/web/fetch/fetch.test.ts b/test/js/web/fetch/fetch.test.ts
index 85e2296cd..8c5e27f88 100644
--- a/test/js/web/fetch/fetch.test.ts
+++ b/test/js/web/fetch/fetch.test.ts
@@ -1241,6 +1241,16 @@ describe("Request", () => {
     expect(req.signal.aborted).toBe(true);
   });
 
+  it("copies method (#6144)", () => {
+    const request = new Request("http://localhost:1337/test", {
+      method: "POST",
+    });
+    const new_req = new Request(request, {
+      body: JSON.stringify({ message: "Hello world" }),
+    });
+    expect(new_req.method).toBe("POST");
+  });
+
   it("cloned signal", async () => {
     gc();
     const controller = new AbortController();
@@ -1692,3 +1702,95 @@ it("should throw RedirectURLTooLong when location is too long", async () => {
   expect(err.code).toStrictEqual("RedirectURLTooLong");
   server.stop(true);
 });
+
+it("304 not modified with missing content-length does not cause a request timeout", async () => {
+  const server = await Bun.listen({
+    socket: {
+      open(socket) {
+        socket.write("HTTP/1.1 304 Not Modified\r\n\r\n");
+        socket.flush();
+        setTimeout(() => {
+          socket.end();
+        }, 9999).unref();
+      },
+      data() {},
+      close() {},
+    },
+    port: 0,
+    hostname: "localhost",
+  });
+
+  const response = await fetch(`http://${server.hostname}:${server.port}/`);
+  expect(response.status).toBe(304);
+  expect(await response.arrayBuffer()).toHaveLength(0);
+  server.stop(true);
+});
+
+it("304 not modified with missing content-length and connection close does not cause a request timeout", async () => {
+  const server = await Bun.listen({
+    socket: {
+      open(socket) {
+        socket.write("HTTP/1.1 304 Not Modified\r\nConnection: close\r\n\r\n");
+        socket.flush();
+        setTimeout(() => {
+          socket.end();
+        }, 9999).unref();
+      },
+      data() {},
+      close() {},
+    },
+    port: 0,
+    hostname: "localhost",
+  });
+
+  const response = await fetch(`http://${server.hostname}:${server.port}/`);
+  expect(response.status).toBe(304);
+  expect(await response.arrayBuffer()).toHaveLength(0);
+  server.stop(true);
+});
+
+it("304 not modified with content-length 0 and connection close does not cause a request timeout", async () => {
+  const server = await Bun.listen({
+    socket: {
+      open(socket) {
+        socket.write("HTTP/1.1 304 Not Modified\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+        socket.flush();
+        setTimeout(() => {
+          socket.end();
+        }, 9999).unref();
+      },
+      data() {},
+      close() {},
+    },
+    port: 0,
+    hostname: "localhost",
+  });
+
+  const response = await fetch(`http://${server.hostname}:${server.port}/`);
+  expect(response.status).toBe(304);
+  expect(await response.arrayBuffer()).toHaveLength(0);
+  server.stop(true);
+});
+
+it("304 not modified with 0 content-length does not cause a request timeout", async () => {
+  const server = await Bun.listen({
+    socket: {
+      open(socket) {
+        socket.write("HTTP/1.1 304 Not Modified\r\nContent-Length: 0\r\n\r\n");
+        socket.flush();
+        setTimeout(() => {
+          socket.end();
+        }, 9999).unref();
+      },
+      data() {},
+      close() {},
+    },
+    port: 0,
+    hostname: "localhost",
+  });
+
+  const response = await fetch(`http://${server.hostname}:${server.port}/`);
+  expect(response.status).toBe(304);
+  expect(await response.arrayBuffer()).toHaveLength(0);
+  server.stop(true);
+});