Commit 4096767d365 for nodejs
commit 4096767d365e4296c36fbc52aa5e568d948141d6
Author: Node.js GitHub Bot <github-bot@iojs.org>
Date: Fri Oct 16 09:03:04 2026 -0400
deps: update undici to 8.12.2
PR-URL: https://github.com/nodejs/node/pull/66721
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
diff --git a/deps/undici/src/CONTRIBUTING.md b/deps/undici/src/CONTRIBUTING.md
index 35f2773e635..9dd6b011b5a 100644
--- a/deps/undici/src/CONTRIBUTING.md
+++ b/deps/undici/src/CONTRIBUTING.md
@@ -2,6 +2,7 @@
* [Guides](#guides)
* [Update `llhttp`](#update-llhttp)
+ * [Update `milo`](#update-milo)
* [Lint](#lint)
* [Test](#test)
* [Coverage](#coverage)
@@ -59,7 +60,7 @@ npm i
> This requires [docker](https://www.docker.com/) installed on your machine.
```bash
-npm run build:wasm
+npm run build-wasm
```
#### Copy the sources to `undici`
@@ -83,13 +84,94 @@ cp src/native/api.h build/llhttp.h <your-path-to-undici>/deps/llhttp/include/
```bash
cd <your-path-to-undici>
-npm run build:wasm
+npm run build:llhttp
```
#### Commit the contents of lib/llhttp
Create a commit which includes all of the updated files in lib/llhttp.
+<a id="update-milo"></a>
+### Update `milo`
+
+Milo is built from the upstream sources vendored in `deps/milo`, using its own
+Dockerfile rather than a prebuilt npm package. Updating it is manual, like llhttp.
+The standalone release CommonJS modules and their license are saved in `lib/milo`.
+
+The current vendored release is 0.8.5 at commit
+`2ec4642184f20cd1803e30650becc54bbd575c6c`.
+
+#### Clone milo and checkout a release
+
+```sh
+git clone https://github.com/ShogunPanda/milo.git
+cd milo
+git checkout v0.8.5
+```
+
+#### Copy the sources into Undici
+
+Replace the previous contents of `deps/milo` with the following files and
+directories from the selected release, preserving their layout:
+
+```sh
+cp Dockerfile Makefile.toml rust-toolchain.toml LICENSE.md README.md CODE_OF_CONDUCT.md <your-path-to-undici>/deps/milo/
+cp -R macros scripts <your-path-to-undici>/deps/milo/
+mkdir -p <your-path-to-undici>/deps/milo/parser
+cp parser/*.toml parser/*.lock parser/*.md <your-path-to-undici>/deps/milo/parser/
+cp -R parser/src <your-path-to-undici>/deps/milo/parser/
+```
+
+Keep the Cargo manifests and all three lockfiles (`macros/Cargo.lock`,
+`parser/Cargo.lock` and `scripts/Cargo.lock`), Rust binding generators and JavaScript
+template. Preserve Undici's build adjustments: the Docker image digest, pinned
+cargo-make version, Binaryen checksums and `--locked` Cargo builds. Update the
+checksums for both Linux architectures whenever Binaryen is updated.
+Do not copy `parser/tests`, `parser/examples`, `.git`, upstream workflows,
+`target`, `dist`, or prebuilt npm packages. Use a clean checkout so no local build
+outputs are included. When selecting a newer release, update the version and
+full commit recorded above.
+
+#### Build and copy the release artifacts
+
+Docker is the only build tool required on the host. The upstream image installs
+Rust, cargo-make and Binaryen, then runs `makers wasm` in an internal copy of the
+read-only source checkout. See [milo's Docker build instructions](https://github.com/ShogunPanda/milo#building-webassembly-with-docker).
+
+From Undici, build the vendored sources:
+
+```sh
+cd <your-path-to-undici>
+npm run build:milo
+```
+
+`build/milo.js` follows those instructions, mounts `deps/milo` read-only, and
+copies only these release artifacts:
+
+```text
+release/package-cjs/src/simd/index.js -> lib/milo/simd.js
+release/package-cjs/src/no-simd/index.js -> lib/milo/no-simd.js
+release/package-cjs/LICENSE.md -> lib/milo/LICENSE.md
+```
+
+Each JavaScript module already embeds its WASM binary in base64. Separate `.wasm`
+files, unbundled modules, debug packages and package metadata are not copied.
+Temporary Docker outputs are removed when the script finishes. The script does
+not download or update milo's sources; Docker still downloads the image and build
+dependencies as needed.
+
+The shared-builtin CI job removes the bundled Milo modules and rebuilds them
+before compiling Node.js, so that it cannot silently reuse prebuilt artifacts.
+The npm package contains only the license and the two bundled JavaScript modules;
+`lib/milo/binary`, `lib/milo/src` and separate WASM files are excluded.
+
+#### Submit the update
+
+Include the updated sources in `deps/milo`, generated files in `lib/milo` and
+the documentation update in a manually prepared PR. This step prepares milo's
+build inputs; it does not modify
+the runtime parser, llhttp's build script or any workflows.
+
<a id="update-wpts"></a>
### Update `WPTs`
@@ -176,9 +258,9 @@ Use the "Create release PR" github action to generate a release PR.
If you are packaging `undici` for a distro, this might help if you would like to use
an unbundled version instead of bundling one in `libnode.so`.
-To enable this, pass `EXTERNAL_PATH=/path/to/global/node_modules/undici` to `build/wasm.js`.
+To enable this, pass `EXTERNAL_PATH=/path/to/global/node_modules/undici` to `build/llhttp.js`.
Pass this path with `loader.js` appended to `--shared-builtin-undici/undici-path` in Node.js's `configure.py`.
-If building on a non-Alpine Linux distribution, you may need to also set the `WASM_CC`, `WASM_CFLAGS`, `WASM_LDFLAGS` and `WASM_LDLIBS` environment variables before running `build/wasm.js`.
+If building on a non-Alpine Linux distribution, you may need to also set the `WASM_CC`, `WASM_CFLAGS`, `WASM_LDFLAGS` and `WASM_LDLIBS` environment variables before running `build/llhttp.js`.
Similarly, you can set the `WASM_OPT` environment variable to utilize your own `wasm-opt` optimizer.
<a id="benchmarks"></a>
diff --git a/deps/undici/src/README.md b/deps/undici/src/README.md
index 169d0cab13d..479059fbc1a 100644
--- a/deps/undici/src/README.md
+++ b/deps/undici/src/README.md
@@ -86,6 +86,24 @@ Using [benchmark-http2.js](https://github.com/nodejs/undici/blob/main/benchmarks
Node.js includes a built-in `fetch()` implementation powered by undici starting from Node.js v18. However, there are important differences between using the built-in fetch and installing undici as a separate module.
+### WebAssembly requirement
+
+Undici's HTTP/1 parser requires WebAssembly. There is no alternative parser when
+WebAssembly is unavailable, for example in Node.js configurations where
+`--jitless` disables it. The existence of `fetch` does not imply that it can make
+HTTP/1 requests in that environment.
+
+When the HTTP/1 parser is needed without WebAssembly, Client and dispatcher
+requests fail with an `Error` whose code is `ERR_WEBASSEMBLY_NOT_SUPPORTED`.
+`fetch` rejects with a `TypeError` carrying that error in `error.cause`. Importing
+Undici, accessing `fetch`, and using `Headers`, `FormData`, `Request`, or `Response`
+do not themselves require the HTTP/1 parser.
+
+The error is defined locally in Undici and does not depend on Node.js providing
+that error code. For built-in fetch, this behavior depends on the bundled Undici
+version. Node.js receives upstream fixes through its normal vendored Undici
+update, rather than changes to the generated bundle alone.
+
### Built-in Fetch (Node.js v18+)
Node.js's built-in fetch is powered by a bundled version of undici:
@@ -773,14 +791,18 @@ and `undici.Agent`) which will enable the family autoselection algorithm when es
## Collaborators
-* [__Daniele Belardi__](https://github.com/dnlup), <https://www.npmjs.com/~dnlup>
-* [__Ethan Arrowood__](https://github.com/ethan-arrowood), <https://www.npmjs.com/~ethan_arrowood>
+* [__Aras Abbasi__](https://github.com/Uzlopak)
+* [__Carlos Fuentes__](https://github.com/metcoder95), <https://www.npmjs.com/~metcoder95>
+* [__Ethan Arrowood__](https://github.com/Ethan-Arrowood), <https://www.npmjs.com/~ethan_arrowood>
* [__Matteo Collina__](https://github.com/mcollina), <https://www.npmjs.com/~matteo.collina>
* [__Matthew Aitken__](https://github.com/KhafraDev), <https://www.npmjs.com/~khaf>
+* [__Mert Can Altin__](https://github.com/mertcanaltin), <https://www.npmjs.com/~mertcanaltin>
* [__Robert Nagy__](https://github.com/ronag), <https://www.npmjs.com/~ronag>
-* [__Szymon Marczak__](https://github.com/szmarczak), <https://www.npmjs.com/~szmarczak>
+* [__Trivikram Kamat__](https://github.com/trivikr), <https://www.npmjs.com/~trivikr>
+* [__tsctx__](https://github.com/tsctx)
## Past Collaborators
+* [__Szymon Marczak__](https://github.com/szmarczak), <https://www.npmjs.com/~szmarczak>
* [__Tomas Della Vedova__](https://github.com/delvedor), <https://www.npmjs.com/~delvedor>
### Releasers
diff --git a/deps/undici/src/build/wasm.js b/deps/undici/src/build/llhttp.js
similarity index 98%
rename from deps/undici/src/build/wasm.js
rename to deps/undici/src/build/llhttp.js
index 5357177d12e..7862fb2f1ed 100644
--- a/deps/undici/src/build/wasm.js
+++ b/deps/undici/src/build/llhttp.js
@@ -62,7 +62,7 @@ if (process.argv[2] === '--docker') {
cmd += ` --mount type=bind,source=${ROOT}/lib/llhttp,target=/home/node/build/lib/llhttp \
--mount type=bind,source=${ROOT}/build,target=/home/node/build/build \
--mount type=bind,source=${ROOT}/deps,target=/home/node/build/deps \
- -t ${WASM_BUILDER_CONTAINER} node build/wasm.js`
+ -t ${WASM_BUILDER_CONTAINER} node build/llhttp.js`
console.log(`> ${cmd}\n\n`)
execSync(cmd, { stdio: 'inherit' })
process.exit(0) // eslint-disable-line n/no-process-exit
diff --git a/deps/undici/src/build/milo.js b/deps/undici/src/build/milo.js
new file mode 100644
index 00000000000..9c6b57fd78f
--- /dev/null
+++ b/deps/undici/src/build/milo.js
@@ -0,0 +1,53 @@
+'use strict'
+
+const { execFileSync } = require('node:child_process')
+const { chmod, mkdtemp, readFile, cp, rm, mkdir } = require('node:fs/promises')
+const { resolve } = require('node:path')
+
+const artifacts = {
+ 'release/package-cjs/src/no-simd/index.js': 'no-simd.js',
+ 'release/package-cjs/src/simd/index.js': 'simd.js',
+ 'release/package-cjs/LICENSE.md': 'LICENSE.md'
+}
+
+function docker (...args) {
+ return execFileSync('docker', args, { stdio: 'inherit' })
+}
+
+async function buildMilo () {
+ // Setup some folders
+ const source = resolve(__dirname, '../deps/milo')
+ const destination = resolve(__dirname, '../lib/milo')
+ const temporary = await mkdtemp(resolve(__dirname, '../deps/.build-'))
+ const imageFile = resolve(temporary, 'id')
+
+ try {
+ await chmod(temporary, 0o777)
+ docker('build', '--iidfile', imageFile, source)
+
+ const image = (await readFile(imageFile, 'utf8')).trim()
+ if (!/^sha256:[a-f0-9]{64}$/.test(image)) {
+ throw new Error('Docker did not return a valid milo build image ID')
+ }
+
+ // Follow upstream's README: sources are read-only; only results are mounted writable.
+ const sourceMount = `type=bind,source=${source},target=/src,readonly`
+ const outputMount = `type=bind,source=${temporary},target=/output`
+ docker('run', '--rm', '--mount', sourceMount, '--mount', outputMount, image)
+
+ // Clean the destination directory and recreate it before copying artifacts.
+ await rm(destination, { recursive: true, force: true })
+ await mkdir(destination, { recursive: true })
+
+ // Copy artifacts from the temporary build output to the destination directory.
+ for (const [from, to] of Object.entries(artifacts)) {
+ await cp(resolve(temporary, from), resolve(destination, to))
+ }
+
+ console.log(`Milo release artifacts saved in ${destination}`)
+ } finally {
+ await rm(temporary, { recursive: true, force: true })
+ }
+}
+
+buildMilo()
diff --git a/deps/undici/src/deps/milo/CODE_OF_CONDUCT.md b/deps/undici/src/deps/milo/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000000..c42431d657d
--- /dev/null
+++ b/deps/undici/src/deps/milo/CODE_OF_CONDUCT.md
@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+- The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [INSERT EMAIL ADDRESS]. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
diff --git a/deps/undici/src/deps/milo/Dockerfile b/deps/undici/src/deps/milo/Dockerfile
new file mode 100644
index 00000000000..4bd55672acd
--- /dev/null
+++ b/deps/undici/src/deps/milo/Dockerfile
@@ -0,0 +1,36 @@
+FROM ghcr.io/nodejs/wasm-builder@sha256:542fdbef9fa6eb003cc1eb89a9f3e6b967359471fdb29db4910c54474e70911d
+
+USER root
+
+ARG BINARYEN_VERSION=123
+ARG RUST_TOOLCHAIN=nightly-2026-07-29
+ARG CARGO_MAKE_VERSION=0.37.24
+
+RUN set -eux; \
+ case "$(uname -m)" in \
+ x86_64) binaryen_arch=x86_64; binaryen_sha256=e959f2170af4c20c552e9de3a0253704d6a9d2766e8fdb88e4d6ac4bae9388fe ;; \
+ aarch64) binaryen_arch=aarch64; binaryen_sha256=4b6bd61ba6cd3b18c993b4657d93426c782f9b91b74be0d38018cd8be1319376 ;; \
+ *) echo "Unsupported architecture: $(uname -m)" >&2; exit 1 ;; \
+ esac; \
+ wget -q "https://github.com/WebAssembly/binaryen/releases/download/version_${BINARYEN_VERSION}/binaryen-version_${BINARYEN_VERSION}-${binaryen_arch}-linux.tar.gz" -O /tmp/binaryen.tar.gz; \
+ echo "${binaryen_sha256} /tmp/binaryen.tar.gz" | sha256sum -c -; \
+ tar -xzf /tmp/binaryen.tar.gz -C /tmp; \
+ install -m 0755 "/tmp/binaryen-version_${BINARYEN_VERSION}/bin/wasm-opt" /usr/local/bin/wasm-opt; \
+ rm -rf /tmp/binaryen.tar.gz "/tmp/binaryen-version_${BINARYEN_VERSION}"
+
+USER node
+
+RUN set -eux; \
+ rustup toolchain install "${RUST_TOOLCHAIN}" --profile minimal; \
+ rustup target add wasm32-unknown-unknown --toolchain "${RUST_TOOLCHAIN}"; \
+ rustup component add rust-src --toolchain "${RUST_TOOLCHAIN}"; \
+ cargo +"${RUST_TOOLCHAIN}" install cargo-make --version "${CARGO_MAKE_VERSION}" --locked
+
+ENV PATH="/home/node/.cargo/bin:${PATH}"
+ENV RUSTUP_TOOLCHAIN=${RUST_TOOLCHAIN}
+
+WORKDIR /workspace/parser
+
+# Build from an internal copy so Cargo and the build tasks cannot modify the
+# read-only source mount. Only the generated WASM artifacts are written out.
+CMD ["sh", "-ec", "cp -a /src /tmp/milo && cd /tmp/milo/parser && makers wasm && mkdir -p /output && cp -a /tmp/milo/dist/wasm/. /output/"]
diff --git a/deps/undici/src/deps/milo/LICENSE.md b/deps/undici/src/deps/milo/LICENSE.md
new file mode 100644
index 00000000000..c485e26f764
--- /dev/null
+++ b/deps/undici/src/deps/milo/LICENSE.md
@@ -0,0 +1,7 @@
+ISC License
+
+Copyright (c) 2023, and above Paolo Insogna, NearForm and other contributors
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/deps/undici/src/deps/milo/Makefile.toml b/deps/undici/src/deps/milo/Makefile.toml
new file mode 100644
index 00000000000..aa5527b36e9
--- /dev/null
+++ b/deps/undici/src/deps/milo/Makefile.toml
@@ -0,0 +1,140 @@
+[config]
+ skip_core_tasks = true
+
+[tasks.default]
+ dependencies = ["build"]
+
+[tasks.build]
+ script = ["cd parser", "makers build"]
+
+[tasks.test]
+ dependencies = ["test:rust", "test:wasm"]
+
+[tasks."test:rust"]
+ script = ["cd parser", "cargo test"]
+
+[tasks."test:wasm"]
+ script = ["cd parser", "makers test:wasm"]
+
+[tasks.format]
+ dependencies = ["format:rust", "format:js", "format:cpp"]
+
+[tasks.lint]
+ dependencies = ["lint:rust", "lint:js"]
+
+[tasks.clean]
+ dependencies = ["clean:rust", "clean:dist", "clean:tmp"]
+
+[tasks.benchmarks]
+ dependencies = ["benchmarks:cpp", "benchmarks:wasm"]
+
+[tasks.references]
+ dependencies = ["references:rust", "references:cpp", "references:wasm"]
+
+[tasks."llhttp:import"]
+ script = ["cd parser", "makers scripts:build", "../scripts/target/release/import-llhttp-tests ${1} ."]
+
+[tasks."llhttp:review"]
+ script = ["cd parser", "cargo run --example llhttp -- --review ${1}"]
+
+[tasks."llhttp:show"]
+ script = ["cd parser", "cargo run --example llhttp -- --show ${1}"]
+
+[tasks."llhttp:update"]
+ script = ["cd parser", "cargo run --example llhttp -- --update ${1}"]
+
+[tasks."clean:rust"]
+ script = [
+ "cd macros",
+ "cargo clean",
+ "cd ../parser",
+ "cargo clean",
+ "cd ../references/rust",
+ "cargo clean",
+ "cd ../../scripts",
+ "cargo clean",
+ ]
+
+[tasks."clean:dist"]
+ command = "rm"
+ args = ["-rf", "dist"]
+
+[tasks."clean:tmp"]
+ command = "rm"
+ args = ["-rf", "tmp"]
+
+[tasks."lint:fix"]
+ dependencies = ["lint:rust:fix", "lint:js:fix"]
+
+[tasks."format:rust"]
+ script = [
+ "cd macros",
+ "cargo fmt",
+ "cd ../parser",
+ "cargo fmt",
+ "cd ../references/rust",
+ "cargo fmt",
+ "cd ../../scripts",
+ "cargo fmt",
+ ]
+
+[tasks."format:cpp"]
+ command = "clang-format"
+ args = [
+ "-style=file:clang-format.yml",
+ "-i",
+ "benchmarks/cpp/src/main.cc",
+ "references/cpp/src/reference.cc",
+ "references/cpp/src/readme.cc",
+ ]
+
+[tasks."format:js"]
+ command = "pnpm"
+ args = ["run", "format"]
+
+[tasks."lint:rust"]
+ script = [
+ "cd macros",
+ "cargo clippy",
+ "cd ../parser",
+ "cargo clippy",
+ "cd ../references/rust",
+ "cargo clippy",
+ "cd ../../scripts",
+ "cargo clippy",
+ ]
+
+[tasks."lint:rust:fix"]
+ script = [
+ "cd macros",
+ "cargo clippy --fix --allow-dirty",
+ "cd ../parser",
+ "cargo clippy --fix --allow-dirty",
+ "cd ../references/rust",
+ "cargo clippy --fix --allow-dirty",
+ "cd ../../scripts",
+ "cargo clippy --fix --allow-dirty",
+ ]
+
+[tasks."lint:js"]
+ command = "pnpm"
+ args = ["run", "lint"]
+
+[tasks."lint:js:fix"]
+ command = "pnpm"
+ args = ["run", "lint", "--fix"]
+
+[tasks."benchmarks:cpp"]
+ script = ["cd benchmarks/cpp", "makers benchmarks"]
+
+[tasks."benchmarks:wasm"]
+ script = ["cd benchmarks/wasm", "makers benchmarks"]
+
+[tasks."references:rust"]
+ script = ["cd references/rust", "makers test"]
+
+[tasks."references:cpp"]
+ script = ["cd references/cpp", "makers test"]
+
+[tasks."references:wasm"]
+ script = ["cd references/wasm", "makers test"]
diff --git a/deps/undici/src/deps/milo/README.md b/deps/undici/src/deps/milo/README.md
new file mode 100644
index 00000000000..86a4ae446c2
--- /dev/null
+++ b/deps/undici/src/deps/milo/README.md
@@ -0,0 +1,349 @@
+# @perseveranza-pets/milo
+
+Milo is a fast and embeddable HTTP/1.1 parser written in [Rust][rust].
+
+Milo can report parser activity through callbacks or through parser-owned event buffers. See the language-specific API docs for event decoding details: [JavaScript](./docs/js.md), [Rust](./docs/rust.md), and [C++](./docs/cpp.md).
+
+## Support Matrix
+
+Milo supports strict HTTP/1.1 message parsing for Rust, C++, and JavaScript via WebAssembly.
+
+| Target | Status | Artifact |
+| ---------- | --------- | --------------------------------------------- |
+| Rust | Supported | `milo` crate |
+| C++ | Supported | `milo.h` and `libmilo.a` |
+| JavaScript | Supported | `@perseveranza-pets/milo` WebAssembly package |
+| CLI | Supported | `milo-parser` binary |
+
+Milo intentionally rejects HTTP/0.9, HTTP/1.0, RTSP, obs-fold, bare LF, and bare CR. It does not parse HTTP/2 messages, except for strict `PRI * HTTP/2.0` switch-over detection.
+
+For security and ambiguity reduction, Milo rejects request bodies on `GET` and `HEAD`. Responses to `HEAD` are application context: callers must use `skip_body` when they know a response has no body because it belongs to a `HEAD` request.
+
+Use `max_body_payload` when an integration needs to cap body payload consumed by a single parse call. `0` means unlimited. Reaching the limit returns normally with unconsumed input left for the next parse call.
+
+Use `suspend_after_headers` when an integration needs to inspect headers before body parsing starts. Parsing returns after consuming the header terminator and can continue with the next parse call.
+
+For full parser scope, strictness, and protocol behavior, see [Milo Design](./docs/design.md).
+
+## How to use it (JavaScript via WebAssembly)
+
+Install it from npm:
+
+```
+npm install @perseveranza-pets/milo
+```
+
+For CommonJS projects, install the CJS-only package instead:
+
+```
+npm install @perseveranza-pets/milo-cjs
+```
+
+Then create a sample source file:
+
+```javascript
+import { setup } from '@perseveranza-pets/milo'
+
+/*
+ Milo works using callbacks.
+
+ All callbacks have the same signature, which characterizes the payload:
+
+ * The current parser
+ * from: The payload offset.
+ * size: The payload length.
+
+ The payload parameters above are relative to the last data sent to the milo.parse method.
+
+ If the current callback has no payload, both values are set to 0.
+
+ The callbacks must be provided using setup and are named in snake case.
+*/
+const milo = setup({
+ on_data (p, from, size) {
+ console.log(`Pos=${from} Body: ${message.slice(from, from + size).toString()}`)
+ }
+})
+
+// Prepare a message to parse.
+const message = Buffer.from('HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nabc')
+
+// Allocate a memory in the WebAssembly space. This speeds up data copying to the WebAssembly layer.
+const ptr = milo.alloc(message.length)
+
+// Create a buffer we can use normally.
+const buffer = Buffer.from(milo.memory.buffer, ptr, message.length)
+
+// Create the parser.
+const parser = milo.create()
+
+// Toggle on the callbacks you want to receive
+milo.setActiveCallbacks(parser, milo.CALLBACK_ACTIVE_ON_DATA)
+
+// Now perform the main parsing using milo.parse. The method returns the number of consumed characters.
+buffer.set(message, 0)
+milo.parse(parser, ptr, message.length)
+
+// Cleanup used resources.
+milo.destroy(parser)
+milo.dealloc(ptr, message.length)
+```
+
+The default JavaScript entry point uses the SIMD WebAssembly build. Use `@perseveranza-pets/milo/no-simd` when SIMD is not available, and add `/unbundled` to either entry point to load the external `.wasm` file instead of the bundled JavaScript module.
+
+The WebAssembly release build uses immediate-abort panics: panics trap without unwinding or rich panic messages. The debug build also enables the `on_state_change` callback and provides more detailed WebAssembly errors.
+
+CommonJS projects can use the same entry points from `@perseveranza-pets/milo-cjs`:
+
+```javascript
+const { setup } = require('@perseveranza-pets/milo-cjs')
+```
+
+Finally build and execute it using `node`:
+
+```bash
+node index.js
+# Pos=38 Body: abc
+```
+
+## How to use it (Rust)
+
+Add `milo-parser` to your `Cargo.toml`:
+
+```toml
+[package]
+name = "milo-example"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[dependencies]
+milo-parser = "0.4.0"
+```
+
+Create a sample source file:
+
+```rust
+use core::ffi::c_void;
+use core::slice;
+
+use milo_parser::{Parser, CALLBACK_ACTIVE_ON_DATA};
+
+fn main() {
+ // Create the parser.
+ let mut parser = Parser::new();
+
+ // Prepare a message to parse.
+ let message = String::from("HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nabc");
+ parser.context = message.as_ptr() as *mut c_void;
+
+ // Milo works using callbacks.
+ //
+ // All callbacks have the same signature, which characterizes the payload:
+ //
+ // p: The current parser.
+ // from: The payload offset.
+ // size: The payload length.
+ //
+ // The payload parameters above are relative to the last data sent to the parse
+ // method.
+ //
+ // If the current callback has no payload, both values are set to 0.
+ parser.callbacks.on_data = |p: &mut Parser, from: usize, size: usize| {
+ let message =
+ unsafe { std::str::from_utf8_unchecked(slice::from_raw_parts(p.context.add(from) as *const u8, size)) };
+
+ // Use the callback data.
+ println!("Pos={} Body: {}", from, message);
+ };
+
+ // Toggle on the callbacks you want to receive
+ parser.active_callbacks |= CALLBACK_ACTIVE_ON_DATA;
+
+ // Now perform the main parsing using milo.parse. The method returns the number
+ // of consumed characters.
+ parser.parse(message.as_ptr(), message.len());
+}
+
+```
+
+Finally build and execute it using `cargo`:
+
+```bash
+cargo run
+# Pos=38 Body: abc
+```
+
+## How to use it (C++)
+
+First, let's download Milo release from GitHub.
+
+You will need a static library file (for Linux/Unix/MacOS is `libmilo.a`) and a header file (`milo.h`).
+
+Create a sample source file:
+
+```cpp
+#include "milo.h"
+#include <cinttypes>
+#include <cstdio>
+#include <cstring>
+
+int main() {
+ // Create the parser.
+ milo_parser::Parser* parser = milo_parser::milo_create();
+
+ // Prepare a message to parse.
+ const char* message = "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nabc";
+
+ parser->context = (char*) message;
+
+ /*
+ Milo works using callbacks.
+
+ All callbacks have the same signature, which characterizes the payload:
+
+ * p: The current parser.
+ * from: The payload offset.
+ * size: The payload length.
+
+ The payload parameters above are relative to the last data sent to the milo_parse method.
+
+ If the current callback has no payload, both values are set to 0.
+ */
+ parser->callbacks.on_data = [](milo_parser::Parser* p, uintptr_t from, uintptr_t size) {
+ const char* payload = reinterpret_cast<const char*>(p->context) + from;
+
+ printf("Pos=%" PRIuPTR " Body: %.*s\n", from, static_cast<int>(size), payload);
+ };
+
+ // Toggle on the callbacks you want to receive
+ parser->active_callbacks |= milo_parser::CALLBACK_ACTIVE_ON_DATA;
+
+ // Now perform the main parsing using milo.parse. The method returns the number of consumed characters.
+ milo_parser::milo_parse(parser, reinterpret_cast<const unsigned char*>(message), strlen(message));
+
+ // Cleanup used resources.
+ milo_parser::milo_destroy(parser);
+}
+```
+
+And then you can compile using your preferred build system. For instance, let's try with [Clang]:
+
+```bash
+clang++ -std=c++11 -o example main.cc libmilo.a
+./example
+# Pos=38 Body: abc
+```
+
+## How to use it (CLI)
+
+Install it from crates.io:
+
+```bash
+cargo install milo-parser
+```
+
+The `milo-parser` binary reads an HTTP/1.1 message from standard input by default and prints the callbacks emitted by Milo:
+
+```bash
+printf 'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n' | milo-parser
+# offset=0 size=0 event=request
+# offset=0 size=0 event=message_start
+# offset=0 size=0 event=state_change
+# offset=0 size=3 event=method
+```
+
+Each output line uses this format:
+
+```text
+offset=$OFFSET size=$SIZE event=$EVENT
+```
+
+Parser errors are emitted as callback lines too:
+
+```text
+offset=$OFFSET size=$SIZE event=error error=$ERROR description="$DESCRIPTION"
+```
+
+Use `-f` or `--file` to parse a file:
+
+```bash
+milo-parser --file request.http
+```
+
+By default Milo autodetects request or response input. Use `-o` or `--request` to force request parsing, and `-i` or `--response` to force response parsing:
+
+```bash
+milo-parser --request --file request.http
+milo-parser --response --file response.http
+```
+
+## API
+
+See the following files, according to the language you are using:
+
+- [JavaScript via WebAssembly API](./docs/js.md)
+- [Rust API](./docs/rust.md)
+- [C++ API](./docs/cpp.md)
+
+## Strictness Differences From llhttp
+
+Milo does not aim for byte-for-byte llhttp compatibility when lenient behavior would conflict with Milo's strict parser policy.
+
+- Milo rejects HTTP/0.9, HTTP/1.0, RTSP, obs-fold, bare LF, and bare CR.
+- Milo rejects normal HTTP/2 request and response messages.
+- Milo rejects request bodies on `GET` and `HEAD`.
+- Milo requires `skip_body` for application-known no-body response contexts such as responses to `HEAD`.
+- Milo validates protocol framing and syntax, but leaves application semantics to callers.
+
+## Security Boundaries
+
+Milo validates HTTP/1.1 syntax, message framing, protocol switching, connection management, and data-after-close behavior. Milo does not validate routing, authorization, representation semantics, URI normalization, `Host` policy, method-specific request-target forms, CONNECT authority-form, or full header field semantics unless they affect safe framing.
+
+## How it works?
+
+Milo is a simple state machine which copies data in only one optional case: automatically handling the unconsumed portion of the input data.
+
+In all other cases, no data is copied and the memory footprint is very small as only a few dozen `bool`, `uintptr_t`, or `uint64_t` fields can represent the entire parser state.
+
+## Why?
+
+The scope of Milo is to replace [llhttp] as [Node.js] main HTTP parser.
+
+This project aims to:
+
+- Make it maintainable and verifiable using easy to read Rust code.
+- Be performant by avoiding any unnecessary data copy.
+- Be self-contained and dependency-free.
+
+To see the rationale behind the replacement of llhttp, check Paolo's talk at [Vancouver's Node Collab Summit][vancouver-talk] in January 2023 ([slides][vancouver-slides]).
+
+To see the initial disclosure of milo, check Paolo's talk at [NodeConf EU 2023][nodeconf-talk] in November 2023 ([slides][slides]).
+
+## Sponsored by
+
+[][nearform]
+
+## Contributing to milo
+
+See [AGENTS.md](./AGENTS.md) for development setup, local and Docker builds, tests, and contribution guidelines.
+
+## Copyright
+
+Copyright (C) 2023 and above Paolo Insogna (paolo@cowtech.it) and NearForm (https://nearform.com).
+
+Licensed under the ISC license, which can be found at https://choosealicense.com/licenses/isc or in the [LICENSE.md](./LICENSE.md) file.
+
+[rust]: https://www.rust-lang.org/
+[webassembly]: https://webassembly.org/
+[nearform]: https://nearform.com
+[llhttp]: https://github.com/nodejs/llhttp
+[Node.js]: https://nodejs.org
+[vancouver-talk]: https://youtube.com/watch?v=L-VONzXQ944
+[vancouver-slides]: https://talks.cowtech.it/http-parser
+[nodeconf-talk]: https://youtube.com/watch?v=dcHbAeO_ccY
+[slides]: https://talks.paoloinsogna.dev/milo
+[isc]: https://choosealicense.com/licenses/isc
+[match]: https://doc.rust-lang.org/rust-by-example/flow_control/match.html
+[match-slice]: https://doc.rust-lang.org/rust-by-example/flow_control/match/destructuring/destructure_slice.html
+[Clang]: https://clang.llvm.org/
diff --git a/deps/undici/src/deps/milo/macros/Cargo.toml b/deps/undici/src/deps/milo/macros/Cargo.toml
new file mode 100644
index 00000000000..22bdc39224a
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+ name = "milo-macros"
+ version = "0.9.0"
+ edition = "2024"
+ description = "Macros for milo-parser, a fast and embeddable HTTP/1.1 parser."
+ homepage = "https://sw.cowtech.it/milo"
+ repository = "https://github.com/ShogunPanda/milo"
+ license = "ISC"
+ keywords = ["http", "parser", "http-parser"]
+ categories = ["network-programming", "parser-implementations"]
+ include = ["Cargo.toml", "src/**/*.rs", "constants/*.yml"]
+
+[lib]
+ proc-macro = true
+
+[[bin]]
+ name = "milo-parser-fields"
+ path = "src/parser_fields.rs"
+
+[dependencies]
+ indexmap = { version = "2.13.0", features = ["serde"] }
+ proc-macro2 = "1.0.106"
+ quote = "1.0.45"
+ regex = "1.12.3"
+ semver = "1.0.27"
+ serde = { version = "1.0.228", features = ["derive"] }
+ serde_json = "1.0.149"
+ serde_yaml = "0.9.34"
+ syn = { version = "2.0.117", features = ["full", "extra-traits"] }
+ toml = "1.0.7"
diff --git a/deps/undici/src/deps/milo/macros/README.md b/deps/undici/src/deps/milo/macros/README.md
new file mode 100644
index 00000000000..2053fc1a6a3
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/README.md
@@ -0,0 +1,34 @@
+# milo-macros
+
+milo-macros is an internal crate which represents the core of Milo.
+
+It leverages Rust's [procedural macro], [syn] and [quote] crates to allow an easy definition of states and matchers for the parser.
+
+To define a new macro, you have to define a new method which the following signature:
+
+```rust
+#[proc_macro]
+pub fn new_macro(input: TokenStream) -> TokenStream {
+ TokenStream::new( /* ... */)
+}
+```
+
+Everything that is not included **within** the return value will not be present in the executed code. Macro performance is not important for runtime because macros are only evaluated at compile time.
+
+The `generate!` macro also emits parser constants and internal byte lookup tables used by syntax validators. These tables are generated at compile time and are not public API.
+
+To return a new code, leverage the `quote!` macro, while for parsing use the `parse_macro_input!` macro. Here's an example:
+
+```rust
+#[proc_macro]
+pub fn char(input: TokenStream) -> TokenStream {
+ let character = parse_macro_input!(input as LitChar);
+ let byte = LitByte::new(c_uchar::try_from(character.value()).unwrap(), character.span());
+
+ TokenStream::from(quote! { #byte })
+}
+```
+
+[procedural macro]: https://doc.rust-lang.org/reference/procedural-macros.html
+[syn]: https://crates.io/crates/syn
+[quote]: https://crates.io/crates/quote
diff --git a/deps/undici/src/deps/milo/macros/constants/callbacks.yml b/deps/undici/src/deps/milo/macros/constants/callbacks.yml
new file mode 100644
index 00000000000..9313d6d18a7
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/constants/callbacks.yml
@@ -0,0 +1,29 @@
+---
+- on_error
+- on_finish
+- on_message_start
+- on_message_complete
+- on_request
+- on_response
+- on_reset
+- on_method
+- on_url
+- on_protocol
+- on_version
+- on_status
+- on_reason
+- on_header_name
+- on_header_value
+- on_headers
+- on_connect
+- on_upgrade
+- on_chunk_length
+- on_chunk_extension_name
+- on_chunk_extension_value
+- on_chunk
+- on_body
+- on_data
+- on_trailer_name
+- on_trailer_value
+- on_trailers
+- on_state_change
diff --git a/deps/undici/src/deps/milo/macros/constants/errors.yml b/deps/undici/src/deps/milo/macros/constants/errors.yml
new file mode 100644
index 00000000000..dd064151aeb
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/constants/errors.yml
@@ -0,0 +1,19 @@
+---
+- NONE
+- USER
+- CALLBACK_ERROR
+- UNEXPECTED_STATE
+- UNEXPECTED_DATA
+- UNEXPECTED_EOF
+- UNEXPECTED_CHARACTER
+- UNEXPECTED_CONTENT_LENGTH
+- UNEXPECTED_TRANSFER_ENCODING
+- UNEXPECTED_CONTENT
+- UNEXPECTED_TRAILERS
+- INVALID_VERSION
+- INVALID_STATUS
+- INVALID_CONTENT_LENGTH
+- INVALID_TRANSFER_ENCODING
+- INVALID_CHUNK_SIZE
+- MISSING_CONNECTION_UPGRADE
+- UNSUPPORTED_HTTP_VERSION
diff --git a/deps/undici/src/deps/milo/macros/constants/methods.yml b/deps/undici/src/deps/milo/macros/constants/methods.yml
new file mode 100644
index 00000000000..faf0a788f7c
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/constants/methods.yml
@@ -0,0 +1,19 @@
+---
+# Milo doesn't validate the method, that is left to the application
+- OTHER
+
+# RFC 9110 section 9 (HTTP Semantics — Methods)
+- GET
+- HEAD
+- POST
+- PUT
+- DELETE
+- CONNECT
+- OPTIONS
+- TRACE
+
+# RFC 5789 section 2 (PATCH Method) - This is included as widely used
+- PATCH
+
+# RFC 7540 section 3.5 (HTTP/2 connection preface)
+- PRI
diff --git a/deps/undici/src/deps/milo/macros/constants/states.yml b/deps/undici/src/deps/milo/macros/constants/states.yml
new file mode 100644
index 00000000000..8d0505c49fe
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/constants/states.yml
@@ -0,0 +1,16 @@
+---
+- start
+- finish
+- error
+- request_line
+- status_line
+- http2_preface
+- header
+- body_decision
+- body_via_content_length
+- body_with_no_length
+- chunk_header
+- chunk_extensions
+- chunk_data
+- trailer
+- tunnel
diff --git a/deps/undici/src/deps/milo/macros/src/actions.rs b/deps/undici/src/deps/milo/macros/src/actions.rs
new file mode 100644
index 00000000000..9ef3f8b01c6
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/src/actions.rs
@@ -0,0 +1,172 @@
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use syn::{Expr, Ident, parse_macro_input};
+
+use crate::structs::{EventRequest, FailureRequest};
+
+/// Emits an event carrying an input range.
+pub fn event_with_range(input: TokenStream) -> TokenStream {
+ let definition = parse_macro_input!(input as EventRequest);
+ let callback = &definition.identifier;
+ let callback_const = format_ident!("CALLBACK_{}", callback.to_string().to_uppercase());
+ let event_type = quote! { #callback_const + 1 };
+ let bitmask = format_ident!("EVENT_ACTIVE_{}", definition.identifier.to_string().to_uppercase());
+ let offset = definition.offset.as_ref().expect("event_with_range requires offset");
+ let length = definition.length.as_ref().expect("event_with_range requires length");
+ let needed = quote! { EVENT_RANGE_SIZE };
+ let emit = quote! {
+ let at = (self.position + #offset) as u32;
+ let len = (#length) as u32;
+ unsafe {
+ *self.events.add(event_cursor) = #event_type;
+ core::ptr::write_unaligned(
+ self.events.add(event_cursor + 1) as *mut u32,
+ at.to_le(),
+ );
+ core::ptr::write_unaligned(
+ self.events.add(event_cursor + 5) as *mut u32,
+ len.to_le(),
+ );
+ }
+ };
+
+ TokenStream::from(quote! {
+ if active_events & #bitmask != 0 {
+ // Reserve space for a later error event and the batch terminator.
+ if event_cursor + #needed + EVENT_ERROR_RESERVE <= EVENTS_BUFFER_SIZE {
+ #emit
+ event_cursor += #needed;
+ } else {
+ suspend!();
+ }
+ }
+ })
+}
+
+/// Emits an error event.
+pub fn event_with_error(input: TokenStream) -> TokenStream {
+ let definition = parse_macro_input!(input as EventRequest);
+ let callback = &definition.identifier;
+ let callback_const = format_ident!("CALLBACK_{}", callback.to_string().to_uppercase());
+ let event_type = quote! { #callback_const + 1 };
+ let bitmask = format_ident!("EVENT_ACTIVE_{}", definition.identifier.to_string().to_uppercase());
+ let needed = quote! { EVENT_ERROR_SIZE };
+ let emit = quote! {
+ let at = self.position as u32;
+ unsafe {
+ *self.events.add(event_cursor) = #event_type;
+ core::ptr::write_unaligned(
+ self.events.add(event_cursor + 1) as *mut u32,
+ at.to_le(),
+ );
+ *self.events.add(event_cursor + 5) = self.error_code;
+ }
+ };
+
+ TokenStream::from(quote! {
+ if active_events & #bitmask != 0 {
+ if event_cursor + #needed + EVENT_END_SIZE <= EVENTS_BUFFER_SIZE {
+ #emit
+ event_cursor += #needed;
+ } else {
+ suspend!();
+ }
+ }
+ })
+}
+
+/// Emits an event carrying parsed metadata.
+pub fn event_with_metadata(input: TokenStream) -> TokenStream {
+ let definition = parse_macro_input!(input as EventRequest);
+ let callback = &definition.identifier;
+ let callback_const = format_ident!("CALLBACK_{}", callback.to_string().to_uppercase());
+ let event_type = quote! { #callback_const + 1 };
+ let bitmask = format_ident!("EVENT_ACTIVE_{}", definition.identifier.to_string().to_uppercase());
+ let offset = definition.offset.unwrap_or_else(|| syn::parse_quote! { 0 });
+ let needed = quote! { EVENT_METADATA_SIZE };
+ let emit = quote! {
+ let at = (self.position + #offset) as u32;
+ let status_or_method = if self.is_request { self.method as u16 } else { self.status as u16 };
+ let body_kind = if self.has_content_length { 0u8 } else if self.has_chunked_transfer_encoding { 1u8 } else { 2u8 };
+ let should_keep_alive = (!self.has_connection_close) as u8;
+ // Responses switch protocols only with status 101; requests can propose an upgrade.
+ let should_upgrade = (self.has_upgrade && self.has_connection_upgrade && (self.is_request || self.status == 101)) as u8;
+ let has_trailers = self.has_trailers as u8;
+ let content_length = if self.has_content_length { self.content_length } else { 0 };
+
+ unsafe {
+ *self.events.add(event_cursor) = #event_type;
+ core::ptr::write_unaligned(
+ self.events.add(event_cursor + 1) as *mut u32,
+ at.to_le(),
+ );
+ core::ptr::write_unaligned(
+ self.events.add(event_cursor + 5) as *mut u16,
+ status_or_method.to_le(),
+ );
+ *self.events.add(event_cursor + 7) = should_keep_alive;
+ *self.events.add(event_cursor + 8) = should_upgrade;
+ *self.events.add(event_cursor + 9) = has_trailers;
+ *self.events.add(event_cursor + 10) = body_kind;
+ core::ptr::write_unaligned(
+ self.events.add(event_cursor + 11) as *mut u64,
+ content_length.to_le(),
+ );
+ }
+ };
+
+ TokenStream::from(quote! {
+ if active_events & #bitmask != 0 {
+ // Reserve space for a later error event and the batch terminator.
+ if event_cursor + #needed + EVENT_ERROR_RESERVE <= EVENTS_BUFFER_SIZE {
+ #emit
+ event_cursor += #needed;
+ } else {
+ suspend!();
+ }
+ }
+ })
+}
+
+// Marks a certain number of characters as used.
+pub fn advance(input: TokenStream) -> TokenStream {
+ let len = parse_macro_input!(input as Expr);
+
+ TokenStream::from(quote! { advanced += #len; })
+}
+
+/// Moves the parser to a new state.
+pub fn move_to(input: TokenStream) -> TokenStream {
+ let definition = parse_macro_input!(input as Ident);
+ let state = format_ident!("STATE_{}", definition.to_string().to_uppercase());
+
+ TokenStream::from(quote! {
+ if self.state != STATE_ERROR {
+ self.state = #state;
+ }
+ })
+}
+
+/// Go to the next iteration of the parser
+pub fn next() -> TokenStream { TokenStream::from(quote! { break 'state; }) }
+
+/// Marks the parser as suspended, waiting for more data.
+pub fn suspend() -> TokenStream {
+ TokenStream::from(quote! {
+ parsing = false;
+ break 'state;
+ })
+}
+
+/// Marks the parsing a failed, setting a error code and and error message.
+pub fn fail(input: TokenStream) -> TokenStream {
+ let definition = parse_macro_input!(input as FailureRequest);
+ let error = format_ident!("ERROR_{}", definition.error);
+ let message = definition.message;
+
+ TokenStream::from(quote! {
+ self.set_error(#error, #message);
+ failed = true;
+ break 'parser;
+ })
+}
diff --git a/deps/undici/src/deps/milo/macros/src/generators.rs b/deps/undici/src/deps/milo/macros/src/generators.rs
new file mode 100644
index 00000000000..f5111106b40
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/src/generators.rs
@@ -0,0 +1,443 @@
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use regex::{Captures, Regex};
+use syn::{Arm, ItemConst, parse_str};
+
+use crate::{native, parser_fields, wasm};
+
+fn init_constants() -> (Vec<String>, Vec<String>, Vec<String>, Vec<String>) {
+ let methods = serde_yaml::from_str(include_str!("../constants/methods.yml")).unwrap();
+ let errors = serde_yaml::from_str(include_str!("../constants/errors.yml")).unwrap();
+ let callbacks = serde_yaml::from_str(include_str!("../constants/callbacks.yml")).unwrap();
+ let states = serde_yaml::from_str(include_str!("../constants/states.yml")).unwrap();
+
+ (methods, errors, callbacks, states)
+}
+
+fn generate_constants_internal(
+ items: &[String],
+ prefix: &str,
+ start: usize,
+ strip_prefix: Option<&str>,
+) -> Vec<ItemConst> {
+ let mut consts: Vec<ItemConst> = Vec::new();
+ let mut bytes: Vec<&[u8]> = vec![];
+
+ for (i, x) in items.iter().enumerate() {
+ let value = strip_prefix.and_then(|prefix| x.strip_prefix(prefix)).unwrap_or(x);
+ let uppercased = value.to_uppercase();
+ let name = uppercased.replace('-', "_");
+ bytes.push(x.as_bytes());
+
+ consts.push(parse_str::<ItemConst>(&format!("pub const {}_{}: u8 = {};", prefix, name, i + start)).unwrap());
+ }
+
+ consts
+}
+
+fn generate_bitmask(items: &[String], prefix: &str) -> Vec<ItemConst> {
+ let mut consts: Vec<ItemConst> = Vec::new();
+ let mut all = 0u64;
+
+ consts.push(parse_str::<ItemConst>(&format!("pub const {}_NONE: u64 = 0;", prefix)).unwrap());
+
+ for (i, x) in items.iter().enumerate() {
+ let uppercased = x.to_uppercase();
+ let name = uppercased.replace('-', "_");
+ let bit = 1 << i;
+ all |= bit;
+
+ consts.push(parse_str::<ItemConst>(&format!("pub const {}_{}: u64 = {};", prefix, name, bit)).unwrap());
+ }
+
+ consts.push(parse_str::<ItemConst>(&format!("pub const {}_ALL: u64 = {};", prefix, all)).unwrap());
+
+ consts
+}
+
+fn generate_table<F>(validator: F) -> Vec<bool>
+where
+ F: Fn(u16) -> bool,
+{
+ // Precompute byte validators so the parser can use table lookups in hot paths.
+ (0..=255).map(validator).collect()
+}
+
+/// Generates all parser constants.
+fn generate_constants(methods: &[String], errors: &[String], callbacks: &[String], states: &[String]) -> TokenStream {
+ let methods_consts = generate_constants_internal(methods, "METHOD", 0, None);
+ let states_consts = generate_constants_internal(states, "STATE", 0, None);
+ let errors_consts = generate_constants_internal(errors, "ERROR", 0, None);
+ let callbacks_consts = generate_constants_internal(callbacks, "CALLBACK", 0, None);
+ let callbacks_bitmask = generate_bitmask(callbacks, "CALLBACK_ACTIVE");
+ let event_bitmask = generate_bitmask(callbacks, "EVENT_ACTIVE");
+ let event_consts = generate_constants_internal(callbacks, "EVENT", 1, Some("on_"));
+ let parser_field_offsets = parser_fields::generate_constants();
+ let token_table = generate_table(|byte| {
+ (0x30..=0x39).contains(&byte)
+ || (0x41..=0x5a).contains(&byte)
+ || (0x61..=0x7a).contains(&byte)
+ || matches!(
+ byte as u8,
+ b'!' | b'#' | b'$' | b'%' | b'&' | b'\'' | b'*' | b'+' | b'-' | b'.' | b'^' | b'_' | b'`' | b'|' | b'~'
+ )
+ });
+ let url_table = generate_table(|byte| {
+ (0x30..=0x39).contains(&byte)
+ || (0x41..=0x5a).contains(&byte)
+ || (0x61..=0x7a).contains(&byte)
+ || matches!(
+ byte as u8,
+ b'-'
+ | b'.'
+ | b'_'
+ | b'~'
+ | b':'
+ | b'/'
+ | b'?'
+ | b'['
+ | b']'
+ | b'@'
+ | b'!'
+ | b'$'
+ | b'&'
+ | b'\''
+ | b'('
+ | b')'
+ | b'*'
+ | b'+'
+ | b','
+ | b';'
+ | b'='
+ | b'%'
+ )
+ });
+ let quoted_string_table = generate_table(|byte| {
+ byte == 0x09
+ || byte == 0x20
+ || byte == 0x21
+ || (0x23..=0x5b).contains(&byte)
+ || (0x5d..=0x7e).contains(&byte)
+ || byte >= 0x80
+ });
+ let quoted_pair_table =
+ generate_table(|byte| byte == 0x09 || byte == 0x20 || (0x21..=0x7e).contains(&byte) || byte >= 0x80);
+
+ TokenStream::from(quote! {
+ pub type StateHandler = fn (parser: &mut Parser, data: &[c_uchar], available: usize);
+
+ #[unsafe(no_mangle)]
+ pub type Callback = fn (&mut Parser, usize, usize);
+
+ #(#methods_consts)*
+ #(#errors_consts)*
+ #(#callbacks_consts)*
+ pub const EVENT_END: u8 = 0;
+ #(#event_consts)*
+ #(#callbacks_bitmask)*
+ #(#event_bitmask)*
+ #(#states_consts)*
+ #parser_field_offsets
+
+ const EVENTS_BUFFER_SIZE: usize = 64 * 1024;
+ const EVENT_RANGE_SIZE: usize = 9;
+ const EVENT_METADATA_SIZE: usize = 19;
+ const EVENT_ERROR_SIZE: usize = 6;
+ const EVENT_END_SIZE: usize = 1;
+ const EVENT_ERROR_RESERVE: usize = EVENT_ERROR_SIZE + EVENT_END_SIZE;
+ // Reserve MESSAGE_COMPLETE, RESET and FINISH, regardless of which events are enabled.
+ const EVENT_COMPLETION_SIZE: usize = 3 * EVENT_RANGE_SIZE;
+ // Include DATA and BODY before the completion group.
+ const EVENT_BODY_COMPLETION_SIZE: usize = 2 * EVENT_RANGE_SIZE + EVENT_COMPLETION_SIZE;
+ // Include TRAILERS before the completion group.
+ const EVENT_TRAILER_COMPLETION_SIZE: usize = EVENT_RANGE_SIZE + EVENT_COMPLETION_SIZE;
+
+ /// cbindgen:ignore
+ static TOKEN_TABLE: [bool; 256] = [#(#token_table),*];
+
+ /// cbindgen:ignore
+ static URL_TABLE: [bool; 256] = [#(#url_table),*];
+
+ /// cbindgen:ignore
+ static QUOTED_STRING_TABLE: [bool; 256] = [#(#quoted_string_table),*];
+
+ /// cbindgen:ignore
+ static QUOTED_PAIR_TABLE: [bool; 256] = [#(#quoted_pair_table),*];
+ })
+}
+
+/// Generates all parser enums.
+fn generate_enums(methods: &[String], errors: &[String], callbacks: &[String], states: &[String]) -> TokenStream {
+ let snake_matcher = Regex::new(r"_([a-z])").unwrap();
+
+ let methods_ref = methods;
+ let errors_ref = errors;
+ let callbacks_ref = callbacks;
+ let events_ref: Vec<String> = core::iter::once("END".to_string())
+ .chain(
+ callbacks_ref
+ .iter()
+ .map(|x| x.strip_prefix("on_").unwrap_or(x).to_string()),
+ )
+ .collect();
+ let states_ref = states;
+
+ let methods: Vec<_> = methods_ref
+ .iter()
+ .map(|x| format_ident!("{}", x.replace('-', "_")))
+ .collect();
+
+ let errors: Vec<_> = errors_ref.iter().map(|x| format_ident!("{}", x)).collect();
+
+ let callbacks: Vec<_> = callbacks_ref
+ .iter()
+ .map(|x| {
+ let lowercase = x.to_lowercase();
+
+ format_ident!(
+ "{}",
+ snake_matcher.replace_all(lowercase.as_str(), |captures: &Captures| captures[1].to_uppercase())
+ )
+ })
+ .collect();
+
+ let events: Vec<_> = events_ref
+ .iter()
+ .map(|x| format_ident!("{}", x.to_uppercase()))
+ .collect();
+
+ let states: Vec<_> = states_ref
+ .iter()
+ .map(|x| format_ident!("{}", x.to_uppercase()))
+ .collect();
+
+ let methods_from: Vec<_> = methods_ref
+ .iter()
+ .enumerate()
+ .map(|(x, i)| parse_str::<Arm>(&format!("{} => Ok(Methods::{})", x, i.replace('-', "_"))).unwrap())
+ .collect();
+
+ let errors_from: Vec<_> = errors_ref
+ .iter()
+ .enumerate()
+ .map(|(x, i)| parse_str::<Arm>(&format!("{} => Ok(Errors::{})", x, i)).unwrap())
+ .collect();
+
+ let callbacks_from: Vec<_> = callbacks
+ .iter()
+ .enumerate()
+ .map(|(x, i)| parse_str::<Arm>(&format!("{} => Ok(Callbacks::{})", x, i)).unwrap())
+ .collect();
+
+ let events_from: Vec<_> = events
+ .iter()
+ .enumerate()
+ .map(|(x, i)| parse_str::<Arm>(&format!("{} => Ok(Events::{})", x, i)).unwrap())
+ .collect();
+
+ let states_from: Vec<_> = states
+ .iter()
+ .enumerate()
+ .map(|(x, i)| parse_str::<Arm>(&format!("{} => Ok(States::{})", x, i)).unwrap())
+ .collect();
+
+ let methods_into: Vec<_> = methods_ref
+ .iter()
+ .map(|x| parse_str::<Arm>(&format!("Methods::{} => \"{}\"", x.replace('-', "_"), x)).unwrap())
+ .collect();
+
+ let errors_into: Vec<_> = errors_ref
+ .iter()
+ .map(|x| parse_str::<Arm>(&format!("Errors::{} => \"{}\"", x, x)).unwrap())
+ .collect();
+
+ let callbacks_into: Vec<_> = callbacks
+ .iter()
+ .map(|x| parse_str::<Arm>(&format!("Callbacks::{} => \"{}\"", x, x)).unwrap())
+ .collect();
+
+ let events_into: Vec<_> = events_ref
+ .iter()
+ .map(|x| parse_str::<Arm>(&format!("Events::{} => \"{}\"", x.to_uppercase(), x.to_uppercase())).unwrap())
+ .collect();
+
+ let states_into: Vec<_> = states
+ .iter()
+ .map(|x| parse_str::<Arm>(&format!("States::{} => \"{}\"", x, x)).unwrap())
+ .collect();
+
+ TokenStream::from(quote! {
+ #[repr(u8)]
+ #[derive(Copy, Clone, Debug)]
+ pub enum Methods {
+ #(#methods),*
+ }
+
+ #[repr(u8)]
+ #[derive(Copy, Clone, Debug)]
+ pub enum Errors {
+ #(#errors),*
+ }
+
+ #[repr(u8)]
+ #[derive(Copy, Clone, Debug)]
+ pub enum Callbacks {
+ #(#callbacks),*
+ }
+
+ #[repr(u8)]
+ #[derive(Copy, Clone, Debug)]
+ pub enum Events {
+ #(#events),*
+ }
+
+ #[repr(u8)]
+ #[derive(Copy, Clone, Debug)]
+ pub enum States {
+ #(#states),*
+ }
+
+ impl TryFrom<u8> for Methods {
+ type Error = ();
+
+ fn try_from(value: u8) -> Result<Self, ()> {
+ match value {
+ #(#methods_from),*,
+ _ => Err(())
+ }
+ }
+ }
+
+ impl TryFrom<u8> for Errors {
+ type Error = ();
+
+ fn try_from(value: u8) -> Result<Self, ()> {
+ match value {
+ #(#errors_from),*,
+ _ => Err(())
+ }
+ }
+ }
+
+ impl TryFrom<u8> for Callbacks {
+ type Error = ();
+
+ fn try_from(value: u8) -> Result<Self, ()> {
+ match value {
+ #(#callbacks_from),*,
+ _ => Err(())
+ }
+ }
+ }
+
+ impl TryFrom<u8> for Events {
+ type Error = ();
+
+ fn try_from(value: u8) -> Result<Self, ()> {
+ match value {
+ #(#events_from),*,
+ _ => Err(())
+ }
+ }
+ }
+
+ impl TryFrom<u8> for States {
+ type Error = ();
+
+ fn try_from(value: u8) -> Result<Self, ()> {
+ match value {
+ #(#states_from),*,
+ _ => Err(())
+ }
+ }
+ }
+
+ impl From<Methods> for &str {
+ fn from(value: Methods) -> Self {
+ match value {
+ #(#methods_into),*
+ }
+ }
+ }
+
+ impl From<Errors> for &str {
+ fn from(value: Errors) -> Self {
+ match value {
+ #(#errors_into),*
+ }
+ }
+ }
+
+ impl From<Callbacks> for &str {
+ fn from(value: Callbacks) -> Self {
+ match value {
+ #(#callbacks_into),*
+ }
+ }
+ }
+
+ impl From<Events> for &str {
+ fn from(value: Events) -> Self {
+ match value {
+ #(#events_into),*
+ }
+ }
+ }
+
+ impl From<States> for &str {
+ fn from(value: States) -> Self {
+ match value {
+ #(#states_into),*
+ }
+ }
+ }
+
+ impl Methods {
+ pub fn as_str(self) -> &'static str {
+ self.into()
+ }
+ }
+
+ impl Errors {
+ pub fn as_str(self) -> &'static str {
+ self.into()
+ }
+ }
+
+ impl Callbacks {
+ pub fn as_str(self) -> &'static str {
+ self.into()
+ }
+ }
+
+ impl Events {
+ pub fn as_str(self) -> &'static str {
+ self.into()
+ }
+ }
+
+ impl States {
+ pub fn as_str(self) -> &'static str {
+ self.into()
+ }
+ }
+ })
+}
+
+fn generate_callbacks(callbacks: &[String]) -> TokenStream {
+ let native = native::generate_callbacks(callbacks);
+ let wasm = wasm::generate_callbacks(callbacks);
+
+ TokenStream::from_iter([native, wasm])
+}
+
+/// Generates the complete parser.
+pub fn generate() -> TokenStream {
+ let (methods, errors, callbacks, states) = init_constants();
+
+ let constants_code = generate_constants(&methods, &errors, &callbacks, &states);
+ let enums_code = generate_enums(&methods, &errors, &callbacks, &states);
+ let callbacks_code = generate_callbacks(&callbacks);
+
+ TokenStream::from_iter([constants_code, enums_code, callbacks_code])
+}
diff --git a/deps/undici/src/deps/milo/macros/src/lib.rs b/deps/undici/src/deps/milo/macros/src/lib.rs
new file mode 100644
index 00000000000..ea68cd5e8cc
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/src/lib.rs
@@ -0,0 +1,39 @@
+use proc_macro::TokenStream;
+
+mod actions;
+mod generators;
+mod matchers;
+mod native;
+mod parser_fields;
+mod structs;
+mod wasm;
+
+#[proc_macro]
+pub fn generate(_: TokenStream) -> TokenStream { generators::generate() }
+
+#[proc_macro]
+pub fn case_insensitive_string(input: TokenStream) -> TokenStream { matchers::case_insensitive_string(input) }
+
+#[proc_macro]
+pub fn event_with_range(input: TokenStream) -> TokenStream { actions::event_with_range(input) }
+
+#[proc_macro]
+pub fn event_with_error(input: TokenStream) -> TokenStream { actions::event_with_error(input) }
+
+#[proc_macro]
+pub fn event_with_metadata(input: TokenStream) -> TokenStream { actions::event_with_metadata(input) }
+
+#[proc_macro]
+pub fn advance(input: TokenStream) -> TokenStream { actions::advance(input) }
+
+#[proc_macro]
+pub fn move_to(input: TokenStream) -> TokenStream { actions::move_to(input) }
+
+#[proc_macro]
+pub fn next(_: TokenStream) -> TokenStream { actions::next() }
+
+#[proc_macro]
+pub fn suspend(_: TokenStream) -> TokenStream { actions::suspend() }
+
+#[proc_macro]
+pub fn fail(input: TokenStream) -> TokenStream { actions::fail(input) }
diff --git a/deps/undici/src/deps/milo/macros/src/matchers.rs b/deps/undici/src/deps/milo/macros/src/matchers.rs
new file mode 100644
index 00000000000..43da6e23e79
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/src/matchers.rs
@@ -0,0 +1,16 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{Expr, LitStr, parse_macro_input, parse_str};
+
+/// Matches a string in case insensitive way.
+pub fn case_insensitive_string(input: TokenStream) -> TokenStream {
+ let definition = parse_macro_input!(input as LitStr);
+
+ let bytes: Vec<_> = definition
+ .value()
+ .bytes()
+ .map(|b| parse_str::<Expr>(&format!("{} | {}", b.to_ascii_uppercase(), b.to_ascii_lowercase())).unwrap())
+ .collect();
+
+ TokenStream::from(quote! { [#(#bytes),*] })
+}
diff --git a/deps/undici/src/deps/milo/macros/src/native.rs b/deps/undici/src/deps/milo/macros/src/native.rs
new file mode 100644
index 00000000000..a10f57c678c
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/src/native.rs
@@ -0,0 +1,90 @@
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+
+/// Generates all parser callbacks.
+pub fn generate_callbacks(callbacks: &[String]) -> TokenStream {
+ let callbacks: Vec<_> = callbacks.iter().map(|x| format_ident!("{}", x)).collect();
+ let replay_arms = callbacks.iter().map(|callback| {
+ let callback_name = callback.to_string();
+ let event_const = format_ident!(
+ "EVENT_{}",
+ callback_name
+ .strip_prefix("on_")
+ .unwrap_or(&callback_name)
+ .to_uppercase()
+ );
+ let active_const = format_ident!("CALLBACK_ACTIVE_{}", callback_name.to_uppercase());
+
+ if callback_name == "on_error" {
+ quote! {
+ #event_const => {
+ let at = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 1) as *const u32) }.to_le() as usize;
+ if self.active_callbacks & #active_const != 0 {
+ (self.callbacks.#callback)(self, at, 0);
+ }
+ cursor += EVENT_ERROR_SIZE;
+ }
+ }
+ } else if callback_name == "on_headers" {
+ quote! {
+ #event_const => {
+ let at = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 1) as *const u32) }.to_le() as usize;
+ if self.active_callbacks & #active_const != 0 {
+ (self.callbacks.#callback)(self, at, 0);
+ }
+ cursor += EVENT_METADATA_SIZE;
+ }
+ }
+ } else {
+ quote! {
+ #event_const => {
+ let at = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 1) as *const u32) }.to_le() as usize;
+ let len = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 5) as *const u32) }.to_le() as usize;
+ if self.active_callbacks & #active_const != 0 {
+ (self.callbacks.#callback)(self, at, len);
+ }
+ cursor += EVENT_RANGE_SIZE;
+ }
+ }
+ }
+ });
+
+ TokenStream::from(quote! {
+ #[cfg(not(target_family = "wasm"))]
+ fn noop_internal(_parser: &mut Parser, _at: usize, _len: usize) {}
+
+ #[cfg(not(target_family = "wasm"))]
+ #[repr(C)]
+ #[derive(Clone, Debug)]
+ pub struct ParserCallbacks {
+ #( pub #callbacks: Callback),*
+ }
+
+ #[cfg(not(target_family = "wasm"))]
+ impl ParserCallbacks {
+ fn new() -> ParserCallbacks {
+ ParserCallbacks {
+ #( #callbacks: noop_internal ),*
+ }
+ }
+ }
+
+ #[cfg(not(target_family = "wasm"))]
+ impl Parser {
+ #[inline]
+ fn invoke_callbacks(&mut self) {
+ let mut cursor = 0usize;
+
+ loop {
+ let event_type = unsafe { *self.events.add(cursor) };
+
+ match event_type {
+ EVENT_END => break,
+ #(#replay_arms)*
+ _ => break,
+ }
+ }
+ }
+ }
+ })
+}
diff --git a/deps/undici/src/deps/milo/macros/src/parser_fields.rs b/deps/undici/src/deps/milo/macros/src/parser_fields.rs
new file mode 100644
index 00000000000..c547583bc50
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/src/parser_fields.rs
@@ -0,0 +1,122 @@
+use core::mem::offset_of;
+
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
+
+type WasmPointer = u32;
+type WasmUsize = u32;
+
+// Keep this in sync with parser::Parser when compiled with target_family =
+// "wasm".
+#[repr(C)]
+struct ParserStub {
+ max_start_line_length: WasmUsize,
+ max_header_length: WasmUsize,
+ max_body_payload: u64,
+ autodetect: bool,
+ is_request: bool,
+ suspend_after_headers: bool,
+ manage_unconsumed: bool,
+ continue_without_data: bool,
+ is_connect: bool,
+ skip_body: bool,
+ debug: bool,
+ parsed: u64,
+ position: WasmUsize,
+ state: u8,
+ paused: bool,
+ error_code: u8,
+ content_length: u64,
+ chunk_size: u64,
+ remaining_content_length: u64,
+ remaining_chunk_size: u64,
+ status: u32,
+ method: u8,
+ has_content_length: bool,
+ has_transfer_encoding: bool,
+ has_chunked_transfer_encoding: bool,
+ has_connection_close: bool,
+ has_connection_upgrade: bool,
+ has_upgrade: bool,
+ has_trailers: bool,
+ active_callbacks: u64,
+ active_events: u64,
+ ptr: WasmPointer,
+ error_description: [u8; 255],
+ unconsumed: WasmPointer,
+ unconsumed_len: WasmUsize,
+ error_description_len: u8,
+ events: WasmPointer,
+}
+
+pub const FIELDS: &[(&str, usize)] = &[
+ ("MAX_START_LINE_LENGTH", offset_of!(ParserStub, max_start_line_length)),
+ ("MAX_HEADER_LENGTH", offset_of!(ParserStub, max_header_length)),
+ ("MAX_BODY_PAYLOAD", offset_of!(ParserStub, max_body_payload)),
+ ("AUTODETECT", offset_of!(ParserStub, autodetect)),
+ ("IS_REQUEST", offset_of!(ParserStub, is_request)),
+ ("SUSPEND_AFTER_HEADERS", offset_of!(ParserStub, suspend_after_headers)),
+ ("MANAGE_UNCONSUMED", offset_of!(ParserStub, manage_unconsumed)),
+ ("CONTINUE_WITHOUT_DATA", offset_of!(ParserStub, continue_without_data)),
+ ("IS_CONNECT", offset_of!(ParserStub, is_connect)),
+ ("SKIP_BODY", offset_of!(ParserStub, skip_body)),
+ ("DEBUG", offset_of!(ParserStub, debug)),
+ ("PARSED", offset_of!(ParserStub, parsed)),
+ ("POSITION", offset_of!(ParserStub, position)),
+ ("STATE", offset_of!(ParserStub, state)),
+ ("PAUSED", offset_of!(ParserStub, paused)),
+ ("ERROR_CODE", offset_of!(ParserStub, error_code)),
+ ("CONTENT_LENGTH", offset_of!(ParserStub, content_length)),
+ ("CHUNK_SIZE", offset_of!(ParserStub, chunk_size)),
+ (
+ "REMAINING_CONTENT_LENGTH",
+ offset_of!(ParserStub, remaining_content_length),
+ ),
+ ("REMAINING_CHUNK_SIZE", offset_of!(ParserStub, remaining_chunk_size)),
+ ("STATUS", offset_of!(ParserStub, status)),
+ ("METHOD", offset_of!(ParserStub, method)),
+ ("HAS_CONTENT_LENGTH", offset_of!(ParserStub, has_content_length)),
+ ("HAS_TRANSFER_ENCODING", offset_of!(ParserStub, has_transfer_encoding)),
+ (
+ "HAS_CHUNKED_TRANSFER_ENCODING",
+ offset_of!(ParserStub, has_chunked_transfer_encoding),
+ ),
+ ("HAS_CONNECTION_CLOSE", offset_of!(ParserStub, has_connection_close)),
+ ("HAS_CONNECTION_UPGRADE", offset_of!(ParserStub, has_connection_upgrade)),
+ ("HAS_UPGRADE", offset_of!(ParserStub, has_upgrade)),
+ ("HAS_TRAILERS", offset_of!(ParserStub, has_trailers)),
+ ("ACTIVE_CALLBACKS", offset_of!(ParserStub, active_callbacks)),
+ ("ACTIVE_EVENTS", offset_of!(ParserStub, active_events)),
+ ("PTR", offset_of!(ParserStub, ptr)),
+ ("ERROR_DESCRIPTION", offset_of!(ParserStub, error_description)),
+ ("UNCONSUMED", offset_of!(ParserStub, unconsumed)),
+ ("UNCONSUMED_LEN", offset_of!(ParserStub, unconsumed_len)),
+ ("ERROR_DESCRIPTION_LEN", offset_of!(ParserStub, error_description_len)),
+ ("EVENTS", offset_of!(ParserStub, events)),
+];
+
+pub fn generate_constants() -> TokenStream {
+ let constants = FIELDS.iter().map(|(name, offset)| {
+ let ident = format_ident!("PARSER_FIELD_{}", name);
+
+ quote! {
+ #[cfg(target_family = "wasm")]
+ pub const #ident: usize = #offset;
+ }
+ });
+
+ quote! {
+ #(#constants)*
+ }
+}
+
+#[allow(dead_code)]
+fn main() {
+ let constants = FIELDS
+ .iter()
+ .map(|(name, offset)| format!("\"PARSER_FIELD_{name}\":{offset}"))
+ .collect::<Vec<_>>()
+ .join(",");
+
+ println!("{{{}}}", constants);
+}
diff --git a/deps/undici/src/deps/milo/macros/src/structs.rs b/deps/undici/src/deps/milo/macros/src/structs.rs
new file mode 100644
index 00000000000..2252fe81a29
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/src/structs.rs
@@ -0,0 +1,65 @@
+use syn::parse::{Parse, ParseStream};
+use syn::{Expr, Ident, Result, Token};
+
+/// An identifier associated to a message, typically a string - An example of
+/// this is used in `fail!`.
+pub struct FailureRequest {
+ pub error: Ident,
+ pub message: Expr,
+}
+
+/// An identifier associated to an expression - An example of this is used in
+/// `event_with_range!`.
+pub struct EventRequest {
+ pub identifier: Ident,
+ pub offset: Option<Expr>,
+ pub length: Option<Expr>,
+}
+
+impl Parse for FailureRequest {
+ // Parses a failure definition
+ fn parse(input: ParseStream) -> Result<Self> {
+ // Get the code
+ let error = input.parse()?;
+
+ // Discard the comma
+ input.parse::<Token![,]>()?;
+
+ // Get the message
+ let message = input.parse()?;
+
+ Ok(FailureRequest { error, message })
+ }
+}
+
+impl Parse for EventRequest {
+ // Parses a identifier and its optional expression
+ fn parse(input: ParseStream) -> Result<Self> {
+ let identifier = input.parse()?;
+ let mut offset = None;
+ let mut length = None;
+
+ // If there is more input
+ if !input.is_empty() {
+ // Discard the comma
+ input.parse::<Token![,]>()?;
+
+ // Parse the expression
+ offset = Some(input.parse::<Expr>()?);
+
+ if !input.is_empty() {
+ // Discard the comma
+ input.parse::<Token![,]>()?;
+
+ // Parse the expression
+ length = Some(input.parse::<Expr>()?);
+ }
+ }
+
+ Ok(EventRequest {
+ identifier,
+ offset,
+ length,
+ })
+ }
+}
diff --git a/deps/undici/src/deps/milo/macros/src/wasm.rs b/deps/undici/src/deps/milo/macros/src/wasm.rs
new file mode 100644
index 00000000000..8b8cc3ef3c0
--- /dev/null
+++ b/deps/undici/src/deps/milo/macros/src/wasm.rs
@@ -0,0 +1,115 @@
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+
+/// Generates all parser callbacks.
+pub fn generate_callbacks(callbacks: &[String]) -> TokenStream {
+ let callbacks: Vec<_> = callbacks
+ .iter()
+ .filter(|x| x.as_str() != "on_headers")
+ .map(|x| format_ident!("{}", x))
+ .collect();
+ let replay_arms = callbacks
+ .iter()
+ .filter(|callback| callback.to_string() != "on_error")
+ .map(|callback| {
+ let callback_name = callback.to_string();
+ let event_const = format_ident!(
+ "EVENT_{}",
+ callback_name
+ .strip_prefix("on_")
+ .unwrap_or(&callback_name)
+ .to_uppercase()
+ );
+ let active_const = format_ident!("CALLBACK_ACTIVE_{}", callback_name.to_uppercase());
+
+ quote! {
+ #event_const => {
+ let at = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 1) as *const u32) }.to_le() as usize;
+ let len = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 5) as *const u32) }.to_le() as usize;
+ if self.active_callbacks & #active_const != 0 {
+ unsafe { #callback(self.ptr, at, len); }
+ }
+ cursor += EVENT_RANGE_SIZE;
+ }
+ }
+ });
+
+ TokenStream::from(quote! {
+ #[cfg(target_family = "wasm")]
+ #[link(wasm_import_module = "env")]
+ unsafe extern "C" {
+ #(fn #callbacks(parser: *mut c_void, _at: usize, _len: usize);)*
+ fn on_headers(
+ parser: *mut c_void,
+ at: usize,
+ method_or_status: u32,
+ should_keep_alive: bool,
+ should_upgrade: bool,
+ has_trailers: bool,
+ body_kind: u8,
+ content_length: f64,
+ );
+
+ #[cfg(any(debug_assertions, feature = "debug"))]
+ fn logger(message: u64);
+ }
+
+ #[cfg(all(any(debug_assertions, feature = "debug"), target_family = "wasm"))]
+ #[unsafe(no_mangle)]
+ pub fn __start() {
+ std::panic::set_hook(Box::new(|panic_info| {
+ debug(format!("WebAssembly panicked: {:#?}", panic_info));
+ }));
+ }
+
+ #[cfg(target_family = "wasm")]
+ impl Parser {
+ #[inline]
+ fn invoke_callbacks(&mut self) {
+ let mut cursor = 0usize;
+
+ loop {
+ let event_type = unsafe { *self.events.add(cursor) };
+
+ match event_type {
+ EVENT_END => break,
+ EVENT_ERROR => {
+ let at = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 1) as *const u32) }.to_le() as usize;
+ if self.active_callbacks & CALLBACK_ACTIVE_ON_ERROR != 0 {
+ unsafe { on_error(self.ptr, at, 0); }
+ }
+ cursor += EVENT_ERROR_SIZE;
+ }
+ EVENT_HEADERS => {
+ let at = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 1) as *const u32) }.to_le() as usize;
+ let method_or_status = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 5) as *const u16) }.to_le() as u32;
+ let should_keep_alive = unsafe { *self.events.add(cursor + 7) } != 0;
+ let should_upgrade = unsafe { *self.events.add(cursor + 8) } != 0;
+ let has_trailers = unsafe { *self.events.add(cursor + 9) } != 0;
+ let body_kind = unsafe { *self.events.add(cursor + 10) };
+ let content_length = unsafe { core::ptr::read_unaligned(self.events.add(cursor + 11) as *const u64) }.to_le() as f64;
+
+ if self.active_callbacks & CALLBACK_ACTIVE_ON_HEADERS != 0 {
+ unsafe {
+ on_headers(
+ self.ptr,
+ at,
+ method_or_status,
+ should_keep_alive,
+ should_upgrade,
+ has_trailers,
+ body_kind,
+ content_length,
+ );
+ }
+ }
+ cursor += EVENT_METADATA_SIZE;
+ }
+ #(#replay_arms)*
+ _ => break,
+ }
+ }
+ }
+ }
+ })
+}
diff --git a/deps/undici/src/deps/milo/parser/Cargo.toml b/deps/undici/src/deps/milo/parser/Cargo.toml
new file mode 100644
index 00000000000..c5b3abed8ac
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+ name = "milo-parser"
+ version = "0.9.0"
+ edition = "2024"
+ description = "A fast and embeddable HTTP/1.1 parser."
+ homepage = "https://sw.cowtech.it/milo"
+ repository = "https://github.com/ShogunPanda/milo"
+ license = "ISC"
+ keywords = ["http", "parser", "http-parser"]
+ categories = ["network-programming", "parser-implementations"]
+
+[lib]
+ crate-type = ["cdylib", "staticlib", "lib"]
+
+[[bin]]
+ name = "milo-parser"
+ path = "src/main.rs"
+
+[features]
+ debug = []
+
+[dependencies]
+ milo-macros = { version = "0.9.0", path = "../macros" }
+ memchr = "2.8.0"
+
+[dev-dependencies]
+ comfy-table = { version = "7.2.2" }
+ libc = "0.2"
+ regex = "1.12.3"
+ serde = { version = "1.0.228", features = ["derive"] }
+ serde_json = "1.0.145"
+ serde_yaml = "0.9.34"
+ similar = "3.0.0"
+
+[profile.release]
+ opt-level = 3
+ debug = false
+ debug-assertions = false
+ overflow-checks = false
+ lto = true
+ panic = 'abort'
+ incremental = false
+ codegen-units = 1
+ rpath = false
+ strip = true
diff --git a/deps/undici/src/deps/milo/parser/Makefile.toml b/deps/undici/src/deps/milo/parser/Makefile.toml
new file mode 100644
index 00000000000..d77d7745241
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/Makefile.toml
@@ -0,0 +1,64 @@
+[config]
+ skip_core_tasks = true
+
+[env]
+ TARGET = { script = ["rustc -vV | sed -n 's|host: ||p'"] }
+
+[tasks.default]
+ dependencies = ["build"]
+
+[tasks.build]
+ dependencies = ["cpp", "wasm"]
+
+[tasks.test]
+ dependencies = ["build", "test:rust", "test:wasm"]
+
+[tasks."test:rust"]
+ command = "cargo"
+ args = ["test"]
+
+[tasks."test:wasm"]
+ dependencies = ["wasm:release"]
+ command = "node"
+ args = ["--test", "--test-reporter=cleaner-spec-reporter", "wasm/test/*.test.js"]
+
+[tasks.cpp]
+ dependencies = ["cpp:headers", "cpp:libs"]
+
+[tasks.wasm]
+ dependencies = ["wasm:release", "wasm:debug"]
+
+[tasks."cpp:libs"]
+ dependencies = ["cpp:release", "cpp:debug"]
+
+[tasks."cpp:release"]
+ env = { CONFIGURATION = "release", "CARGO_OPTIONS" = "--release" }
+ run_task = "cpp:lib"
+
+[tasks."cpp:debug"]
+ env = { CONFIGURATION = "debug", "CARGO_OPTIONS" = "--release --features debug" }
+ run_task = "cpp:lib"
+
+[tasks."cpp:lib"]
+ dependencies = ["scripts:build"]
+ script = ["mkdir -p ../dist/cpp/${CONFIGURATION}", "rm -rf ../dist/cpp/${CONFIGURATION}/*", "cargo build --locked -Z unstable-options --target ${TARGET} ${CARGO_OPTIONS} --artifact-dir target/cpp/${CONFIGURATION}", "cp target/cpp/${CONFIGURATION}/libmilo_parser.a ../dist/cpp/${CONFIGURATION}/libmilo.a", "cp target/headers/milo.h ../dist/cpp/${CONFIGURATION}", "../scripts/target/release/postbuild-cpp ${CONFIGURATION}"]
+
+[tasks."scripts:build"]
+ command = "cargo"
+ args = ["build", "--locked", "--release", "--manifest-path", "../scripts/Cargo.toml", "--target-dir", "../scripts/target", "--bins"]
+
+[tasks."cpp:headers"]
+ command = "cbindgen"
+ args = ["--quiet", "--output", "target/headers/milo.h"]
+
+[tasks."wasm:release"]
+ env = { CONFIGURATION = "release", CARGO_BUILD_OPTIONS = "-Z unstable-options -Z build-std=std,panic_abort", CARGO_OPTIONS = "--release", RUSTFLAGS_BASE = "-Z unstable-options -C panic=immediate-abort", WASMPACK_OPTIONS = "--release" }
+ run_task = "wasm:module"
+
+[tasks."wasm:debug"]
+ env = { CONFIGURATION = "debug", CARGO_BUILD_OPTIONS = "-Z unstable-options", CARGO_OPTIONS = "--release --features debug", RUSTFLAGS_BASE = "", WASMPACK_OPTIONS = "--release" }
+ run_task = "wasm:module"
+
+[tasks."wasm:module"]
+ dependencies = ["scripts:build"]
+ script = ["mkdir -p ../dist/wasm", "rm -rf ../dist/wasm/${CONFIGURATION}", "mkdir -p ../dist/wasm/${CONFIGURATION}/binary", "RUSTFLAGS=\"${RUSTFLAGS_BASE} -C target-feature=+simd128\" cargo build --locked --lib ${CARGO_BUILD_OPTIONS} --target wasm32-unknown-unknown ${CARGO_OPTIONS}", "cp -a target/wasm32-unknown-unknown/release/milo_parser.wasm ../dist/wasm/${CONFIGURATION}/binary/simd.wasm", "wasm-opt -O3 --enable-bulk-memory-opt --enable-simd -o ../dist/wasm/${CONFIGURATION}/binary/simd.wasm ../dist/wasm/${CONFIGURATION}/binary/simd.wasm", "RUSTFLAGS=\"${RUSTFLAGS_BASE}\" cargo build --locked --lib ${CARGO_BUILD_OPTIONS} --target wasm32-unknown-unknown ${CARGO_OPTIONS}", "cp -a target/wasm32-unknown-unknown/release/milo_parser.wasm ../dist/wasm/${CONFIGURATION}/binary/no-simd.wasm", "wasm-opt -O3 --enable-bulk-memory-opt -o ../dist/wasm/${CONFIGURATION}/binary/no-simd.wasm ../dist/wasm/${CONFIGURATION}/binary/no-simd.wasm", "../scripts/target/release/postbuild-wasm ${CONFIGURATION}"]
diff --git a/deps/undici/src/deps/milo/parser/README.md b/deps/undici/src/deps/milo/parser/README.md
new file mode 100644
index 00000000000..7e99f16ff41
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/README.md
@@ -0,0 +1,26 @@
+# Milo Parser
+
+This folder contains the milo main parser.
+
+To build milo, simply run:
+
+```bash
+makers
+```
+
+this will generate `cpp` and `wasm` build in `dist` folder.
+These files can be copied in the source code to embed milo.
+
+## How to use the API
+
+See the main [README.md](../README.md) in the parent folder.
+
+## Verify compiled code and macro substitution
+
+Once [cargo-expand](https://github.com/dtolnay/cargo-expand), is installed, run:
+
+```bash
+cargo expand > compiled.rs
+```
+
+This will generate a file which can be analyzed to see what is the final compiled code after all macros have been evaluated.
diff --git a/deps/undici/src/deps/milo/parser/cbindgen.toml b/deps/undici/src/deps/milo/parser/cbindgen.toml
new file mode 100644
index 00000000000..844779ada29
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/cbindgen.toml
@@ -0,0 +1,21 @@
+language = "C++"
+include_guard = "MILO_H"
+namespace = "milo_parser"
+
+[parse.expand]
+ crates = ["milo-parser"]
+
+[export]
+ include = [
+ "Parser",
+ "ParserCallbacks",
+ "CStringWithLength",
+ "Callback",
+ "MessageTypes",
+ "Connections",
+ "Methods",
+ "States",
+ "Errors",
+ "Callbacks",
+ "Events",
+ ]
diff --git a/deps/undici/src/deps/milo/parser/src/lib.rs b/deps/undici/src/deps/milo/parser/src/lib.rs
new file mode 100644
index 00000000000..f5f0b50d6f9
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/src/lib.rs
@@ -0,0 +1,359 @@
+#![allow(unused_imports)]
+
+extern crate alloc;
+
+use alloc::ffi::CString;
+use alloc::vec::Vec;
+use alloc::{boxed::Box, format};
+use core::cell::{Cell, RefCell};
+use core::ffi::{c_char, c_uchar, c_void};
+use core::fmt::Debug;
+use core::str;
+use core::{mem, ptr};
+use core::{slice, slice::from_raw_parts};
+
+use milo_macros::generate;
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct Parser {
+ // User writable
+ #[cfg(not(target_family = "wasm"))]
+ pub context: *mut c_void,
+ pub max_start_line_length: usize,
+ pub max_header_length: usize,
+ pub max_body_payload: u64,
+ pub autodetect: bool,
+ pub is_request: bool,
+ pub suspend_after_headers: bool,
+ pub manage_unconsumed: bool,
+ pub continue_without_data: bool,
+ pub is_connect: bool,
+ pub skip_body: bool,
+ pub debug: bool,
+
+ // Generic state
+ pub parsed: u64,
+ pub position: usize,
+ pub state: u8,
+ pub paused: bool,
+ pub error_code: u8,
+
+ // Current message flags
+ pub content_length: u64,
+ pub chunk_size: u64,
+ pub remaining_content_length: u64,
+ pub remaining_chunk_size: u64,
+ pub status: u32,
+ pub method: u8,
+ pub has_content_length: bool,
+ pub has_transfer_encoding: bool,
+ pub has_chunked_transfer_encoding: bool,
+ pub has_connection_close: bool,
+ pub has_connection_upgrade: bool,
+ pub has_upgrade: bool,
+ pub has_trailers: bool,
+
+ // Callback handling
+ pub active_callbacks: u64,
+ pub active_events: u64,
+ #[cfg(not(target_family = "wasm"))]
+ pub callbacks: ParserCallbacks,
+
+ // WASM Specific
+ #[cfg(target_family = "wasm")]
+ pub ptr: *mut c_void,
+
+ // Complex data types - We need to split them in order to be exportable to C++
+ pub error_description: [u8; 255],
+ pub unconsumed: *const c_uchar,
+ pub unconsumed_len: usize,
+ pub error_description_len: u8,
+
+ // Event buffer. Keep this at the end of the struct for external readers.
+ pub events: *mut c_uchar,
+}
+
+#[cfg(not(target_family = "wasm"))]
+mod native;
+
+#[cfg(not(target_family = "wasm"))]
+pub use crate::native::*;
+
+#[cfg(target_family = "wasm")]
+mod wasm;
+
+#[cfg(target_family = "wasm")]
+pub use crate::wasm::*;
+
+generate!();
+
+impl Parser {
+ /// Creates a new parser
+ pub fn new() -> Parser {
+ let mut events = Box::new([0u8; 65536]);
+ let events_ptr = events.as_mut_ptr();
+ mem::forget(events);
+
+ Parser {
+ // User writable
+ #[cfg(not(target_family = "wasm"))]
+ context: ptr::null_mut(),
+ max_start_line_length: 8192,
+ max_header_length: 8192,
+ max_body_payload: 0,
+ autodetect: true,
+ is_request: false,
+ suspend_after_headers: false,
+ manage_unconsumed: false,
+ continue_without_data: false,
+ is_connect: false,
+ skip_body: false,
+ debug: false,
+ // Generic state
+ parsed: 0,
+ position: 0,
+ state: STATE_START,
+ paused: false,
+ error_code: ERROR_NONE,
+ // Current message flags
+ content_length: 0,
+ chunk_size: 0,
+ remaining_content_length: 0,
+ remaining_chunk_size: 0,
+ status: 0,
+ method: 0,
+ has_content_length: false,
+ has_transfer_encoding: false,
+ has_chunked_transfer_encoding: false,
+ has_connection_close: false,
+ has_connection_upgrade: false,
+ has_upgrade: false,
+ has_trailers: false,
+ // Callbacks handling
+ active_callbacks: 0,
+ active_events: 0,
+ #[cfg(not(target_family = "wasm"))]
+ callbacks: ParserCallbacks::new(),
+ // WASM Specific
+ #[cfg(target_family = "wasm")]
+ ptr: ptr::null_mut(),
+ // Complex data types
+ error_description: [0; 255],
+ unconsumed: ptr::null(),
+ unconsumed_len: 0,
+ error_description_len: 0,
+ events: events_ptr,
+ }
+ }
+
+ /// Resets a parser. The second parameters specifies if to also reset the
+ /// parsed counter.
+ ///
+ /// The following fields are not modified:
+ /// * position
+ /// * context
+ /// * autodetect
+ /// * is_request
+ /// * suspend_after_headers
+ /// * manage_unconsumed
+ /// * continue_without_data
+ /// * debug
+ /// * context
+ pub fn reset(&mut self, keep_parsed: bool) {
+ self.state = STATE_START;
+ self.paused = false;
+
+ if !keep_parsed {
+ self.parsed = 0;
+ }
+
+ self.error_code = ERROR_NONE;
+
+ self.error_description[0] = 0;
+ self.error_description_len = 0;
+
+ self.clear_unconsumed();
+
+ self.clear();
+ self.skip_body = false;
+ unsafe {
+ *self.events = EVENT_END;
+ }
+ }
+
+ pub(crate) fn clear_unconsumed(&mut self) {
+ if self.unconsumed_len > 0 {
+ // SAFETY: Retained input is allocated as a boxed slice with exactly this
+ // length, and the parser owns it until replacement, reset, or destruction.
+ unsafe {
+ drop(Box::from_raw(ptr::slice_from_raw_parts_mut(
+ self.unconsumed as *mut c_uchar,
+ self.unconsumed_len,
+ )));
+ }
+ }
+ self.unconsumed = ptr::null();
+ self.unconsumed_len = 0;
+ }
+
+ /// Clears all values about the message in the parser.
+ pub fn clear(&mut self) {
+ self.is_connect = false;
+ self.method = 0;
+ self.status = 0;
+ self.has_content_length = false;
+ self.has_transfer_encoding = false;
+ self.has_chunked_transfer_encoding = false;
+ self.has_connection_close = false;
+ self.has_connection_upgrade = false;
+ self.has_upgrade = false;
+ self.has_trailers = false;
+ self.content_length = 0;
+ self.chunk_size = 0;
+ self.remaining_content_length = 0;
+ self.remaining_chunk_size = 0;
+ }
+
+ #[inline(always)]
+ pub(crate) fn try_emit_event_range(
+ &mut self,
+ event_cursor: &mut usize,
+ event_type: u8,
+ at: usize,
+ len: usize,
+ ) -> bool {
+ // Reserve six bytes for a later error event and one for the terminator.
+ if *event_cursor + EVENT_RANGE_SIZE + EVENT_ERROR_RESERVE > EVENTS_BUFFER_SIZE {
+ return false;
+ }
+
+ unsafe {
+ *self.events.add(*event_cursor) = event_type;
+ core::ptr::write_unaligned(self.events.add(*event_cursor + 1) as *mut u32, (at as u32).to_le());
+ core::ptr::write_unaligned(self.events.add(*event_cursor + 5) as *mut u32, (len as u32).to_le());
+ }
+ *event_cursor += EVENT_RANGE_SIZE;
+ true
+ }
+
+ #[inline(always)]
+ pub(crate) fn try_emit_event_error(&mut self, event_cursor: &mut usize) -> bool {
+ if *event_cursor + EVENT_ERROR_SIZE + EVENT_END_SIZE > EVENTS_BUFFER_SIZE {
+ return false;
+ }
+
+ unsafe {
+ *self.events.add(*event_cursor) = EVENT_ERROR;
+ core::ptr::write_unaligned(
+ self.events.add(*event_cursor + 1) as *mut u32,
+ (self.position as u32).to_le(),
+ );
+ *self.events.add(*event_cursor + 5) = self.error_code;
+ }
+ *event_cursor += EVENT_ERROR_SIZE;
+ true
+ }
+
+ /// Pauses the parser. It will have to be resumed via `resume`.
+ pub fn pause(&mut self) { self.paused = true; }
+
+ /// Resumes the parser.
+ pub fn resume(&mut self) { self.paused = false; }
+
+ /// Marks the parser as finished. Any new data received via `parse` will
+ /// put the parser in the error state.
+ pub fn finish(&mut self) {
+ match self.state {
+ // If the parser is one of the initial states, simply jump to finish
+ STATE_START | STATE_REQUEST_LINE | STATE_STATUS_LINE | STATE_FINISH => {
+ self.state = STATE_FINISH;
+ }
+ STATE_BODY_WITH_NO_LENGTH => {
+ // Notify that the message has been completed
+ let active_events = self.active_events | self.active_callbacks;
+ let mut event_cursor = 0usize;
+ if active_events & EVENT_ACTIVE_ON_MESSAGE_COMPLETE != 0 {
+ self.try_emit_event_range(&mut event_cursor, EVENT_MESSAGE_COMPLETE, self.position, 0);
+ }
+ unsafe {
+ *self.events.add(event_cursor) = EVENT_END;
+ }
+
+ // Set the state to be finished
+ self.state = STATE_FINISH;
+ }
+ STATE_ERROR => (),
+ // In another other state, this is an error
+ _ => {
+ self.fail(ERROR_UNEXPECTED_EOF, "Unexpected end of data");
+ }
+ }
+ }
+
+ /// Marks parsing as failed and starts a standalone error event batch.
+ #[inline(always)]
+ pub fn fail(&mut self, code: u8, description: &str) {
+ self.set_error(code, description);
+ let mut event_cursor = 0usize;
+ if (self.active_events | self.active_callbacks) & EVENT_ACTIVE_ON_ERROR != 0 {
+ self.try_emit_event_error(&mut event_cursor);
+ }
+ // SAFETY: The cursor follows at most one error event in the owned event buffer.
+ unsafe {
+ *self.events.add(event_cursor) = EVENT_END;
+ }
+ }
+
+ /// Records an error without changing the current event batch.
+ #[inline(always)]
+ pub(crate) fn set_error(&mut self, code: u8, description: &str) {
+ let bytes = description.as_bytes();
+ let len = bytes.len().min(254);
+
+ self.state = STATE_ERROR;
+ self.error_code = code;
+ self.error_description[..len].copy_from_slice(&bytes[..len]);
+ self.error_description[len] = 0;
+ self.error_description_len = len as u8;
+ }
+
+ /// Returns the current parser's state as string.
+ pub fn state_str(&self) -> &str { States::try_from(self.state).unwrap().as_str() }
+
+ /// Returns the current parser's error state as string.
+ pub fn error_code_str(&self) -> &str { Errors::try_from(self.error_code).unwrap().as_str() }
+
+ /// Returns the current parser's error description as string.
+ pub fn error_description_str(&self) -> &str {
+ unsafe {
+ if self.error_description_len > 0 {
+ str::from_utf8_unchecked(from_raw_parts(
+ self.error_description.as_ptr(),
+ self.error_description_len as usize,
+ ))
+ } else {
+ ""
+ }
+ }
+ }
+}
+
+impl Drop for Parser {
+ fn drop(&mut self) {
+ self.clear_unconsumed();
+ if !self.events.is_null() {
+ unsafe {
+ let _ = Box::from_raw(self.events as *mut [u8; 65536]);
+ }
+ self.events = ptr::null_mut();
+ }
+ }
+}
+
+impl Default for Parser {
+ fn default() -> Self { Self::new() }
+}
+
+mod matchers;
+mod parse;
diff --git a/deps/undici/src/deps/milo/parser/src/main.rs b/deps/undici/src/deps/milo/parser/src/main.rs
new file mode 100644
index 00000000000..46ae7fc795d
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/src/main.rs
@@ -0,0 +1,271 @@
+use std::env;
+use std::ffi::c_void;
+use std::fs;
+use std::io::{self, Read};
+use std::path::PathBuf;
+use std::process::ExitCode;
+
+use milo_parser::{CALLBACK_ACTIVE_ALL, Parser, STATE_ERROR};
+
+struct Options {
+ file: Option<PathBuf>,
+ mode: Mode,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+enum Mode {
+ Autodetect,
+ Request,
+ Response,
+}
+
+struct Context {
+ output: Vec<String>,
+}
+
+enum RunError {
+ Usage(String),
+ Io(String),
+}
+
+fn print_usage() {
+ eprintln!("Usage: milo-parser [-f|--file PATH] [-o|--request | -i|--response]");
+}
+
+fn parse_args() -> Result<Options, String> {
+ let mut args = env::args().skip(1);
+ let mut options = Options {
+ file: None,
+ mode: Mode::Autodetect,
+ };
+
+ while let Some(arg) = args.next() {
+ match arg.as_str() {
+ "-f" | "--file" => {
+ let path = args.next().ok_or_else(|| format!("Missing value for {arg}"))?;
+ options.file = Some(PathBuf::from(path));
+ }
+ "-o" | "--request" => {
+ if options.mode != Mode::Autodetect {
+ return Err("Cannot use both request and response mode".into());
+ }
+
+ options.mode = Mode::Request;
+ }
+ "-i" | "--response" => {
+ if options.mode != Mode::Autodetect {
+ return Err("Cannot use both request and response mode".into());
+ }
+
+ options.mode = Mode::Response;
+ }
+ "-h" | "--help" => {
+ print_usage();
+ std::process::exit(0);
+ }
+ _ => return Err(format!("Unknown argument: {arg}")),
+ }
+ }
+
+ Ok(options)
+}
+
+fn read_input(options: &Options) -> io::Result<Vec<u8>> {
+ match &options.file {
+ Some(path) => fs::read(path),
+ None => {
+ let mut input = Vec::new();
+ io::stdin().read_to_end(&mut input)?;
+ Ok(input)
+ }
+ }
+}
+
+fn quote(value: &str) -> String {
+ let mut quoted = String::with_capacity(value.len() + 2);
+ quoted.push('"');
+
+ for c in value.chars() {
+ match c {
+ '"' => quoted.push_str("\\\""),
+ '\\' => quoted.push_str("\\\\"),
+ '\n' => quoted.push_str("\\n"),
+ '\r' => quoted.push_str("\\r"),
+ '\t' => quoted.push_str("\\t"),
+ _ => quoted.push(c),
+ }
+ }
+
+ quoted.push('"');
+ quoted
+}
+
+fn append_output(parser: &mut Parser, line: String) {
+ let mut context = unsafe { Box::from_raw(parser.context as *mut Context) };
+ context.output.push(line);
+ let _ = Box::into_raw(context);
+}
+
+fn event(parser: &mut Parser, offset: usize, size: usize, name: &str) {
+ append_output(parser, format!("offset={offset} size={size} event={name}"));
+}
+
+fn on_error(parser: &mut Parser, offset: usize, size: usize) {
+ append_output(
+ parser,
+ format!(
+ "offset={offset} size={size} event=error error={} description={}",
+ parser.error_code_str(),
+ quote(parser.error_description_str())
+ ),
+ );
+}
+
+fn on_finish(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "finish"); }
+
+fn on_message_start(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "message_start"); }
+
+fn on_message_complete(parser: &mut Parser, offset: usize, size: usize) {
+ event(parser, offset, size, "message_complete");
+}
+
+fn on_request(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "request"); }
+
+fn on_response(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "response"); }
+
+fn on_reset(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "reset"); }
+
+fn on_method(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "method"); }
+
+fn on_url(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "url"); }
+
+fn on_protocol(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "protocol"); }
+
+fn on_version(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "version"); }
+
+fn on_status(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "status"); }
+
+fn on_reason(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "reason"); }
+
+fn on_header_name(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "header_name"); }
+
+fn on_header_value(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "header_value"); }
+
+fn on_headers(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "headers"); }
+
+fn on_connect(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "connect"); }
+
+fn on_upgrade(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "upgrade"); }
+
+fn on_chunk_length(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "chunk_length"); }
+
+fn on_chunk_extension_name(parser: &mut Parser, offset: usize, size: usize) {
+ event(parser, offset, size, "chunk_extension_name");
+}
+
+fn on_chunk_extension_value(parser: &mut Parser, offset: usize, size: usize) {
+ event(parser, offset, size, "chunk_extension_value");
+}
+
+fn on_chunk(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "chunk"); }
+
+fn on_body(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "body"); }
+
+fn on_data(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "data"); }
+
+fn on_trailer_name(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "trailer_name"); }
+
+fn on_trailer_value(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "trailer_value"); }
+
+fn on_trailers(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "trailers"); }
+
+fn on_state_change(parser: &mut Parser, offset: usize, size: usize) { event(parser, offset, size, "state_change"); }
+
+fn create_parser(mode: Mode) -> Parser {
+ let mut parser = Parser::new();
+ let context = Box::new(Context { output: Vec::new() });
+ parser.context = Box::into_raw(context) as *mut c_void;
+ parser.active_callbacks = CALLBACK_ACTIVE_ALL;
+
+ match mode {
+ Mode::Autodetect => {
+ parser.autodetect = true;
+ }
+ Mode::Request => {
+ parser.autodetect = false;
+ parser.is_request = true;
+ }
+ Mode::Response => {
+ parser.autodetect = false;
+ parser.is_request = false;
+ }
+ }
+
+ parser.callbacks.on_error = on_error;
+ parser.callbacks.on_finish = on_finish;
+ parser.callbacks.on_message_start = on_message_start;
+ parser.callbacks.on_message_complete = on_message_complete;
+ parser.callbacks.on_request = on_request;
+ parser.callbacks.on_response = on_response;
+ parser.callbacks.on_reset = on_reset;
+ parser.callbacks.on_method = on_method;
+ parser.callbacks.on_url = on_url;
+ parser.callbacks.on_protocol = on_protocol;
+ parser.callbacks.on_version = on_version;
+ parser.callbacks.on_status = on_status;
+ parser.callbacks.on_reason = on_reason;
+ parser.callbacks.on_header_name = on_header_name;
+ parser.callbacks.on_header_value = on_header_value;
+ parser.callbacks.on_headers = on_headers;
+ parser.callbacks.on_connect = on_connect;
+ parser.callbacks.on_upgrade = on_upgrade;
+ parser.callbacks.on_chunk_length = on_chunk_length;
+ parser.callbacks.on_chunk_extension_name = on_chunk_extension_name;
+ parser.callbacks.on_chunk_extension_value = on_chunk_extension_value;
+ parser.callbacks.on_chunk = on_chunk;
+ parser.callbacks.on_body = on_body;
+ parser.callbacks.on_data = on_data;
+ parser.callbacks.on_trailer_name = on_trailer_name;
+ parser.callbacks.on_trailer_value = on_trailer_value;
+ parser.callbacks.on_trailers = on_trailers;
+ parser.callbacks.on_state_change = on_state_change;
+
+ parser
+}
+
+fn run() -> Result<bool, RunError> {
+ let options = parse_args().map_err(RunError::Usage)?;
+ let input = read_input(&options).map_err(|e| RunError::Io(e.to_string()))?;
+ let mut parser = create_parser(options.mode);
+
+ parser.parse(input.as_ptr(), input.len());
+
+ if parser.state != STATE_ERROR {
+ parser.finish();
+ }
+
+ let failed = parser.state == STATE_ERROR;
+ let context = unsafe { Box::from_raw(parser.context as *mut Context) };
+
+ for line in &context.output {
+ println!("{line}");
+ }
+
+ Ok(failed)
+}
+
+fn main() -> ExitCode {
+ match run() {
+ Ok(false) => ExitCode::SUCCESS,
+ Ok(true) => ExitCode::from(1),
+ Err(RunError::Usage(error)) => {
+ eprintln!("{error}");
+ print_usage();
+ ExitCode::from(2)
+ }
+ Err(RunError::Io(error)) => {
+ eprintln!("{error}");
+ ExitCode::from(1)
+ }
+ }
+}
diff --git a/deps/undici/src/deps/milo/parser/src/matchers.rs b/deps/undici/src/deps/milo/parser/src/matchers.rs
new file mode 100644
index 00000000000..0687d26b394
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/src/matchers.rs
@@ -0,0 +1,489 @@
+use crate::{QUOTED_PAIR_TABLE, QUOTED_STRING_TABLE, TOKEN_TABLE, URL_TABLE};
+
+pub enum MatchResult {
+ Continue,
+ Suspend,
+ Stop,
+}
+
+pub enum HeaderLineScanResult {
+ Cr(usize),
+ Invalid(usize),
+ Incomplete,
+}
+
+#[inline(always)]
+pub fn ensure_valid_line(data: &[u8], cr: usize, available: usize) -> MatchResult {
+ if cr + 1 == available {
+ MatchResult::Suspend
+ } else if data[cr + 1] != b'\n' {
+ MatchResult::Stop
+ } else {
+ MatchResult::Continue
+ }
+}
+
+#[inline(always)]
+pub fn find_cr(data: &[u8], available: usize) -> Option<usize> {
+ if available == 0 {
+ None
+ } else {
+ find_char(data, 0, available - 1, b'\r')
+ }
+}
+
+#[inline(always)]
+pub fn find_char(buf: &[u8], start: usize, end: usize, needle: u8) -> Option<usize> {
+ if start > end || end >= buf.len() {
+ return None;
+ }
+
+ memchr::memchr(needle, &buf[start..=end]).map(|i| start + i)
+}
+
+#[inline(always)]
+pub fn find_char2(buf: &[u8], start: usize, end: usize, needle1: u8, needle2: u8) -> Option<usize> {
+ if start > end || end >= buf.len() {
+ return None;
+ }
+
+ memchr::memchr2(needle1, needle2, &buf[start..=end]).map(|i| start + i)
+}
+
+#[inline(always)]
+pub fn is_digit(byte: u8) -> bool { byte.wrapping_sub(b'0') <= 9 }
+
+#[inline(always)]
+pub fn is_ws(byte: u8) -> bool { byte == b' ' || byte == b'\t' }
+
+#[inline(always)]
+pub fn validate_token(data: &[u8], start: usize, end: usize) -> bool {
+ if start == end {
+ return false;
+ }
+
+ let mut i = start;
+ while i < end {
+ if !TOKEN_TABLE[data[i] as usize] {
+ return false;
+ }
+
+ i += 1;
+ }
+
+ true
+}
+
+#[inline(always)]
+pub fn validate_quoted_string(data: &[u8], start: usize, end: usize) -> bool {
+ let mut i = start;
+ while i < end {
+ let byte = data[i];
+ if byte == b'\\' {
+ i += 1;
+ if i == end || !QUOTED_PAIR_TABLE[data[i] as usize] {
+ return false;
+ }
+ } else if !QUOTED_STRING_TABLE[byte as usize] {
+ return false;
+ }
+
+ i += 1;
+ }
+
+ true
+}
+
+#[inline(always)]
+pub fn validate_url(data: &[u8], start: usize, end: usize) -> bool {
+ if start == end {
+ return false;
+ }
+
+ let mut i = start;
+ while i < end {
+ if !URL_TABLE[data[i] as usize] {
+ return false;
+ }
+
+ i += 1;
+ }
+
+ true
+}
+
+#[inline(always)]
+pub fn strip_ows_fast(data: &[u8], start_ref: &mut usize, end_ref: &mut usize, allow_empty: bool) -> bool {
+ let start = *start_ref;
+ let end = *end_ref;
+
+ // The single-space shortcut is valid only when no further leading OWS follows.
+ if start + 1 < end && data[start] == b' ' && !is_ws(data[start + 1]) && !is_ws(data[end - 1]) {
+ *start_ref = start + 1;
+ return true;
+ }
+
+ strip_ows(data, start_ref, end_ref, allow_empty)
+}
+
+#[inline(always)]
+pub fn strip_ows(data: &[u8], start_ref: &mut usize, end_ref: &mut usize, allow_empty: bool) -> bool {
+ let mut start = *start_ref;
+ let mut end = *end_ref;
+
+ while start < end && is_ws(data[start]) {
+ start += 1;
+ }
+
+ while end > start && is_ws(data[end - 1]) {
+ end -= 1;
+ }
+
+ if start == end && !allow_empty {
+ return false;
+ }
+
+ *start_ref = start;
+ *end_ref = end;
+ true
+}
+
+#[inline(always)]
+fn scan_header_line_scalar(ptr: *const u8, mut i: usize, end: usize) -> HeaderLineScanResult {
+ while i < end {
+ let byte = unsafe { *ptr.add(i) };
+
+ if byte == b'\r' {
+ return HeaderLineScanResult::Cr(i);
+ }
+
+ if (byte < 0x20 && byte != b'\t') || byte == 0x7f {
+ return HeaderLineScanResult::Invalid(i);
+ }
+
+ i += 1;
+ }
+
+ HeaderLineScanResult::Incomplete
+}
+
+#[cfg(target_arch = "aarch64")]
+#[inline(always)]
+pub fn find_header_line_end(ptr: *const u8, len: usize) -> HeaderLineScanResult {
+ use core::arch::aarch64::*;
+
+ if len < 16 {
+ return scan_header_line_scalar(ptr, 0, len);
+ }
+
+ let mut i = 0;
+ let v_20 = unsafe { vdupq_n_u8(0x20) };
+ let v_7f = unsafe { vdupq_n_u8(0x7f) };
+ let v_tab = unsafe { vdupq_n_u8(b'\t') };
+ let v_cr = unsafe { vdupq_n_u8(b'\r') };
+
+ while i + 16 <= len {
+ let x = unsafe { vld1q_u8(ptr.add(i)) };
+ let lt_20 = unsafe { vcltq_u8(x, v_20) };
+ let eq_tab = unsafe { vceqq_u8(x, v_tab) };
+ let eq_cr = unsafe { vceqq_u8(x, v_cr) };
+ let eq_7f = unsafe { vceqq_u8(x, v_7f) };
+
+ // Header lines stop at CR; other control bytes are invalid except HTAB.
+ let ctrl = unsafe { vbicq_u8(lt_20, eq_tab) };
+ let invalid = unsafe { vbicq_u8(vorrq_u8(ctrl, eq_7f), eq_cr) };
+ let found = unsafe { vorrq_u8(eq_cr, invalid) };
+
+ if unsafe { vmaxvq_u8(found) } != 0 {
+ return scan_header_line_scalar(ptr, i, i + 16);
+ }
+
+ i += 16;
+ }
+
+ scan_header_line_scalar(ptr, i, len)
+}
+
+#[cfg(target_arch = "x86_64")]
+#[inline(always)]
+pub fn find_header_line_end(ptr: *const u8, len: usize) -> HeaderLineScanResult {
+ use core::arch::x86_64::*;
+
+ if len < 16 {
+ return scan_header_line_scalar(ptr, 0, len);
+ }
+
+ let mut i = 0;
+ let v_20 = unsafe { _mm_set1_epi8(0x20u8 as i8) };
+ let v_7f = unsafe { _mm_set1_epi8(0x7fu8 as i8) };
+ let v_tab = unsafe { _mm_set1_epi8(b'\t' as i8) };
+ let v_cr = unsafe { _mm_set1_epi8(b'\r' as i8) };
+ let v_zero = unsafe { _mm_setzero_si128() };
+ let v_ones = unsafe { _mm_cmpeq_epi8(v_zero, v_zero) };
+
+ while i + 32 <= len {
+ let x = unsafe { _mm_loadu_si128(ptr.add(i) as *const __m128i) };
+ let lt_20 = unsafe { _mm_andnot_si128(_mm_cmpeq_epi8(_mm_subs_epu8(v_20, x), v_zero), v_ones) };
+ let eq_tab = unsafe { _mm_cmpeq_epi8(x, v_tab) };
+ let eq_cr = unsafe { _mm_cmpeq_epi8(x, v_cr) };
+ let eq_7f = unsafe { _mm_cmpeq_epi8(x, v_7f) };
+
+ // Header lines stop at CR; other control bytes are invalid except HTAB.
+ let ctrl = unsafe { _mm_andnot_si128(eq_tab, lt_20) };
+ let invalid = unsafe { _mm_andnot_si128(eq_cr, _mm_or_si128(ctrl, eq_7f)) };
+ let cr_mask = unsafe { _mm_movemask_epi8(eq_cr) };
+ let invalid_mask = unsafe { _mm_movemask_epi8(invalid) };
+ let found_mask = cr_mask | invalid_mask;
+
+ if found_mask != 0 {
+ let index = i + found_mask.trailing_zeros() as usize;
+ return if cr_mask & (1 << (index - i)) != 0 {
+ HeaderLineScanResult::Cr(index)
+ } else {
+ HeaderLineScanResult::Invalid(index)
+ };
+ }
+
+ let x = unsafe { _mm_loadu_si128(ptr.add(i + 16) as *const __m128i) };
+ let lt_20 = unsafe { _mm_andnot_si128(_mm_cmpeq_epi8(_mm_subs_epu8(v_20, x), v_zero), v_ones) };
+ let eq_tab = unsafe { _mm_cmpeq_epi8(x, v_tab) };
+ let eq_cr = unsafe { _mm_cmpeq_epi8(x, v_cr) };
+ let eq_7f = unsafe { _mm_cmpeq_epi8(x, v_7f) };
+ let ctrl = unsafe { _mm_andnot_si128(eq_tab, lt_20) };
+ let invalid = unsafe { _mm_andnot_si128(eq_cr, _mm_or_si128(ctrl, eq_7f)) };
+ let cr_mask = unsafe { _mm_movemask_epi8(eq_cr) };
+ let invalid_mask = unsafe { _mm_movemask_epi8(invalid) };
+ let found_mask = cr_mask | invalid_mask;
+
+ if found_mask != 0 {
+ let lane = found_mask.trailing_zeros() as usize;
+ let index = i + 16 + lane;
+ return if cr_mask & (1 << lane) != 0 {
+ HeaderLineScanResult::Cr(index)
+ } else {
+ HeaderLineScanResult::Invalid(index)
+ };
+ }
+
+ i += 32;
+ }
+
+ while i + 16 <= len {
+ let x = unsafe { _mm_loadu_si128(ptr.add(i) as *const __m128i) };
+ let lt_20 = unsafe { _mm_andnot_si128(_mm_cmpeq_epi8(_mm_subs_epu8(v_20, x), v_zero), v_ones) };
+ let eq_tab = unsafe { _mm_cmpeq_epi8(x, v_tab) };
+ let eq_cr = unsafe { _mm_cmpeq_epi8(x, v_cr) };
+ let eq_7f = unsafe { _mm_cmpeq_epi8(x, v_7f) };
+ let ctrl = unsafe { _mm_andnot_si128(eq_tab, lt_20) };
+ let invalid = unsafe { _mm_andnot_si128(eq_cr, _mm_or_si128(ctrl, eq_7f)) };
+ let cr_mask = unsafe { _mm_movemask_epi8(eq_cr) };
+ let invalid_mask = unsafe { _mm_movemask_epi8(invalid) };
+ let found_mask = cr_mask | invalid_mask;
+
+ if found_mask != 0 {
+ let lane = found_mask.trailing_zeros() as usize;
+ let index = i + lane;
+ return if cr_mask & (1 << lane) != 0 {
+ HeaderLineScanResult::Cr(index)
+ } else {
+ HeaderLineScanResult::Invalid(index)
+ };
+ }
+
+ i += 16;
+ }
+
+ scan_header_line_scalar(ptr, i, len)
+}
+
+#[cfg(all(target_arch = "wasm32", target_feature = "simd128"))]
+#[target_feature(enable = "simd128")]
+pub fn find_header_line_end(ptr: *const u8, len: usize) -> HeaderLineScanResult {
+ use core::arch::wasm32::*;
+
+ if len < 16 {
+ return scan_header_line_scalar(ptr, 0, len);
+ }
+
+ let mut i = 0;
+ let v_20 = u8x16_splat(0x20);
+ let v_7f = u8x16_splat(0x7f);
+ let v_tab = u8x16_splat(b'\t');
+ let v_cr = u8x16_splat(b'\r');
+
+ while i + 16 <= len {
+ let x = unsafe { v128_load(ptr.add(i) as *const v128) };
+ let lt_20 = u8x16_lt(x, v_20);
+ let eq_tab = u8x16_eq(x, v_tab);
+ let eq_cr = u8x16_eq(x, v_cr);
+ let eq_7f = u8x16_eq(x, v_7f);
+
+ // Header lines stop at CR; other control bytes are invalid except HTAB.
+ // WASM andnot(a, b) computes a & !b, unlike the x86 intrinsic.
+ let ctrl = v128_andnot(lt_20, eq_tab);
+ let invalid = v128_andnot(v128_or(ctrl, eq_7f), eq_cr);
+ let found = v128_or(eq_cr, invalid);
+
+ if v128_any_true(found) {
+ return scan_header_line_scalar(ptr, i, i + 16);
+ }
+
+ i += 16;
+ }
+
+ scan_header_line_scalar(ptr, i, len)
+}
+
+#[cfg(not(any(
+ target_arch = "aarch64",
+ target_arch = "x86_64",
+ all(target_arch = "wasm32", target_feature = "simd128")
+)))]
+#[inline(always)]
+pub fn find_header_line_end(ptr: *const u8, len: usize) -> HeaderLineScanResult { scan_header_line_scalar(ptr, 0, len) }
+
+#[cfg(target_arch = "aarch64")]
+#[target_feature(enable = "neon")]
+pub fn validate_token_value(ptr: *const u8, len: usize) -> bool {
+ use core::arch::aarch64::*;
+
+ let mut i = 0;
+
+ let v_20 = vdupq_n_u8(0x20);
+ let v_7f = vdupq_n_u8(0x7f);
+ let v_tab = vdupq_n_u8(9);
+
+ while i + 16 <= len {
+ let x = unsafe { vld1q_u8(ptr.add(i)) };
+ let lt_20 = vcltq_u8(x, v_20);
+ let eq_tab = vceqq_u8(x, v_tab);
+ let eq_7f = vceqq_u8(x, v_7f);
+
+ // Field values allow HTAB but reject the remaining C0 controls and DEL.
+ let ctrl = vbicq_u8(lt_20, eq_tab); // lt_20 & !eq_tab
+ let invalid = vorrq_u8(ctrl, eq_7f);
+
+ if vmaxvq_u8(invalid) != 0 {
+ return false;
+ }
+
+ i += 16;
+ }
+
+ while i < len {
+ let b = unsafe { *ptr.add(i) };
+
+ if (b < 0x20 && b != b'\t') || b == 0x7f {
+ return false;
+ }
+
+ i += 1;
+ }
+
+ true
+}
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "sse2")]
+pub fn validate_token_value(ptr: *const u8, len: usize) -> bool {
+ use core::arch::x86_64::*;
+
+ let mut i = 0;
+ let v_20 = _mm_set1_epi8(0x20u8 as i8);
+ let v_7f = _mm_set1_epi8(0x7fu8 as i8);
+ let v_tab = _mm_set1_epi8(b'\t' as i8);
+ let v_zero = _mm_setzero_si128();
+ let v_ones = _mm_cmpeq_epi8(v_zero, v_zero);
+
+ while i + 16 <= len {
+ let x = unsafe { _mm_loadu_si128(ptr.add(i) as *const __m128i) };
+ let lt_20 = _mm_andnot_si128(_mm_cmpeq_epi8(_mm_subs_epu8(v_20, x), v_zero), v_ones);
+ let eq_tab = _mm_cmpeq_epi8(x, v_tab);
+ let eq_7f = _mm_cmpeq_epi8(x, v_7f);
+
+ // Field values allow HTAB but reject the remaining C0 controls and DEL.
+ let ctrl = _mm_andnot_si128(eq_tab, lt_20);
+ let invalid = _mm_or_si128(ctrl, eq_7f);
+
+ if _mm_movemask_epi8(invalid) != 0 {
+ return false;
+ }
+
+ i += 16;
+ }
+
+ while i < len {
+ let b = unsafe { *ptr.add(i) };
+
+ if (b < 0x20 && b != b'\t') || b == 0x7f {
+ return false;
+ }
+
+ i += 1;
+ }
+
+ true
+}
+
+#[cfg(all(target_arch = "wasm32", target_feature = "simd128"))]
+#[target_feature(enable = "simd128")]
+pub fn validate_token_value(ptr: *const u8, len: usize) -> bool {
+ use core::arch::wasm32::*;
+
+ let mut i = 0;
+ let v_20 = u8x16_splat(0x20);
+ let v_7f = u8x16_splat(0x7f);
+ let v_tab = u8x16_splat(b'\t');
+
+ while i + 16 <= len {
+ let x = unsafe { v128_load(ptr.add(i) as *const v128) };
+ let lt_20 = u8x16_lt(x, v_20);
+ let eq_tab = u8x16_eq(x, v_tab);
+ let eq_7f = u8x16_eq(x, v_7f);
+
+ // Field values allow HTAB but reject the remaining C0 controls and DEL.
+ // WASM andnot(a, b) computes a & !b, unlike the x86 intrinsic.
+ let ctrl = v128_andnot(lt_20, eq_tab);
+ let invalid = v128_or(ctrl, eq_7f);
+
+ if v128_any_true(invalid) {
+ return false;
+ }
+
+ i += 16;
+ }
+
+ while i < len {
+ let b = unsafe { *ptr.add(i) };
+
+ if (b < 0x20 && b != b'\t') || b == 0x7f {
+ return false;
+ }
+
+ i += 1;
+ }
+
+ true
+}
+
+#[cfg(not(any(
+ target_arch = "aarch64",
+ target_arch = "x86_64",
+ all(target_arch = "wasm32", target_feature = "simd128")
+)))]
+#[inline(always)]
+pub fn validate_token_value(ptr: *const u8, len: usize) -> bool {
+ let mut i = 0;
+
+ while i < len {
+ let b = unsafe { *ptr.add(i) };
+
+ if (b < 0x20 && b != b'\t') || b == 0x7f {
+ return false;
+ }
+
+ i += 1;
+ }
+
+ true
+}
diff --git a/deps/undici/src/deps/milo/parser/src/native.rs b/deps/undici/src/deps/milo/parser/src/native.rs
new file mode 100644
index 00000000000..071802e7eed
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/src/native.rs
@@ -0,0 +1,220 @@
+#![allow(clippy::not_unsafe_ptr_arg_deref)]
+
+use core::ptr;
+use core::str;
+use core::{slice, slice::from_raw_parts};
+use std::ffi::{CString, c_char, c_uchar};
+
+use crate::parse;
+use crate::{Callbacks, Errors, Events, Methods, Parser, States};
+
+#[repr(C)]
+pub struct CStringWithLength {
+ pub ptr: *const c_uchar,
+ pub len: usize,
+}
+
+impl CStringWithLength {
+ fn new(value: &str) -> CStringWithLength {
+ let cstring = CString::new(value).unwrap();
+
+ CStringWithLength {
+ ptr: cstring.into_raw() as *const c_uchar,
+ len: value.len(),
+ }
+ }
+}
+
+impl From<&str> for CStringWithLength {
+ fn from(value: &str) -> Self { CStringWithLength::new(value) }
+}
+
+impl From<CStringWithLength> for &str {
+ fn from(value: CStringWithLength) -> Self {
+ unsafe { str::from_utf8_unchecked(slice::from_raw_parts(value.ptr, value.len)) }
+ }
+}
+
+/// Returns if debug informations are available in this build.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_has_debug() -> bool { cfg!(any(debug_assertions, feature = "debug")) }
+
+/// Returns if debug tracing is enabled for this parser.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_is_debug(parser: *const Parser) -> bool { unsafe { (*parser).debug } }
+
+/// A callback that simply returns `0`.
+///
+/// Use this callback as pointer when you want to remove a callback from the
+/// parser.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_noop(_parser: &mut Parser, _at: usize, _len: usize) {}
+
+/// Cleans up memory used by a string previously returned by one of the milo's C
+/// public interface.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_free_string(s: CStringWithLength) {
+ unsafe {
+ let _ = CString::from_raw(s.ptr as *mut c_char);
+ }
+}
+
+/// Creates a new parser.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_create() -> *mut Parser { Box::into_raw(Box::new(Parser::new())) }
+
+/// Destroys a parser.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_destroy(parser: *mut Parser) {
+ if parser.is_null() {
+ return;
+ }
+
+ unsafe {
+ let _ = Box::from_raw(parser);
+ }
+}
+
+/// Parses a slice of characters. It returns the number of consumed characters.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_parse(parser: *mut Parser, data: *const c_uchar, limit: usize) -> usize {
+ unsafe { (*parser).parse(data, limit) }
+}
+
+/// Sets the parser event bitmask.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_set_active_events(parser: *mut Parser, value: u64) {
+ unsafe {
+ (*parser).active_events = value;
+ }
+}
+
+/// Sets the maximum body payload consumed by a single parse invocation.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_set_max_body_payload(parser: *mut Parser, value: u64) {
+ unsafe {
+ (*parser).max_body_payload = value;
+ }
+}
+
+/// Sets whether parsing should stop after headers have completed.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_set_suspend_after_headers(parser: *mut Parser, value: bool) {
+ unsafe {
+ (*parser).suspend_after_headers = value;
+ }
+}
+
+/// Resets a parser. The second parameters specifies if to also reset the
+/// parsed counter.
+///
+/// The following fields are not modified:
+/// * position
+/// * context
+/// * autodetect
+/// * is_request
+/// * suspend_after_headers
+/// * max_body_payload
+/// * manage_unconsumed
+/// * continue_without_data
+/// * debug
+/// * context
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_reset(parser: *mut Parser, keep_parsed: bool) { unsafe { (*parser).reset(keep_parsed) } }
+
+/// Clears all values about the message in the parser.
+///
+/// The autodetect and is_request fields are not cleared.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_clear(parser: *mut Parser) { unsafe { (*parser).clear() } }
+
+/// Pauses the parser. It will have to be resumed via `milo_resume`.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_pause(parser: *mut Parser) { unsafe { (*parser).pause() } }
+
+/// Resumes the parser.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_resume(parser: *mut Parser) { unsafe { (*parser).resume() } }
+
+/// Completes the current message without consuming more input.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_complete(parser: *mut Parser) { unsafe { (*parser).complete() } }
+
+/// Marks the parser as finished. Any new data received via `milo_parse` will
+/// put the parser in the error state.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_finish(parser: *mut Parser) { unsafe { (*parser).finish() } }
+
+/// Marks the parsing a failed, setting a error code and and error message.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_fail(parser: *mut Parser, code: u8, description: CStringWithLength) {
+ unsafe { (*parser).fail(code, description.into()) };
+}
+
+/// Returns the current parser's state as string.
+///
+/// The returned value must be freed using `free_string`.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_state_string(parser: *mut Parser) -> CStringWithLength {
+ unsafe { (*parser).state_str().into() }
+}
+
+/// Returns a parser method as string.
+///
+/// The returned value must be freed using `free_string`.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_method_to_string(method: u8) -> CStringWithLength {
+ Methods::try_from(method)
+ .map_or("UNKNOWN", |method| method.as_str())
+ .into()
+}
+
+/// Returns a parser error as string.
+///
+/// The returned value must be freed using `free_string`.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_error_to_string(error: u8) -> CStringWithLength {
+ Errors::try_from(error).map_or("UNKNOWN", |error| error.as_str()).into()
+}
+
+/// Returns a parser callback as string.
+///
+/// The returned value must be freed using `free_string`.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_callback_to_string(callback: u8) -> CStringWithLength {
+ Callbacks::try_from(callback)
+ .map_or("UNKNOWN", |callback| callback.as_str())
+ .into()
+}
+
+/// Returns a parser state as string.
+///
+/// The returned value must be freed using `free_string`.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_state_to_string(state: u8) -> CStringWithLength {
+ States::try_from(state).map_or("UNKNOWN", |state| state.as_str()).into()
+}
+
+/// Returns a parser event as string.
+///
+/// The returned value must be freed using `free_string`.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_event_to_string(event: u8) -> CStringWithLength {
+ Events::try_from(event).map_or("UNKNOWN", |event| event.as_str()).into()
+}
+
+/// Returns the current parser's error state as string.
+///
+/// The returned value must be freed using `free_string`.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_error_code_string(parser: *mut Parser) -> CStringWithLength {
+ unsafe { (*parser).error_code_str().into() }
+}
+
+/// Returns the current parser's error descrition.
+///
+/// The returned value must be freed using `free_string`.
+#[unsafe(no_mangle)]
+pub extern "C" fn milo_error_description_string(parser: *mut Parser) -> CStringWithLength {
+ unsafe { (*parser).error_description_str().into() }
+}
diff --git a/deps/undici/src/deps/milo/parser/src/parse.rs b/deps/undici/src/deps/milo/parser/src/parse.rs
new file mode 100644
index 00000000000..80105a0a20c
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/src/parse.rs
@@ -0,0 +1,1578 @@
+#![allow(clippy::not_unsafe_ptr_arg_deref)]
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use alloc::{boxed::Box, format};
+use core::cell::{Cell, RefCell};
+use core::ffi::{c_char, c_uchar, c_void};
+use core::fmt::Debug;
+use core::ptr;
+use core::str;
+use core::{slice, slice::from_raw_parts};
+use std::string;
+#[cfg(all(not(target_family = "wasm"), any(debug_assertions, feature = "debug")))]
+use std::time::Instant;
+
+use milo_macros::*;
+
+use crate::Methods::CONNECT;
+use crate::matchers::*;
+use crate::*;
+
+impl Parser {
+ /// Parses a slice of characters.
+ ///
+ /// It returns the number of consumed characters.
+ pub fn parse(&mut self, input: *const c_uchar, limit: usize) -> usize {
+ let mut event_cursor = 0usize;
+ let mut failed = false;
+ let active_events = self.active_events | self.active_callbacks;
+
+ // Error states cannot resume without reset. Do not aggregate or retain new
+ // input on retries, which would otherwise grow the pending buffer forever.
+ if self.state == STATE_ERROR {
+ self.position = 0;
+ }
+
+ // Paused and failed parsers consume nothing and produce an empty event batch.
+ if self.paused || self.state == STATE_ERROR {
+ if active_events != 0 {
+ // SAFETY: The live parser owns the event buffer and its first byte.
+ unsafe {
+ *self.events = EVENT_END;
+ }
+ }
+
+ return 0;
+ }
+
+ let input = unsafe { from_raw_parts(input, limit) };
+
+ // Set the data to analyze, prepending unconsumed data from previous iteration
+ // if needed
+ let mut limit = limit;
+ let aggregate: Vec<c_uchar>;
+ let unconsumed_len = self.unconsumed_len;
+
+ let mut data = if self.manage_unconsumed && unconsumed_len > 0 {
+ unsafe {
+ limit += unconsumed_len;
+ let unconsumed = from_raw_parts(self.unconsumed, unconsumed_len);
+
+ // Rebuild a contiguous view so state handlers can scan across parse-call
+ // boundaries.
+ aggregate = [unconsumed, input].concat();
+ &aggregate[..]
+ }
+ } else {
+ input
+ };
+
+ // Limit the data that is currently analyzed
+ data = &data[..limit];
+
+ let mut available = data.len();
+
+ #[cfg(all(not(target_family = "wasm"), any(debug_assertions, feature = "debug")))]
+ let mut last = Instant::now();
+
+ #[cfg(all(not(target_family = "wasm"), any(debug_assertions, feature = "debug")))]
+ let start = Instant::now();
+
+ #[cfg(any(debug_assertions, feature = "debug"))]
+ let mut previous_state = self.state;
+
+ #[cfg(any(debug_assertions, feature = "debug"))]
+ let previous_position = self.position;
+
+ // States will advance position manually, the parser has to explicitly
+ // track it
+ self.position = 0;
+ let mut advanced: usize;
+ let mut parsing = true;
+ let max_body_payload = self.max_body_payload;
+ let mut body_payload_read = 0u64;
+ let has_active_events = active_events != 0;
+ let (
+ has_request_start_events,
+ has_response_start_events,
+ has_request_line_events,
+ has_response_line_events,
+ has_metadata_event,
+ has_header_name_event,
+ has_header_value_event,
+ has_trailer_name_event,
+ has_trailer_value_event,
+ has_complete_events,
+ has_finish_event,
+ ) = if has_active_events {
+ (
+ active_events & (EVENT_ACTIVE_ON_REQUEST | EVENT_ACTIVE_ON_MESSAGE_START) != 0,
+ active_events & (EVENT_ACTIVE_ON_RESPONSE | EVENT_ACTIVE_ON_MESSAGE_START) != 0,
+ active_events
+ & (EVENT_ACTIVE_ON_METHOD | EVENT_ACTIVE_ON_URL | EVENT_ACTIVE_ON_PROTOCOL | EVENT_ACTIVE_ON_VERSION)
+ != 0,
+ active_events
+ & (EVENT_ACTIVE_ON_PROTOCOL | EVENT_ACTIVE_ON_VERSION | EVENT_ACTIVE_ON_STATUS | EVENT_ACTIVE_ON_REASON)
+ != 0,
+ active_events & EVENT_ACTIVE_ON_HEADERS != 0,
+ active_events & EVENT_ACTIVE_ON_HEADER_NAME != 0,
+ active_events & EVENT_ACTIVE_ON_HEADER_VALUE != 0,
+ active_events & EVENT_ACTIVE_ON_TRAILER_NAME != 0,
+ active_events & EVENT_ACTIVE_ON_TRAILER_VALUE != 0,
+ active_events & (EVENT_ACTIVE_ON_MESSAGE_COMPLETE | EVENT_ACTIVE_ON_RESET) != 0,
+ active_events & EVENT_ACTIVE_ON_FINISH != 0,
+ )
+ } else {
+ (
+ false, false, false, false, false, false, false, false, false, false, false,
+ )
+ };
+
+ #[cfg(any(debug_assertions, feature = "debug"))]
+ if self.debug {
+ eprintln!("[milo_parser::debug] loop enter");
+ }
+
+ // Until there is data or there is a request to continue
+ 'parser: while parsing && (!self.paused) && (available != 0 || self.continue_without_data) {
+ #[cfg(any(debug_assertions, feature = "debug"))]
+ if self.debug {
+ eprintln!(
+ "[milo_parser::debug] loop before processing: previous_position={}, position={}, available={}, \
+ continue_without_data={}",
+ previous_position, self.position, available, self.continue_without_data
+ );
+ }
+
+ // Reset the flag before processing; states set it again when they need another
+ // zero-byte turn.
+ self.continue_without_data = false;
+ advanced = 0;
+
+ 'state: {
+ match self.state {
+ // If the parser has finished and it receives more data, error
+ STATE_FINISH => {
+ fail!(UNEXPECTED_CHARACTER, "Unexpected data");
+ }
+
+ // The error state is a no-op
+ STATE_ERROR => {
+ suspend!();
+ }
+
+ // Choose the initial state depending on the configured message type.
+ STATE_START => {
+ if !self.autodetect && self.is_request {
+ if has_request_start_events {
+ event_with_range!(on_request, 0, 0);
+ event_with_range!(on_message_start, 0, 0);
+ }
+ move_to!(request_line);
+ } else if !self.autodetect {
+ if has_response_start_events {
+ event_with_range!(on_response, 0, 0);
+ event_with_range!(on_message_start, 0, 0);
+ }
+ move_to!(status_line);
+ } else if data.len() >= 5 && data[4] == b'/' && data.starts_with(b"HTTP") {
+ self.is_request = false;
+ if has_response_start_events {
+ event_with_range!(on_response, 0, 0);
+ event_with_range!(on_message_start, 0, 0);
+ }
+ move_to!(status_line);
+ } else if data.len() >= 2 && data.starts_with(b"\r\n") {
+ // RFC 9112 section 2.2
+ advance!(2);
+ } else {
+ // For performance reason, we assume it's a request so we don't lookup the
+ // method twice
+ self.is_request = true;
+ if has_request_start_events {
+ event_with_range!(on_request, 0, 0);
+ event_with_range!(on_message_start, 0, 0);
+ }
+ move_to!(request_line);
+ }
+ }
+
+ STATE_REQUEST_LINE => {
+ match find_cr(data, available) {
+ // // RFC 9112 section 3
+ Some(cr) => {
+ match ensure_valid_line(data, cr, available) {
+ MatchResult::Continue => {}
+ MatchResult::Suspend => {
+ suspend!();
+ }
+ MatchResult::Stop => {
+ fail!(UNEXPECTED_CHARACTER, "Expected CRLF");
+ }
+ }
+
+ // RFC 9112 section 2.2 - Repeated
+ if cr == 0 {
+ advance!(2);
+ next!();
+ } else if cr < 14
+ // Length of "GET / HTTP/1.1"
+ {
+ fail!(UNEXPECTED_CHARACTER, "Request line too short");
+ }
+
+ // The line is potentially valid, clear the parser
+ self.clear();
+
+ // RFC 9112 section 3.1
+ let method_start = 0;
+ let method_end = match find_char(data, method_start, cr, b' ') {
+ Some(index) if index > method_start => index,
+ _ => {
+ fail!(UNEXPECTED_CHARACTER, "Expected space after method");
+ }
+ };
+
+ // RFC 9112 section 3.2
+ let url_start = method_end + 1;
+ let url_end = match find_char(data, url_start, cr, b' ') {
+ Some(index) if index > url_start => index,
+ _ => {
+ fail!(UNEXPECTED_CHARACTER, "Expected space after URL");
+ }
+ };
+
+ // RFC 9112 section 2.3
+ let protocol_start = url_end + 1;
+ let protocol_end = match find_char(data, protocol_start, cr, b'/') {
+ Some(index) if index > protocol_start => index,
+ _ => {
+ fail!(UNEXPECTED_CHARACTER, "Expected / after the protocol name");
+ }
+ };
+
+ let method_slice = &data[method_start..method_end];
+ self.method = match method_slice.len() {
+ 3 => {
+ match method_slice {
+ b"GET" => METHOD_GET,
+ b"PUT" => METHOD_PUT,
+ b"PRI" => METHOD_PRI,
+ _ => METHOD_OTHER,
+ }
+ }
+ 4 => {
+ match method_slice {
+ b"HEAD" => METHOD_HEAD,
+ b"POST" => METHOD_POST,
+ _ => METHOD_OTHER,
+ }
+ }
+ 5 => {
+ match method_slice {
+ b"PATCH" => METHOD_PATCH,
+ b"TRACE" => METHOD_TRACE,
+ _ => METHOD_OTHER,
+ }
+ }
+ 6 => {
+ match method_slice {
+ b"DELETE" => METHOD_DELETE,
+ _ => METHOD_OTHER,
+ }
+ }
+ 7 => {
+ match method_slice {
+ b"CONNECT" => {
+ self.is_connect = true;
+ METHOD_CONNECT
+ }
+ b"OPTIONS" => METHOD_OPTIONS,
+ _ => METHOD_OTHER,
+ }
+ }
+ _ => METHOD_OTHER,
+ };
+
+ if self.method == METHOD_OTHER && !validate_token(data, method_start, method_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid method character");
+ }
+
+ if !validate_url(data, url_start, url_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid URL character");
+ }
+
+ let version_start = protocol_end + 1;
+ if cr != protocol_start + 8 {
+ fail!(UNEXPECTED_CHARACTER, "Invalid protocol name");
+ }
+
+ if &data[protocol_start..cr] == b"HTTP/1.1" {
+ if self.method == METHOD_PRI {
+ fail!(UNSUPPORTED_HTTP_VERSION, "PRI is only valid with HTTP/2.0");
+ }
+ } else if &data[protocol_start..cr] == b"HTTP/2.0" {
+ if self.method != METHOD_PRI {
+ fail!(UNSUPPORTED_HTTP_VERSION, "Unsupported HTTP version");
+ }
+ } else {
+ fail!(UNEXPECTED_CHARACTER, "Invalid protocol");
+ }
+
+ if has_request_line_events {
+ event_with_range!(on_method, method_start, method_end - method_start);
+ event_with_range!(on_url, url_start, url_end - url_start);
+ event_with_range!(on_protocol, protocol_start, protocol_end - protocol_start);
+ event_with_range!(on_version, version_start, 3);
+ }
+
+ advance!(cr + 2);
+
+ if self.method == METHOD_PRI {
+ move_to!(http2_preface);
+ } else {
+ move_to!(header);
+ }
+ }
+ None => {
+ if available >= self.max_start_line_length {
+ fail!(UNEXPECTED_CHARACTER, "Request line too long");
+ } else {
+ suspend!();
+ }
+ }
+ }
+ }
+
+ // RFC 9112 section 4
+ STATE_STATUS_LINE => {
+ match find_cr(data, available) {
+ Some(cr) => {
+ match ensure_valid_line(data, cr, available) {
+ MatchResult::Continue => {}
+ MatchResult::Suspend => {
+ suspend!();
+ }
+ MatchResult::Stop => {
+ fail!(UNEXPECTED_CHARACTER, "Expected CRLF");
+ }
+ }
+
+ // RFC 9112 section 2.2 - Repeated
+ if cr == 0 {
+ advance!(2);
+ next!();
+ } else if cr < 13
+ // Length of "HTTP/1.1 200 "
+ {
+ fail!(UNEXPECTED_CHARACTER, "Status line too short");
+ }
+
+ // The line is potentially valid, clear the parser
+ self.clear();
+
+ let protocol_start = 0;
+ let protocol_end = 4;
+ let version_start = protocol_end + 1;
+ let version_end = protocol_start + 8;
+
+ if cr < version_end || data[version_end] != b' ' {
+ fail!(UNEXPECTED_CHARACTER, "Expected space after protocol");
+ }
+
+ match &data[protocol_start..version_end] {
+ b"HTTP/1.1" => {}
+ [b'H', b'T', b'T', b'P', b'/', ..] => {
+ fail!(UNSUPPORTED_HTTP_VERSION, "Unsupported HTTP version");
+ }
+ _ => {
+ fail!(UNEXPECTED_CHARACTER, "Invalid protocol");
+ }
+ }
+
+ let status_start = version_end + 1;
+ // Even if the reason is empty, there must be at least a space after the status
+ // code. So three digits plus a space
+ let status_end = version_end + 5;
+ if status_end > cr {
+ fail!(INVALID_STATUS, "Expected HTTP response status");
+ }
+
+ if !is_digit(data[status_start])
+ || !is_digit(data[status_start + 1])
+ || !is_digit(data[status_start + 2])
+ {
+ fail!(INVALID_STATUS, "Invalid HTTP response status");
+ }
+
+ if data[status_start + 3] != b' ' {
+ fail!(INVALID_STATUS, "Expected a space after HTTP response status");
+ }
+
+ let reason_start = status_start + 4;
+ let reason_end = cr;
+ if reason_start != reason_end
+ && unsafe { !validate_token_value(data.as_ptr().add(reason_start), reason_end - reason_start) }
+ {
+ fail!(UNEXPECTED_CHARACTER, "Invalid status reason character");
+ }
+
+ self.status = ((data[status_start] - b'0') as u32) * 100
+ + ((data[status_start + 1] - b'0') as u32) * 10
+ + (data[status_start + 2] - b'0') as u32;
+
+ if has_response_line_events {
+ event_with_range!(on_protocol, protocol_start, 4);
+ event_with_range!(on_version, version_start, 3);
+ event_with_range!(on_status, status_start, 3);
+ if reason_end > reason_start {
+ event_with_range!(on_reason, reason_start, reason_end - reason_start);
+ }
+ }
+
+ advance!(cr + 2);
+ move_to!(header);
+ }
+ None => {
+ if available >= self.max_start_line_length {
+ fail!(UNEXPECTED_CHARACTER, "Status line too long");
+ } else {
+ suspend!();
+ }
+ }
+ }
+ }
+
+ STATE_HTTP2_PREFACE => {
+ if available < 8 {
+ suspend!();
+ } else if &data[..8] == b"\r\nSM\r\n\r\n" {
+ advance!(8);
+ move_to!(tunnel);
+ } else {
+ fail!(UNEXPECTED_CHARACTER, "Malformed HTTP/2.0 preface");
+ }
+ }
+
+ STATE_HEADER => {
+ match find_header_line_end(data.as_ptr(), available) {
+ HeaderLineScanResult::Cr(cr) => {
+ match ensure_valid_line(data, cr, available) {
+ MatchResult::Continue => {}
+ MatchResult::Suspend => {
+ suspend!();
+ }
+ MatchResult::Stop => {
+ fail!(UNEXPECTED_CHARACTER, "Expected CRLF");
+ }
+ }
+
+ // No more headers or no headers at all, move to the headers state
+ if cr == 0 {
+ advance!(2);
+ if has_metadata_event {
+ event_with_metadata!(on_headers, 2);
+ }
+ move_to!(body_decision);
+ self.continue_without_data = true;
+
+ if self.suspend_after_headers {
+ suspend!();
+ } else {
+ next!();
+ }
+ }
+
+ // RFC 9112 section.4
+ // RFC 9110 section 5.5 and 5.6
+ let header_name_start = 0;
+ let header_name_end = match find_char(data, header_name_start, cr, b':') {
+ Some(index) if index > header_name_start => index,
+ _ => {
+ fail!(UNEXPECTED_CHARACTER, "Invalid header field name character");
+ }
+ };
+ let mut header_value_start = header_name_end + 1;
+ let mut header_value_end = cr;
+
+ let status = self.status;
+ let first_header_byte = data[header_name_start];
+ if !matches!(first_header_byte, b'c' | b'C' | b't' | b'T' | b'u' | b'U') {
+ if !validate_token(data, header_name_start, header_name_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid header field name character");
+ }
+
+ if has_header_value_event {
+ strip_ows_fast(data, &mut header_value_start, &mut header_value_end, true);
+ }
+ } else {
+ let header_name_len = header_name_end - header_name_start;
+ match (header_name_len, &data[header_name_start..header_name_end]) {
+ // RFC 9112 section 6.2
+ (14, case_insensitive_string!("content-length")) => {
+ if self.has_transfer_encoding {
+ fail!(
+ UNEXPECTED_CONTENT_LENGTH,
+ "Unexpected Content-Length header when Transfer-Encoding header is present"
+ );
+ } else if status == 205 || status == 204 || status / 100 == 1 {
+ fail!(
+ UNEXPECTED_CONTENT_LENGTH,
+ "Unexpected Content-Length header for a response without body"
+ );
+ } else if self.has_content_length {
+ fail!(INVALID_CONTENT_LENGTH, "Invalid duplicate Content-Length header");
+ }
+
+ if header_value_start < cr && !is_ws(data[cr - 1]) {
+ let value_start = if data[header_value_start] == b' ' {
+ header_value_start + 1
+ } else {
+ header_value_start
+ };
+
+ if value_start < cr && !is_ws(data[value_start]) {
+ header_value_start = value_start;
+ } else if !strip_ows_fast(data, &mut header_value_start, &mut header_value_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected Content-Length header value");
+ }
+ } else if !strip_ows_fast(data, &mut header_value_start, &mut header_value_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected Content-Length header value");
+ }
+
+ let mut i = header_value_start;
+ let mut content_length = 0u64;
+
+ if header_value_end - header_value_start > 19 {
+ // Milo caps Content-Length at 19 digits as a practical limit. This keeps
+ // parsing overflow-safe while allowing values far
+ // beyond realistic message sizes.
+ fail!(INVALID_CONTENT_LENGTH, "Invalid Content-Length header");
+ }
+
+ while i < header_value_end {
+ let current = data[i];
+ if !is_digit(current) {
+ fail!(INVALID_CONTENT_LENGTH, "Invalid Content-Length header");
+ }
+
+ content_length = content_length * 10 + (current - b'0') as u64;
+ i += 1;
+ }
+
+ self.has_content_length = true;
+ self.content_length = content_length;
+ self.remaining_content_length = content_length;
+ }
+ // RFC 9112 section 6.1
+ (17, case_insensitive_string!("transfer-encoding")) => {
+ if self.has_content_length {
+ fail!(
+ UNEXPECTED_TRANSFER_ENCODING,
+ "Unexpected Transfer-Encoding header when Content-Length header is present"
+ );
+ } else if status == 304 || status == 205 || status == 204 || status / 100 == 1 {
+ fail!(
+ UNEXPECTED_TRANSFER_ENCODING,
+ "Unexpected Transfer-Encoding header for a response without body"
+ );
+ }
+
+ if !strip_ows_fast(data, &mut header_value_start, &mut header_value_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected Transfer-Encoding header value");
+ }
+
+ self.has_transfer_encoding = true;
+
+ if &data[header_value_start..header_value_end] == b"chunked" {
+ // If this is true, it means the Transfer-Encoding header was specified more
+ // than once. This is the second repetition and therefore, the previous one is
+ // no longer the last one, making it invalid.
+ if self.has_chunked_transfer_encoding {
+ fail!(
+ INVALID_TRANSFER_ENCODING,
+ "The value \"chunked\" in the Transfer-Encoding header must be the last provided and can \
+ be provided only once"
+ );
+ }
+
+ self.has_chunked_transfer_encoding = true;
+ } else {
+ let mut token_start = header_value_start;
+ loop {
+ while token_start < header_value_end && is_ws(data[token_start]) {
+ token_start += 1;
+ }
+
+ if token_start == header_value_end {
+ break;
+ }
+
+ let token_end_raw = match find_char(data, token_start, header_value_end, b',') {
+ Some(comma) => comma,
+ None => header_value_end,
+ };
+ let mut token_end = token_end_raw;
+
+ if !strip_ows_fast(data, &mut token_start, &mut token_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected Transfer-Encoding header value");
+ }
+
+ self.has_transfer_encoding = true;
+
+ if let case_insensitive_string!("chunked") = data[token_start..token_end] {
+ // If this is true, it means the Transfer-Encoding header was specified more
+ // than once. This is the second repetition and therefore, the previous one is
+ // no longer the last one, making it invalid.
+ if self.has_chunked_transfer_encoding {
+ fail!(
+ INVALID_TRANSFER_ENCODING,
+ "The value \"chunked\" in the Transfer-Encoding header must be the last provided and \
+ can be provided only once"
+ );
+ }
+
+ self.has_chunked_transfer_encoding = true;
+ } else {
+ if self.has_chunked_transfer_encoding {
+ // Any other value when chunked was already specified is invalid as the previous
+ // chunked would not be the last one anymore
+ fail!(
+ INVALID_TRANSFER_ENCODING,
+ "The value \"chunked\" in the Transfer-Encoding header must be the last provided"
+ );
+ }
+ }
+
+ if token_end_raw == header_value_end {
+ break;
+ } else {
+ token_start = token_end_raw + 1;
+ }
+ }
+ }
+ }
+ // RFC 9112 section 9.6
+ (10, case_insensitive_string!("connection")) => {
+ if !strip_ows_fast(data, &mut header_value_start, &mut header_value_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected Connection header value");
+ }
+
+ match data[header_value_start..header_value_end] {
+ case_insensitive_string!("close") => {
+ self.has_connection_close = true;
+ }
+ case_insensitive_string!("keep-alive") => {
+ // Keep-alive is implicit unless Connection: close is
+ // present.
+ }
+ case_insensitive_string!("upgrade") => {
+ self.has_connection_upgrade = true;
+ }
+ _ => {
+ // Comma separated values
+ let mut token_start = header_value_start;
+ loop {
+ while token_start < header_value_end && is_ws(data[token_start]) {
+ token_start += 1;
+ }
+
+ if token_start == header_value_end {
+ break;
+ }
+
+ let token_end_raw = match find_char(data, token_start, header_value_end, b',') {
+ Some(comma) => comma,
+ None => header_value_end,
+ };
+ let mut token_end = token_end_raw;
+
+ if !strip_ows_fast(data, &mut token_start, &mut token_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected Connection header value");
+ }
+
+ match data[token_start..token_end] {
+ case_insensitive_string!("close") => {
+ self.has_connection_close = true;
+ }
+ case_insensitive_string!("upgrade") => {
+ self.has_connection_upgrade = true;
+ }
+ case_insensitive_string!("keep-alive") => {}
+ _ => {
+ if !validate_token(data, token_start, token_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid Connection header value");
+ }
+ }
+ }
+
+ if token_end_raw == header_value_end {
+ break;
+ } else {
+ token_start = token_end_raw + 1;
+ }
+ }
+ }
+ }
+ }
+ (7, case_insensitive_string!("trailer")) => {
+ self.has_trailers = true;
+
+ if !strip_ows_fast(data, &mut header_value_start, &mut header_value_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected Trailer header value");
+ }
+ }
+ (7, case_insensitive_string!("upgrade")) => {
+ if !strip_ows_fast(data, &mut header_value_start, &mut header_value_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected Upgrade header value");
+ }
+
+ let mut token_start = header_value_start;
+ loop {
+ while token_start < header_value_end && is_ws(data[token_start]) {
+ token_start += 1;
+ }
+
+ if token_start == header_value_end {
+ break;
+ }
+
+ let token_end_raw = match find_char(data, token_start, header_value_end, b',') {
+ Some(comma) => comma,
+ None => header_value_end,
+ };
+ let mut token_end = token_end_raw;
+
+ if !strip_ows_fast(data, &mut token_start, &mut token_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected Upgrade header value");
+ }
+
+ let protocol_name_end = find_char(data, token_start, token_end, b'/').unwrap_or(token_end);
+ if !validate_token(data, token_start, protocol_name_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid Upgrade header value");
+ }
+
+ if protocol_name_end < token_end {
+ let protocol_version_start = protocol_name_end + 1;
+ if find_char(data, protocol_version_start, token_end, b'/').is_some()
+ || !validate_token(data, protocol_version_start, token_end)
+ {
+ fail!(UNEXPECTED_CHARACTER, "Invalid Upgrade header value");
+ }
+ }
+
+ if token_end_raw == header_value_end {
+ break;
+ } else {
+ token_start = token_end_raw + 1;
+ }
+ }
+
+ self.has_upgrade = true;
+ }
+ _ => {
+ if !validate_token(data, header_name_start, header_name_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid header field name character");
+ }
+
+ if has_header_value_event {
+ strip_ows_fast(data, &mut header_value_start, &mut header_value_end, true);
+ }
+ }
+ }
+ }
+
+ if has_header_name_event {
+ event_with_range!(on_header_name, header_name_start, header_name_end - header_name_start);
+ }
+
+ if has_header_value_event {
+ event_with_range!(
+ on_header_value,
+ header_value_start,
+ header_value_end - header_value_start
+ );
+ }
+
+ advance!(cr + 2);
+ }
+ HeaderLineScanResult::Invalid(invalid) => {
+ match find_char(data, 0, invalid, b':') {
+ Some(_) => {
+ fail!(UNEXPECTED_CHARACTER, "Invalid header field value character");
+ }
+ None => {
+ fail!(UNEXPECTED_CHARACTER, "Invalid header field name character");
+ }
+ }
+ }
+ HeaderLineScanResult::Incomplete => {
+ if available >= self.max_header_length {
+ fail!(UNEXPECTED_CHARACTER, "Header line too long");
+ } else {
+ suspend!();
+ }
+ }
+ }
+ }
+
+ // RFC 9110 section 9.3.6 and 7.8 - Headers have finished, check if the
+ // connection must be upgraded or a body is expected.
+ STATE_BODY_DECISION => {
+ let method = self.method;
+ let status = self.status;
+
+ if self.has_upgrade && !self.has_connection_upgrade {
+ fail!(
+ MISSING_CONNECTION_UPGRADE,
+ "Missing Connection header set to \"upgrade\" when using the Upgrade header"
+ );
+ }
+
+ if self.has_trailers && !self.has_chunked_transfer_encoding {
+ fail!(
+ UNEXPECTED_TRAILERS,
+ "Trailers are not allowed when not using chunked transfer encoding"
+ );
+ } else if self.is_request && (method == METHOD_GET || method == METHOD_HEAD) && self.content_length > 0 {
+ fail!(UNEXPECTED_CONTENT, "Unexpected content for the request (GET or HEAD)");
+ }
+
+ // In case of Connection: Upgrade or a CONNECT method
+ if self.is_connect {
+ // In case of CONNECT method
+ event_with_range!(on_connect, 0, 0);
+ move_to!(tunnel);
+ } else if self.has_upgrade && !self.is_request && status == 101 {
+ event_with_range!(on_upgrade, 0, 0);
+ move_to!(tunnel);
+ } else if self.is_request {
+ if self.has_transfer_encoding && !self.has_chunked_transfer_encoding {
+ fail!(
+ UNEXPECTED_CONTENT_LENGTH,
+ "Transfer-Encoding last header value must be \"chunked\" if the header is present"
+ );
+ } else if self.skip_body {
+ self.continue_without_data = true;
+ if !self.complete_message(
+ 0,
+ active_events,
+ has_complete_events,
+ has_finish_event,
+ &mut event_cursor,
+ ) {
+ suspend!();
+ }
+ } else if self.has_content_length {
+ // RFC 9110 section 6.3
+ if self.content_length == 0 {
+ self.continue_without_data = true;
+ if !self.complete_message(
+ 0,
+ active_events,
+ has_complete_events,
+ has_finish_event,
+ &mut event_cursor,
+ ) {
+ suspend!();
+ }
+ } else {
+ move_to!(body_via_content_length);
+ }
+ } else if !self.has_chunked_transfer_encoding {
+ self.continue_without_data = true;
+ if !self.complete_message(
+ 0,
+ active_events,
+ has_complete_events,
+ has_finish_event,
+ &mut event_cursor,
+ ) {
+ suspend!();
+ }
+ } else {
+ move_to!(chunk_header);
+ }
+ } else {
+ // Response
+ // RFC 9110 section 15.4.5
+ if self.skip_body || (status < 200 && status != 101) || status == 204 || status == 205 || status == 304 {
+ self.continue_without_data = true;
+ if !self.complete_message(
+ 0,
+ active_events,
+ has_complete_events,
+ has_finish_event,
+ &mut event_cursor,
+ ) {
+ suspend!();
+ }
+ } else if self.has_content_length {
+ if self.content_length == 0 {
+ self.continue_without_data = true;
+ if !self.complete_message(
+ 0,
+ active_events,
+ has_complete_events,
+ has_finish_event,
+ &mut event_cursor,
+ ) {
+ suspend!();
+ }
+ } else {
+ move_to!(body_via_content_length);
+ }
+ } else if self.has_chunked_transfer_encoding {
+ move_to!(chunk_header);
+ } else {
+ move_to!(body_with_no_length);
+ }
+ }
+ }
+
+ // RFC 9112 section 6.2
+ STATE_BODY_VIA_CONTENT_LENGTH => {
+ let expected = self.remaining_content_length;
+ let mut to_consume = expected.min(available as u64);
+
+ if max_body_payload != 0 {
+ if body_payload_read >= max_body_payload {
+ suspend!();
+ }
+
+ to_consume = to_consume.min(max_body_payload - body_payload_read);
+ }
+
+ if to_consume == 0 {
+ suspend!();
+ }
+
+ let to_consume_usize = to_consume as usize;
+ body_payload_read += to_consume;
+
+ if to_consume < expected {
+ event_with_range!(on_data, 0, to_consume_usize);
+ self.remaining_content_length -= to_consume;
+ advance!(to_consume_usize);
+ } else {
+ // Suspend before emitting or consuming any part of the final body segment.
+ if event_cursor + EVENT_BODY_COMPLETION_SIZE + EVENT_ERROR_RESERVE > EVENTS_BUFFER_SIZE {
+ suspend!();
+ }
+ event_with_range!(on_data, 0, to_consume_usize);
+ event_with_range!(on_body, to_consume_usize, 0);
+
+ self.remaining_content_length = 0;
+
+ self.continue_without_data = true;
+
+ if !self.complete_message(
+ to_consume_usize,
+ active_events,
+ has_complete_events,
+ has_finish_event,
+ &mut event_cursor,
+ ) {
+ suspend!();
+ }
+ advance!(to_consume_usize);
+ }
+ }
+
+ // RFC 9110 section 6.3 - Body with no length nor chunked encoding.
+ // This is only allowed in responses.
+ // Note that on_body can't and will not be called here as there is no way to
+ // know when the response finishes.
+ STATE_BODY_WITH_NO_LENGTH => {
+ let mut to_consume = available as u64;
+
+ if max_body_payload != 0 {
+ if body_payload_read >= max_body_payload {
+ suspend!();
+ }
+
+ to_consume = to_consume.min(max_body_payload - body_payload_read);
+ }
+
+ if to_consume == 0 {
+ suspend!();
+ }
+
+ let to_consume_usize = to_consume as usize;
+ body_payload_read += to_consume;
+
+ event_with_range!(on_data, 0, to_consume_usize);
+ advance!(to_consume_usize);
+ }
+
+ // RFC 9112 section 7.1
+ STATE_CHUNK_HEADER => {
+ match find_cr(data, available) {
+ Some(cr) => {
+ match ensure_valid_line(data, cr, available) {
+ MatchResult::Continue => {}
+ MatchResult::Suspend => {
+ suspend!();
+ }
+ MatchResult::Stop => {
+ fail!(UNEXPECTED_CHARACTER, "Expected CRLF");
+ }
+ }
+
+ let chunk_length_start = 0;
+ // Note, the character is optional since chunk extensions are not required
+ let chunk_length_end = match find_char(data, chunk_length_start, cr, b';') {
+ Some(index) => index,
+ None => cr,
+ };
+
+ if chunk_length_end == 0 {
+ fail!(UNEXPECTED_CHARACTER, "Invalid chunk length character");
+ } else if chunk_length_end - chunk_length_start > 16 {
+ fail!(INVALID_CHUNK_SIZE, "Invalid chunk length size");
+ }
+
+ let mut i = chunk_length_start;
+ let mut chunk_length = 0u64;
+ while i < chunk_length_end {
+ let b = data[i];
+
+ let hex = if b.is_ascii_digit() {
+ (b - b'0') as u64
+ } else if (b'a'..=b'f').contains(&b) {
+ (b - b'a' + 10) as u64
+ } else if (b'A'..=b'F').contains(&b) {
+ (b - b'A' + 10) as u64
+ } else {
+ fail!(UNEXPECTED_CHARACTER, "Invalid chunk length character");
+ };
+
+ chunk_length = chunk_length * 16 + hex;
+ i += 1;
+ }
+
+ self.chunk_size = chunk_length;
+ self.remaining_chunk_size = chunk_length;
+
+ event_with_range!(
+ on_chunk_length,
+ chunk_length_start,
+ chunk_length_end - chunk_length_start
+ );
+
+ // There are extensions
+ if chunk_length_end < cr {
+ advance!(chunk_length_end + 1);
+ move_to!(chunk_extensions);
+ } else {
+ self.continue_without_data = true;
+
+ if self.chunk_size == 0 {
+ event_with_range!(on_chunk, 3, 0);
+ event_with_range!(on_body, 3, 0);
+ advance!(cr + 2);
+ move_to!(trailer);
+ } else {
+ advance!(cr + 2);
+ move_to!(chunk_data);
+ }
+ }
+ }
+ None => {
+ if available >= self.max_header_length {
+ fail!(UNEXPECTED_CHARACTER, "Chunk header too long");
+ } else {
+ suspend!();
+ }
+ }
+ }
+ }
+
+ STATE_CHUNK_EXTENSIONS => {
+ match find_cr(data, available) {
+ Some(cr) => {
+ match ensure_valid_line(data, cr, available) {
+ MatchResult::Continue => {}
+ MatchResult::Suspend => {
+ suspend!();
+ }
+ MatchResult::Stop => {
+ fail!(UNEXPECTED_CHARACTER, "Expected CRLF");
+ }
+ }
+
+ let mut name_start = 0;
+ // Find the first between = or ;
+ let name_end_raw = find_char2(data, name_start, cr, b'=', b';').unwrap_or(cr);
+ let mut name_end = name_end_raw;
+
+ if !strip_ows(data, &mut name_start, &mut name_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected chunk extension name");
+ }
+
+ if !validate_token(data, name_start, name_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid chunk extension name character");
+ }
+
+ // No value
+ if name_end == cr || data[name_end_raw] == b';' {
+ event_with_range!(on_chunk_extension_name, name_start, name_end - name_start);
+
+ if name_end_raw == cr {
+ if self.chunk_size == 0 {
+ event_with_range!(on_body, 0, 0);
+ advance!(cr + 2);
+ move_to!(trailer);
+ } else {
+ advance!(cr + 2);
+ move_to!(chunk_data);
+ }
+ } else {
+ advance!(name_end_raw + 1);
+ move_to!(chunk_extensions);
+ }
+ } else {
+ // Get the value
+ let mut value_start = name_end_raw + 1;
+ let mut value_end: usize;
+ let next_extension: usize;
+
+ // Strip OWS before the value
+ while value_start < cr && is_ws(data[value_start]) {
+ value_start += 1;
+ }
+
+ if value_start == cr {
+ fail!(UNEXPECTED_CHARACTER, "Expected chunk extension value");
+ }
+
+ // Quoted string
+ // RFC 9110 section 5.6.4
+ let mut quoted = false;
+ let quote_start = value_start;
+ if data[value_start] == b'"' {
+ quoted = true;
+ value_start += 1;
+ let mut quote_start = value_start;
+
+ loop {
+ match find_char(data, quote_start, cr, b'"') {
+ Some(index) => {
+ // Count consecutive backslashes immediately before the quote
+ let mut backslash_count = 0usize;
+ let mut i = index;
+
+ while i > quote_start && data[i - 1] == b'\\' {
+ backslash_count += 1;
+ i -= 1;
+ }
+
+ if backslash_count.is_multiple_of(2) {
+ // quote is not escaped
+ value_end = index;
+ break;
+ } else {
+ // quote is escaped, continue searching after it
+ quote_start = index + 1;
+ }
+ }
+ None => {
+ fail!(UNEXPECTED_CHARACTER, "Expected closing quote for chunk extension value");
+ }
+ };
+ }
+
+ if !validate_quoted_string(data, value_start, value_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid chunk extension quoted value character");
+ }
+
+ next_extension = value_end + 1;
+ } else {
+ value_end = find_char(data, value_start, cr, b';').unwrap_or(cr);
+ next_extension = if value_end == cr { cr } else { value_end };
+
+ if !strip_ows(data, &mut value_start, &mut value_end, false) {
+ fail!(UNEXPECTED_CHARACTER, "Expected chunk extension value");
+ }
+
+ if value_start != value_end && !validate_token(data, value_start, value_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid chunk extension value character");
+ }
+ }
+
+ event_with_range!(on_chunk_extension_name, name_start, name_end - name_start);
+
+ if quoted {
+ event_with_range!(on_chunk_extension_value, quote_start, value_end - quote_start + 1);
+ } else {
+ event_with_range!(on_chunk_extension_value, value_start, value_end - value_start);
+ }
+
+ let next_semicolon = find_char(data, next_extension, cr, b';').unwrap_or(cr);
+
+ let mut i = next_extension;
+ while i < next_semicolon {
+ if !is_ws(data[i]) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid chunk extension character after value");
+ }
+ i += 1;
+ }
+
+ if next_semicolon < cr {
+ advance!(next_semicolon + 1);
+ } else {
+ if self.chunk_size == 0 {
+ event_with_range!(on_body, 0, 0);
+ advance!(cr + 2);
+ move_to!(trailer);
+ } else {
+ advance!(cr + 2);
+ move_to!(chunk_data);
+ }
+ }
+ }
+ }
+ None => {
+ // Given in chunk_header we already validated this, this should not happen.
+ if available >= self.max_header_length {
+ fail!(UNEXPECTED_CHARACTER, "Chunk header too long");
+ } else {
+ suspend!();
+ }
+ }
+ }
+ }
+
+ STATE_CHUNK_DATA => {
+ let expected = self.remaining_chunk_size;
+
+ // No more data for this chunk, just wait for the CRLF
+ if expected == 0 {
+ if available < 2 {
+ suspend!();
+ } else if data[0] != b'\r' || data[1] != b'\n' {
+ fail!(UNEXPECTED_CHARACTER, "Expected CRLF after chunk data");
+ } else {
+ advance!(2);
+ move_to!(chunk_header);
+ }
+ } else {
+ let mut to_consume = expected.min(available as u64);
+
+ if max_body_payload != 0 {
+ if body_payload_read >= max_body_payload {
+ suspend!();
+ }
+
+ to_consume = to_consume.min(max_body_payload - body_payload_read);
+ }
+
+ if to_consume == 0 {
+ suspend!();
+ }
+
+ let to_consume_usize = to_consume as usize;
+ body_payload_read += to_consume;
+
+ event_with_range!(on_chunk, 0, to_consume_usize);
+ event_with_range!(on_data, 0, to_consume_usize);
+
+ if to_consume < expected {
+ self.remaining_chunk_size -= to_consume;
+ } else {
+ self.remaining_chunk_size = 0;
+ }
+
+ advance!(to_consume_usize);
+ }
+ }
+
+ // RFC 9112 section 7.1.2
+ STATE_TRAILER => {
+ match find_header_line_end(data.as_ptr(), available) {
+ HeaderLineScanResult::Cr(cr) => {
+ match ensure_valid_line(data, cr, available) {
+ MatchResult::Continue => {}
+ MatchResult::Suspend => {
+ suspend!();
+ }
+ MatchResult::Stop => {
+ fail!(UNEXPECTED_CHARACTER, "Expected CRLF");
+ }
+ }
+
+ // No more trailers or no trailers at all, message completed
+ if cr == 0 {
+ // Keep the trailer notification and completion in the same batch.
+ if event_cursor + EVENT_TRAILER_COMPLETION_SIZE + EVENT_ERROR_RESERVE > EVENTS_BUFFER_SIZE {
+ suspend!();
+ }
+ event_with_range!(on_trailers, 2, 0);
+ self.continue_without_data = true;
+ if !self.complete_message(
+ 2,
+ active_events,
+ has_complete_events,
+ has_finish_event,
+ &mut event_cursor,
+ ) {
+ suspend!();
+ }
+ advance!(2);
+ next!();
+ }
+
+ let trailer_name_start = 0;
+ let trailer_name_end = match find_char(data, trailer_name_start, cr, b':') {
+ Some(index) if index > trailer_name_start => index,
+ _ => {
+ fail!(UNEXPECTED_CHARACTER, "Invalid trailer field name character");
+ }
+ };
+
+ let mut trailer_value_start = trailer_name_end + 1;
+ let mut trailer_value_end = cr;
+ if has_trailer_value_event {
+ strip_ows_fast(data, &mut trailer_value_start, &mut trailer_value_end, true);
+ }
+
+ // Validate
+ if !validate_token(data, trailer_name_start, trailer_name_end) {
+ fail!(UNEXPECTED_CHARACTER, "Invalid trailer field name character");
+ }
+
+ if has_trailer_name_event {
+ event_with_range!(
+ on_trailer_name,
+ trailer_name_start,
+ trailer_name_end - trailer_name_start
+ );
+ }
+
+ if has_trailer_value_event {
+ event_with_range!(
+ on_trailer_value,
+ trailer_value_start,
+ trailer_value_end - trailer_value_start
+ );
+ }
+ advance!(cr + 2);
+ }
+ HeaderLineScanResult::Invalid(invalid) => {
+ match find_char(data, 0, invalid, b':') {
+ Some(_) => {
+ fail!(UNEXPECTED_CHARACTER, "Invalid trailer field value character");
+ }
+ None => {
+ fail!(UNEXPECTED_CHARACTER, "Invalid trailer field name character");
+ }
+ }
+ }
+ HeaderLineScanResult::Incomplete => {
+ if available >= self.max_header_length {
+ fail!(UNEXPECTED_CHARACTER, "Trailer line too long");
+ } else {
+ suspend!();
+ }
+ }
+ }
+ }
+
+ // Return PAUSE makes this method idempotent without failing - In this state
+ // all data is ignored since the connection is not in HTTP anymore
+ STATE_TUNNEL => {
+ suspend!();
+ }
+
+ _ => {
+ fail!(UNEXPECTED_STATE, "Invalid state");
+ }
+ }
+ }
+
+ // Update the parser position
+ if advanced > 0 {
+ self.position += advanced;
+ data = &data[advanced..];
+ available -= advanced;
+
+ #[cfg(any(debug_assertions, feature = "debug"))]
+ if self.debug {
+ eprintln!(
+ "[milo_parser::debug] loop before processing: position={}, advanced={}, available={}, \
+ continue_without_data={}",
+ self.position, advanced, available, self.continue_without_data
+ );
+ }
+ }
+
+ // Notify the status change
+ #[cfg(any(debug_assertions, feature = "debug"))]
+ if previous_state != self.state {
+ if active_events & EVENT_ACTIVE_ON_STATE_CHANGE != 0
+ && !self.try_emit_event_range(
+ &mut event_cursor,
+ EVENT_STATE_CHANGE,
+ self.position,
+ self.state as usize,
+ )
+ {
+ parsing = false;
+ continue 'parser;
+ }
+ previous_state = self.state;
+ }
+
+ // Show the duration of the operation
+ #[cfg(all(not(target_family = "wasm"), any(debug_assertions, feature = "debug")))]
+ if self.debug {
+ let duration = Instant::now().duration_since(last).as_nanos();
+
+ if duration > 0 {
+ eprintln!(
+ "[milo_parser::debug] loop iteration ({:?}) completed in {} ns",
+ self.state_str(),
+ duration
+ );
+ }
+
+ last = Instant::now();
+ }
+ }
+
+ #[cfg(any(debug_assertions, feature = "debug"))]
+ if self.debug {
+ eprintln!("[milo_parser::debug] loop exit");
+ }
+
+ let consumed = self.position;
+ self.parsed += consumed as u64;
+
+ if self.manage_unconsumed {
+ self.clear_unconsumed();
+
+ // Use a boxed slice so the length also determines the allocation layout
+ // when releasing retained input; Vec capacity is not stored in the ABI.
+ if consumed < limit {
+ let retained = data.to_vec().into_boxed_slice();
+ self.unconsumed_len = retained.len();
+ self.unconsumed = Box::into_raw(retained) as *const c_uchar;
+ }
+ }
+
+ #[cfg(all(not(target_family = "wasm"), any(debug_assertions, feature = "debug")))]
+ if self.debug {
+ let duration = Instant::now().duration_since(start).as_nanos();
+
+ if duration > 0 {
+ eprintln!(
+ "[milo_parser::debug] parse ({:?}, consumed {} of {}) completed in {} ns",
+ self.state_str(),
+ consumed,
+ limit,
+ duration
+ );
+ }
+ }
+
+ // Append only errors raised by this call, after all preceding events.
+ if failed && active_events & EVENT_ACTIVE_ON_ERROR != 0 {
+ self.try_emit_event_error(&mut event_cursor);
+ }
+
+ if has_active_events {
+ unsafe {
+ *self.events.add(event_cursor) = EVENT_END;
+ }
+ }
+
+ if self.active_callbacks != 0 {
+ self.invoke_callbacks();
+ }
+
+ // Return the number of consumed bytes
+ consumed
+ }
+
+ /// Completes the current message without consuming more input.
+ ///
+ /// This is intended for integrations that consume opaque body bytes outside
+ /// Milo after headers were parsed, then need Milo to perform the normal
+ /// completion transition and emit completion events.
+ pub fn complete(&mut self) {
+ match self.state {
+ STATE_BODY_DECISION
+ | STATE_TUNNEL
+ | STATE_BODY_VIA_CONTENT_LENGTH
+ | STATE_BODY_WITH_NO_LENGTH
+ | STATE_CHUNK_HEADER
+ | STATE_TRAILER => {}
+ _ => {
+ self.fail(ERROR_UNEXPECTED_STATE, "Invalid state");
+ return;
+ }
+ }
+
+ let active_events = self.active_events | self.active_callbacks;
+ let has_complete_events = active_events & (EVENT_ACTIVE_ON_MESSAGE_COMPLETE | EVENT_ACTIVE_ON_RESET) != 0;
+ let has_finish_event = active_events & EVENT_ACTIVE_ON_FINISH != 0;
+ let mut event_cursor = 0usize;
+
+ if !self.complete_message(
+ 0,
+ active_events,
+ has_complete_events,
+ has_finish_event,
+ &mut event_cursor,
+ ) {
+ self.paused = true;
+ }
+
+ unsafe {
+ *self.events.add(event_cursor) = EVENT_END;
+ }
+ }
+
+ // RFC 9110 section 6.4.1 - Message completed.
+ #[inline(always)]
+ fn complete_message(
+ &mut self,
+ offset: usize,
+ active_events: u64,
+ has_complete_events: bool,
+ has_finish_event: bool,
+ event_cursor: &mut usize,
+ ) -> bool {
+ // Never publish a partial completion group that would be replayed on retry.
+ if *event_cursor + EVENT_COMPLETION_SIZE + EVENT_ERROR_RESERVE > EVENTS_BUFFER_SIZE {
+ return false;
+ }
+ if has_complete_events {
+ if (active_events & EVENT_ACTIVE_ON_MESSAGE_COMPLETE != 0
+ && !self.try_emit_event_range(event_cursor, EVENT_MESSAGE_COMPLETE, self.position + offset, 0))
+ || (active_events & EVENT_ACTIVE_ON_RESET != 0
+ && !self.try_emit_event_range(event_cursor, EVENT_RESET, self.position + offset, 0))
+ {
+ return false;
+ }
+ }
+
+ self.continue_without_data = false;
+ self.skip_body = false;
+
+ if self.has_upgrade && self.is_request {
+ move_to!(tunnel);
+ } else if self.has_connection_close {
+ if has_finish_event && !self.try_emit_event_range(event_cursor, EVENT_FINISH, self.position, 0) {
+ return false;
+ }
+ move_to!(finish);
+ } else {
+ move_to!(start);
+ }
+
+ true
+ }
+}
diff --git a/deps/undici/src/deps/milo/parser/src/wasm.rs b/deps/undici/src/deps/milo/parser/src/wasm.rs
new file mode 100644
index 00000000000..73d380c7ba5
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/src/wasm.rs
@@ -0,0 +1,363 @@
+use core::ffi::{c_uchar, c_void};
+use std::slice;
+
+use crate::Parser;
+
+#[cfg(any(debug_assertions, feature = "debug"))]
+pub fn debug(message: String) { unsafe { crate::logger(((message.as_ptr() as u64) << 32) + message.len() as u64) } }
+
+/// Returns if debug informations are available in this build.
+#[unsafe(no_mangle)]
+pub fn milo_has_debug() -> bool { cfg!(any(debug_assertions, feature = "debug")) }
+
+#[unsafe(no_mangle)]
+pub fn alloc(len: usize) -> *mut c_void {
+ let buffer = Vec::with_capacity(len);
+ let (ptr, _, _) = { buffer.into_raw_parts() };
+ ptr as *mut c_void
+}
+
+#[unsafe(no_mangle)]
+pub fn dealloc(ptr: *mut c_void, len: usize) {
+ if ptr.is_null() {
+ return;
+ }
+
+ unsafe {
+ let _ = Vec::from_raw_parts(ptr, len, len);
+ }
+}
+
+/// Creates a new parser.
+#[unsafe(no_mangle)]
+pub fn create() -> *mut c_void {
+ let ptr = Box::into_raw(Box::new(Parser::new())) as *mut c_void;
+
+ // Recreate the parser from the box to assign the reference to itself
+ let mut parser = unsafe { Box::from_raw(ptr as *mut Parser) };
+ parser.ptr = ptr;
+ let _ = Box::into_raw(parser);
+
+ ptr
+}
+
+/// Destroys a parser.
+#[unsafe(no_mangle)]
+pub fn destroy(parser: *mut c_void) {
+ if parser.is_null() {
+ return;
+ }
+
+ unsafe {
+ let _ = Box::from_raw(parser as *mut Parser);
+ }
+}
+
+/// Resets a parser. The second parameters specifies if to also reset the
+/// parsed counter.
+#[unsafe(no_mangle)]
+pub fn reset(parser: *mut c_void, keep_parsed: bool) { unsafe { (*(parser as *mut Parser)).reset(keep_parsed) } }
+
+/// Clears all values in the parser.
+///
+/// Persisted fields, unconsumed data and the position are not cleared.
+#[unsafe(no_mangle)]
+pub fn clear(parser: *mut c_void) { unsafe { (*(parser as *mut Parser)).clear() } }
+
+// Parses a slice of characters. It returns the number of consumed characters.
+#[unsafe(no_mangle)]
+pub fn parse(parser: *mut c_void, data: *const c_uchar, limit: usize) -> usize {
+ unsafe { (*(parser as *mut Parser)).parse(data, limit) }
+}
+
+/// Pauses the parser. It will have to be resumed via `resume`.
+#[unsafe(no_mangle)]
+pub fn pause(parser: *mut c_void) { unsafe { (*(parser as *mut Parser)).pause() } }
+
+/// Resumes the parser.
+#[unsafe(no_mangle)]
+pub fn resume(parser: *mut c_void) { unsafe { (*(parser as *mut Parser)).resume() } }
+
+/// Completes the current message without consuming more input.
+#[unsafe(no_mangle)]
+pub fn complete(parser: *mut c_void) { unsafe { (*(parser as *mut Parser)).complete() } }
+
+/// Marks the parser as finished. Any new data received via `parse` will
+/// put the parser in the error state.
+#[unsafe(no_mangle)]
+pub fn finish(parser: *mut c_void) { unsafe { (*(parser as *mut Parser)).finish() } }
+
+/// Marks the parser as failed.
+#[unsafe(no_mangle)]
+pub fn fail(parser: *mut c_void, code: u8, description_ptr: *const c_uchar, description_len: usize) {
+ unsafe {
+ (*(parser as *mut Parser)).fail(
+ code,
+ std::str::from_utf8_unchecked(slice::from_raw_parts(description_ptr, description_len)),
+ );
+ }
+}
+
+// Generates a getter.
+// pub fn wasm_getter(input: TokenStream) -> TokenStream {
+// let snake_matcher = Regex::new(r"([A-Z])").unwrap();
+//
+// let definition = parse_macro_input!(input as Property);
+// let property = definition.property;
+// let fn_name = format_ident!(
+// "{}",
+// snake_matcher.replace_all(&definition.getter.to_string().as_str(), |captures:
+// &Captures| { format!("_{}", captures[1].to_lowercase())
+// })
+// );
+//
+// let return_type = definition.r#type;
+//
+// TokenStream::from(quote! {
+// Gets the parser #property.
+// #[unsafe(no_mangle)]
+// pub fn #fn_name(parser: *const c_void) -> #return_type { unsafe { (*(parser
+// as *const Parser)).#property } } })
+// }
+
+// Getters
+// Get the parser autodetect property.
+#[unsafe(no_mangle)]
+pub fn is_autodetect(parser: *const c_void) -> bool { unsafe { (*(parser as *const Parser)).autodetect } }
+
+// Get the parser is_request property.
+#[unsafe(no_mangle)]
+pub fn is_request(parser: *const c_void) -> bool { unsafe { (*(parser as *const Parser)).is_request } }
+
+// Get the parser debug property.
+#[unsafe(no_mangle)]
+pub fn is_debug(parser: *const c_void) -> bool { unsafe { (*(parser as *const Parser)).debug } }
+
+// Get the parser paused property.
+#[unsafe(no_mangle)]
+pub fn is_paused(parser: *const c_void) -> bool { unsafe { (*(parser as *const Parser)).paused } }
+
+// Get the parser manage_unconsumed property.
+#[unsafe(no_mangle)]
+pub fn should_manage_unconsumed(parser: *const c_void) -> bool {
+ unsafe { (*(parser as *const Parser)).manage_unconsumed }
+}
+
+// Get the parser suspend_after_headers property.
+#[unsafe(no_mangle)]
+pub fn should_suspend_after_headers(parser: *const c_void) -> bool {
+ unsafe { (*(parser as *const Parser)).suspend_after_headers }
+}
+
+// Get the parser max_start_line_length property.
+#[unsafe(no_mangle)]
+pub fn get_max_start_line_length(parser: *const c_void) -> usize {
+ unsafe { (*(parser as *const Parser)).max_start_line_length }
+}
+
+// Get the parser max_header_length property.
+#[unsafe(no_mangle)]
+pub fn get_max_header_length(parser: *const c_void) -> usize {
+ unsafe { (*(parser as *const Parser)).max_header_length }
+}
+
+// Get the parser max_body_payload property.
+#[unsafe(no_mangle)]
+pub fn get_max_body_payload(parser: *const c_void) -> u64 { unsafe { (*(parser as *const Parser)).max_body_payload } }
+
+// Get the parser continue_without_data property.
+#[unsafe(no_mangle)]
+pub fn should_continue_without_data(parser: *const c_void) -> bool {
+ unsafe { (*(parser as *const Parser)).continue_without_data }
+}
+
+// Get the parser is_connect property.
+#[unsafe(no_mangle)]
+pub fn is_connect(parser: *const c_void) -> bool { unsafe { (*(parser as *const Parser)).is_connect } }
+
+// Get the parser skip_body property.
+#[unsafe(no_mangle)]
+pub fn should_skip_body(parser: *const c_void) -> bool { unsafe { (*(parser as *const Parser)).skip_body } }
+
+// Get the parser state property.
+#[unsafe(no_mangle)]
+pub fn get_state(parser: *const c_void) -> u8 { unsafe { (*(parser as *const Parser)).state } }
+
+// Get the parser position property.
+#[unsafe(no_mangle)]
+pub fn get_position(parser: *const c_void) -> usize { unsafe { (*(parser as *const Parser)).position } }
+
+// Get the parser parsed property.
+#[unsafe(no_mangle)]
+pub fn get_parsed(parser: *const c_void) -> u64 { unsafe { (*(parser as *const Parser)).parsed } }
+
+// Get the parser error_code property.
+#[unsafe(no_mangle)]
+pub fn get_error_code(parser: *const c_void) -> u8 { unsafe { (*(parser as *const Parser)).error_code } }
+
+// Get the parser method property.
+#[unsafe(no_mangle)]
+pub fn get_method(parser: *const c_void) -> u8 { unsafe { (*(parser as *const Parser)).method } }
+
+// Get the parser status property.
+#[unsafe(no_mangle)]
+pub fn get_status(parser: *const c_void) -> u32 { unsafe { (*(parser as *const Parser)).status } }
+
+// Get the parser has_connection_close property.
+#[unsafe(no_mangle)]
+pub fn has_connection_close(parser: *const c_void) -> bool {
+ unsafe { (*(parser as *const Parser)).has_connection_close }
+}
+
+// Get the parser has_connection_upgrade property.
+#[unsafe(no_mangle)]
+pub fn has_connection_upgrade(parser: *const c_void) -> bool {
+ unsafe { (*(parser as *const Parser)).has_connection_upgrade }
+}
+
+// Get the parser content_length property.
+#[unsafe(no_mangle)]
+pub fn get_content_length(parser: *const c_void) -> u64 { unsafe { (*(parser as *const Parser)).content_length } }
+
+// Get the parser chunk_size property.
+#[unsafe(no_mangle)]
+pub fn get_chunk_size(parser: *const c_void) -> u64 { unsafe { (*(parser as *const Parser)).chunk_size } }
+
+// Get the parser remaining_content_length property.
+#[unsafe(no_mangle)]
+pub fn get_remaining_content_length(parser: *const c_void) -> u64 {
+ unsafe { (*(parser as *const Parser)).remaining_content_length }
+}
+
+// Get the parser remaining_chunk_size property.
+#[unsafe(no_mangle)]
+pub fn get_remaining_chunk_size(parser: *const c_void) -> u64 {
+ unsafe { (*(parser as *const Parser)).remaining_chunk_size }
+}
+
+// Get the parser has_content_length property.
+#[unsafe(no_mangle)]
+pub fn has_content_length(parser: *const c_void) -> bool { unsafe { (*(parser as *const Parser)).has_content_length } }
+
+// Get the parser has_transfer_encoding property.
+#[unsafe(no_mangle)]
+pub fn has_transfer_encoding(parser: *const c_void) -> bool {
+ unsafe { (*(parser as *const Parser)).has_transfer_encoding }
+}
+
+// Get the parser has_chunked_transfer_encoding property.
+#[unsafe(no_mangle)]
+pub fn has_chunked_transfer_encoding(parser: *const c_void) -> bool {
+ unsafe { (*(parser as *const Parser)).has_chunked_transfer_encoding }
+}
+
+// Get the parser has_upgrade property.
+#[unsafe(no_mangle)]
+pub fn has_upgrade(parser: *const c_void) -> bool { unsafe { (*(parser as *const Parser)).has_upgrade } }
+
+// Get the parser has_trailers property.
+#[unsafe(no_mangle)]
+pub fn has_trailers(parser: *const c_void) -> bool { unsafe { (*(parser as *const Parser)).has_trailers } }
+
+/// Gets the parser callback error description, if any. This is meant for
+/// internal use.
+#[unsafe(no_mangle)]
+pub fn get_error_description_raw(parser: *mut c_void) -> u64 {
+ let parser = unsafe { &(*(parser as *const Parser)) };
+
+ let ptr = parser.error_description.as_ptr() as u64;
+ let len = parser.error_description_len as u64;
+
+ (ptr << 32) + len
+}
+
+#[unsafe(no_mangle)]
+pub fn set_should_autodetect(parser: *mut c_void, value: bool) {
+ unsafe {
+ (*(parser as *mut Parser)).autodetect = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_is_request(parser: *mut c_void, value: bool) {
+ unsafe {
+ (*(parser as *mut Parser)).is_request = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_should_manage_unconsumed(parser: *mut c_void, value: bool) {
+ unsafe {
+ (*(parser as *mut Parser)).manage_unconsumed = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_should_suspend_after_headers(parser: *mut c_void, value: bool) {
+ unsafe {
+ (*(parser as *mut Parser)).suspend_after_headers = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_max_start_line_length(parser: *mut c_void, value: usize) {
+ unsafe {
+ (*(parser as *mut Parser)).max_start_line_length = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_max_header_length(parser: *mut c_void, value: usize) {
+ unsafe {
+ (*(parser as *mut Parser)).max_header_length = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_max_body_payload(parser: *mut c_void, value: u64) {
+ unsafe {
+ (*(parser as *mut Parser)).max_body_payload = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_should_continue_without_data(parser: *mut c_void, value: bool) {
+ unsafe {
+ (*(parser as *mut Parser)).continue_without_data = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_should_skip_body(parser: *mut c_void, value: bool) {
+ unsafe {
+ (*(parser as *mut Parser)).skip_body = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_is_connect(parser: *mut c_void, value: bool) {
+ unsafe {
+ (*(parser as *mut Parser)).is_connect = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_debug(parser: *mut c_void, value: bool) {
+ unsafe {
+ (*(parser as *mut Parser)).debug = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_active_callbacks(parser: *mut c_void, value: u64) {
+ unsafe {
+ (*(parser as *mut Parser)).active_callbacks = value;
+ }
+}
+
+#[unsafe(no_mangle)]
+pub fn set_active_events(parser: *mut c_void, value: u64) {
+ unsafe {
+ (*(parser as *mut Parser)).active_events = value;
+ }
+}
diff --git a/deps/undici/src/deps/milo/parser/wasm/src/package.json b/deps/undici/src/deps/milo/parser/wasm/src/package.json
new file mode 100644
index 00000000000..ca21cebd75b
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/wasm/src/package.json
@@ -0,0 +1,38 @@
+{
+ "name": "@perseveranza-pets/milo",
+ "version": "0.9.0",
+ "description": "A fast and embeddable HTTP/1.1 parser.",
+ "homepage": "https://sw.cowtech.it/milo",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/ShogunPanda/milo.git"
+ },
+ "keywords": [
+ "http",
+ "parser"
+ ],
+ "bugs": {
+ "url": "https://github.com/ShogunPanda/milo/issues"
+ },
+ "author": "Shogun <shogun@cowtech.it>",
+ "license": "ISC",
+ "private": false,
+ "type": "module",
+ "files": [
+ "binary",
+ "src",
+ "CODE_OF_CONDUCT.md",
+ "LICENSE.md",
+ "README.md"
+ ],
+ "main": "src/simd/index.js",
+ "exports": {
+ ".": "./src/simd/index.js",
+ "./unbundled": "./src/simd/unbundled.js",
+ "./no-simd": "./src/no-simd/index.js",
+ "./no-simd/unbundled": "./src/no-simd/unbundled.js"
+ },
+ "engines": {
+ "node": ">= 22.21.0"
+ }
+}
diff --git a/deps/undici/src/deps/milo/parser/wasm/src/template.js b/deps/undici/src/deps/milo/parser/wasm/src/template.js
new file mode 100644
index 00000000000..8c3d066c7c7
--- /dev/null
+++ b/deps/undici/src/deps/milo/parser/wasm/src/template.js
@@ -0,0 +1,129 @@
+/* REPLACE: module */
+
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+
+function log (logger, raw) {
+ const len = Number(BigInt.asUintN(32, raw))
+ const ptr = Number(raw >> 32n)
+
+ logger(textDecoder.decode(new Uint8Array(this.memory.buffer, ptr, len)))
+}
+
+function alloc (len) {
+ return this.alloc(len) >>> 0
+}
+
+function dealloc (ptr, len) {
+ return this.dealloc(ptr, len)
+}
+
+function create () {
+ return this.create() >>> 0
+}
+
+function destroy (parser) {
+ this.destroy(parser)
+}
+
+function parse (parser, data, limit) {
+ return this.parse(parser, data, limit) >>> 0
+}
+
+function fail (parser, code, description) {
+ const len = description.length
+ const ptr = this.alloc(len)
+ const buffer = new Uint8Array(this.memory.buffer, ptr, len)
+ textEncoder.encodeInto(description, buffer)
+
+ this.fail(parser, code, ptr, len)
+ this.dealloc(ptr, len)
+}
+
+function hasDebug () {
+ return this.milo_has_debug() !== 0
+}
+
+/* REPLACE: enums */
+
+/* REPLACE: getters */
+
+/* REPLACE: setters */
+
+function simpleCreate (spans, create) {
+ const parser = create()
+ spans[parser] = []
+ this.setActiveCallbacks(parser, this.CALLBACK_ACTIVE_ALL)
+ return parser
+}
+
+function simpleDestroy (spans, destroy, parser) {
+ spans[parser] = undefined
+ destroy(parser)
+}
+
+export function noop () {}
+
+export function setup (env = {}) {
+ let { logger: logOption, ...instanceEnvironment } = env
+ let logger = noop
+ const context = {}
+
+ if (logOption) {
+ if (typeof logOption !== 'function') {
+ logOption = console.log
+ }
+
+ logger = log.bind(context, logOption)
+ }
+
+ // Create the WASM instance
+ /* eslint-disable-next-line no-undef */
+ const instance = new WebAssembly.Instance(wasmModule, {
+ env: {
+ logger,
+ /* REPLACE: callbacks:noop */
+ ...instanceEnvironment
+ }
+ })
+
+ const wasm = instance.exports
+ context.memory = wasm.memory
+
+ const milo = {
+ /* REPLACE: version */
+ /* REPLACE: constants */
+ /* REPLACE: enums:list */
+ /* REPLACE: getters:list */
+ /* REPLACE: setters:list */
+ memory: wasm.memory,
+ alloc: alloc.bind(wasm),
+ dealloc: dealloc.bind(wasm),
+ create: create.bind(wasm),
+ destroy: destroy.bind(wasm),
+ parse: parse.bind(wasm),
+ fail: fail.bind(wasm),
+ hasDebug: hasDebug.bind(wasm),
+ clear: wasm.clear,
+ complete: wasm.complete,
+ finish: wasm.finish,
+ pause: wasm.pause,
+ reset: wasm.reset,
+ resume: wasm.resume
+ }
+
+ /* REPLACE: start */
+ return milo
+}
+
+export function simple () {
+ const spans = {}
+
+ const milo = setup({/* REPLACE: callbacks:simple */})
+
+ milo.spans = spans
+ milo.create = simpleCreate.bind(milo, spans, milo.create)
+ milo.destroy = simpleDestroy.bind(milo, spans, milo.destroy)
+
+ return milo
+}
diff --git a/deps/undici/src/deps/milo/rust-toolchain.toml b/deps/undici/src/deps/milo/rust-toolchain.toml
new file mode 100644
index 00000000000..26f190453c0
--- /dev/null
+++ b/deps/undici/src/deps/milo/rust-toolchain.toml
@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly-2026-07-29"
diff --git a/deps/undici/src/deps/milo/scripts/Cargo.toml b/deps/undici/src/deps/milo/scripts/Cargo.toml
new file mode 100644
index 00000000000..9e2a4c819a9
--- /dev/null
+++ b/deps/undici/src/deps/milo/scripts/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+ name = "milo-build-scripts"
+ version = "0.1.0"
+ edition = "2024"
+ publish = false
+
+[dependencies]
+ base64 = "0.22.1"
+ icu_collator = "2.1"
+ icu_normalizer = "2.1"
+ markdown = "1.0.0"
+ proc-macro2 = "1.0.106"
+ quote = "1.0.45"
+ regex = "1.12.3"
+ semver = "1.0.27"
+ serde = { version = "1.0.228", features = ["derive"] }
+ serde_json = { version = "1.0.149", features = ["preserve_order"] }
+ serde_yaml = "0.9.34"
+ toml = "1.0.7"
diff --git a/deps/undici/src/deps/milo/scripts/src/bin/buildinfo.rs b/deps/undici/src/deps/milo/scripts/src/bin/buildinfo.rs
new file mode 100644
index 00000000000..f0274a44a0a
--- /dev/null
+++ b/deps/undici/src/deps/milo/scripts/src/bin/buildinfo.rs
@@ -0,0 +1,8 @@
+use std::error::Error;
+
+use milo_build_scripts::get_build_info;
+
+fn main() -> Result<(), Box<dyn Error>> {
+ println!("{}", serde_json::to_string_pretty(&get_build_info()?)?);
+ Ok(())
+}
diff --git a/deps/undici/src/deps/milo/scripts/src/bin/import-llhttp-tests.rs b/deps/undici/src/deps/milo/scripts/src/bin/import-llhttp-tests.rs
new file mode 100644
index 00000000000..138d18e7d54
--- /dev/null
+++ b/deps/undici/src/deps/milo/scripts/src/bin/import-llhttp-tests.rs
@@ -0,0 +1,549 @@
+use std::{
+ collections::HashSet,
+ env,
+ error::Error,
+ fs,
+ io::ErrorKind,
+ path::{Path, PathBuf},
+ process::{self, Command},
+ sync::LazyLock,
+};
+
+use icu_collator::{Collator, options::CollatorOptions};
+use icu_normalizer::DecomposingNormalizer;
+use markdown::{ParseOptions, mdast::Node, to_mdast};
+use regex::Regex;
+use serde_json::{Map, Value, json};
+
+const FIXTURE_PREFIX: &str = "tests/fixtures/llhttp";
+
+struct Case {
+ titles: Vec<String>,
+ source: Value,
+ meta: Value,
+ http: Option<String>,
+ log: Option<String>,
+}
+
+fn fail(message: &str) -> ! {
+ eprintln!("{message}");
+ process::exit(1);
+}
+
+fn clean_heading(title: &str) -> String { title.replace('`', "").trim().to_owned() }
+
+fn decode_html_entities(value: &str) -> Result<String, Box<dyn Error>> {
+ static ENTITIES: LazyLock<Regex> =
+ LazyLock::new(|| Regex::new(r"&(?:quot|apos|amp|lt|gt|#(\d+)|#x([0-9a-fA-F]+));").unwrap());
+ let mut decoded = String::new();
+ let mut end = 0;
+ for captures in ENTITIES.captures_iter(value) {
+ let matched = captures.get(0).unwrap();
+ decoded.push_str(&value[end..matched.start()]);
+ let character = match matched.as_str() {
+ """ => '"',
+ "'" => '\'',
+ "&" => '&',
+ "<" => '<',
+ ">" => '>',
+ _ => {
+ let code = if let Some(decimal) = captures.get(1) {
+ decimal.as_str().parse::<u32>()?
+ } else {
+ u32::from_str_radix(captures.get(2).unwrap().as_str(), 16)?
+ };
+ char::from_u32(code).ok_or("Invalid HTML character reference")?
+ }
+ };
+ decoded.push(character);
+ end = matched.end();
+ }
+ decoded.push_str(&value[end..]);
+ Ok(decoded)
+}
+
+fn parse_html_meta(value: &str) -> Result<Option<Value>, Box<dyn Error>> {
+ static COMMENT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?s)<!--\s*meta=(.*?)\s*-->").unwrap());
+ static BARE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?s)^\s*meta=(.*?)\s*$").unwrap());
+ let Some(captures) = COMMENT.captures(value).or_else(|| BARE.captures(value)) else {
+ return Ok(None);
+ };
+ // llhttp stores JSON metadata in markdown HTML nodes, sometimes entity-escaped
+ // by the parser.
+ let meta: Value = serde_json::from_str(&decode_html_entities(captures[1].trim())?)?;
+ if !has_meta(&meta) {
+ return Ok(None);
+ }
+ Ok(Some(meta))
+}
+
+fn has_meta(value: &Value) -> bool { value.as_object().is_some_and(|object| !object.is_empty()) }
+
+fn stringify_fixture(fixture: &Value) -> String {
+ // Match yaml's QUOTE_SINGLE values, PLAIN keys, and unlimited line width.
+ // serde_yaml has no option for choosing the scalar style, so emit this JSON
+ // subset explicitly while retaining the insertion order of object keys.
+ fn quote(value: &str, indent: usize, key: bool) -> String {
+ let double = value
+ .chars()
+ .any(|c| matches!(c, '\0'..='\u{8}' | '\u{b}'..='\u{1f}' | '\u{7f}'..='\u{9f}'))
+ || (key && value.contains('\n'))
+ || value
+ .as_bytes()
+ .windows(2)
+ .any(|pair| matches!(pair, [b' ' | b'\t', b'\n'] | [b'\n', b' ' | b'\t']));
+ if double {
+ let json = serde_json::to_string(value).unwrap();
+ let characters = json.chars().collect::<Vec<_>>();
+ let mut result = String::new();
+ let mut i = 0;
+ while i < characters.len() {
+ if characters[i] == ' ' && characters.get(i + 1..i + 3) == Some(&['\\', 'n']) {
+ result.push_str("\\ ");
+ i += 1;
+ }
+ if characters[i] == '\\' {
+ match characters[i + 1] {
+ 'u' => {
+ let code = characters[i + 2..i + 6].iter().collect::<String>();
+ match code.as_str() {
+ "0000" => result.push_str("\\0"),
+ "0007" => result.push_str("\\a"),
+ "000b" => result.push_str("\\v"),
+ "001b" => result.push_str("\\e"),
+ _ if code.starts_with("00") => result.push_str(&format!("\\x{}", &code[2..])),
+ _ => result.push_str(&format!("\\u{code}")),
+ }
+ i += 6;
+ continue;
+ }
+ 'n' if !key && characters.get(i + 2) != Some(&'"') && json.encode_utf16().count() >= 40 => {
+ result.push_str("\n\n");
+ while characters.get(i + 2..i + 4) == Some(&['\\', 'n']) && characters.get(i + 4) != Some(&'"') {
+ result.push('\n');
+ i += 2;
+ }
+ result.push_str(&" ".repeat(indent));
+ if characters.get(i + 2) == Some(&' ') {
+ result.push('\\');
+ }
+ i += 2;
+ continue;
+ }
+ _ => {
+ result.push(characters[i]);
+ result.push(characters[i + 1]);
+ i += 2;
+ continue;
+ }
+ }
+ }
+ result.push(characters[i]);
+ i += 1;
+ }
+ return result;
+ }
+ let mut result = String::from("'");
+ let mut characters = value.chars().peekable();
+ while let Some(character) = characters.next() {
+ result.push(character);
+ if character == '\'' {
+ result.push('\'');
+ } else if character == '\n' && characters.peek() != Some(&'\n') {
+ result.push('\n');
+ result.push_str(&" ".repeat(indent));
+ }
+ }
+ result.push('\'');
+ result
+ }
+
+ fn key(value: &str, indent: usize) -> String {
+ static SPECIAL: LazyLock<Regex> = LazyLock::new(|| {
+ Regex::new(r#"^[\n\t ,\[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$"#).unwrap()
+ });
+ if value.is_empty()
+ || SPECIAL.is_match(value)
+ || !matches!(serde_yaml::from_str::<Value>(value), Ok(Value::String(_)))
+ {
+ return quote(value, indent, true);
+ }
+ value.to_owned()
+ }
+
+ fn scalar(value: &Value, indent: usize) -> Option<String> {
+ match value {
+ Value::String(value) => Some(quote(value, indent, false)),
+ Value::Array(value) if value.is_empty() => Some("[]".into()),
+ Value::Object(value) if value.is_empty() => Some("{}".into()),
+ Value::Array(_) | Value::Object(_) => None,
+ _ => Some(value.to_string()),
+ }
+ }
+
+ fn emit(value: &Value, indent: usize) -> String {
+ let padding = " ".repeat(indent);
+ let mut output = String::new();
+ match value {
+ Value::Object(object) => {
+ for (name, value) in object {
+ output.push_str(&format!("{padding}{}:", key(name, indent)));
+ if let Some(value) = scalar(value, indent + 2) {
+ output.push_str(&format!(" {value}\n"));
+ } else {
+ output.push('\n');
+ output.push_str(&emit(value, indent + 2));
+ }
+ }
+ }
+ Value::Array(array) => {
+ for value in array {
+ output.push_str(&format!("{padding}- "));
+ if let Some(value) = scalar(value, indent + 2) {
+ output.push_str(&value);
+ output.push('\n');
+ } else {
+ let nested = emit(value, indent + 2);
+ output.push_str(&nested[indent + 2..]);
+ }
+ }
+ }
+ _ => {
+ output.push_str(&format!("{padding}{}\n", scalar(value, indent).unwrap()));
+ }
+ }
+ output
+ }
+
+ format!("---\n{}", emit(fixture, 0))
+}
+
+fn normalize_fixture_for_comparison(value: &Value) -> Value {
+ match value {
+ Value::Array(values) => values.iter().map(normalize_fixture_for_comparison).collect(),
+ Value::Object(object) => {
+ // Compare semantic fixture data only; checked is local review state and key
+ // order is irrelevant.
+ let mut keys = object.keys().filter(|key| *key != "checked").collect::<Vec<_>>();
+ keys.sort();
+ keys
+ .into_iter()
+ .map(|key| (key.clone(), normalize_fixture_for_comparison(&object[key])))
+ .collect()
+ }
+ _ => value.clone(),
+ }
+}
+
+// Node's glob excludes dotfiles and does not descend into symlinked
+// directories.
+fn glob_files(root: &Path, extension: &str) -> Result<Vec<PathBuf>, Box<dyn Error>> {
+ let entries = match fs::read_dir(root) {
+ Ok(entries) => entries,
+ Err(error) if error.kind() == ErrorKind::NotFound => return Ok(Vec::new()),
+ Err(error) => return Err(error.into()),
+ };
+ let mut entries = entries.collect::<Result<Vec<_>, _>>()?;
+ entries.sort_by_key(|entry| entry.file_name());
+ let mut files = Vec::new();
+ for entry in entries {
+ if entry.file_name().to_string_lossy().starts_with('.') {
+ continue;
+ }
+ if entry.file_type()?.is_dir() {
+ files.extend(glob_files(&entry.path(), extension)?);
+ } else if entry.path().extension().is_some_and(|value| value == extension) {
+ files.push(entry.path());
+ }
+ }
+ Ok(files)
+}
+
+fn process_section(
+ llhttp_root: &Path,
+ output_root: &Path,
+ fixture_root: &Path,
+ section: &str,
+ seen_files: &mut HashSet<String>,
+) -> Result<(), Box<dyn Error>> {
+ let source = llhttp_root.join("test").join(section);
+ let mut cases = Vec::new();
+ let mut used_names = HashSet::new();
+
+ // Find markdown files.
+ let mut files = glob_files(&source, "md")?;
+ // Use Unicode collation, as localeCompare does, rather than byte ordering.
+ let collator = Collator::try_new(Default::default(), CollatorOptions::default())?;
+ files.sort_by(|a, b| collator.compare(&a.to_string_lossy(), &b.to_string_lossy()));
+
+ // Process each file.
+ for file in files {
+ let raw = fs::read_to_string(&file)?;
+ let source_path = file.strip_prefix(llhttp_root)?.to_string_lossy().replace('\\', "/");
+ // Parse llhttp markdown sections into test cases.
+ // markdown-rs exposes the same mdast node types used by remark-parse.
+ let tree = to_mdast(&raw, &ParseOptions::default()).map_err(|error| error.to_string())?;
+ let mut parsed = Vec::new();
+ let mut current_section: Option<String> = None;
+ let mut current_case: Option<Case> = None;
+
+ let flush_case = |current_case: &mut Option<Case>, parsed: &mut Vec<Case>| {
+ // A valid llhttp markdown case is complete only after both input and expected
+ // log blocks are seen.
+ if let Some(case) = current_case.take()
+ && case.http.is_some()
+ && case.log.is_some()
+ {
+ parsed.push(case);
+ }
+ };
+
+ for node in tree.children().into_iter().flatten() {
+ if let Node::Heading(heading) = node
+ && (heading.depth == 2 || heading.depth == 3)
+ {
+ flush_case(&mut current_case, &mut parsed);
+ let heading_text = heading
+ .children
+ .iter()
+ .filter_map(|child| {
+ match child {
+ Node::Text(text) => Some(text.value.as_str()),
+ Node::InlineCode(code) => Some(code.value.as_str()),
+ _ => None,
+ }
+ })
+ .collect::<String>();
+ let cleaned_heading = clean_heading(&heading_text);
+ let titles = if heading.depth == 2 {
+ current_section = Some(cleaned_heading.clone());
+ vec![cleaned_heading]
+ } else if let Some(section) = current_section.as_ref().filter(|section| !section.is_empty()) {
+ vec![section.clone(), cleaned_heading]
+ } else {
+ vec![cleaned_heading]
+ };
+ current_case = Some(Case {
+ titles,
+ source: json!({ "path": source_path, "line": heading.position.as_ref().map_or(1, |position| position.start.line) }),
+ meta: Value::Null,
+ http: None,
+ log: None,
+ });
+ continue;
+ }
+
+ if let Node::Html(html) = node
+ && let Some(case) = current_case.as_mut().filter(|case| case.http.is_none())
+ {
+ if let Some(Value::Object(meta)) = parse_html_meta(&html.value)? {
+ if !case.meta.is_object() {
+ case.meta = Value::Object(Map::new());
+ }
+ case.meta.as_object_mut().unwrap().extend(meta);
+ }
+ continue;
+ }
+
+ if let Node::Code(code) = node
+ && let Some(case) = current_case.as_mut()
+ {
+ let code_lang = code.lang.as_deref().unwrap_or("").to_lowercase();
+ if code_lang == "http" {
+ case.http = Some(code.value.clone());
+ } else if code_lang == "log" {
+ case.log = Some(code.value.clone());
+ }
+ }
+ }
+ flush_case(&mut current_case, &mut parsed);
+
+ for item in parsed {
+ let input = item.http.unwrap();
+ let log = item.log.unwrap();
+ if input.is_empty() || log.is_empty() {
+ continue;
+ }
+
+ // Build deterministic fixture file name from titles.
+ // Keep the original normalization and collision suffixes for fixture names.
+ static NON_NAME: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[^a-z0-9\s-]").unwrap());
+ static SPACES: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[\s_]+").unwrap());
+ static HYPHENS: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"-+").unwrap());
+ let name = item
+ .titles
+ .iter()
+ .map(|part| {
+ let normalized = DecomposingNormalizer::new_nfkd()
+ .normalize(&clean_heading(part))
+ .to_lowercase();
+ let normalized = NON_NAME.replace_all(&normalized, " ");
+ let normalized = SPACES.replace_all(normalized.trim(), "-");
+ HYPHENS.replace_all(&normalized, "-").trim_matches('-').to_owned()
+ })
+ .filter(|part| !part.is_empty())
+ .collect::<Vec<_>>()
+ .join("-");
+ let mut file_name = format!("{}.yml", if name.is_empty() { "test" } else { &name });
+ if !used_names.contains(&file_name) {
+ used_names.insert(file_name.clone());
+ } else {
+ let mut counter = 2;
+ while used_names.contains(&format!("{name}-{counter}.yml")) {
+ counter += 1;
+ }
+ file_name = format!("{name}-{counter}.yml");
+ used_names.insert(file_name.clone());
+ }
+
+ let prefix = &item.titles[0];
+ let child = item.titles.get(1).filter(|child| !child.is_empty());
+ // Keep display names aligned with existing fixture format.
+ let title_case = |value: &str| {
+ value
+ .split_whitespace()
+ .map(|part| {
+ let mut characters = part.chars();
+ format!("{}{}", characters.next().unwrap().to_uppercase(), characters.as_str())
+ })
+ .collect::<Vec<_>>()
+ .join(" ")
+ };
+ let mut fixture = json!({
+ "path": format!("{FIXTURE_PREFIX}/{section}/{file_name}"),
+ "name": if let Some(child) = child {
+ format!("{} / {}", clean_heading(prefix), title_case(&clean_heading(child)))
+ } else {
+ title_case(&clean_heading(prefix))
+ },
+ "checked": false,
+ "source": item.source,
+ });
+ if has_meta(&item.meta) {
+ fixture["meta"] = item.meta;
+ }
+ fixture["input"] = input.split('\n').map(|line| Value::String(line.into())).collect();
+ fixture["llhttp"] = log.split('\n').map(|line| Value::String(line.into())).collect();
+ cases.push((file_name, fixture));
+ }
+ }
+
+ let target_dir = fixture_root.join(format!("{section}s"));
+ fs::create_dir_all(&target_dir)?;
+ let temp_fixture_path = target_dir.join(format!(".import-llhttp-{section}-temp.yml"));
+ for (i, (path, fixture)) in cases.iter().enumerate() {
+ println!("Processing {section} case {}/{}: {path}", i + 1, cases.len());
+ let file_path = target_dir.join(path);
+ seen_files.insert(format!("{section}s/{path}"));
+ let mut initial_fixture = fixture.clone();
+ initial_fixture["output"] = json!([]);
+ let initial_content = stringify_fixture(&initial_fixture);
+ fs::write(&temp_fixture_path, initial_content)?;
+
+ // Run generator using a temporary fixture to compute output.
+ let file_arg = temp_fixture_path
+ .strip_prefix(output_root)?
+ .to_string_lossy()
+ .replace('\\', "/");
+ let result = Command::new("cargo")
+ .args(["run", "--example", "llhttp", "--", "--generate", &file_arg])
+ .current_dir(output_root)
+ .output();
+ let stdout = match result {
+ Ok(result)
+ if result.status.success()
+ && result.stdout.len() <= 10 * 1024 * 1024
+ && result.stderr.len() <= 10 * 1024 * 1024 =>
+ {
+ String::from_utf8_lossy(&result.stdout).into_owned()
+ }
+ result => {
+ let details = result
+ .map(|result| String::from_utf8_lossy(&result.stderr).trim().to_owned())
+ .unwrap_or_default();
+ let details = if details.is_empty() {
+ String::new()
+ } else {
+ format!("\n{details}")
+ };
+ fail(&format!("Failed to run cargo generator for {file_arg}{details}"));
+ }
+ };
+ let Some(marker_index) = stdout.find("---") else {
+ fail(&format!(
+ "Failed to parse cargo output for {file_arg}: missing YAML marker"
+ ));
+ };
+ let yaml_snippet = stdout[marker_index + 3..].trim();
+ if yaml_snippet.is_empty() {
+ fail(&format!(
+ "Failed to parse cargo output for {file_arg}: empty YAML snippet"
+ ));
+ }
+ let output: Value = serde_yaml::from_str(yaml_snippet)?;
+ let mut final_fixture = fixture.clone();
+ final_fixture["output"] = output;
+
+ // Skip writes when only comments/checked differ semantically.
+ let skip_overwrite = match fs::read_to_string(&file_path) {
+ Ok(raw) => {
+ serde_yaml::from_str::<Value>(&raw).is_ok_and(|existing_fixture| {
+ normalize_fixture_for_comparison(&existing_fixture) == normalize_fixture_for_comparison(&final_fixture)
+ })
+ }
+ Err(error) if error.kind() == ErrorKind::NotFound => false,
+ Err(error) => return Err(error.into()),
+ };
+ if skip_overwrite {
+ continue;
+ }
+ let final_content = stringify_fixture(&final_fixture);
+ fs::write(file_path, final_content)?;
+ }
+ match fs::remove_file(temp_fixture_path) {
+ Ok(()) => {}
+ Err(error) if error.kind() == ErrorKind::NotFound => {}
+ Err(error) => return Err(error.into()),
+ }
+ Ok(())
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+ let args = env::args().collect::<Vec<_>>();
+ if args.len() < 3 || args[1].is_empty() || args[2].is_empty() {
+ println!("Usage: import-llhttp-tests <llhttp-root> <output-root>");
+ return Ok(());
+ }
+ let llhttp_root = std::path::absolute(&args[1])?;
+ let output_root = std::path::absolute(&args[2])?;
+ let fixture_root = output_root.join(FIXTURE_PREFIX);
+ fs::create_dir_all(&fixture_root)?;
+
+ // Snapshot fixtures that existed before import starts.
+ // Keep discovery order for stale-file messages, as JavaScript's Set does.
+ let mut existing_files = Vec::new();
+ for section in ["requests", "responses"] {
+ let section_root = fixture_root.join(section);
+ // Section folder may not exist yet.
+ if let Ok(files) = glob_files(§ion_root, "yml") {
+ for file in files {
+ existing_files.push(file.strip_prefix(&fixture_root)?.to_string_lossy().replace('\\', "/"));
+ }
+ }
+ }
+ let mut seen_files = HashSet::new();
+ process_section(&llhttp_root, &output_root, &fixture_root, "request", &mut seen_files)?;
+ process_section(&llhttp_root, &output_root, &fixture_root, "response", &mut seen_files)?;
+ for file in existing_files {
+ if seen_files.contains(&file) {
+ continue;
+ }
+ match fs::remove_file(fixture_root.join(&file)) {
+ Ok(()) => {}
+ Err(error) if error.kind() == ErrorKind::NotFound => {}
+ Err(error) => return Err(error.into()),
+ }
+ println!("Removed stale fixture: {file}");
+ }
+ Ok(())
+}
diff --git a/deps/undici/src/deps/milo/scripts/src/bin/postbuild-cpp.rs b/deps/undici/src/deps/milo/scripts/src/bin/postbuild-cpp.rs
new file mode 100644
index 00000000000..b45f5597725
--- /dev/null
+++ b/deps/undici/src/deps/milo/scripts/src/bin/postbuild-cpp.rs
@@ -0,0 +1,66 @@
+use std::{env, error::Error, fs, path::Path};
+
+use milo_build_scripts::get_build_info;
+
+fn prepend_version_and_method_map(header: &str) -> Result<String, Box<dyn Error>> {
+ let header_matcher = "namespace milo_parser {";
+ let info = get_build_info()?;
+ let version = info.version;
+ // Create the method map, required by Node.js.
+ let methods = info
+ .constants
+ .iter()
+ .filter_map(|(key, value)| {
+ key
+ .strip_prefix("METHOD_")
+ .map(|method| format!(" EACH({value}, {method}, {method}) \\"))
+ })
+ .collect::<Vec<_>>()
+ .join("\n");
+ let updated_header = format!(
+ r#"#define MILO_VERSION "{}"
+#define MILO_VERSION_MAJOR {}
+#define MILO_VERSION_MINOR {}
+#define MILO_VERSION_PATCH {}
+#define MILO_VERSION_PRERELEASE "{}"
+
+#define MILO_METHODS_MAP(EACH) \
+{methods}
+
+namespace milo_parser {{
+
+struct Parser;"#,
+ version.raw, version.major, version.minor, version.patch, version.prerelease
+ );
+
+ // Replace the header with the new code.
+ // Match the JavaScript normalization without changing other whitespace.
+ let mut normalized = String::with_capacity(header.len());
+ let mut newlines = 0;
+ for character in header.chars() {
+ if character == '\n' {
+ newlines += 1;
+ } else {
+ newlines = 0;
+ }
+ if newlines <= 2 {
+ normalized.push(character);
+ }
+ }
+ Ok(normalized.replacen(header_matcher, &updated_header, 1))
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+ let profile = env::args().nth(1).ok_or("Usage: postbuild-cpp <profile>")?;
+ // Read the file.
+ let header_path = Path::new(env!("CARGO_MANIFEST_DIR"))
+ .join("../dist/cpp")
+ .join(profile)
+ .join("milo.h");
+ let header = fs::read_to_string(&header_path)?;
+ // Apply modifications.
+ let header = prepend_version_and_method_map(&header)?;
+ // Write the updated file.
+ fs::write(header_path, header)?;
+ Ok(())
+}
diff --git a/deps/undici/src/deps/milo/scripts/src/bin/postbuild-wasm.rs b/deps/undici/src/deps/milo/scripts/src/bin/postbuild-wasm.rs
new file mode 100644
index 00000000000..33a248210db
--- /dev/null
+++ b/deps/undici/src/deps/milo/scripts/src/bin/postbuild-wasm.rs
@@ -0,0 +1,391 @@
+use std::{env, error::Error, fs, io::ErrorKind, path::Path};
+
+use base64::{Engine, engine::general_purpose::STANDARD};
+use milo_build_scripts::{BuildInfo, get_build_info};
+use serde_json::Value;
+
+const ENUMS: &[(&str, &str)] = &[
+ ("ERROR_", "Errors"),
+ ("METHOD_", "Methods"),
+ ("CALLBACK_", "Callbacks"),
+ ("CALLBACK_ACTIVE_", "CallbackActives"),
+ ("EVENT_", "Events"),
+ ("EVENT_ACTIVE_", "EventActives"),
+ ("STATE_", "States"),
+ ("PARSER_FIELD_", "ParserFields"),
+];
+
+enum GetterType {
+ Bool,
+ Number,
+ BigInt,
+ String,
+}
+
+const GETTERS: &[(&str, GetterType, &str)] = &[
+ ("isAutodetect", GetterType::Bool, "is_autodetect"),
+ ("isRequest", GetterType::Bool, "is_request"),
+ ("isPaused", GetterType::Bool, "is_paused"),
+ ("shouldManageUnconsumed", GetterType::Bool, "should_manage_unconsumed"),
+ (
+ "shouldSuspendAfterHeaders",
+ GetterType::Bool,
+ "should_suspend_after_headers",
+ ),
+ ("getMaxStartLineLength", GetterType::Number, "get_max_start_line_length"),
+ ("getMaxHeaderLength", GetterType::Number, "get_max_header_length"),
+ ("getMaxBodyPayload", GetterType::BigInt, "get_max_body_payload"),
+ (
+ "shouldContinueWithoutData",
+ GetterType::Bool,
+ "should_continue_without_data",
+ ),
+ ("isConnect", GetterType::Bool, "is_connect"),
+ ("isDebug", GetterType::Bool, "is_debug"),
+ ("shouldSkipBody", GetterType::Bool, "should_skip_body"),
+ ("getState", GetterType::Number, "get_state"),
+ ("getPosition", GetterType::Number, "get_position"),
+ ("getParsed", GetterType::BigInt, "get_parsed"),
+ ("getErrorCode", GetterType::Number, "get_error_code"),
+ ("getMethod", GetterType::Number, "get_method"),
+ ("getStatus", GetterType::Number, "get_status"),
+ ("hasConnectionClose", GetterType::Bool, "has_connection_close"),
+ ("hasConnectionUpgrade", GetterType::Bool, "has_connection_upgrade"),
+ ("getContentLength", GetterType::BigInt, "get_content_length"),
+ ("getChunkSize", GetterType::BigInt, "get_chunk_size"),
+ (
+ "getRemainingContentLength",
+ GetterType::BigInt,
+ "get_remaining_content_length",
+ ),
+ ("getRemainingChunkSize", GetterType::BigInt, "get_remaining_chunk_size"),
+ ("hasContentLength", GetterType::Bool, "has_content_length"),
+ ("hasTransferEncoding", GetterType::Bool, "has_transfer_encoding"),
+ (
+ "hasChunkedTransferEncoding",
+ GetterType::Bool,
+ "has_chunked_transfer_encoding",
+ ),
+ ("hasUpgrade", GetterType::Bool, "has_upgrade"),
+ ("hasTrailers", GetterType::Bool, "has_trailers"),
+ ("getErrorDescription", GetterType::String, "get_error_description_raw"),
+];
+
+const SETTERS: &[(&str, &str)] = &[
+ ("setShouldAutodetect", "set_should_autodetect"),
+ ("setShouldContinueWithoutData", "set_should_continue_without_data"),
+ ("setIsRequest", "set_is_request"),
+ ("setIsConnect", "set_is_connect"),
+ ("setDebug", "set_debug"),
+ ("setShouldManageUnconsumed", "set_should_manage_unconsumed"),
+ ("setShouldSuspendAfterHeaders", "set_should_suspend_after_headers"),
+ ("setMaxStartLineLength", "set_max_start_line_length"),
+ ("setMaxHeaderLength", "set_max_header_length"),
+ ("setMaxBodyPayload", "set_max_body_payload"),
+ ("setShouldSkipBody", "set_should_skip_body"),
+ ("setActiveCallbacks", "set_active_callbacks"),
+ ("setActiveEvents", "set_active_events"),
+];
+
+fn get_callbacks(info: &BuildInfo) -> Vec<(&str, &Value)> {
+ info
+ .constants
+ .iter()
+ .filter(|(key, _)| key.starts_with("CALLBACK_") && !key.starts_with("CALLBACK_ACTIVE"))
+ .map(|(key, value)| (key.as_str(), value))
+ .collect()
+}
+
+fn generate_enums(info: &BuildInfo) -> String {
+ let mut replacement = String::new();
+ for &(selector, name) in ENUMS {
+ let mut matching = info
+ .constants
+ .iter()
+ .filter(|(key, _)| key.starts_with(selector))
+ .collect::<Vec<_>>();
+ let mut suffix = "";
+ if selector == "CALLBACK_" {
+ matching.retain(|(key, _)| !key.starts_with("CALLBACK_ACTIVE"));
+ } else if selector == "EVENT_" {
+ matching.retain(|(key, _)| !key.starts_with("EVENT_ACTIVE_"));
+ } else if selector == "CALLBACK_ACTIVE_" || selector == "EVENT_ACTIVE_" {
+ suffix = "n";
+ }
+ let entries = matching
+ .iter()
+ .map(|(key, value)| format!(" {}: {value}{suffix}", &key[selector.len()..]))
+ .chain(
+ matching
+ .iter()
+ .map(|(key, value)| format!(" {value}{suffix}: '{}'", &key[selector.len()..])),
+ )
+ .collect::<Vec<_>>()
+ .join(",\n");
+ replacement.push_str(&format!("const {name} = Object.freeze({{\n{entries}\n}})\n\n"));
+ }
+ replacement.trim_end().to_owned()
+}
+
+fn generate_enums_lists() -> String {
+ ENUMS
+ .iter()
+ .map(|(_, name)| format!("{name},"))
+ .collect::<Vec<_>>()
+ .join("\n")
+}
+
+fn generate_constants(info: &BuildInfo) -> String {
+ info
+ .constants
+ .iter()
+ .map(|(key, value)| {
+ let mut value = value.to_string();
+ if key.starts_with("CALLBACK_ACTIVE_") || key.starts_with("EVENT_ACTIVE_") {
+ value.push('n');
+ }
+ format!("{key}: {value},")
+ })
+ .collect::<Vec<_>>()
+ .join("\n")
+}
+
+fn generate_getters() -> String {
+ let mut replacement = String::new();
+ for (getter, kind, raw_getter) in GETTERS {
+ let call = format!("this.{raw_getter}(parser)");
+ let body = match kind {
+ GetterType::Bool => format!(" return {call} !== 0"),
+ GetterType::Number => format!(" return {call} >>> 0"),
+ GetterType::BigInt => format!(" return BigInt.asUintN(64, {call})"),
+ GetterType::String => {
+ format!(
+ " const raw = {call}\n const len = Number(BigInt.asUintN(32, raw))\n const ptr = Number(raw >> 32n)\n \
+ return textDecoder.decode(new Uint8Array(this.memory.buffer, ptr, len))"
+ )
+ }
+ };
+ replacement.push_str(&format!("function {getter} (parser) {{\n{body}\n}}\n\n"));
+ }
+ replacement.trim_end().to_owned()
+}
+
+fn generate_setters() -> String {
+ let mut replacement = String::new();
+ for (setter, raw_setter) in SETTERS {
+ replacement.push_str(&format!(
+ "function {setter} (parser, value) {{\n this.{raw_setter}(parser, value)\n}}\n\n"
+ ));
+ }
+ replacement.trim_end().to_owned()
+}
+
+fn generate_getters_list() -> String {
+ GETTERS
+ .iter()
+ .map(|(name, _, _)| format!("{name}: {name}.bind(wasm),"))
+ .collect::<Vec<_>>()
+ .join("\n")
+}
+
+fn generate_setters_list() -> String {
+ SETTERS
+ .iter()
+ .map(|(name, _)| format!("{name}: {name}.bind(wasm),"))
+ .collect::<Vec<_>>()
+ .join("\n")
+}
+
+fn generate_noop_callbacks(info: &BuildInfo) -> String {
+ get_callbacks(info)
+ .iter()
+ .map(|(key, _)| format!("{}: noop,", key.replacen("CALLBACK_", "", 1).to_lowercase()))
+ .collect::<Vec<_>>()
+ .join("\n")
+}
+
+fn generate_simple_callbacks(info: &BuildInfo) -> String {
+ get_callbacks(info)
+ .iter()
+ .map(|(key, value)| {
+ let name = key.replacen("CALLBACK_", "", 1).to_lowercase();
+ format!("{name} (parser, at, len) {{\n spans[parser].push([{value}, at, len])\n}}")
+ })
+ .collect::<Vec<_>>()
+ .join(",\n")
+}
+
+fn generate_module(profile: &str, info: &BuildInfo, loader: &str, commonjs: bool) -> Result<String, Box<dyn Error>> {
+ let template = fs::read_to_string(Path::new(env!("CARGO_MANIFEST_DIR")).join("../parser/wasm/src/template.js"))?;
+ let version = &info.version;
+ let mut output = String::new();
+
+ // The template is shared by bundled/unbundled and ESM/CJS outputs;
+ // placeholders keep the runtime code identical.
+ // Placeholders occupy complete lines. Emit already formatted fragments using
+ // the template's indentation, so packaging needs no JavaScript formatter.
+ for line in template.lines() {
+ let trimmed = line.trim_start();
+ if let Some(id) = trimmed.strip_prefix("/* REPLACE: ").and_then(|s| s.strip_suffix(" */")) {
+ let replacement = match id {
+ "module" => loader.to_owned(),
+ "version" => {
+ format!(
+ "version: {{\n raw: '{}',\n major: {},\n minor: {},\n patch: {},\n prerelease: '{}'\n}},",
+ version.raw, version.major, version.minor, version.patch, version.prerelease
+ )
+ }
+ "enums" => generate_enums(info),
+ "enums:list" => generate_enums_lists(),
+ "constants" => generate_constants(info),
+ "getters" => generate_getters(),
+ "setters" => generate_setters(),
+ "getters:list" => generate_getters_list(),
+ "setters:list" => generate_setters_list(),
+ "callbacks:noop" => generate_noop_callbacks(info),
+ "callbacks:simple" => generate_simple_callbacks(info),
+ "start" => {
+ if profile == "debug" {
+ "wasm.__start()".to_owned()
+ } else {
+ continue;
+ }
+ }
+ _ => {
+ eprintln!("Unsupported placeholder type {id}");
+ trimmed.to_owned()
+ }
+ };
+ let indent = &line[..line.len() - trimmed.len()];
+ for fragment in replacement.lines() {
+ if !fragment.is_empty() {
+ output.push_str(indent);
+ output.push_str(fragment);
+ }
+ output.push('\n');
+ }
+ } else {
+ output.push_str(line);
+ output.push('\n');
+ }
+ }
+ if commonjs {
+ output = output
+ .lines()
+ .map(|line| {
+ if line.starts_with("export function ") {
+ &line["export ".len()..]
+ } else {
+ line
+ }
+ })
+ .collect::<Vec<_>>()
+ .join("\n");
+ output.push('\n');
+ output.push_str("\nmodule.exports = { wasmModule, noop, setup, simple }\n");
+ }
+ Ok(output)
+}
+
+fn generate_commonjs_package_json(package_json: &Value) -> Value {
+ let mut cjs_package_json = package_json.clone();
+ cjs_package_json["name"] = "@perseveranza-pets/milo-cjs".into();
+ cjs_package_json["type"] = "commonjs".into();
+ cjs_package_json
+}
+
+fn generate_variant(
+ profile: &str,
+ info: &BuildInfo,
+ root_folder: &Path,
+ variant: &str,
+ commonjs: bool,
+) -> Result<(), Box<dyn Error>> {
+ let wasm_file = format!("{variant}.wasm");
+ let source_folder = root_folder.join("src").join(variant);
+ let profile_root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../dist/wasm").join(profile);
+ let wasm = STANDARD.encode(fs::read(profile_root.join("binary").join(&wasm_file))?);
+ let unbundled_loader = if commonjs {
+ format!(
+ "const {{ readFileSync }} = require('node:fs')\nconst {{ join }} = require('node:path')\n\nconst wasmModule = \
+ new WebAssembly.Module(readFileSync(join(__dirname, '../../binary/{wasm_file}')))"
+ )
+ } else {
+ format!(
+ "import {{ readFileSync }} from 'node:fs'\n\nexport const wasmModule = new WebAssembly.Module(readFileSync(new \
+ URL('../../binary/{wasm_file}', import.meta.url)))"
+ )
+ };
+ let bundled_loader = if commonjs {
+ format!("const wasmModule = new WebAssembly.Module(\n Buffer.from(\n '{wasm}',\n 'base64'\n )\n)")
+ } else {
+ format!(
+ "export const wasmModule = new WebAssembly.Module(\n Uint8Array.from(\n globalThis.atob(\n '{wasm}'\n ),\n c => c.codePointAt(0)\n )\n)"
+ )
+ };
+ let unbundled = generate_module(profile, info, &unbundled_loader, commonjs)?;
+ let bundled = generate_module(profile, info, &bundled_loader, commonjs)?;
+ fs::create_dir_all(&source_folder)?;
+ fs::write(source_folder.join("unbundled.js"), unbundled)?;
+ fs::write(source_folder.join("index.js"), bundled)?;
+ Ok(())
+}
+
+fn copy_directory(source: &Path, destination: &Path) -> Result<(), Box<dyn Error>> {
+ fs::create_dir_all(destination)?;
+ for entry in fs::read_dir(source)? {
+ let entry = entry?;
+ let target = destination.join(entry.file_name());
+ if entry.file_type()?.is_dir() {
+ copy_directory(&entry.path(), &target)?;
+ } else {
+ fs::copy(entry.path(), target)?;
+ }
+ }
+ Ok(())
+}
+
+// TODO@PI: Generate TypeScript declarations.
+fn main() -> Result<(), Box<dyn Error>> {
+ let info = get_build_info()?;
+ let profile = env::args().nth(1).ok_or("Usage: postbuild-wasm <profile>")?;
+ let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
+ // Open the package.json and update the version.
+ let mut package_json: Value = serde_json::from_str(&fs::read_to_string(root.join("parser/wasm/src/package.json"))?)?;
+ let profile_root = root.join("dist/wasm").join(&profile);
+ let root_folder = profile_root.join("package");
+ let cjs_root_folder = profile_root.join("package-cjs");
+ package_json["version"] = info.version.raw.clone().into();
+ let cjs_package_json = generate_commonjs_package_json(&package_json);
+
+ // Write files.
+ for folder in [&root_folder, &cjs_root_folder] {
+ match fs::remove_dir_all(folder) {
+ Ok(()) => {}
+ Err(error) if error.kind() == ErrorKind::NotFound => {}
+ Err(error) => return Err(error.into()),
+ }
+ }
+ fs::create_dir_all(&root_folder)?;
+ fs::create_dir_all(&cjs_root_folder)?;
+ copy_directory(&profile_root.join("binary"), &root_folder.join("binary"))?;
+ copy_directory(&profile_root.join("binary"), &cjs_root_folder.join("binary"))?;
+ generate_variant(&profile, &info, &root_folder, "simd", false)?;
+ generate_variant(&profile, &info, &root_folder, "no-simd", false)?;
+ generate_variant(&profile, &info, &cjs_root_folder, "simd", true)?;
+ generate_variant(&profile, &info, &cjs_root_folder, "no-simd", true)?;
+ fs::write(
+ root_folder.join("package.json"),
+ serde_json::to_string_pretty(&package_json)?,
+ )?;
+ fs::write(
+ cjs_root_folder.join("package.json"),
+ serde_json::to_string_pretty(&cjs_package_json)?,
+ )?;
+ // Copy other Markdown files from root.
+ for name in ["CODE_OF_CONDUCT.md", "LICENSE.md", "README.md"] {
+ fs::copy(root.join(name), root_folder.join(name))?;
+ fs::copy(root.join(name), cjs_root_folder.join(name))?;
+ }
+ Ok(())
+}
diff --git a/deps/undici/src/deps/milo/scripts/src/bin/sync-versions.rs b/deps/undici/src/deps/milo/scripts/src/bin/sync-versions.rs
new file mode 100644
index 00000000000..85c171ca579
--- /dev/null
+++ b/deps/undici/src/deps/milo/scripts/src/bin/sync-versions.rs
@@ -0,0 +1,39 @@
+use std::{
+ env,
+ error::Error,
+ fs,
+ path::Path,
+ process::{Command, Stdio},
+};
+
+use regex::{Captures, Regex};
+
+fn main() -> Result<(), Box<dyn Error>> {
+ let folders = ["macros", "parser", "references/rust", "parser/wasm/src"];
+ let version = env::args().nth(1).ok_or("Usage: sync-versions <version>")?;
+ let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
+
+ for folder in folders {
+ let path = root.join(folder);
+ env::set_current_dir(path)?;
+ // Like execFileSync, wait for each update and discard its stdout.
+ let output = Command::new("cambi")
+ .args(["update", &version])
+ .stderr(Stdio::inherit())
+ .output()?;
+ if !output.status.success() {
+ return Err(format!("cambi update failed in {folder}: {}", output.status).into());
+ }
+ }
+
+ // Dependency of milo-macros.
+ // Update it without reformatting the manifest.
+ let main_cargo = root.join("parser/Cargo.toml");
+ let main_cargo_content = fs::read_to_string(&main_cargo)?;
+ let matcher = Regex::new(r#"(?m)^(\s+milo-macros = \{ version = ")([^"]+)(")"#)?;
+ let main_cargo_content = matcher.replace(&main_cargo_content, |captures: &Captures<'_>| {
+ format!("{}{version}{}", &captures[1], &captures[3])
+ });
+ fs::write(main_cargo, main_cargo_content.as_bytes())?;
+ Ok(())
+}
diff --git a/deps/undici/src/deps/milo/scripts/src/lib.rs b/deps/undici/src/deps/milo/scripts/src/lib.rs
new file mode 100644
index 00000000000..666dc6be0d6
--- /dev/null
+++ b/deps/undici/src/deps/milo/scripts/src/lib.rs
@@ -0,0 +1,109 @@
+use std::{error::Error, fs, path::Path};
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+
+// Reuse the layout used by the macros without spawning Cargo at runtime.
+// The macro generator and CLI entry point are unused in this crate.
+#[allow(dead_code)]
+#[path = "../../macros/src/parser_fields.rs"]
+mod parser_fields;
+
+#[derive(Serialize)]
+pub struct Version {
+ pub raw: String,
+ pub major: u64,
+ pub minor: u64,
+ pub patch: u64,
+ pub prerelease: String,
+}
+
+#[derive(Serialize)]
+pub struct BuildInfo {
+ pub version: Version,
+ pub constants: Map<String, Value>,
+}
+
+#[derive(Deserialize)]
+struct Package {
+ version: String,
+}
+
+#[derive(Deserialize)]
+struct Manifest {
+ package: Package,
+}
+
+fn read_yaml_list(name: &str) -> Result<Vec<String>, Box<dyn Error>> {
+ let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
+ let raw = fs::read_to_string(root.join(format!("macros/constants/{name}.yml")))?;
+ Ok(serde_yaml::from_str(&raw)?)
+}
+
+fn read_version() -> Result<Version, Box<dyn Error>> {
+ let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
+ let manifest: Manifest = toml::from_str(&fs::read_to_string(root.join("parser/Cargo.toml"))?)?;
+ let parsed = semver::Version::parse(&manifest.package.version)?;
+ Ok(Version {
+ raw: manifest.package.version,
+ major: parsed.major,
+ minor: parsed.minor,
+ patch: parsed.patch,
+ prerelease: parsed.pre.to_string(),
+ })
+}
+
+fn read_parser_fields() -> Map<String, Value> {
+ // The JavaScript helper spawned Cargo; Rust can reuse the same offsets
+ // directly.
+ parser_fields::FIELDS
+ .iter()
+ .map(|&(name, offset)| (format!("PARSER_FIELD_{name}"), offset.into()))
+ .collect()
+}
+
+/// Reads the current repository inputs, independently of the working directory.
+pub fn get_build_info() -> Result<BuildInfo, Box<dyn Error>> {
+ let version = read_version()?;
+ let methods = read_yaml_list("methods")?;
+ let errors = read_yaml_list("errors")?;
+ let callbacks = read_yaml_list("callbacks")?;
+ let states = read_yaml_list("states")?;
+ let parser_fields = read_parser_fields();
+
+ // Insertion order is part of the generated JSON and downstream bindings.
+ let mut constants = Map::new();
+ for (i, method) in methods.iter().enumerate() {
+ constants.insert(format!("METHOD_{}", method.replace('-', "_")), i.into());
+ }
+ for (i, callback) in callbacks.iter().enumerate() {
+ constants.insert(format!("CALLBACK_{}", callback.to_uppercase()), i.into());
+ }
+ constants.insert("EVENT_END".into(), 0.into());
+ for (i, callback) in callbacks.iter().enumerate() {
+ let name = callback.strip_prefix("on_").unwrap_or(callback).to_uppercase();
+ constants.insert(format!("EVENT_{name}"), (i + 1).into());
+ }
+
+ let mut all = 0;
+ constants.insert("CALLBACK_ACTIVE_NONE".into(), 0.into());
+ constants.insert("EVENT_ACTIVE_NONE".into(), 0.into());
+ for (i, callback) in callbacks.iter().enumerate() {
+ // Match JavaScript's signed 32-bit shifts, including the masked shift count.
+ let bit = 1_i32.wrapping_shl((i % 32) as u32);
+ constants.insert(format!("CALLBACK_ACTIVE_{}", callback.to_uppercase()), bit.into());
+ constants.insert(format!("EVENT_ACTIVE_{}", callback.to_uppercase()), bit.into());
+ all |= bit;
+ }
+ constants.insert("CALLBACK_ACTIVE_ALL".into(), all.into());
+ constants.insert("EVENT_ACTIVE_ALL".into(), all.into());
+ for (i, error) in errors.iter().enumerate() {
+ constants.insert(format!("ERROR_{error}"), i.into());
+ }
+ for (i, state) in states.iter().enumerate() {
+ constants.insert(format!("STATE_{}", state.to_uppercase()), i.into());
+ }
+ constants.extend(parser_fields);
+
+ Ok(BuildInfo { version, constants })
+}
diff --git a/deps/undici/src/docs/docs/api/CacheStore.md b/deps/undici/src/docs/docs/api/CacheStore.md
index 3e30abd5699..45c202d8987 100644
--- a/deps/undici/src/docs/docs/api/CacheStore.md
+++ b/deps/undici/src/docs/docs/api/CacheStore.md
@@ -42,7 +42,8 @@ added: v7.0.0
Stores cached responses in memory. The store enforces upper bounds on the total
number of responses, the total size of all responses, and the size of any single
response. When a limit is exceeded, the store evicts approximately half of its
-entries and emits a [`'maxSizeExceeded'`](#event-maxsizeexceeded) event.
+entries, least recently used first, and emits a
+[`'maxSizeExceeded'`](#event-maxsizeexceeded) event.
```mjs
import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
@@ -163,7 +164,9 @@ added: v7.0.0
-->
Stores cached responses in a SQLite database using the [`node:sqlite`][] API.
-The constructor throws when [`node:sqlite`][] is not available.
+The constructor throws when [`node:sqlite`][] is not available. Response bodies
+larger than `compressThreshold` are stored compressed with zstd and
+decompressed when read back, saving database space.
```mjs
import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
@@ -189,9 +192,16 @@ added: v7.0.0
* `maxEntrySize` {number} The maximum size, in bytes, of a single response
body. Responses whose body exceeds this value are not cached. Must not
exceed `2000000000` (2 GB). **Default:** `2000000000` (2 GB).
+ * `compressThreshold` {number} The size, in bytes, above which a response
+ body is stored compressed with zstd. Responses with an easily compressible
+ Content-Type (e.g. json, xml, plain text) are compressed regardless of
+ size. Requires a Node version with zstd
+ support (22.19+); when unavailable, bodies are stored uncompressed.
+ **Default:** `1048576` (1 MiB).
-`maxCount` and `maxEntrySize` must be non-negative integers; a `TypeError` is
-thrown otherwise, or if `maxEntrySize` is greater than 2 GB.
+`maxCount`, `maxEntrySize`, and `compressThreshold` must be non-negative
+integers; a `TypeError` is thrown otherwise, or if `maxEntrySize` is greater
+than 2 GB.
### `sqliteCacheStore.close()`
@@ -225,7 +235,8 @@ added: v7.0.0
See [`GetResult`](#getresult).
Looks up a cached response for `key`, comparing the request method and every
-header named in the stored `vary` map.
+header named in the stored `vary` map. A body that was stored compressed is
+decompressed before being returned.
### `sqliteCacheStore.set(key, value)`
@@ -240,9 +251,11 @@ added: v7.0.0
* Returns: {undefined}
Writes a response into the database directly, without going through a stream. If
-the body exceeds `maxEntrySize`, nothing is stored. When an entry already exists
-for `key` it is overwritten; otherwise a new row is inserted and old entries are
-pruned to honour `maxCount`. This method is used internally by
+the body exceeds `maxEntrySize`, nothing is stored. A body larger than
+`compressThreshold`, or with an easily compressible Content-Type (e.g. json,
+xml, plain text), is compressed with zstd before being written. When an entry
+already exists for `key` it is overwritten; otherwise a new row is inserted and
+old entries are pruned to honour `maxCount`. This method is used internally by
[`sqliteCacheStore.createWriteStream()`](#sqlitecachestorecreatewritestreamkey-value).
### `sqliteCacheStore.createWriteStream(key, value)`
@@ -260,7 +273,9 @@ added: v7.0.0
Returns a {Writable} stream used to write the response body into the store. When
the stream finishes, the buffered body is committed via
-[`sqliteCacheStore.set()`](#sqlitecachestoresetkey-value). If the body exceeds
+[`sqliteCacheStore.set()`](#sqlitecachestoresetkey-value), where bodies larger
+than `compressThreshold` or with an easily compressible Content-Type are
+compressed with zstd. If the body exceeds
`maxEntrySize`, the stream is destroyed and nothing is stored.
### `sqliteCacheStore.delete(key)`
diff --git a/deps/undici/src/docs/docs/api/Client.md b/deps/undici/src/docs/docs/api/Client.md
index 5f44ae42db8..b81aef5559b 100644
--- a/deps/undici/src/docs/docs/api/Client.md
+++ b/deps/undici/src/docs/docs/api/Client.md
@@ -116,8 +116,8 @@ added: v1.0.0
* `maxConcurrentStreams` {number} _Deprecated: use h2Options.useH2c instead_ The maximum number of concurrent HTTP/2
streams for a single session. Once h2 is negotiated this — not `pipelining`,
which is HTTP/1.1 only — is the ceiling used to dispatch in-flight requests.
- It may be overridden by the server's `SETTINGS_MAX_CONCURRENT_STREAMS`
- frame. **Default:** `100`.
+ The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can lower this limit, but
+ not raise it. **Default:** `100`.
* `connectionWindowSize` {number} _Deprecated: use h2Options.connectionWindowSize instead_ The HTTP/2 connection-level flow-control
window size set via `ClientHttp2Session.setLocalWindowSize()`. Must be a
positive integer. **Default:** `524288`.
@@ -130,8 +130,8 @@ added: v1.0.0
* `maxConcurrentStreams` {number} The maximum number of concurrent HTTP/2
streams for a single session. Once h2 is negotiated this — not `pipelining`,
which is HTTP/1.1 only — is the ceiling used to dispatch in-flight requests.
- It may be overridden by the server's `SETTINGS_MAX_CONCURRENT_STREAMS`
- frame. **Default:** `100`.
+ The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can lower this limit, but
+ not raise it. **Default:** `100`.
* `connectionWindowSize` {number} The HTTP/2 connection-level flow-control
window size set via `ClientHttp2Session.setLocalWindowSize()`. Must be a
positive integer. **Default:** `524288`.
@@ -148,8 +148,13 @@ added: v1.0.0
payloads, and decompressed (`permessage-deflate`) messages. Set to `0` to
disable the limit. **Default:** `134217728`.
* `eventSource` {Object} (optional) EventSource-specific configuration.
- * `maxEventSize` {number} The maximum allowed event size, in bytes, for
- EventSource messages. Set to `0` to disable the limit.
+ * `maxEventSize` {number} The maximum total bytes of data and metadata
+ field values retained for a pending EventSource event. Each unfinished
+ line is separately limited to this value plus seven syntax bytes, before
+ its line ending arrives. The number of `data:` lines per event and input
+ chunks buffered for an unfinished line are each limited to
+ `min(131072, max(1024, floor(maxEventSize / 128)))` to bound object overhead.
+ Set to `0` to disable these limits.
**Default:** `buffer.kStringMaxLength`.
* Returns: {Client}
diff --git a/deps/undici/src/docs/docs/api/Dispatcher.md b/deps/undici/src/docs/docs/api/Dispatcher.md
index c85705b4c52..4e3c1293130 100644
--- a/deps/undici/src/docs/docs/api/Dispatcher.md
+++ b/deps/undici/src/docs/docs/api/Dispatcher.md
@@ -209,6 +209,9 @@ added: v4.0.0
* `path` {string} The request path.
* `method` {string} The HTTP method, e.g. `'GET'` or `'POST'`.
* `body` {string|Buffer|Uint8Array|Readable|FormData|null} The request body.
+ Undici's network clients require a `FormData` body created by the same
+ undici package instance. A body from another source, including Node.js's
+ built-in `FormData`, is rejected with an `InvalidArgumentError`.
**Default:** `null`.
* `headers` {UndiciHeaders} Request headers. **Default:** `null`.
* `query` {Object} Query string parameters embedded into the request URL. Both
diff --git a/deps/undici/src/docs/docs/api/Errors.md b/deps/undici/src/docs/docs/api/Errors.md
index d390bfaeb00..c71d61d77a5 100644
--- a/deps/undici/src/docs/docs/api/Errors.md
+++ b/deps/undici/src/docs/docs/api/Errors.md
@@ -18,7 +18,7 @@ if (err instanceof errors.ConnectTimeoutError) {
}
```
-All errors, except [`HTTPParserError`][], extend [`UndiciError`][]. Each error
+All errors, except [`HTTPParserError`][] and `WebAssemblyNotSupportedError`, extend [`UndiciError`][]. Each error
carries a stable `code` string (for example `UND_ERR_CONNECT_TIMEOUT`) and a
`name`.
@@ -32,6 +32,37 @@ if (err.code === 'UND_ERR_CONNECT_TIMEOUT') {
}
```
+## Timeout-related errors
+
+The timeout errors below are controlled by dispatcher/client options:
+
+| Error code | When it is thrown | Related option |
+| ---------- | ----------------- | -------------- |
+| `UND_ERR_CONNECT_TIMEOUT` | A connection could not be established before the connection timeout elapsed. | [`connect.timeout`](Client.md) |
+| `UND_ERR_HEADERS_TIMEOUT` | The full response headers were not received before the headers timeout elapsed. | [`headersTimeout`](Client.md) |
+| `UND_ERR_BODY_TIMEOUT` | While reading the response body, no new data arrived before the body timeout elapsed. | [`bodyTimeout`](Client.md) |
+| `UND_ERR_SOCKET` | A generic socket-level failure happened. | Inspect `error.socket` for connection details. |
+
+### Configuring timeouts for `fetch`
+
+If you are using `fetch` (including Node.js built-in `fetch`), configure timeouts
+through the global dispatcher:
+
+```js
+import { Agent, setGlobalDispatcher, fetch } from 'undici'
+
+setGlobalDispatcher(new Agent({
+ connect: { timeout: 10_000 }, // connection phase
+ headersTimeout: 15_000, // wait for response headers
+ bodyTimeout: 30_000 // wait between response body chunks
+}))
+
+await fetch('https://example.com/data')
+```
+
+You can inspect timeout error codes from `error.code` or (for wrapped fetch
+errors) from `error.cause?.code`.
+
## Class: `UndiciError`
<!-- YAML
@@ -52,6 +83,35 @@ on a well-known symbol rather than the prototype chain.
* `name` {string} Always `'UndiciError'`.
* `code` {string} Always `'UND_ERR'`.
+## Class: `WebAssemblyNotSupportedError`
+
+* Extends: {Error}
+
+WebAssembly is unavailable when Undici initializes its HTTP/1 parser. Undici does
+not provide an alternative parser for environments without WebAssembly, including
+Node.js configurations where `--jitless` disables it. The check is performed when
+the parser is needed, not when importing Undici or accessing `fetch`.
+
+* `name` {string} Always `'Error'`.
+* `code` {string} Always `'ERR_WEBASSEMBLY_NOT_SUPPORTED'`.
+* `message` {string} By default `'WebAssembly is not supported in this environment, but is required for HTTP/1 parsing'`.
+
+Client and dispatcher requests report this error directly. `fetch` rejects with
+a `TypeError` whose `cause` is this error:
+
+```js
+try {
+ await fetch('http://localhost:3000')
+} catch (error) {
+ if (error.cause?.code === 'ERR_WEBASSEMBLY_NOT_SUPPORTED') {
+ // HTTP/1 parsing requires WebAssembly in this environment.
+ }
+}
+```
+
+`Headers`, `FormData`, `Request`, `Response`, and other operations that do not need
+the HTTP/1 parser remain usable without WebAssembly.
+
## Class: `ConnectTimeoutError`
<!-- YAML
@@ -436,6 +496,7 @@ The response returned an error status code. This is raised, for example, when th
* `code` {string} Always `'UND_ERR_RESPONSE'`.
* `statusCode` {number} The HTTP status code of the response.
* `body` {Object|string|null} The response body.
+* `bodyTruncated` {boolean} Whether `body` was truncated by a configured limit.
* `headers` {Object|string[]|null} The response headers.
### `new ResponseError(message, code, options)`
@@ -445,6 +506,7 @@ The response returned an error status code. This is raised, for example, when th
* `options` {Object}
* `headers` {Object|string[]|null} The response headers. (optional)
* `body` {Object|string|null} The response body. (optional)
+ * `bodyTruncated` {boolean} Whether `body` was truncated. **Default:** `false`.
## Class: `ProxyConnectionError`
@@ -512,6 +574,19 @@ The maximum number of allowed origins has been reached.
* `name` {string} Always `'MaxOriginsReachedError'`.
* `code` {string} Always `'UND_ERR_MAX_ORIGINS_REACHED'`.
+## Class: `MaxRedirectsError`
+
+<!-- YAML
+added: v8.12.0
+-->
+
+* Extends: {UndiciError}
+
+The maximum number of redirects has been reached.
+
+* `name` {string} Always `'MaxRedirectsError'`.
+* `code` {string} Always `'UND_ERR_REDIRECT_MAX'`.
+
## Class: `Socks5ProxyError`
<!-- YAML
diff --git a/deps/undici/src/docs/docs/api/H2CClient.md b/deps/undici/src/docs/docs/api/H2CClient.md
index 298a7d4c688..2a48dc037d9 100644
--- a/deps/undici/src/docs/docs/api/H2CClient.md
+++ b/deps/undici/src/docs/docs/api/H2CClient.md
@@ -55,8 +55,9 @@ added: v7.7.0
hostname, and port. Only the `http:` protocol is supported.
* `options` {H2CClientOptions} (optional)
* `maxConcurrentStreams` {number} The maximum number of concurrent HTTP/2
- streams for the session. It is advertised to the server and may be overridden
- by a remote `SETTINGS` frame. Must be a positive integer. **Default:** `100`.
+ streams for the session. The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can
+ lower this limit, but not raise it. Must be a positive integer.
+ **Default:** `100`.
* `pipelining` {number} The number of concurrent requests multiplexed over the
single connection. For an `H2CClient` this is aliased to
`maxConcurrentStreams` and may not exceed it. Must be a positive integer.
diff --git a/deps/undici/src/docs/docs/api/Interceptors.md b/deps/undici/src/docs/docs/api/Interceptors.md
index 4eefc17aec6..ce4015ada81 100644
--- a/deps/undici/src/docs/docs/api/Interceptors.md
+++ b/deps/undici/src/docs/docs/api/Interceptors.md
@@ -163,9 +163,10 @@ Follows HTTP redirects (3xx responses) automatically.
* `maxRedirections` {number} Maximum number of redirects to follow. Passing
`0` disables redirect following entirely. **Default:** `undefined`
(inherits from the per-request `maxRedirections` option).
- * `throwOnMaxRedirect` {boolean} When `true`, throws an error once the
- redirect limit is reached instead of returning the final redirect response.
- **Default:** `false`.
+ * `throwOnMaxRedirect` {boolean} When `true`, throws an error when a
+ redirect would be followed but the redirect limit has been reached, instead
+ of returning that redirect response. A non-redirect response after exactly
+ `maxRedirections` redirects is returned normally. **Default:** `false`.
* `stripHeadersOnRedirect` {string[]} List of header names to remove from
the request when following any redirect. **Default:** `[]`.
* `stripHeadersOnCrossOriginRedirect` {string[]} List of header names to
@@ -198,7 +199,10 @@ const agent = new Agent().compose(
## `interceptors.decompress([opts])`
Automatically decompresses response bodies encoded with `gzip`, `x-gzip`,
-`br` (Brotli), `deflate`, `compress`, `x-compress`, or `zstd`.
+`br` (Brotli), `deflate`, or `zstd`. Any other coding, including `compress`
+and `x-compress`, is left untouched, matching `fetch()`. As required by
+[RFC 9659](https://www.rfc-editor.org/rfc/rfc9659.html), a `zstd` frame that
+requires a window size larger than 8 MB fails to decode.
> **Experimental:** This interceptor is experimental and subject to change.
> A one-time `ExperimentalWarning` is emitted on first use.
@@ -244,8 +248,11 @@ The error body is automatically decoded for `application/json` and
**Parameters**
-* `opts` {Object} (optional) — currently reserved for future use; may be
- omitted.
+* `opts` {Object} (optional)
+ * `maxSize` {number} Maximum number of response body bytes to include in the
+ error. If the body exceeds this limit, the resulting `ResponseError`
+ contains the retained prefix with `bodyTruncated` set to `true`. Set to `0`
+ to disable the limit. **Default:** `1048576` (1 MiB).
**Returns:** {Dispatcher.DispatcherComposeInterceptor}
diff --git a/deps/undici/src/docs/docs/api/RedirectHandler.md b/deps/undici/src/docs/docs/api/RedirectHandler.md
index cedb0291d8a..c90cb37b62f 100644
--- a/deps/undici/src/docs/docs/api/RedirectHandler.md
+++ b/deps/undici/src/docs/docs/api/RedirectHandler.md
@@ -57,9 +57,10 @@ added: v4.0.0
* `opts` {DispatchOptions} The dispatch options for the request. In addition to
the standard dispatch options, the following redirect-specific fields are
recognized:
- * `throwOnMaxRedirect` {boolean} When `true`, an error is thrown once
- `maxRedirections` is reached instead of returning the last redirect response.
- **Default:** `false`.
+ * `throwOnMaxRedirect` {boolean} When `true`, an error is thrown when a
+ redirect would be followed but `maxRedirections` has been reached, instead of
+ returning that redirect response. A non-redirect response after exactly
+ `maxRedirections` redirects is returned normally. **Default:** `false`.
* `stripHeadersOnRedirect` {string[]} Header names to remove from the request on
every redirect hop. **Default:** `null`.
* `stripHeadersOnCrossOriginRedirect` {string[]} Additional header names to
@@ -165,13 +166,15 @@ added: v7.0.0
* `statusMessage` {string} The HTTP status message.
Inspects the response headers to decide whether to follow a redirect. When the
-status code is redirectable, the `maxRedirections` limit has not been reached, and
-the request body has not been consumed, the `location` property is set, the method
-and headers are adjusted for the next hop, and the response is not forwarded.
-Otherwise the event is forwarded to the wrapped `handler`.
-
-Throws when `throwOnMaxRedirect` is `true` and the number of recorded redirects
-has reached `maxRedirections`, and throws an [`InvalidArgumentError`][] if a
+status code is redirectable, the response has a `Location` header, the
+`maxRedirections` limit has not been reached, and the request body has not been
+consumed, the `location` property is set, the method and headers are adjusted
+for the next hop, and the response is not forwarded. Otherwise the event is
+forwarded to the wrapped `handler`.
+
+Throws when `throwOnMaxRedirect` is `true` and a redirect that would otherwise be
+followed arrives after `maxRedirections` redirects have already been followed,
+and throws an [`InvalidArgumentError`][] if a
redirect loop is detected (for example when a [`Client`][] or [`Pool`][] is used
for a cross-origin redirect; use an [`Agent`][] instead).
diff --git a/deps/undici/src/docs/docs/index.md b/deps/undici/src/docs/docs/index.md
index 341f2d0ab56..bb402702ee7 100644
--- a/deps/undici/src/docs/docs/index.md
+++ b/deps/undici/src/docs/docs/index.md
@@ -13,7 +13,7 @@ It is also a Stranger Things reference.
Have a question about using Undici? Open a [Q&A Discussion](https://github.com/nodejs/undici/discussions/new) or join our official OpenJS [Slack](https://openjs-foundation.slack.com/archives/C01QF9Q31QD) channel.
-Looking to contribute? Start by reading the [contributing guide](./CONTRIBUTING.md)
+Looking to contribute? Start by reading the [contributing guide](https://github.com/nodejs/undici/blob/main/CONTRIBUTING.md)
## Install
@@ -417,7 +417,7 @@ For more information about their behavior, please reference the body mixin from
## Common API Methods
-This section documents our most commonly used API methods. Additional APIs are documented in their own files within the [docs](./docs/) folder and are accessible via the navigation list on the left side of the docs site.
+This section documents our most commonly used API methods. Additional APIs are documented in their own files within the [`api`](./api/) folder and are accessible via the navigation list on the left side of the docs site.
For the top-level APIs below, the `url` argument supplies the request origin and
path. Do not pass `origin` or `path` in the second `options` argument. The linked
@@ -427,19 +427,19 @@ lower-level APIs that do not receive a separate `url` argument.
### `undici.request([url, options])`
* `url` {string|URL|UrlObject}
-* `options` {RequestOptions} See [`RequestOptions`](./docs/docs/api/Dispatcher.md#parameter-requestoptions).
+* `options` {RequestOptions} See [`RequestOptions`](./api/Dispatcher.md#parameter-requestoptions).
* `dispatcher` {Dispatcher} **Default:** [getGlobalDispatcher](#undicigetglobaldispatcher).
* `method` {string} **Default:** `PUT` if `options.body`, otherwise `GET`.
* Returns: {Promise} A promise with the result of the `Dispatcher.request` method.
Calls `options.dispatcher.request(options)`.
-See [Dispatcher.request](./docs/docs/api/Dispatcher.md#dispatcherrequestoptions-callback) for more details, and [request examples](./docs/examples/README.md) for examples.
+See [Dispatcher.request](./api/Dispatcher.md#dispatcherrequestoptions-callback) for more details, and [request examples](https://github.com/nodejs/undici/blob/main/docs/examples/README.md) for examples.
### `undici.stream([url, options, ]factory)`
* `url` {string|URL|UrlObject}
-* `options` {StreamOptions} See [`StreamOptions`](./docs/docs/api/Dispatcher.md#parameter-streamoptions).
+* `options` {StreamOptions} See [`StreamOptions`](./api/Dispatcher.md#parameter-streamoptions).
* `dispatcher` {Dispatcher} **Default:** [getGlobalDispatcher](#undicigetglobaldispatcher).
* `method` {string} **Default:** `PUT` if `options.body`, otherwise `GET`.
* `factory` {Function} `Dispatcher.stream.factory`.
@@ -447,12 +447,12 @@ See [Dispatcher.request](./docs/docs/api/Dispatcher.md#dispatcherrequestoptions-
Calls `options.dispatcher.stream(options, factory)`.
-See [Dispatcher.stream](./docs/docs/api/Dispatcher.md#dispatcherstreamoptions-factory-callback) for more details.
+See [Dispatcher.stream](./api/Dispatcher.md#dispatcherstreamoptions-factory-callback) for more details.
### `undici.pipeline([url, options, ]handler)`
* `url` {string|URL|UrlObject}
-* `options` {PipelineOptions} See [`PipelineOptions`](./docs/docs/api/Dispatcher.md#parameter-pipelineoptions).
+* `options` {PipelineOptions} See [`PipelineOptions`](./api/Dispatcher.md#parameter-pipelineoptions).
* `dispatcher` {Dispatcher} **Default:** [getGlobalDispatcher](#undicigetglobaldispatcher).
* `method` {string} **Default:** `PUT` if `options.body`, otherwise `GET`.
* `handler` {Function} `Dispatcher.pipeline.handler`.
@@ -460,21 +460,21 @@ See [Dispatcher.stream](./docs/docs/api/Dispatcher.md#dispatcherstreamoptions-fa
Calls `options.dispatch.pipeline(options, handler)`.
-See [Dispatcher.pipeline](./docs/docs/api/Dispatcher.md#dispatcherpipelineoptions-handler) for more details.
+See [Dispatcher.pipeline](./api/Dispatcher.md#dispatcherpipelineoptions-handler) for more details.
### `undici.connect([url, options])`
Starts two-way communications with the requested resource using [HTTP CONNECT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/CONNECT).
* `url` {string|URL|UrlObject}
-* `options` {ConnectOptions} See [`ConnectOptions`](./docs/docs/api/Dispatcher.md#parameter-connectoptions).
+* `options` {ConnectOptions} See [`ConnectOptions`](./api/Dispatcher.md#parameter-connectoptions).
* `dispatcher` {Dispatcher} **Default:** [getGlobalDispatcher](#undicigetglobaldispatcher).
* `callback` {Function} (optional) — `(err, data) => void`.
* Returns: {Promise} A promise with the result of the `Dispatcher.connect` method.
Calls `options.dispatch.connect(options)`.
-See [Dispatcher.connect](./docs/docs/api/Dispatcher.md#dispatcherconnectoptions-callback) for more details.
+See [Dispatcher.connect](./api/Dispatcher.md#dispatcherconnectoptions-callback) for more details.
### `undici.fetch(input[, init])`
@@ -647,14 +647,14 @@ Undici limits the number of `Content-Encoding` layers in a response to **5** to
Upgrade to a different protocol. See [MDN - HTTP - Protocol upgrade mechanism](https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism) for more details.
* `url` {string|URL|UrlObject}
-* `options` {UpgradeOptions} See [`UpgradeOptions`](./docs/docs/api/Dispatcher.md#parameter-upgradeoptions).
+* `options` {UpgradeOptions} See [`UpgradeOptions`](./api/Dispatcher.md#parameter-upgradeoptions).
* `dispatcher` {Dispatcher} **Default:** [getGlobalDispatcher](#undicigetglobaldispatcher).
* `callback` {Function} (optional) — `(error, data) => void`.
* Returns: {Promise} A promise with the result of the `Dispatcher.upgrade` method.
Calls `options.dispatcher.upgrade(options)`.
-See [Dispatcher.upgrade](./docs/docs/api/Dispatcher.md#dispatcherupgradeoptions-callback) for more details.
+See [Dispatcher.upgrade](./api/Dispatcher.md#dispatcherupgradeoptions-callback) for more details.
### `undici.setGlobalDispatcher(dispatcher)`
diff --git a/deps/undici/src/docs/docs/type-map.json b/deps/undici/src/docs/docs/type-map.json
index 307b159bc89..0bf7c089ae8 100644
--- a/deps/undici/src/docs/docs/type-map.json
+++ b/deps/undici/src/docs/docs/type-map.json
@@ -1,79 +1,79 @@
{
- "AbortError": "/api/Errors.md#class-aborterror",
- "Agent": "/api/Agent.md#class-agent",
- "AgentDispatchOptions": "/api/Agent.md#agentdispatchoptions-handler",
- "AgentOptions": "/api/Agent.md#new-agentoptions",
- "BalancedPool": "/api/BalancedPool.md#class-balancedpool",
- "BalancedPoolOptions": "/api/BalancedPool.md#parameter-balancedpooloptions",
- "BodyMixin": "/api/Fetch.md#new-formdata",
+ "AbortError": "/api/Errors.html#class-aborterror",
+ "Agent": "/api/Agent.html#class-agent",
+ "AgentDispatchOptions": "/api/Agent.html#agentdispatchoptions-handler",
+ "AgentOptions": "/api/Agent.html#new-agentoptions",
+ "BalancedPool": "/api/BalancedPool.html#class-balancedpool",
+ "BalancedPoolOptions": "/api/BalancedPool.html#parameter-balancedpooloptions",
+ "BodyMixin": "/api/Fetch.html#new-formdata",
"Buffer": "https://nodejs.org/api/buffer.html#class-buffer",
- "BuildOptions": "/api/Connector.md#buildconnectoroptions",
- "CacheKey": "/api/CacheStore.md#cachekey",
- "CacheStore": "/api/CacheStore.md#new-memorycachestoreoptions",
- "CacheValue": "/api/CacheStore.md#cachevalue",
- "ClientDestroyedError": "/api/Errors.md#class-clientdestroyederror",
- "ClientOptions": "/api/Client.md#new-clienturl-options",
- "ClientStats": "/api/ClientStats.md#class-clientstats",
- "ConnectOptions": "/api/Dispatcher.md#class-dispatcher",
- "Cookie": "/api/Cookies.md#cookie",
- "DispatchController": "/api/Dispatcher.md#class-dispatcher",
- "DispatchHandler": "/api/Dispatcher.md#class-dispatcher",
- "DispatchOptions": "/api/Dispatcher.md#class-dispatcher",
- "Dispatcher": "/api/Dispatcher.md#class-dispatcher",
+ "BuildOptions": "/api/Connector.html#buildconnectoroptions",
+ "CacheKey": "/api/CacheStore.html#cachekey",
+ "CacheStore": "/api/CacheStore.html#new-memorycachestoreoptions",
+ "CacheValue": "/api/CacheStore.html#cachevalue",
+ "ClientDestroyedError": "/api/Errors.html#class-clientdestroyederror",
+ "ClientOptions": "/api/Client.html#new-clienturl-options",
+ "ClientStats": "/api/ClientStats.html#class-clientstats",
+ "ConnectOptions": "/api/Dispatcher.html#class-dispatcher",
+ "Cookie": "/api/Cookies.html#cookie",
+ "DispatchController": "/api/Dispatcher.html#class-dispatcher",
+ "DispatchHandler": "/api/Dispatcher.html#class-dispatcher",
+ "DispatchOptions": "/api/Dispatcher.html#class-dispatcher",
+ "Dispatcher": "/api/Dispatcher.html#class-dispatcher",
"Duplex": "https://nodejs.org/api/stream.html#class-streamduplex",
- "EnvHttpProxyAgent": "/api/EnvHttpProxyAgent.md#class-envhttpproxyagent",
- "EnvHttpProxyAgentOptions": "/api/EnvHttpProxyAgent.md#new-envhttpproxyagentoptions",
+ "EnvHttpProxyAgent": "/api/EnvHttpProxyAgent.html#class-envhttpproxyagent",
+ "EnvHttpProxyAgentOptions": "/api/EnvHttpProxyAgent.html#new-envhttpproxyagentoptions",
"EventEmitter": "https://nodejs.org/api/events.html#class-eventemitter",
- "GetResult": "/api/CacheStore.md#getresult",
- "H2CClientOptions": "/api/H2CClient.md#new-h2cclienturl-options",
+ "GetResult": "/api/CacheStore.html#getresult",
+ "H2CClientOptions": "/api/H2CClient.html#new-h2cclienturl-options",
"HeadersInit": "https://developer.mozilla.org/docs/Web/API/Headers/Headers",
- "InvalidArgumentError": "/api/Errors.md#class-invalidargumenterror",
+ "InvalidArgumentError": "/api/Errors.html#class-invalidargumenterror",
"Iterable": "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Iteration_protocols",
- "MaxOriginsReachedError": "/api/Errors.md#class-maxoriginsreachederror",
- "MockAgent": "/api/MockAgent.md#class-mockagent",
- "MockAgentOptions": "/api/MockAgent.md#parameter-mockagentoptions",
- "MockCallHistory": "/api/MockCallHistory.md#class-mockcallhistory",
- "MockCallHistoryLog": "/api/MockCallHistoryLog.md#class-mockcallhistorylog",
- "MockClient": "/api/MockClient.md#class-mockclient",
- "MockClientOptions": "/api/MockClient.md#parameter-mockclientoptions",
- "MockInterceptor": "/api/MockPool.md#return-mockinterceptor",
- "MockInterceptor.Options": "/api/MockPool.md#parameter-mockpoolinterceptoptions",
- "MockPool": "/api/MockPool.md#class-mockpool",
- "MockPoolInterceptOptions": "/api/MockPool.md#parameter-mockpoolinterceptoptions",
- "MockPoolOptions": "/api/MockPool.md#parameter-mockpooloptions",
- "MockResponseOptions": "/api/MockPool.md#parameter-mockresponseoptions",
- "MockScope": "/api/MockPool.md#return-mockscope",
- "PendingInterceptor": "/api/MockAgent.md#new-mockagentoptions",
- "PipelineOptions": "/api/Dispatcher.md#class-dispatcher",
- "Pool": "/api/Pool.md#class-pool",
- "PoolOptions": "/api/Pool.md#new-poolurl-options",
- "PoolStats": "/api/PoolStats.md#class-poolstats",
- "ProxyAgent": "/api/ProxyAgent.md#class-proxyagent",
- "ProxyAgentOptions": "/api/ProxyAgent.md#new-proxyagentoptions",
+ "MaxOriginsReachedError": "/api/Errors.html#class-maxoriginsreachederror",
+ "MockAgent": "/api/MockAgent.html#class-mockagent",
+ "MockAgentOptions": "/api/MockAgent.html#parameter-mockagentoptions",
+ "MockCallHistory": "/api/MockCallHistory.html#class-mockcallhistory",
+ "MockCallHistoryLog": "/api/MockCallHistoryLog.html#class-mockcallhistorylog",
+ "MockClient": "/api/MockClient.html#class-mockclient",
+ "MockClientOptions": "/api/MockClient.html#parameter-mockclientoptions",
+ "MockInterceptor": "/api/MockPool.html#return-mockinterceptor",
+ "MockInterceptor.Options": "/api/MockPool.html#parameter-mockpoolinterceptoptions",
+ "MockPool": "/api/MockPool.html#class-mockpool",
+ "MockPoolInterceptOptions": "/api/MockPool.html#parameter-mockpoolinterceptoptions",
+ "MockPoolOptions": "/api/MockPool.html#parameter-mockpooloptions",
+ "MockResponseOptions": "/api/MockPool.html#parameter-mockresponseoptions",
+ "MockScope": "/api/MockPool.html#return-mockscope",
+ "PendingInterceptor": "/api/MockAgent.html#new-mockagentoptions",
+ "PipelineOptions": "/api/Dispatcher.html#class-dispatcher",
+ "Pool": "/api/Pool.html#class-pool",
+ "PoolOptions": "/api/Pool.html#new-poolurl-options",
+ "PoolStats": "/api/PoolStats.html#class-poolstats",
+ "ProxyAgent": "/api/ProxyAgent.html#class-proxyagent",
+ "ProxyAgentOptions": "/api/ProxyAgent.html#new-proxyagentoptions",
"Readable": "https://nodejs.org/api/stream.html#class-streamreadable",
"Record": "https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type",
- "RequestInit": "/api/Fetch.md#new-formdata",
- "RequestOptions": "/api/Dispatcher.md#class-dispatcher",
- "ResponseInit": "/api/Fetch.md#new-formdata",
- "RetryContext": "/api/RetryHandler.md#retrycontext",
- "RetryHandler": "/api/RetryHandler.md#class-retryhandler",
- "RetryHandlers": "/api/RetryHandler.md#parameter-retryhandlers",
- "RetryOptions": "/api/RetryHandler.md#retryoptions",
- "RetryState": "/api/RetryHandler.md#retrystate",
- "RoundRobinPoolOptions": "/api/RoundRobinPool.md#parameter-roundrobinpooloptions",
- "SnapshotRecorder": "/api/SnapshotAgent.md#new-snapshotagentoptions",
+ "RequestInit": "/api/Fetch.html#new-formdata",
+ "RequestOptions": "/api/Dispatcher.html#class-dispatcher",
+ "ResponseInit": "/api/Fetch.html#new-formdata",
+ "RetryContext": "/api/RetryHandler.html#retrycontext",
+ "RetryHandler": "/api/RetryHandler.html#class-retryhandler",
+ "RetryHandlers": "/api/RetryHandler.html#parameter-retryhandlers",
+ "RetryOptions": "/api/RetryHandler.html#retryoptions",
+ "RetryState": "/api/RetryHandler.html#retrystate",
+ "RoundRobinPoolOptions": "/api/RoundRobinPool.html#parameter-roundrobinpooloptions",
+ "SnapshotRecorder": "/api/SnapshotAgent.html#new-snapshotagentoptions",
"Socket": "https://nodejs.org/api/net.html#class-netsocket",
- "SocketInfo": "/api/Errors.md#new-requestretryerrormessage-code-options",
- "StreamOptions": "/api/Dispatcher.md#class-dispatcher",
+ "SocketInfo": "/api/Errors.html#new-requestretryerrormessage-code-options",
+ "StreamOptions": "/api/Dispatcher.html#class-dispatcher",
"TLSSocket": "https://nodejs.org/api/tls.html#class-tlstlssocket",
- "UndiciError": "/api/Errors.md#class-undicierror",
- "UndiciHeaders": "/api/Dispatcher.md#class-dispatcher",
- "UpgradeOptions": "/api/Dispatcher.md#class-dispatcher",
- "UrlObject": "/index.md#urlobject",
- "WebSocketInit": "/api/WebSocket.md#new-websocketurl-protocols",
- "WebSocketStreamOptions": "/api/WebSocket.md#new-websocketurl-protocols",
+ "UndiciError": "/api/Errors.html#class-undicierror",
+ "UndiciHeaders": "/api/Dispatcher.html#class-dispatcher",
+ "UpgradeOptions": "/api/Dispatcher.html#class-dispatcher",
+ "UrlObject": "/index.html#urlobject",
+ "WebSocketInit": "/api/WebSocket.html#new-websocketurl-protocols",
+ "WebSocketStreamOptions": "/api/WebSocket.html#new-websocketurl-protocols",
"Writable": "https://nodejs.org/api/stream.html#class-streamwritable",
- "buildConnector.BuildOptions": "/api/Connector.md#buildconnectoroptions",
+ "buildConnector.BuildOptions": "/api/Connector.html#buildconnectoroptions",
"net.Socket": "https://nodejs.org/api/net.html#class-netsocket",
"stream.Readable": "https://nodejs.org/api/stream.html#class-streamreadable"
-}
\ No newline at end of file
+}
diff --git a/deps/undici/src/eslint.config.js b/deps/undici/src/eslint.config.js
index d768afe6b9b..ab6d247f020 100644
--- a/deps/undici/src/eslint.config.js
+++ b/deps/undici/src/eslint.config.js
@@ -6,6 +6,8 @@ const { installedExports } = require('./lib/global')
module.exports = [
...neo({
ignores: [
+ 'deps/milo',
+ 'lib/milo',
'lib/llhttp',
'test/fixtures/cache-tests',
'undici-fetch.js',
diff --git a/deps/undici/src/lib/cache/memory-cache-store.js b/deps/undici/src/lib/cache/memory-cache-store.js
index 07dba9c3988..7aeba57fe46 100644
--- a/deps/undici/src/lib/cache/memory-cache-store.js
+++ b/deps/undici/src/lib/cache/memory-cache-store.js
@@ -100,6 +100,11 @@ class MemoryCacheStore extends EventEmitter {
const entry = entries ? findEntry(key, entries, now) : null
+ if (entry != null) {
+ this.#entries.delete(topLevelKey)
+ this.#entries.set(topLevelKey, entries)
+ }
+
return entry == null
? undefined
: {
@@ -148,11 +153,13 @@ class MemoryCacheStore extends EventEmitter {
},
final (callback) {
let entries = store.#entries.get(topLevelKey)
- if (!entries) {
+ if (entries) {
+ store.#entries.delete(topLevelKey)
+ } else {
entries = []
- store.#entries.set(topLevelKey, entries)
}
- const previousEntry = findEntry(key, entries, Date.now())
+ store.#entries.set(topLevelKey, entries)
+ const previousEntry = findEntry(key, entries, -Infinity)
if (previousEntry) {
const index = entries.indexOf(previousEntry)
entries.splice(index, 1, entry)
@@ -177,16 +184,7 @@ class MemoryCacheStore extends EventEmitter {
store.#hasEmittedMaxSizeEvent = true
}
- // Perform eviction
- for (const [key, entries] of store.#entries) {
- for (const entry of entries.splice(0, Math.ceil(entries.length / 2))) {
- store.#size -= entry.size
- store.#count -= 1
- }
- if (entries.length === 0) {
- store.#entries.delete(key)
- }
- }
+ store.#evict(entry)
// Reset the event flag after eviction
if (store.#size < store.#maxSize && store.#count < store.#maxCount) {
@@ -199,6 +197,43 @@ class MemoryCacheStore extends EventEmitter {
})
}
+ #evict (keep) {
+ const targetSize = this.#maxSize / 2
+ const targetCount = this.#maxCount / 2
+
+ for (const [key, entries] of this.#entries) {
+ for (let i = 0; i < entries.length && (this.#size > targetSize || this.#count > targetCount);) {
+ const entry = entries[i]
+ if (entry === keep) {
+ i++
+ continue
+ }
+ entries.splice(i, 1)
+ this.#size -= entry.size
+ this.#count -= 1
+ }
+
+ if (entries.length === 0) {
+ this.#entries.delete(key)
+ }
+
+ if (this.#size <= targetSize && this.#count <= targetCount) {
+ return
+ }
+ }
+
+ if (this.#size > this.#maxSize || this.#count > this.#maxCount) {
+ const topLevelKey = `${keep.origin}:${keep.path}`
+ const entries = this.#entries.get(topLevelKey)
+ entries.splice(entries.indexOf(keep), 1)
+ this.#size -= keep.size
+ this.#count -= 1
+ if (entries.length === 0) {
+ this.#entries.delete(topLevelKey)
+ }
+ }
+ }
+
/**
* @param {CacheKey} key
*/
diff --git a/deps/undici/src/lib/cache/sqlite-cache-store.js b/deps/undici/src/lib/cache/sqlite-cache-store.js
index ab97da6b5e4..d17b13241b1 100644
--- a/deps/undici/src/lib/cache/sqlite-cache-store.js
+++ b/deps/undici/src/lib/cache/sqlite-cache-store.js
@@ -2,14 +2,22 @@
const { Writable } = require('node:stream')
const { assertCacheKey, assertCacheValue } = require('../util/cache.js')
+const { zstdCompressSync, zstdDecompressSync } = require('node:zlib')
let DatabaseSync
-const VERSION = 3
+const VERSION = 4
// 2gb
const MAX_ENTRY_SIZE = 2 * 1000 * 1000 * 1000
+// 1MiB
+const COMPRESS_THRESHOLD = 1024 * 1024
+
+// zstd support landed in Node 22.19.0/23.4.0, so it may be missing even when
+// node:sqlite is available.
+const hasZstd = typeof zstdCompressSync === 'function' && typeof zstdDecompressSync === 'function'
+
/**
* @typedef {import('../../types/cache-interceptor.d.ts').default.CacheStore} CacheStore
* @implements {CacheStore}
@@ -17,6 +25,7 @@ const MAX_ENTRY_SIZE = 2 * 1000 * 1000 * 1000
* @typedef {{
* id: Readonly<number>,
* body?: Uint8Array
+ * compressed?: string
* statusCode: number
* statusMessage: string
* headers?: string
@@ -31,6 +40,7 @@ const MAX_ENTRY_SIZE = 2 * 1000 * 1000 * 1000
module.exports = class SqliteCacheStore {
#maxEntrySize = MAX_ENTRY_SIZE
#maxCount = Infinity
+ #compressThreshold = COMPRESS_THRESHOLD
/**
* @type {import('node:sqlite').DatabaseSync}
@@ -107,6 +117,17 @@ module.exports = class SqliteCacheStore {
}
this.#maxCount = opts.maxCount
}
+
+ if (opts.compressThreshold !== undefined) {
+ if (
+ typeof opts.compressThreshold !== 'number' ||
+ !Number.isInteger(opts.compressThreshold) ||
+ opts.compressThreshold < 0
+ ) {
+ throw new TypeError('SqliteCacheStore options.compressThreshold must be a non-negative integer')
+ }
+ this.#compressThreshold = opts.compressThreshold
+ }
}
if (!DatabaseSync) {
@@ -128,6 +149,7 @@ module.exports = class SqliteCacheStore {
-- Data returned to the interceptor
body BUF NULL,
+ compressed TEXT NULL,
deleteAt INTEGER NOT NULL,
statusCode INTEGER NOT NULL,
statusMessage TEXT NOT NULL,
@@ -147,6 +169,7 @@ module.exports = class SqliteCacheStore {
SELECT
id,
body,
+ compressed,
deleteAt,
statusCode,
statusMessage,
@@ -167,6 +190,7 @@ module.exports = class SqliteCacheStore {
this.#updateValueQuery = this.#db.prepare(`
UPDATE cacheInterceptorV${VERSION} SET
body = ?,
+ compressed = ?,
deleteAt = ?,
statusCode = ?,
statusMessage = ?,
@@ -185,6 +209,7 @@ module.exports = class SqliteCacheStore {
url,
method,
body,
+ compressed,
deleteAt,
statusCode,
statusMessage,
@@ -194,7 +219,7 @@ module.exports = class SqliteCacheStore {
vary,
cachedAt,
staleAt
- ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`)
this.#deleteByUrlQuery = this.#db.prepare(
@@ -237,7 +262,11 @@ module.exports = class SqliteCacheStore {
const value = this.#findValue(key)
return value
? {
- body: value.body ? Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength) : undefined,
+ body: value.body
+ ? value.compressed === 'zstd'
+ ? zstdDecompressSync(Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength))
+ : Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength)
+ : undefined,
statusCode: value.statusCode,
statusMessage: value.statusMessage,
headers: value.headers ? JSON.parse(value.headers) : undefined,
@@ -268,11 +297,22 @@ module.exports = class SqliteCacheStore {
return
}
+ let compressed = null
+ let storedBody = body
+ if (body && hasZstd && (size > this.#compressThreshold || isCompressibleContentType(getContentType(value.headers)))) {
+ const candidate = zstdCompressSync(body)
+ if (candidate.byteLength < body.byteLength) {
+ storedBody = candidate
+ compressed = 'zstd'
+ }
+ }
+
const existingValue = this.#findValue(key, true)
if (existingValue) {
// Updating an existing response, let's overwrite it
this.#updateValueQuery.run(
- body,
+ storedBody,
+ compressed,
value.deleteAt,
value.statusCode,
value.statusMessage,
@@ -289,7 +329,8 @@ module.exports = class SqliteCacheStore {
this.#insertValueQuery.run(
url,
key.method,
- body,
+ storedBody,
+ compressed,
value.deleteAt,
value.statusCode,
value.statusMessage,
@@ -467,3 +508,40 @@ function headerValueEquals (lhs, rhs) {
return lhs === rhs
}
+
+/**
+ * @param {Record<string, string|string[]>|null|undefined} headers
+ * @returns {string|undefined}
+ */
+function getContentType (headers) {
+ if (headers == null) {
+ return undefined
+ }
+
+ for (const key in headers) {
+ if (key.toLowerCase() === 'content-type') {
+ const value = headers[key]
+ return Array.isArray(value) ? value[0] : value
+ }
+ }
+
+ return undefined
+}
+
+/**
+ * @param {string|undefined} contentType
+ * @returns {boolean}
+ */
+function isCompressibleContentType (contentType) {
+ if (contentType == null) {
+ return false
+ }
+
+ const type = contentType.toLowerCase()
+
+ // text/* and application/json, xml, javascript, ... are easily compressible
+ // even at smaller sizes, so ignore the compressThreshold for them.
+ return /^text\//.test(type) ||
+ /^application\/(json|xml|javascript|x-www-form-urlencoded|graphql)(\s|;|$)/.test(type) ||
+ /\+(json|xml)(\s|;|$)/.test(type)
+}
diff --git a/deps/undici/src/lib/core/connect.js b/deps/undici/src/lib/core/connect.js
index f729dfb0526..ee42fd6ea30 100644
--- a/deps/undici/src/lib/core/connect.js
+++ b/deps/undici/src/lib/core/connect.js
@@ -41,16 +41,22 @@ const SessionCache = class WeakSessionCache {
if (this._sessionCache.has(sessionKey)) {
this._sessionCache.delete(sessionKey)
} else if (this._sessionCache.size >= this._maxCachedSessions) {
+ // Make room for the new session: prefer an entry whose session has
+ // already been collected, otherwise evict the oldest one.
+ let evicted = false
for (const [key, ref] of this._sessionCache) {
if (ref.deref() === undefined) {
this._sessionCache.delete(key)
- return
+ evicted = true
+ break
}
}
- const oldest = this._sessionCache.keys().next()
- if (!oldest.done) {
- this._sessionCache.delete(oldest.value)
+ if (!evicted) {
+ const oldest = this._sessionCache.keys().next()
+ if (!oldest.done) {
+ this._sessionCache.delete(oldest.value)
+ }
}
}
diff --git a/deps/undici/src/lib/core/constants.js b/deps/undici/src/lib/core/constants.js
index 000c0194909..ef2d80653c8 100644
--- a/deps/undici/src/lib/core/constants.js
+++ b/deps/undici/src/lib/core/constants.js
@@ -114,7 +114,18 @@ for (let i = 0; i < wellknownHeaderNames.length; ++i) {
lowerCasedKey
}
+/**
+ * Default WebSocket receive limits (see `webSocket` in Client.md). Used by
+ * DispatcherBase#webSocketOptions and by the WebSocket parser when the
+ * dispatcher doesn't provide a value, so a dispatcher without
+ * `webSocketOptions` (a custom one, or a wrapper) doesn't remove the limits.
+ */
+const defaultWebSocketMaxFragments = 131072
+const defaultWebSocketMaxPayloadSize = 128 * 1024 * 1024 // 128 MB
+
module.exports = {
wellknownHeaderNames,
- headerNameLowerCasedRecord
+ headerNameLowerCasedRecord,
+ defaultWebSocketMaxFragments,
+ defaultWebSocketMaxPayloadSize
}
diff --git a/deps/undici/src/lib/core/errors.js b/deps/undici/src/lib/core/errors.js
index d509d925a69..a8686f45a31 100644
--- a/deps/undici/src/lib/core/errors.js
+++ b/deps/undici/src/lib/core/errors.js
@@ -306,6 +306,22 @@ class BalancedPoolMissingUpstreamError extends UndiciError {
}
}
+const kWebAssemblyNotSupportedError = Symbol.for('undici.error.ERR_WEBASSEMBLY_NOT_SUPPORTED')
+class WebAssemblyNotSupportedError extends Error {
+ constructor (message) {
+ super(message || 'WebAssembly is not supported in this environment, but is required for HTTP/1 parsing')
+ this.code = 'ERR_WEBASSEMBLY_NOT_SUPPORTED'
+ }
+
+ static [Symbol.hasInstance] (instance) {
+ return instance && instance[kWebAssemblyNotSupportedError] === true
+ }
+
+ get [kWebAssemblyNotSupportedError] () {
+ return true
+ }
+}
+
const kHTTPParserError = Symbol.for('undici.error.UND_ERR_HTTP_PARSER')
class HTTPParserError extends Error {
constructor (message, code, data) {
@@ -365,13 +381,14 @@ class RequestRetryError extends UndiciError {
const kResponseError = Symbol.for('undici.error.UND_ERR_RESPONSE')
class ResponseError extends UndiciError {
- constructor (message, code, { headers, body }) {
+ constructor (message, code, { headers, body, bodyTruncated = false }) {
super(message)
this.name = 'ResponseError'
this.message = message || 'Response error'
this.code = 'UND_ERR_RESPONSE'
this.statusCode = code
this.body = body
+ this.bodyTruncated = bodyTruncated
this.headers = headers
}
@@ -422,6 +439,24 @@ class ProxyConnectionError extends UndiciError {
}
}
+const kMaxRedirectsError = Symbol.for('undici.error.UND_ERR_REDIRECT_MAX')
+class MaxRedirectsError extends UndiciError {
+ constructor (message) {
+ super(message)
+ this.name = 'MaxRedirectsError'
+ this.message = message || 'max redirects'
+ this.code = 'UND_ERR_REDIRECT_MAX'
+ }
+
+ static [Symbol.hasInstance] (instance) {
+ return instance && instance[kMaxRedirectsError] === true
+ }
+
+ get [kMaxRedirectsError] () {
+ return true
+ }
+}
+
const kMaxOriginsReachedError = Symbol.for('undici.error.UND_ERR_MAX_ORIGINS_REACHED')
class MaxOriginsReachedError extends UndiciError {
constructor (message) {
@@ -469,6 +504,7 @@ class MessageSizeExceededError extends UndiciError {
module.exports = {
AbortError,
+ WebAssemblyNotSupportedError,
HTTPParserError,
UndiciError,
HeadersTimeoutError,
@@ -492,6 +528,7 @@ module.exports = {
SecureProxyConnectionError,
ProxyConnectionError,
MaxOriginsReachedError,
+ MaxRedirectsError,
Socks5ProxyError,
MessageSizeExceededError
}
diff --git a/deps/undici/src/lib/core/request.js b/deps/undici/src/lib/core/request.js
index a66d9311664..efa391b8edf 100644
--- a/deps/undici/src/lib/core/request.js
+++ b/deps/undici/src/lib/core/request.js
@@ -206,7 +206,12 @@ class Request {
this.body = body.byteLength ? Buffer.from(body) : null
} else if (typeof body === 'string') {
this.body = body.length ? Buffer.from(body) : null
- } else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) {
+ } else if (isFormDataLike(body)) {
+ if (!isUndiciFormData(body)) {
+ throw new InvalidArgumentError('body must be a FormData created by this undici package instance; FormData from other sources, such as the built-in FormData provided by Node.js, is not supported')
+ }
+ this.body = body
+ } else if (isIterable(body) || isBlobLike(body)) {
this.body = body
} else {
throw new InvalidArgumentError('body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable')
@@ -564,4 +569,14 @@ function processHeader (request, key, val) {
}
}
+let isFormData
+
+function isUndiciFormData (body) {
+ if (isFormData === undefined) {
+ require('../web/fetch/formdata')
+ isFormData = require('../web/webidl').webidl.is.FormData
+ }
+ return isFormData(body)
+}
+
module.exports = Request
diff --git a/deps/undici/src/lib/core/symbols.js b/deps/undici/src/lib/core/symbols.js
index 5186052881b..62163ebe2d6 100644
--- a/deps/undici/src/lib/core/symbols.js
+++ b/deps/undici/src/lib/core/symbols.js
@@ -6,6 +6,7 @@ module.exports = {
kDispatch: Symbol('dispatch'),
kUrl: Symbol('url'),
kRequestOrigin: Symbol('request origin'),
+ kRedirectCacheControl: Symbol('redirect cache control'),
kOriginless: Symbol('originless'),
kWriting: Symbol('writing'),
kResuming: Symbol('resuming'),
@@ -72,6 +73,7 @@ module.exports = {
kRemoteSettings: Symbol('http2session remote settings'),
kHTTP2Stream: Symbol('http2session client stream'),
kPingInterval: Symbol('ping interval'),
+ kUseMilo: Symbol('use milo'),
kNoProxyAgent: Symbol('no proxy agent'),
kHttpProxyAgent: Symbol('http proxy agent'),
kHttpsProxyAgent: Symbol('https proxy agent'),
diff --git a/deps/undici/src/lib/core/util.js b/deps/undici/src/lib/core/util.js
index 98cb7228fff..db654c247d2 100644
--- a/deps/undici/src/lib/core/util.js
+++ b/deps/undici/src/lib/core/util.js
@@ -387,7 +387,7 @@ function destroy (stream, err) {
}
}
-const KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/
+const KEEPALIVE_TIMEOUT_EXPR = /(?:^|,)[\t ]*timeout=(\d+)/i
/**
* @param {string} val
* @returns {number | null}
@@ -417,6 +417,30 @@ function bufferToLowerCasedHeaderName (value) {
return tree.lookup(value) ?? value.toString('latin1').toLowerCase()
}
+/**
+ * Writes a header onto a plain object without going through the
+ * `Object.prototype` `__proto__` setter. Plain assignment there drops a string
+ * value and, when the value is an array, replaces the object's prototype
+ * instead of storing anything. Every other name is a normal assignment.
+ *
+ * @param {Record<string, string | string[]>} obj Accumulator to write onto
+ * @param {string} key Header name
+ * @param {string | string[]} value Header value
+ * @returns {void}
+ */
+function setHeader (obj, key, value) {
+ if (key === '__proto__') {
+ Object.defineProperty(obj, key, {
+ value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ })
+ } else {
+ obj[key] = value
+ }
+}
+
/**
* @param {(Buffer | string)[]} headers
* @param {Record<string, string | string[]>} [obj]
@@ -984,6 +1008,7 @@ module.exports = {
toRawHeaders,
encodeRawHeaders,
parseHeaders,
+ setHeader,
parseKeepAliveTimeout,
destroy,
bodyLength,
diff --git a/deps/undici/src/lib/dispatcher/agent.js b/deps/undici/src/lib/dispatcher/agent.js
index 95c1b0923f0..7f95e308700 100644
--- a/deps/undici/src/lib/dispatcher/agent.js
+++ b/deps/undici/src/lib/dispatcher/agent.js
@@ -22,7 +22,7 @@ function defaultFactory (origin, opts) {
}
class Agent extends DispatcherBase {
- constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
+ constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, tls, ...options } = {}) {
if (typeof factory !== 'function') {
throw new InvalidArgumentError('factory must be a function.')
}
@@ -41,7 +41,11 @@ class Agent extends DispatcherBase {
connect = { ...connect }
}
- this[kOptions] = { ...util.deepClone(options), maxOrigins, connect }
+ if (tls && typeof tls !== 'function') {
+ tls = { ...tls }
+ }
+
+ this[kOptions] = { ...util.deepClone(options), maxOrigins, connect, tls }
this[kFactory] = factory
this[kClients] = new Map()
this[kOrigins] = new Set()
diff --git a/deps/undici/src/lib/dispatcher/client-h1.js b/deps/undici/src/lib/dispatcher/client-h1.js
index 3cc24713a37..cbbdaaf3543 100644
--- a/deps/undici/src/lib/dispatcher/client-h1.js
+++ b/deps/undici/src/lib/dispatcher/client-h1.js
@@ -17,6 +17,7 @@ const {
InformationalError,
BodyTimeoutError,
HTTPParserError,
+ WebAssemblyNotSupportedError,
ResponseExceededMaxSizeError
} = require('../core/errors.js')
const {
@@ -51,10 +52,15 @@ const {
kOnError,
kResume,
kHTTPContext,
- kClosed
+ kClosed,
+ kUseMilo
} = require('../core/symbols.js')
const constants = require('../llhttp/constants.js')
+// Node.js core bundles only llhttp; experimental Milo remains available in npm builds.
+const { H1Parser, getMiloEnabled } = typeof esbuildDetection === 'undefined'
+ ? require('./parser-h1.js')
+ : {}
const EMPTY_BUF = Buffer.alloc(0)
const FastBuffer = Buffer[Symbol.species]
const removeAllListeners = util.removeAllListeners
@@ -66,6 +72,11 @@ const kTypeOfService = Symbol('kTypeOfService')
let extractBody
function lazyllhttp () {
+ // Check only when HTTP/1 needs the parser, so other APIs remain usable without WASM.
+ if (typeof WebAssembly === 'undefined') {
+ throw new WebAssemblyNotSupportedError()
+ }
+
const llhttpWasmData = process.env.JEST_WORKER_ID ? require('../llhttp/llhttp-wasm.js') : undefined
let mod
@@ -88,8 +99,7 @@ function lazyllhttp () {
if (useWasmSIMD) {
try {
mod = new WebAssembly.Module(require('../llhttp/llhttp_simd-wasm.js'))
- } catch {
- }
+ } catch {}
}
if (!mod) {
@@ -126,7 +136,7 @@ function lazyllhttp () {
* @param {number} p
* @returns {number}
*/
- wasm_on_message_begin: (p) => {
+ wasm_on_message_begin: p => {
assert(currentParser.ptr === p)
return currentParser.onMessageBegin()
},
@@ -178,11 +188,10 @@ function lazyllhttp () {
* @param {number} p
* @returns {number}
*/
- wasm_on_message_complete: (p) => {
+ wasm_on_message_complete: p => {
assert(currentParser.ptr === p)
return currentParser.onMessageComplete()
}
-
}
})
}
@@ -215,10 +224,10 @@ const TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER
class Parser {
/**
- * @param {import('./client.js')} client
- * @param {import('net').Socket} socket
- * @param {*} llhttp
- */
+ * @param {import('./client.js')} client
+ * @param {import('net').Socket} socket
+ * @param {*} llhttp
+ */
constructor (client, socket, { exports }) {
this.llhttp = exports
this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE)
@@ -245,7 +254,8 @@ class Parser {
this.keepAlive = ''
this.contentLength = -1
- this.connectionKeepAlive = false
+ this.hasTransferEncoding = false
+ this.connection = ''
this.maxResponseSize = client[kMaxResponseSize]
}
@@ -253,10 +263,7 @@ class Parser {
// If the existing timer and the new timer are of different timer type
// (fast or native) or have different delay, we need to clear the existing
// timer and set a new one.
- if (
- delay !== this.timeoutValue ||
- (type & USE_FAST_TIMER) ^ (this.timeoutType & USE_FAST_TIMER)
- ) {
+ if (delay !== this.timeoutValue || (type & USE_FAST_TIMER) ^ (this.timeoutType & USE_FAST_TIMER)) {
// If a timeout is already set, clear it with clearTimeout of the fast
// timer implementation, as it can clear fast and native timers.
if (this.timeout) {
@@ -441,9 +448,7 @@ class Parser {
if (ptr) {
const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0)
message =
- 'Response does not match the HTTP/1.1 protocol (' +
- Buffer.from(llhttp.memory.buffer, ptr, len).toString() +
- ')'
+ 'Response does not match the HTTP/1.1 protocol (' + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ')'
}
return new HTTPParserError(message, constants.ERROR[ret], data)
@@ -521,6 +526,7 @@ class Parser {
*/
onHeaderValue (buf) {
let len = this.headers.length
+ const isContinuation = (len & 1) === 0
if ((len & 1) === 1) {
this.headers.push(buf)
@@ -533,19 +539,19 @@ class Parser {
if (key.length === 10) {
const headerName = util.bufferToLowerCasedHeaderName(key)
if (headerName === 'keep-alive') {
- this.keepAlive += buf.toString()
+ this.keepAlive += (isContinuation || this.keepAlive.length === 0 ? '' : ',') + buf.toString()
} else if (headerName === 'connection') {
- this.connectionKeepAlive =
- this.headers[len - 1].length === 10 &&
- util.bufferToLowerCasedHeaderName(this.headers[len - 1]) === 'keep-alive'
+ this.connection += (isContinuation || this.connection.length === 0 ? '' : ',') + buf.toString()
}
} else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === 'content-length') {
if (this.contentLength === -1) {
this.contentLength = 0
}
for (let i = 0; i < buf.length; i++) {
- this.contentLength = (this.contentLength * 10) + (buf[i] - 0x30)
+ this.contentLength = this.contentLength * 10 + (buf[i] - 0x30)
}
+ } else if (key.length === 17 && util.bufferToLowerCasedHeaderName(key) === 'transfer-encoding') {
+ this.hasTransferEncoding = true
}
this.trackHeader(buf.length)
@@ -652,16 +658,27 @@ class Parser {
assert(this.timeoutType === TIMEOUT_HEADERS)
this.statusCode = statusCode
- this.shouldKeepAlive = (
+ this.shouldKeepAlive =
shouldKeepAlive ||
// Override llhttp value which does not allow keepAlive for HEAD.
- (request.method === 'HEAD' && !socket[kReset] && this.connectionKeepAlive)
- )
+ (request.method === 'HEAD' && !socket[kReset] &&
+ /(?:^|,)[\t ]*keep-alive[\t ]*(?:,|$)/i.test(this.connection) &&
+ !/(?:^|,)[\t ]*close[\t ]*(?:,|$)/i.test(this.connection))
+
+ // Responses to HEAD and 204/304 responses never carry content
+ if (request.method === 'HEAD' || statusCode === 204 || statusCode === 304) {
+ // A non-zero Content-Length or Transfer-Encoding on a 204/304 means the
+ // server may also have sent content inappropriately, which would then be
+ // parsed as the next response on this connection. Accept it, but do not
+ // reuse the connection. HEAD requests are fine tho.
+ if (request.method !== 'HEAD' && (this.contentLength > 0 || this.hasTransferEncoding)) {
+ this.shouldKeepAlive = false
+ }
+ this.contentLength = -1
+ }
if (this.statusCode >= 200) {
- const bodyTimeout = request.bodyTimeout != null
- ? request.bodyTimeout
- : client[kBodyTimeout]
+ const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout]
this.setTimeout(bodyTimeout, TIMEOUT_BODY)
} else if (this.timeout) {
if (this.timeout.refresh) {
@@ -689,10 +706,7 @@ class Parser {
const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null
if (keepAliveTimeout != null) {
- const timeout = Math.min(
- keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
- client[kKeepAliveMaxTimeout]
- )
+ const timeout = Math.min(keepAliveTimeout - client[kKeepAliveTimeoutThreshold], client[kKeepAliveMaxTimeout])
if (timeout <= 0) {
socket[kReset] = true
} else {
@@ -789,8 +803,9 @@ class Parser {
this.statusText = ''
this.bytesRead = 0
this.contentLength = -1
+ this.hasTransferEncoding = false
this.keepAlive = ''
- this.connectionKeepAlive = false
+ this.connection = ''
this.headers = []
this.headersSize = 0
@@ -799,7 +814,7 @@ class Parser {
return 0
}
- if (request.method !== 'HEAD' && contentLength !== -1 && bytesRead !== contentLength) {
+ if (contentLength !== -1 && bytesRead !== contentLength) {
util.destroy(socket, new ResponseContentLengthMismatchError())
return -1
}
@@ -887,7 +902,9 @@ function connectH1 (client, socket) {
socket[kIdleSocketValidation] = 0
socket[kIdleSocketValidationTimeout] = null
socket[kSocketUsed] = false
- socket[kParser] = new Parser(client, socket, llhttpInstance)
+ socket[kParser] = typeof esbuildDetection === 'undefined' && (client[kUseMilo] ?? getMiloEnabled())
+ ? new H1Parser(client, socket)
+ : new Parser(client, socket, llhttpInstance)
util.addListener(socket, 'error', onHttpSocketError)
util.addListener(socket, 'readable', onHttpSocketReadable)
@@ -948,8 +965,11 @@ function connectH1 (client, socket) {
return true
}
- if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 &&
- (util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body))) {
+ if (
+ client[kRunning] > 0 &&
+ util.bodyLength(request.body) !== 0 &&
+ (util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body))
+ ) {
// Request with stream or iterator body can error while other requests
// are inflight and indirectly error those as well.
// Ensure this doesn't happen by waiting for inflight
@@ -968,8 +988,6 @@ function connectH1 (client, socket) {
}
function onHttpSocketError (err) {
- assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
-
const parser = this[kParser]
// On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
@@ -1137,9 +1155,7 @@ function resumeH1 (client) {
} else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
const request = client[kQueue][client[kRunningIdx]]
- const headersTimeout = request.headersTimeout != null
- ? request.headersTimeout
- : client[kHeadersTimeout]
+ const headersTimeout = request.headersTimeout != null ? request.headersTimeout : client[kHeadersTimeout]
socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS)
}
}
@@ -1196,14 +1212,13 @@ function writeH1 (client, request) {
// servers and corrupt connection state. Do not
// re-use the connection for further requests.
- const expectsPayload = (
+ const expectsPayload =
method === 'PUT' ||
method === 'POST' ||
method === 'PATCH' ||
method === 'QUERY' ||
method === 'PROPFIND' ||
method === 'PROPPATCH'
- )
if (util.isFormDataLike(body)) {
if (!extractBody) {
@@ -1252,7 +1267,12 @@ function writeH1 (client, request) {
// https://github.com/nodejs/undici/issues/2046
// A user agent may send a Content-Length header with 0 value, this should be allowed.
- if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
+ if (
+ shouldSendContentLength(method) &&
+ contentLength > 0 &&
+ request.contentLength !== null &&
+ request.contentLength !== contentLength
+ ) {
if (client[kStrictContentLength]) {
util.errorRequest(client, request, new RequestContentLengthMismatchError())
return false
@@ -1268,7 +1288,7 @@ function writeH1 (client, request) {
* @param {Error} [err]
* @returns {void}
*/
- const abort = (err) => {
+ const abort = err => {
if (request.aborted || request.completed) {
return
}
@@ -1453,14 +1473,9 @@ function writeStream (abort, body, client, request, socket, contentLength, heade
assert(socket.destroyed || (socket[kWriting] && client[kRunning] <= 1))
- socket
- .off('drain', onDrain)
- .off('error', onFinished)
+ socket.off('drain', onDrain).off('error', onFinished)
- body
- .removeListener('data', onData)
- .removeListener('end', onFinished)
- .removeListener('close', onClose)
+ body.removeListener('data', onData).removeListener('end', onFinished).removeListener('close', onClose)
if (!err) {
try {
@@ -1479,19 +1494,13 @@ function writeStream (abort, body, client, request, socket, contentLength, heade
}
}
- body
- .on('data', onData)
- .on('end', onFinished)
- .on('error', onFinished)
- .on('close', onClose)
+ body.on('data', onData).on('end', onFinished).on('error', onFinished).on('close', onClose)
if (body.resume) {
body.resume()
}
- socket
- .on('drain', onDrain)
- .on('error', onFinished)
+ socket.on('drain', onDrain).on('error', onFinished)
if (body.errorEmitted ?? body.errored) {
setImmediate(onFinished, body.errored)
@@ -1612,19 +1621,18 @@ async function writeIterable (abort, body, client, request, socket, contentLengt
}
}
- const waitForDrain = () => new Promise((resolve, reject) => {
- assert(callback === null)
+ const waitForDrain = () =>
+ new Promise((resolve, reject) => {
+ assert(callback === null)
- if (socket[kError]) {
- reject(socket[kError])
- } else {
- callback = resolve
- }
- })
+ if (socket[kError]) {
+ reject(socket[kError])
+ } else {
+ callback = resolve
+ }
+ })
- socket
- .on('close', onDrain)
- .on('drain', onDrain)
+ socket.on('close', onDrain).on('drain', onDrain)
const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header })
try {
@@ -1643,9 +1651,7 @@ async function writeIterable (abort, body, client, request, socket, contentLengt
} catch (err) {
writer.destroy(err)
} finally {
- socket
- .off('close', onDrain)
- .off('drain', onDrain)
+ socket.off('close', onDrain).off('drain', onDrain)
}
}
@@ -1670,10 +1676,27 @@ class AsyncWriter {
this.expectsPayload = expectsPayload
this.header = header
this.abort = abort
+ this.lengthMismatch = false
socket[kWriting] = true
}
+ /**
+ * The body doesn't match the declared content-length and strictContentLength
+ * is off. Warn once, and mark the socket so it isn't reused: on the wire this
+ * request's body no longer ends where the server expects, so anything sent
+ * after it on the same connection would be misread.
+ * @returns {void}
+ */
+ onLengthMismatch () {
+ this.socket[kReset] = true
+
+ if (!this.lengthMismatch) {
+ this.lengthMismatch = true
+ process.emitWarning(new RequestContentLengthMismatchError())
+ }
+ }
+
/**
* @param {string|Uint8Array} chunk
* @returns
@@ -1689,7 +1712,7 @@ class AsyncWriter {
return false
}
- const len = chunk instanceof Uint8Array ? chunk.byteLength : Buffer.byteLength(chunk)
+ let len = chunk instanceof Uint8Array ? chunk.byteLength : Buffer.byteLength(chunk)
if (!len) {
return true
}
@@ -1700,7 +1723,17 @@ class AsyncWriter {
throw new RequestContentLengthMismatchError()
}
- process.emitWarning(new RequestContentLengthMismatchError())
+ this.onLengthMismatch()
+
+ // Never write past the declared content-length. The server treats any
+ // extra bytes as the start of the next request, so a body could inject
+ // a request of its own (request smuggling).
+ const remaining = contentLength - bytesWritten
+ if (remaining === 0) {
+ return true
+ }
+ chunk = (typeof chunk === 'string' ? Buffer.from(chunk) : chunk).subarray(0, remaining)
+ len = remaining
}
socket.cork()
@@ -1775,9 +1808,12 @@ class AsyncWriter {
if (contentLength !== null && bytesWritten !== contentLength) {
if (client[kStrictContentLength]) {
throw new RequestContentLengthMismatchError()
- } else {
- process.emitWarning(new RequestContentLengthMismatchError())
}
+
+ // The body is shorter than declared, so the server is still waiting for
+ // the rest. Don't let the next request's bytes on this connection be
+ // read as the missing part of this body.
+ this.onLengthMismatch()
}
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
diff --git a/deps/undici/src/lib/dispatcher/client-h2.js b/deps/undici/src/lib/dispatcher/client-h2.js
index 44d1c13da73..c95ca095814 100644
--- a/deps/undici/src/lib/dispatcher/client-h2.js
+++ b/deps/undici/src/lib/dispatcher/client-h2.js
@@ -548,8 +548,14 @@ function applyConnectionWindowSize (connectionWindowSize) {
}
function onHttp2RemoteSettings (settings) {
- // Fallbacks are a safe bet, remote setting will always override
- this[kClient][kMaxConcurrentStreams] = settings.maxConcurrentStreams ?? this[kClient][kMaxConcurrentStreams]
+ const client = this[kClient]
+
+ // The configured maxConcurrentStreams (default 100) is the client's own
+ // ceiling. The server's SETTINGS_MAX_CONCURRENT_STREAMS can lower it, but
+ // must not raise it: a default Node.js server advertises 2^32-1.
+ const localMaxConcurrentStreams = client[kHTTP2Options].maxConcurrentStreams
+ const remoteMaxConcurrentStreams = settings.maxConcurrentStreams ?? client[kMaxConcurrentStreams] ?? localMaxConcurrentStreams
+ client[kMaxConcurrentStreams] = Math.min(remoteMaxConcurrentStreams, localMaxConcurrentStreams)
/**
* From RFC-8441
* A sender MUST NOT send a SETTINGS_ENABLE_CONNECT_PROTOCOL parameter
@@ -594,8 +600,6 @@ function onHttp2SendPing (session) {
}
function onHttp2SessionError (err) {
- assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
-
this[kSocket][kError] = err
if (this[kReceivedGoAway]) {
@@ -676,6 +680,10 @@ function onHttp2SessionGoAway (errorCode, lastStreamID) {
client[kHTTP2Session] = null
}
+ if (this[kOpenStreams] === 0) {
+ unrefH2Session(this)
+ }
+
clearHttp2IdleTimeout(this)
clearNoStreamsTimeout(this)
@@ -757,8 +765,6 @@ function onHttp2SocketClose () {
}
function onHttp2SocketError (err) {
- assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
-
this[kError] = err
if (this[kHTTP2Session]?.[kReceivedGoAway]) {
@@ -844,25 +850,27 @@ function buildRequestHeaders (reqHeaders) {
for (let n = 0; n < reqHeaders.length; n += 2) {
const key = reqHeaders[n + 0]
const val = reqHeaders[n + 1]
- const current = headers[key]
+ // Reading headers[key] directly resolves `__proto__` through the prototype
+ // chain instead of reporting the header as absent.
+ const current = Object.hasOwn(headers, key) ? headers[key] : undefined
if (key === 'cookie') {
if (current != null) {
- headers[key] = Array.isArray(current) ? (current.push(val), current) : [current, val]
+ util.setHeader(headers, key, Array.isArray(current) ? (current.push(val), current) : [current, val])
} else {
- headers[key] = val
+ util.setHeader(headers, key, val)
}
continue
}
if (typeof val === 'string') {
- headers[key] = current ? `${current}, ${val}` : val
+ util.setHeader(headers, key, current ? `${current}, ${val}` : val)
continue
}
for (let i = 0; i < val.length; i++) {
- headers[key] = headers[key] ? `${headers[key]}, ${val[i]}` : val[i]
+ util.setHeader(headers, key, Object.hasOwn(headers, key) ? `${headers[key]}, ${val[i]}` : val[i])
}
}
@@ -1368,10 +1376,34 @@ function onData (chunk) {
state.bytesRead += chunk.length
if (request.onResponseData(chunk) === false) {
- stream.pause()
+ pauseResponseStream(stream, state)
+ }
+}
+
+// The body timeout measures how long the peer takes to send data. While the
+// consumer applies backpressure the peer can't send (it's out of flow-control
+// window), and Http2Stream's timer, which counts stream activity, would fire.
+// Stop it while paused and start a fresh one on resume, like HTTP/1.1, which
+// ignores the body timeout while its parser is paused.
+function pauseResponseStream (stream, state) {
+ stream.pause()
+ if (state.bodyTimeout) {
+ stream.setTimeout(0)
}
}
+// Passed to the handler as its resume callback, bound to the stream.
+function resumeResponseStream () {
+ const stream = this
+ const state = stream[kRequestStreamState]
+
+ if (state != null && state.bodyTimeout && stream.isPaused()) {
+ stream.setTimeout(state.bodyTimeout)
+ }
+
+ stream.resume()
+}
+
function onInterimResponse (headers) {
const stream = this
const state = stream[kRequestStreamState]
@@ -1446,8 +1478,8 @@ function onResponse (headers) {
return
}
- if (request.onResponseStart(statusCode, headers, stream.resume.bind(stream), '') === false) {
- stream.pause()
+ if (request.onResponseStart(statusCode, headers, resumeResponseStream.bind(stream), '') === false) {
+ pauseResponseStream(stream, state)
}
stream.on('data', onData)
diff --git a/deps/undici/src/lib/dispatcher/client.js b/deps/undici/src/lib/dispatcher/client.js
index 6acca434fbf..05288a5991b 100644
--- a/deps/undici/src/lib/dispatcher/client.js
+++ b/deps/undici/src/lib/dispatcher/client.js
@@ -54,7 +54,8 @@ const {
kMaxConcurrentStreams,
kHostAuthority,
kResume,
- kHTTP2Options
+ kHTTP2Options,
+ kUseMilo
} = require('../core/symbols.js')
const connectH1 = require('./client-h1.js')
const connectH2 = require('./client-h2.js')
@@ -136,6 +137,7 @@ class Client extends DispatcherBase {
initialWindowSize,
connectionWindowSize,
pingInterval,
+ useMilo,
webSocket,
h2Options,
eventSource
@@ -335,6 +337,7 @@ class Client extends DispatcherBase {
initialWindowSize: h2Options?.initialWindowSize ?? initialWindowSize ?? 262144
}
}
+ this[kUseMilo] = useMilo
// kQueue is built up of 3 sections separated by
// the kRunningIdx and kPendingIdx indices.
diff --git a/deps/undici/src/lib/dispatcher/dispatcher-base.js b/deps/undici/src/lib/dispatcher/dispatcher-base.js
index d9d15d6441a..97a4db6e321 100644
--- a/deps/undici/src/lib/dispatcher/dispatcher-base.js
+++ b/deps/undici/src/lib/dispatcher/dispatcher-base.js
@@ -8,6 +8,7 @@ const {
InvalidArgumentError
} = require('../core/errors')
const { kDestroy, kClose, kClosed, kDestroyed, kDispatch } = require('../core/symbols')
+const { defaultWebSocketMaxFragments, defaultWebSocketMaxPayloadSize } = require('../core/constants')
const kOnDestroyed = Symbol('onDestroyed')
const kOnClosed = Symbol('onClosed')
@@ -41,8 +42,8 @@ class DispatcherBase extends Dispatcher {
*/
get webSocketOptions () {
return {
- maxFragments: this[kWebSocketOptions].maxFragments ?? 131072,
- maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? 128 * 1024 * 1024 // 128 MB default
+ maxFragments: this[kWebSocketOptions].maxFragments ?? defaultWebSocketMaxFragments,
+ maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? defaultWebSocketMaxPayloadSize
}
}
diff --git a/deps/undici/src/lib/dispatcher/dispatcher1-wrapper.js b/deps/undici/src/lib/dispatcher/dispatcher1-wrapper.js
index e206984d5a4..87e60c40a6a 100644
--- a/deps/undici/src/lib/dispatcher/dispatcher1-wrapper.js
+++ b/deps/undici/src/lib/dispatcher/dispatcher1-wrapper.js
@@ -17,12 +17,16 @@ class LegacyHandlerWrapper {
}
onRequestUpgrade (controller, statusCode, headers, socket) {
- const rawHeaders = controller?.rawHeaders ?? toRawHeaders(headers ?? {})
+ const rawHeaders = Array.isArray(controller?.rawHeaders)
+ ? controller.rawHeaders
+ : toRawHeaders(controller?.rawHeaders ?? headers ?? {})
this.#handler.onUpgrade?.(statusCode, rawHeaders, socket)
}
onResponseStart (controller, statusCode, headers, statusMessage) {
- const rawHeaders = controller?.rawHeaders ?? toRawHeaders(headers ?? {})
+ const rawHeaders = Array.isArray(controller?.rawHeaders)
+ ? controller.rawHeaders
+ : toRawHeaders(controller?.rawHeaders ?? headers ?? {})
if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === false) {
controller.pause()
@@ -36,7 +40,9 @@ class LegacyHandlerWrapper {
}
onResponseEnd (controller, trailers) {
- const rawTrailers = controller?.rawTrailers ?? toRawHeaders(trailers ?? {})
+ const rawTrailers = Array.isArray(controller?.rawTrailers)
+ ? controller.rawTrailers
+ : toRawHeaders(controller?.rawTrailers ?? trailers ?? {})
this.#handler.onComplete?.(rawTrailers)
}
@@ -98,6 +104,17 @@ class Dispatcher1Wrapper extends Dispatcher {
return this.#dispatcher.dispatch(opts, Dispatcher1Wrapper.wrapHandler(handler))
}
+ // Older undici versions read WebSocket and EventSource receive limits from
+ // the (legacy) global dispatcher, which is this wrapper, so report the
+ // wrapped dispatcher's settings.
+ get webSocketOptions () {
+ return this.#dispatcher.webSocketOptions
+ }
+
+ get eventSourceOptions () {
+ return this.#dispatcher.eventSourceOptions
+ }
+
close (...args) {
return this.#dispatcher.close(...args)
}
diff --git a/deps/undici/src/lib/dispatcher/parser-h1.js b/deps/undici/src/lib/dispatcher/parser-h1.js
new file mode 100644
index 00000000000..263d67e7763
--- /dev/null
+++ b/deps/undici/src/lib/dispatcher/parser-h1.js
@@ -0,0 +1,1064 @@
+'use strict'
+
+const assert = require('node:assert')
+const util = require('../core/util.js')
+const timers = require('../util/timers.js')
+const {
+ HeadersTimeoutError,
+ HeadersOverflowError,
+ SocketError,
+ InformationalError,
+ BodyTimeoutError,
+ HTTPParserError,
+ ResponseContentLengthMismatchError,
+ ResponseExceededMaxSizeError
+} = require('../core/errors.js')
+const {
+ kUrl,
+ kReset,
+ kClient,
+ kParser,
+ kBlocking,
+ kRunning,
+ kWriting,
+ kQueue,
+ kKeepAliveDefaultTimeout,
+ kRunningIdx,
+ kError,
+ kPipelining,
+ kSocket,
+ kKeepAliveTimeoutValue,
+ kKeepAliveMaxTimeout,
+ kKeepAliveTimeoutThreshold,
+ kBodyTimeout,
+ kMaxResponseSize,
+ kResume,
+ kHTTPContext,
+ kMaxHeadersSize
+} = require('../core/symbols.js')
+
+const FastBuffer = Buffer[Symbol.species]
+const removeAllListeners = util.removeAllListeners
+
+const kPausedByHandler = Symbol('kPausedByHandler')
+
+const BUFFER_PAGE_SIZE = 4096
+const INITIAL_BUFFER_SIZE = 128 * 1024
+const EMPTY_BUF = Buffer.alloc(0)
+const BODY_KIND_CONTENT_LENGTH = 0
+const EVENT_RANGE_SIZE = 9
+const EVENT_HEADERS_SIZE = 19
+
+let miloPackage
+
+// We disable wasm SIMD on ppc64 as it seems to be broken on Power 9 architectures.
+let useWasmSIMD = process.arch !== 'ppc64'
+// The Env Variable UNDICI_NO_WASM_SIMD allows explicitly overriding the default behavior.
+if (process.env.UNDICI_NO_WASM_SIMD === '1') {
+ useWasmSIMD = false
+} else if (process.env.UNDICI_NO_WASM_SIMD === '0') {
+ useWasmSIMD = true
+}
+
+const USE_NATIVE_TIMER = 0
+const USE_FAST_TIMER = 1
+const TIMEOUT_HEADERS = 2 | USE_FAST_TIMER
+const TIMEOUT_BODY = 4 | USE_FAST_TIMER
+const TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER
+
+let miloEnabled =
+ process.env.UNDICI_USE_MILO === '1' || process.env.UNDICI_USE_MILO === 'true'
+let miloInstance = null
+let currentBuffer = null
+let currentBufferSize = 0
+let currentBufferPtr = null
+let currentBufferRef = null
+
+function onParserTimeout (parserWeakRef) {
+ const parser = parserWeakRef.deref ? parserWeakRef.deref() : parserWeakRef
+ if (!parser) {
+ return
+ }
+
+ const { socket, timeoutType, client, paused } = parser
+
+ if (timeoutType === TIMEOUT_HEADERS) {
+ if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
+ assert(!paused, 'cannot be paused while waiting for headers')
+ util.destroy(socket, new HeadersTimeoutError())
+ }
+ } else if (timeoutType === TIMEOUT_BODY) {
+ if (!paused) {
+ util.destroy(socket, new BodyTimeoutError())
+ }
+ } else if (timeoutType === TIMEOUT_KEEP_ALIVE) {
+ assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue])
+ util.destroy(socket, new InformationalError('socket idle timeout'))
+ }
+}
+
+function getMilo () {
+ if (miloInstance) {
+ return miloInstance
+ }
+
+ // Milo modules compile WASM on load; defer loading until the parser is needed.
+ if (useWasmSIMD) {
+ try {
+ miloPackage = require('../milo/simd.js')
+ } catch {}
+ }
+
+ miloPackage = miloPackage || require('../milo/no-simd.js')
+ miloInstance = miloPackage.setup()
+ return miloInstance
+}
+
+class H1Parser {
+ constructor (client, socket) {
+ this.milo = getMilo()
+
+ this.client = client
+ this.socket = socket
+ this.parser = this.milo.create()
+ this.events = new FastBuffer(
+ this.milo.memory.buffer,
+ this.parser + this.milo.ParserFields.EVENTS,
+ 4
+ ).readUInt32LE(0)
+
+ this.milo.setShouldAutodetect(this.parser, false)
+ this.milo.setIsRequest(this.parser, false)
+ this.milo.setShouldManageUnconsumed(this.parser, false)
+ this.milo.setShouldSuspendAfterHeaders(this.parser, true)
+ this.milo.setMaxHeaderLength(this.parser, client[kMaxHeadersSize])
+ this.milo.setActiveEvents(
+ this.parser,
+ this.milo.EVENT_ACTIVE_ON_ERROR |
+ this.milo.EVENT_ACTIVE_ON_MESSAGE_COMPLETE |
+ this.milo.EVENT_ACTIVE_ON_REASON |
+ this.milo.EVENT_ACTIVE_ON_HEADER_NAME |
+ this.milo.EVENT_ACTIVE_ON_HEADER_VALUE |
+ this.milo.EVENT_ACTIVE_ON_HEADERS |
+ this.milo.EVENT_ACTIVE_ON_DATA |
+ this.milo.EVENT_ACTIVE_ON_TRAILER_NAME |
+ this.milo.EVENT_ACTIVE_ON_TRAILER_VALUE
+ )
+
+ this.timeout = null
+ this.timeoutWeakRef = new WeakRef(this)
+ this.timeoutValue = null
+ this.timeoutType = null
+ this.statusCode = 0
+ this.statusText = ''
+ this.upgrade = false
+ this.responseStarted = false
+ this.pausedByParser = false
+ this.pauseStateIsStart = false
+ this.headers = []
+ this.trailers = []
+ this.headersSize = 0
+ this.trailersSize = 0
+ this.headersMaxSize = client[kMaxHeadersSize]
+ this.shouldKeepAlive = false
+ this.paused = false
+ this.errored = false
+ this.waitingForMoreData = 0
+ this.resume = this.resume.bind(this)
+ this.bytesRead = 0
+ this.keepAlive = ''
+ this.connection = ''
+ this.contentLength = -1
+ this.maxResponseSize = client[kMaxResponseSize]
+ this.directBodyRemaining = 0
+ this.directBodyCompletePending = false
+ this.headersSuspended = false
+ this.skipBody = false
+
+ this[kPausedByHandler] = false
+
+ if (
+ INITIAL_BUFFER_SIZE > currentBufferSize ||
+ currentBuffer.buffer !== this.milo.memory.buffer
+ ) {
+ this.ensureBuffers(INITIAL_BUFFER_SIZE)
+ } else {
+ this.updateBuffers()
+ }
+ }
+
+ setTimeout (delay, type) {
+ if (
+ delay !== this.timeoutValue ||
+ (type & USE_FAST_TIMER) ^ (this.timeoutType & USE_FAST_TIMER)
+ ) {
+ if (this.timeout) {
+ timers.clearTimeout(this.timeout)
+ this.timeout = null
+ }
+
+ if (delay) {
+ if (type & USE_FAST_TIMER) {
+ this.timeout = timers.setFastTimeout(
+ onParserTimeout,
+ delay,
+ this.timeoutWeakRef
+ )
+ } else {
+ this.timeout = setTimeout(
+ onParserTimeout,
+ delay,
+ this.timeoutWeakRef
+ )
+ this.timeout?.unref()
+ }
+ }
+
+ this.timeoutValue = delay
+ } else if (this.timeout?.refresh) {
+ this.timeout.refresh()
+ }
+
+ this.timeoutType = type
+ }
+
+ ensureBuffers (size) {
+ const { milo } = this
+
+ if (currentBufferPtr != null) {
+ milo.dealloc(currentBufferPtr, currentBufferSize)
+ }
+
+ // Reallocate buffers
+ currentBufferSize = Math.ceil(size / BUFFER_PAGE_SIZE) * BUFFER_PAGE_SIZE
+ currentBufferPtr = milo.alloc(currentBufferSize)
+ currentBuffer = new FastBuffer(
+ milo.memory.buffer,
+ currentBufferPtr,
+ currentBufferSize
+ )
+
+ this.updateBuffers()
+ }
+
+ updateBuffers () {
+ this.parserFields = new FastBuffer(this.milo.memory.buffer, this.parser)
+ this.parserEvents = new FastBuffer(
+ this.milo.memory.buffer,
+ this.events,
+ 64 * 1024
+ )
+ }
+
+ resume () {
+ if (this.socket.destroyed || !this.paused) {
+ return
+ }
+
+ this.milo.resume(this.parser)
+
+ assert(this.timeoutType === TIMEOUT_BODY)
+ if (this.timeout?.refresh) {
+ this.timeout.refresh()
+ }
+
+ this.paused = false
+ if (this.directBodyCompletePending) {
+ try {
+ this.completeDirectBody()
+ } catch (err) {
+ util.destroy(this.socket, err)
+ return
+ }
+
+ if (this.paused) {
+ return
+ }
+ }
+
+ this.readMore()
+ }
+
+ readMore () {
+ if (this.paused || !this.parser) {
+ return
+ }
+
+ while (!this.paused && this.parser) {
+ if (
+ this.waitingForMoreData &&
+ this.socket.readableLength <= this.waitingForMoreData
+ ) {
+ break
+ }
+
+ this.waitingForMoreData = 0
+
+ const chunk = this.socket.read()
+ if (chunk === null) {
+ break
+ }
+
+ if (this.execute(chunk) === false) {
+ break
+ }
+ }
+ }
+
+ execute (data) {
+ const available = data.length
+ assert(!this.paused)
+
+ const { socket, milo } = this
+
+ try {
+ if (this.directBodyRemaining > 0) {
+ return this.consumeDirectBody(data)
+ }
+
+ if (currentBuffer.buffer !== milo.memory.buffer) {
+ currentBuffer = new FastBuffer(
+ milo.memory.buffer,
+ currentBufferPtr,
+ currentBufferSize
+ )
+ this.updateBuffers()
+ } else if (this.parserEvents.buffer !== milo.memory.buffer) {
+ this.updateBuffers()
+ }
+
+ let offset = 0
+ let parseLen = available
+ const headersEnd = this.statusCode === 0 ? data.indexOf('\r\n\r\n') : -1
+
+ if (headersEnd !== -1) {
+ parseLen = headersEnd + 4
+ }
+
+ for (;;) {
+ if (parseLen > currentBufferSize) {
+ this.ensureBuffers(parseLen)
+ }
+
+ const parseData = data.subarray(offset, offset + parseLen)
+ currentBuffer.set(parseData)
+ currentBufferRef = parseData
+
+ const consumed = milo.parse(this.parser, currentBufferPtr, parseLen)
+ this.drainEvents()
+
+ const consumedTotal = offset + consumed
+
+ if (
+ this.errored ||
+ (consumed === 0 &&
+ this.parserFields[milo.ParserFields.ERROR_CODE] !== milo.ERROR_NONE)
+ ) {
+ throw this.createError(data.subarray(consumedTotal))
+ } else if (this.upgrade) {
+ this.onUpgrade(data.subarray(consumedTotal))
+ return false
+ } else if (this.directBodyCompletePending) {
+ this.completeDirectBody()
+
+ if (this.paused) {
+ return false
+ }
+ } else if (this.pausedByParser) {
+ this.pausedByParser = false
+ this.headersSuspended = false
+ if (this[kPausedByHandler] && this.pauseStateIsStart) {
+ this.pauseStateIsStart = false
+ milo.resume(this.parser)
+ this[kPausedByHandler] = false
+ return false
+ }
+
+ this.pauseStateIsStart = false
+ this.paused = true
+ socket.unshift(data.subarray(consumedTotal))
+ return false
+ }
+
+ if (this.directBodyRemaining > 0) {
+ return this.consumeDirectBody(data.subarray(consumedTotal))
+ }
+
+ if (consumed < parseLen) {
+ const remaining = data.subarray(consumedTotal)
+ socket.unshift(remaining)
+ this.waitingForMoreData = consumed === 0 ? remaining.length : 0
+ return false
+ }
+
+ offset = consumedTotal
+
+ if (offset >= available) {
+ if (this.headersSuspended) {
+ this.headersSuspended = false
+ parseLen = 0
+ continue
+ }
+
+ return true
+ }
+
+ this.headersSuspended = false
+ parseLen = available - offset
+ }
+ } catch (err) {
+ util.destroy(socket, err)
+ return false
+ } finally {
+ currentBufferRef = null
+ }
+ }
+
+ consumeDirectBody (data) {
+ const { socket, client, maxResponseSize } = this
+ const available = data.length
+ const len = Math.min(available, this.directBodyRemaining)
+
+ if (this.timeout?.refresh) {
+ this.timeout.refresh()
+ }
+
+ if (len > 0) {
+ const request = client[kQueue][client[kRunningIdx]]
+ assert(request)
+ assert(this.timeoutType === TIMEOUT_BODY)
+ assert(this.statusCode >= 200)
+
+ if (maxResponseSize > -1 && this.bytesRead + len > maxResponseSize) {
+ throw new ResponseExceededMaxSizeError()
+ }
+
+ this.bytesRead += len
+ this.directBodyRemaining -= len
+
+ if (request.onResponseData(data.subarray(0, len)) === false) {
+ this.directBodyCompletePending = this.directBodyRemaining === 0
+ this.pauseParser()
+ this[kPausedByHandler] = true
+ this.pausedByParser = false
+ this.paused = true
+
+ if (len < available) {
+ socket.unshift(data.subarray(len))
+ }
+
+ return false
+ }
+ }
+
+ if (this.directBodyRemaining === 0) {
+ this.completeDirectBody()
+
+ const remaining = data.subarray(len)
+ if (
+ this.errored ||
+ this.parserFields[this.milo.ParserFields.ERROR_CODE] !==
+ this.milo.ERROR_NONE
+ ) {
+ throw this.createError(remaining)
+ } else if (this.pausedByParser) {
+ this.pausedByParser = false
+ this.pauseStateIsStart = false
+ this.paused = true
+ if (remaining.length > 0) {
+ socket.unshift(remaining)
+ }
+ return false
+ }
+
+ if (remaining.length > 0) {
+ socket.unshift(remaining)
+ return false
+ }
+ }
+
+ return true
+ }
+
+ completeDirectBody () {
+ const { milo } = this
+
+ if (currentBuffer.buffer !== milo.memory.buffer) {
+ currentBuffer = new FastBuffer(
+ milo.memory.buffer,
+ currentBufferPtr,
+ currentBufferSize
+ )
+ this.updateBuffers()
+ } else if (this.parserEvents.buffer !== milo.memory.buffer) {
+ this.updateBuffers()
+ }
+
+ this.directBodyCompletePending = false
+ currentBufferRef = EMPTY_BUF
+
+ milo.complete(this.parser)
+ this.drainEvents()
+ }
+
+ setShouldSkipBody (value) {
+ if (this.skipBody !== value) {
+ this.skipBody = value
+ this.milo.setShouldSkipBody(this.parser, value)
+ }
+ }
+
+ finish () {
+ if (!this.parser) {
+ return null
+ }
+
+ if (this.directBodyRemaining > 0) {
+ return new ResponseContentLengthMismatchError()
+ }
+
+ if (this.parserEvents.buffer !== this.milo.memory.buffer) {
+ this.updateBuffers()
+ }
+
+ this.milo.finish(this.parser)
+ this.drainEvents()
+
+ if (!this.errored) {
+ return null
+ }
+
+ return this.createError(EMPTY_BUF)
+ }
+
+ createError (data) {
+ const { contentLength, bytesRead } = this
+
+ if (contentLength !== -1 && bytesRead !== contentLength) {
+ return new ResponseContentLengthMismatchError()
+ }
+
+ const errorCode = this.parserFields[this.milo.ParserFields.ERROR_CODE]
+ const errorName = this.milo.Errors[errorCode]
+ const errorDescription =
+ errorName === 'UNEXPECTED_EOF'
+ ? 'Invalid EOF state'
+ : this.milo.getErrorDescription(this.parser)
+ const reason =
+ errorName === 'UNEXPECTED_EOF'
+ ? errorDescription
+ : errorDescription
+ ? `[ERROR_${errorName}] ${errorDescription}`
+ : `ERROR_${errorName}`
+ return new HTTPParserError(
+ `Response does not match the HTTP/1.1 protocol (${reason})`,
+ errorName,
+ data
+ )
+ }
+
+ destroy () {
+ if (this.parser) {
+ this.milo.destroy(this.parser)
+ this.parser = null
+ }
+
+ this.timeout && timers.clearTimeout(this.timeout)
+ this.timeout = null
+ this.timeoutValue = null
+ this.timeoutType = null
+ this.paused = false
+ this.responseStarted = false
+ this.pausedByParser = false
+ this.pauseStateIsStart = false
+ this.connection = ''
+ this.skipBody = false
+ }
+
+ pauseParser (stateIsStart = false) {
+ this.milo.pause(this.parser)
+ this.pausedByParser = true
+ this.pauseStateIsStart = stateIsStart
+ }
+
+ drainEvents () {
+ const { socket, client, milo } = this
+ let cursor = 0
+
+ const firstEvent = this.parserEvents[0]
+ if (
+ firstEvent !== milo.EVENT_END &&
+ firstEvent !== milo.EVENT_ERROR &&
+ !this.responseStarted
+ ) {
+ this.responseStarted = true
+
+ if (socket.destroyed) {
+ return this.fail(this.milo.ERROR_CALLBACK_ERROR, 'Other side closed')
+ }
+
+ const request = client[kQueue][client[kRunningIdx]]
+ if (!request) {
+ return this.fail(this.milo.ERROR_CALLBACK_ERROR, 'Missing request')
+ }
+
+ request.onResponseStarted()
+ }
+
+ for (;;) {
+ const event = this.parserEvents[cursor]
+ let eventLen = EVENT_RANGE_SIZE
+ switch (event) {
+ case milo.EVENT_END:
+ return
+ case milo.EVENT_ERROR:
+ this.errored = true
+ return
+ case milo.EVENT_MESSAGE_COMPLETE: {
+ const {
+ client,
+ socket,
+ statusCode,
+ upgrade,
+ trailers,
+ contentLength,
+ bytesRead,
+ shouldKeepAlive
+ } = this
+
+ this.responseStarted = false
+
+ if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Other side closed')
+ }
+
+ if (upgrade) {
+ this.pauseParser()
+ return
+ }
+
+ assert(statusCode >= 100)
+
+ const request = client[kQueue][client[kRunningIdx]]
+ assert(request)
+
+ this.statusCode = 0
+ this.statusText = ''
+ this.bytesRead = 0
+ this.contentLength = -1
+ this.directBodyRemaining = 0
+ this.directBodyCompletePending = false
+ this.headersSuspended = false
+ this.skipBody = false
+ this.keepAlive = ''
+ this.connection = ''
+ this.trailers = []
+ this.trailersSize = 0
+
+ if (statusCode < 200) {
+ break
+ }
+
+ if (
+ request.method !== 'HEAD' &&
+ contentLength !== -1 &&
+ bytesRead !== contentLength
+ ) {
+ util.destroy(socket, new ResponseContentLengthMismatchError())
+ this.pauseParser()
+ break
+ }
+
+ request.onResponseEnd(trailers)
+
+ client[kQueue][client[kRunningIdx]++] = null
+
+ if (socket[kWriting]) {
+ assert(client[kRunning] === 0)
+ util.destroy(socket, new InformationalError('reset'))
+ this.pauseParser(true)
+ } else if (!shouldKeepAlive) {
+ util.destroy(socket, new InformationalError('reset'))
+ this.pauseParser(true)
+ } else if (socket[kReset] && client[kRunning] === 0) {
+ util.destroy(socket, new InformationalError('reset'))
+ this.pauseParser(true)
+ } else if (client[kPipelining] == null || client[kPipelining] === 1) {
+ setImmediate(client[kResume])
+ } else {
+ client[kResume]()
+ }
+
+ break
+ }
+ case milo.EVENT_REASON: {
+ const at = this.parserEvents.readUInt32LE(cursor + 1)
+ const len = this.parserEvents.readUInt32LE(cursor + 5)
+ this.statusText = new FastBuffer(
+ currentBufferRef.buffer,
+ currentBufferRef.byteOffset + at,
+ len
+ ).toString()
+ break
+ }
+ case milo.EVENT_HEADER_NAME: {
+ const at = this.parserEvents.readUInt32LE(cursor + 1)
+ const len = this.parserEvents.readUInt32LE(cursor + 5)
+ const data =
+ len > 0
+ ? new FastBuffer(
+ currentBufferRef.buffer,
+ currentBufferRef.byteOffset + at,
+ len
+ )
+ : EMPTY_BUF
+
+ this.headers.push(data)
+ this.headersSize += len
+ if (this.headersSize >= this.headersMaxSize) {
+ util.destroy(this.socket, new HeadersOverflowError())
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Headers overflow')
+ }
+
+ break
+ }
+ case milo.EVENT_HEADER_VALUE: {
+ const at = this.parserEvents.readUInt32LE(cursor + 1)
+ const len = this.parserEvents.readUInt32LE(cursor + 5)
+ const data =
+ len > 0
+ ? new FastBuffer(
+ currentBufferRef.buffer,
+ currentBufferRef.byteOffset + at,
+ len
+ )
+ : EMPTY_BUF
+ const key = this.headers[this.headers.length - 1]
+
+ this.headers.push(data)
+
+ if (key.length === 10) {
+ const headerName = util.bufferToLowerCasedHeaderName(key)
+ if (headerName === 'keep-alive') {
+ this.keepAlive += (this.keepAlive.length === 0 ? '' : ',') + data.toString()
+ } else if (headerName === 'connection') {
+ this.connection += (this.connection.length === 0 ? '' : ',') + data.toString()
+ }
+ }
+
+ this.headersSize += len
+ if (this.headersSize >= this.headersMaxSize) {
+ util.destroy(this.socket, new HeadersOverflowError())
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Headers overflow')
+ }
+
+ break
+ }
+ case milo.EVENT_HEADERS: {
+ eventLen = EVENT_HEADERS_SIZE
+
+ const statusCode = this.parserEvents.readUInt16LE(cursor + 5)
+ const shouldKeepAlive = this.parserEvents[cursor + 7] !== 0
+ const shouldUpgrade = this.parserEvents[cursor + 8] !== 0
+ const hasTrailers = this.parserEvents[cursor + 9] !== 0
+ const bodyKind = this.parserEvents[cursor + 10]
+ const contentLength =
+ this.parserEvents.readUInt32LE(cursor + 11) +
+ this.parserEvents.readUInt32LE(cursor + 15) * 0x100000000
+
+ const { socket, client, headers, statusText } = this
+
+ if (socket.destroyed) {
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Other side closed')
+ }
+
+ const request = client[kQueue][client[kRunningIdx]]
+ if (!request) {
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Missing request')
+ }
+
+ assert(!this.upgrade)
+ assert(this.statusCode < 200)
+
+ if (statusCode === 100) {
+ util.destroy(
+ socket,
+ new SocketError('bad response', util.getSocketInfo(socket))
+ )
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Bad response')
+ }
+
+ if (shouldUpgrade && !request.upgrade) {
+ util.destroy(
+ socket,
+ new SocketError('bad upgrade', util.getSocketInfo(socket))
+ )
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Bad upgrade')
+ }
+
+ assert(this.timeoutType === TIMEOUT_HEADERS)
+
+ this.statusCode = statusCode
+ this.shouldKeepAlive =
+ shouldKeepAlive ||
+ (request.method === 'HEAD' &&
+ !socket[kReset] &&
+ /(?:^|,)[\t ]*keep-alive[\t ]*(?:,|$)/i.test(this.connection) &&
+ !/(?:^|,)[\t ]*close[\t ]*(?:,|$)/i.test(this.connection))
+ this.contentLength =
+ bodyKind === BODY_KIND_CONTENT_LENGTH ? contentLength : -1
+
+ if (this.statusCode >= 200) {
+ const bodyTimeout =
+ request.bodyTimeout != null
+ ? request.bodyTimeout
+ : client[kBodyTimeout]
+ this.setTimeout(bodyTimeout, TIMEOUT_BODY)
+ } else if (this.timeout?.refresh) {
+ this.timeout.refresh()
+ }
+
+ if (request.method === 'CONNECT') {
+ assert(client[kRunning] === 1)
+ milo.setIsConnect(this.parser, true)
+ this.upgrade = true
+ return
+ }
+
+ if (shouldUpgrade) {
+ assert(client[kRunning] === 1)
+ this.upgrade = true
+ this.pauseParser()
+ return
+ }
+
+ this.headers = []
+ this.headersSize = 0
+
+ if (this.shouldKeepAlive && client[kPipelining]) {
+ const keepAliveTimeout = this.keepAlive
+ ? util.parseKeepAliveTimeout(this.keepAlive)
+ : null
+
+ if (keepAliveTimeout != null) {
+ const timeout = Math.min(
+ keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
+ client[kKeepAliveMaxTimeout]
+ )
+ if (timeout <= 0) {
+ socket[kReset] = true
+ } else {
+ client[kKeepAliveTimeoutValue] = timeout
+ }
+ } else {
+ client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]
+ }
+ } else {
+ socket[kReset] = true
+ }
+
+ const pause =
+ request.onResponseStart(
+ statusCode,
+ headers,
+ this.resume,
+ statusText
+ ) === false
+
+ if (request.aborted) {
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Request aborted')
+ }
+
+ if (request.method === 'HEAD' || statusCode < 200) {
+ this.setShouldSkipBody(true)
+ }
+
+ this.headersSuspended = true
+ if (
+ !pause &&
+ request.method !== 'HEAD' &&
+ statusCode >= 200 &&
+ statusCode !== 204 &&
+ statusCode !== 205 &&
+ statusCode !== 304 &&
+ bodyKind === BODY_KIND_CONTENT_LENGTH &&
+ contentLength > 0 &&
+ !hasTrailers
+ ) {
+ this.directBodyRemaining = contentLength
+ }
+
+ if (socket[kBlocking]) {
+ socket[kBlocking] = false
+ client[kResume]()
+ }
+
+ if (pause) {
+ this.pauseParser()
+ this[kPausedByHandler] = true
+ } else if (
+ request.method === 'HEAD' ||
+ statusCode < 200 ||
+ statusCode === 204 ||
+ statusCode === 205 ||
+ statusCode === 304 ||
+ (bodyKind === BODY_KIND_CONTENT_LENGTH && contentLength === 0)
+ ) {
+ this.directBodyCompletePending = true
+ }
+
+ break
+ }
+ case milo.EVENT_DATA: {
+ const at = this.parserEvents.readUInt32LE(cursor + 1)
+ const len = this.parserEvents.readUInt32LE(cursor + 5)
+ const { client, socket, statusCode, maxResponseSize } = this
+
+ if (socket.destroyed) {
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Other side closed')
+ }
+
+ const request = client[kQueue][client[kRunningIdx]]
+ assert(request)
+ assert(this.timeoutType === TIMEOUT_BODY)
+
+ if (this.timeout?.refresh) {
+ this.timeout.refresh()
+ }
+
+ assert(statusCode >= 200)
+
+ if (maxResponseSize > -1 && this.bytesRead + len > maxResponseSize) {
+ util.destroy(socket, new ResponseExceededMaxSizeError())
+ return this.fail(
+ milo.ERROR_CALLBACK_ERROR,
+ 'Response size exceeded'
+ )
+ }
+
+ this.bytesRead += len
+
+ const buffer = currentBufferRef
+ if (
+ request.onResponseData(
+ new FastBuffer(buffer.buffer, buffer.byteOffset + at, len)
+ ) === false
+ ) {
+ this.pauseParser()
+ this[kPausedByHandler] = true
+ }
+
+ break
+ }
+ case milo.EVENT_TRAILER_NAME: {
+ const at = this.parserEvents.readUInt32LE(cursor + 1)
+ const len = this.parserEvents.readUInt32LE(cursor + 5)
+ const data =
+ len > 0
+ ? new FastBuffer(
+ currentBufferRef.buffer,
+ currentBufferRef.byteOffset + at,
+ len
+ )
+ : EMPTY_BUF
+
+ this.trailers.push(data)
+
+ this.trailersSize += len
+ if (this.trailersSize >= this.headersMaxSize) {
+ util.destroy(this.socket, new HeadersOverflowError())
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Headers overflow')
+ }
+
+ break
+ }
+ case milo.EVENT_TRAILER_VALUE: {
+ const at = this.parserEvents.readUInt32LE(cursor + 1)
+ const len = this.parserEvents.readUInt32LE(cursor + 5)
+ const data =
+ len > 0
+ ? new FastBuffer(
+ currentBufferRef.buffer,
+ currentBufferRef.byteOffset + at,
+ len
+ )
+ : EMPTY_BUF
+
+ this.trailers.push(data)
+
+ this.trailersSize += len
+ if (this.trailersSize >= this.headersMaxSize) {
+ util.destroy(this.socket, new HeadersOverflowError())
+ return this.fail(milo.ERROR_CALLBACK_ERROR, 'Headers overflow')
+ }
+
+ break
+ }
+ default:
+ return
+ }
+
+ cursor += eventLen
+ }
+ }
+
+ fail (code, message) {
+ this.milo.fail(this.parser, code, message)
+ this.errored = true
+ }
+
+ onUpgrade (head) {
+ const { upgrade, client, socket, headers, statusCode } = this
+
+ assert(upgrade)
+ assert(client[kSocket] === socket)
+ assert(!socket.destroyed)
+ assert(!this.paused)
+
+ const request = client[kQueue][client[kRunningIdx]]
+ assert(request)
+ assert(request.upgrade || request.method === 'CONNECT')
+
+ this.statusCode = 0
+ this.statusText = ''
+ this.shouldKeepAlive = false
+ this.headers = []
+ this.headersSize = 0
+
+ socket.unshift(head)
+ socket[kParser].destroy()
+ socket[kParser] = null
+ socket[kClient] = null
+ socket[kError] = null
+
+ removeAllListeners(socket)
+
+ client[kSocket] = null
+ client[kHTTPContext] = null
+ client[kQueue][client[kRunningIdx]++] = null
+ client.emit(
+ 'disconnect',
+ client[kUrl],
+ [client],
+ new InformationalError('upgrade')
+ )
+
+ try {
+ request.onRequestUpgrade(statusCode, headers, socket)
+ } catch (err) {
+ util.destroy(socket, err)
+ }
+
+ client[kResume]()
+ }
+}
+
+function setMiloEnabled (value) {
+ miloEnabled = value
+}
+
+function getMiloEnabled () {
+ return miloEnabled
+}
+
+module.exports = { H1Parser, getMiloEnabled, setMiloEnabled }
diff --git a/deps/undici/src/lib/dispatcher/pool-base.js b/deps/undici/src/lib/dispatcher/pool-base.js
index 1aaa708c7fc..e09ea20a7ef 100644
--- a/deps/undici/src/lib/dispatcher/pool-base.js
+++ b/deps/undici/src/lib/dispatcher/pool-base.js
@@ -20,6 +20,25 @@ const kGetDispatcher = Symbol('get dispatcher')
const kHasDispatcher = Symbol('has dispatcher')
const kAddClient = Symbol('add client')
const kRemoveClient = Symbol('remove client')
+const kRetireClient = Symbol('retire client')
+const kRetiring = Symbol('retiring clients')
+
+// Closes every live client, including clients that have been
+// taken out of rotation but are still finishing their own
+// requests.
+function closeClients (pool) {
+ const closeAll = []
+ for (let i = 0; i < pool[kClients].length; i++) {
+ const client = pool[kClients][i]
+ if (!client.destroyed) {
+ closeAll.push(client.close())
+ }
+ }
+ for (const closed of pool[kRetiring].values()) {
+ closeAll.push(closed)
+ }
+ return Promise.all(closeAll)
+}
class PoolBase extends DispatcherBase {
[kQueue] = new FixedQueue();
@@ -28,6 +47,10 @@ class PoolBase extends DispatcherBase {
[kClients] = [];
+ // Clients removed from kClients that have not finished closing,
+ // mapped to a promise that settles once they have.
+ [kRetiring] = new Map();
+
[kNeedDrain] = false;
[kOnDrain] (client, origin, targets) {
@@ -52,6 +75,15 @@ class PoolBase extends DispatcherBase {
client[kNeedDrain] = needDrain
if (needDrain) {
this[kOnClientBusy](client)
+
+ // This client is full but requests are still queued, e.g. an h2
+ // client that has just released everything queued while ALPN was
+ // negotiated and hit maxConcurrentStreams. Hand the rest to other
+ // clients, creating new ones up to the connection limit, instead of
+ // leaving them for this client to drain one batch at a time.
+ if (!queue.isEmpty()) {
+ return this[kDrainQueue](origin, targets)
+ }
}
if (!needDrain && this[kNeedDrain]) {
@@ -60,15 +92,7 @@ class PoolBase extends DispatcherBase {
}
if (this[kClosedResolve] && queue.isEmpty()) {
- const closeAll = []
- for (let i = 0; i < this[kClients].length; i++) {
- const client = this[kClients][i]
- if (!client.destroyed) {
- closeAll.push(client.close())
- }
- }
- return Promise.all(closeAll)
- .then(this[kClosedResolve])
+ return closeClients(this).then(this[kClosedResolve])
}
}
@@ -106,15 +130,7 @@ class PoolBase extends DispatcherBase {
}
if (this[kClosedResolve] && queue.isEmpty()) {
- const closeAll = []
- for (let i = 0; i < this[kClients].length; i++) {
- const client = this[kClients][i]
- if (!client.destroyed) {
- closeAll.push(client.close())
- }
- }
- return Promise.all(closeAll)
- .then(this[kClosedResolve])
+ return closeClients(this).then(this[kClosedResolve])
}
}
@@ -180,14 +196,7 @@ class PoolBase extends DispatcherBase {
[kClose] () {
if (this[kQueue].isEmpty()) {
- const closeAll = []
- for (let i = 0; i < this[kClients].length; i++) {
- const client = this[kClients][i]
- if (!client.destroyed) {
- closeAll.push(client.close())
- }
- }
- return Promise.all(closeAll)
+ return closeClients(this)
} else {
return new Promise((resolve) => {
this[kClosedResolve] = resolve
@@ -208,6 +217,9 @@ class PoolBase extends DispatcherBase {
for (let i = 0; i < this[kClients].length; i++) {
destroyAll[i] = this[kClients][i].destroy(err)
}
+ for (const client of this[kRetiring].keys()) {
+ destroyAll.push(client.destroy(err))
+ }
return Promise.all(destroyAll)
}
@@ -263,13 +275,37 @@ class PoolBase extends DispatcherBase {
return this
}
- [kRemoveClient] (client) {
+ // Takes a client out of rotation. A closed client no longer takes requests
+ // from the pool queue (see kOnDrain), but it finishes the requests it
+ // already has. Until it has, pool.close() waits for it and pool.destroy()
+ // destroys it.
+ [kRetireClient] (client) {
const idx = this[kClients].indexOf(client)
if (idx !== -1) {
this[kClients].splice(idx, 1)
}
- client.close(() => {})
+ if (client.destroyed || this[kRetiring].has(client)) {
+ return
+ }
+
+ // Use the callback form: custom dispatchers from `factory` are not
+ // required to return a promise, and may call back synchronously.
+ let done = false
+ let resolveClosed
+ const closed = new Promise((resolve) => { resolveClosed = resolve })
+ this[kRetiring].set(client, closed)
+ client.close(() => {
+ if (!done) {
+ done = true
+ this[kRetiring].delete(client)
+ resolveClosed()
+ }
+ })
+ }
+
+ [kRemoveClient] (client) {
+ this[kRetireClient](client)
this[kNeedDrain] = !this[kClients].some(dispatcher => (
!dispatcher[kNeedDrain] &&
@@ -285,6 +321,7 @@ module.exports = {
kNeedDrain,
kAddClient,
kRemoveClient,
+ kRetireClient,
kDrainQueue,
kOnClientBusy,
kOnClientDrain,
diff --git a/deps/undici/src/lib/dispatcher/pool.js b/deps/undici/src/lib/dispatcher/pool.js
index 64b5ca2947a..e44ac84b94f 100644
--- a/deps/undici/src/lib/dispatcher/pool.js
+++ b/deps/undici/src/lib/dispatcher/pool.js
@@ -10,14 +10,15 @@ const {
kOnClientDrain,
kGetDispatcher,
kHasDispatcher,
- kRemoveClient
+ kRemoveClient,
+ kRetireClient
} = require('./pool-base')
const Client = require('./client')
const {
InvalidArgumentError
} = require('../core/errors')
const util = require('../core/util')
-const { kConnecting, kHTTPContext, kUrl } = require('../core/symbols')
+const { kConnecting, kHTTPContext, kUrl, kQueued } = require('../core/symbols')
const buildConnector = require('../core/connect')
const kOptions = Symbol('options')
@@ -144,15 +145,17 @@ class Pool extends PoolBase {
resumeQueued = true
}
- // Do not use kRemoveClient here, as it will close the client,
- // but the client cannot be closed in this state.
- const idx = this[kClients].indexOf(target)
- if (idx !== -1) {
- this[kClients].splice(idx, 1)
+ // Retire (close) the client rather than only dropping it from
+ // kClients: otherwise its drain listener keeps pulling requests from
+ // the pool queue onto a client that pool.destroy() can't reach.
+ if (this[kClients].includes(target)) {
+ this[kRetireClient](target)
}
}
- if (resumeQueued) {
+ // The retired client no longer drains the pool queue, so hand any
+ // queued requests to another (possibly new) client.
+ if (resumeQueued || this[kQueued] > 0) {
this[kDrainQueue](origin, targets.slice(1))
}
})
diff --git a/deps/undici/src/lib/dispatcher/proxy-agent.js b/deps/undici/src/lib/dispatcher/proxy-agent.js
index f82ee8d17fd..19319ff8d10 100644
--- a/deps/undici/src/lib/dispatcher/proxy-agent.js
+++ b/deps/undici/src/lib/dispatcher/proxy-agent.js
@@ -83,11 +83,10 @@ class Http1ProxyWrapper extends DispatcherBase {
opts.path = origin + path
- if (!('host' in headers) && !('Host' in headers)) {
- const { host } = new URL(origin)
- headers.host = host
- }
opts.headers = { ...this[kProxyHeaders], ...headers }
+ if (!hasHostHeader(headers)) {
+ opts.headers.host = new URL(origin).host
+ }
// Pin the SNI/cert hostname to the proxy. Without this the underlying
// Client would derive it from the (rewritten) Host header, which points
@@ -276,12 +275,14 @@ class ProxyAgent extends DispatcherBase {
}
dispatch (opts, handler) {
- const headers = buildHeaders(opts.headers)
+ let headers = buildHeaders(opts.headers)
throwIfProxyAuthIsSent(headers)
- if (headers && !('host' in headers) && !('Host' in headers)) {
- const { host } = new URL(opts.origin)
- headers.host = host
+ if (headers && !hasHostHeader(headers)) {
+ if (headers === opts.headers) {
+ headers = { ...headers }
+ }
+ headers.host = new URL(opts.origin).host
}
return this[kAgent].dispatch(
@@ -401,6 +402,15 @@ function isProxyAuthorizationHeader (key) {
return key.length === proxyAuthorization.length && key.toLowerCase() === proxyAuthorization
}
+function hasHostHeader (headers) {
+ for (const key in headers) {
+ if (key.length === 4 && key.toLowerCase() === 'host') {
+ return true
+ }
+ }
+ return false
+}
+
function throwProxyAuthError () {
throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
}
diff --git a/deps/undici/src/lib/dispatcher/retry-agent.js b/deps/undici/src/lib/dispatcher/retry-agent.js
index 0b50f22a318..e0374f80c2d 100644
--- a/deps/undici/src/lib/dispatcher/retry-agent.js
+++ b/deps/undici/src/lib/dispatcher/retry-agent.js
@@ -26,6 +26,16 @@ class RetryAgent extends Dispatcher {
return this.#agent.dispatch(opts, retry)
}
+ // WebSocket and EventSource read their receive limits from the dispatcher
+ // they are given, so report the wrapped agent's settings rather than none.
+ get webSocketOptions () {
+ return this.#agent.webSocketOptions
+ }
+
+ get eventSourceOptions () {
+ return this.#agent.eventSourceOptions
+ }
+
close () {
return this.#agent.close()
}
diff --git a/deps/undici/src/lib/dispatcher/round-robin-pool.js b/deps/undici/src/lib/dispatcher/round-robin-pool.js
index 1db82a9ccb3..657f75557e0 100644
--- a/deps/undici/src/lib/dispatcher/round-robin-pool.js
+++ b/deps/undici/src/lib/dispatcher/round-robin-pool.js
@@ -7,14 +7,16 @@ const {
kAddClient,
kGetDispatcher,
kHasDispatcher,
- kRemoveClient
+ kRemoveClient,
+ kRetireClient,
+ kDrainQueue
} = require('./pool-base')
const Client = require('./client')
const {
InvalidArgumentError
} = require('../core/errors')
const util = require('../core/util')
-const { kUrl } = require('../core/symbols')
+const { kUrl, kQueued } = require('../core/symbols')
const buildConnector = require('../core/connect')
const kOptions = Symbol('options')
@@ -82,12 +84,20 @@ class RoundRobinPool extends PoolBase {
})
this.on('connectionError', (origin, targets, error) => {
+ // Retire (close) the client rather than only dropping it from
+ // kClients: otherwise its drain listener keeps pulling requests from
+ // the pool queue onto a client that pool.destroy() can't reach.
for (const target of targets) {
- const idx = this[kClients].indexOf(target)
- if (idx !== -1) {
- this[kClients].splice(idx, 1)
+ if (this[kClients].includes(target)) {
+ this[kRetireClient](target)
}
}
+
+ // The retired client no longer drains the pool queue, so hand any
+ // queued requests to another (possibly new) client.
+ if (this[kQueued] > 0) {
+ this[kDrainQueue](origin, targets.slice(1))
+ }
})
}
diff --git a/deps/undici/src/lib/handler/cache-handler.js b/deps/undici/src/lib/handler/cache-handler.js
index 2ec550b431a..fed01a1aa0c 100644
--- a/deps/undici/src/lib/handler/cache-handler.js
+++ b/deps/undici/src/lib/handler/cache-handler.js
@@ -1,6 +1,7 @@
'use strict'
const util = require('../core/util')
+const { kRedirectCacheControl } = require('../core/symbols')
const {
parseCacheControlHeader,
hasInvalidCacheControlDirective,
@@ -13,6 +14,63 @@ const { parseHttpDate } = require('../util/date.js')
function noop () {}
+class CacheController {
+ #blocked = false
+ #downstreamPaused = false
+
+ constructor (target) {
+ this.target = target
+ }
+
+ block () {
+ this.#blocked = true
+ }
+
+ release () {
+ this.#blocked = false
+ if (!this.#downstreamPaused) {
+ this.target.resume()
+ }
+ }
+
+ pause () {
+ this.#downstreamPaused = true
+ this.target.pause()
+ }
+
+ resume () {
+ this.#downstreamPaused = false
+ if (!this.#blocked) {
+ this.target.resume()
+ }
+ }
+
+ abort (reason) {
+ this.target.abort(reason)
+ }
+
+ get paused () { return this.#downstreamPaused }
+ get aborted () { return this.target.aborted }
+ get reason () { return this.target.reason }
+ get rawHeaders () { return this.target.rawHeaders }
+ set rawHeaders (value) { this.target.rawHeaders = value }
+ get rawTrailers () { return this.target.rawTrailers }
+ set rawTrailers (value) { this.target.rawTrailers = value }
+}
+
+/**
+ * @param {string | URL} a
+ * @param {string | URL} b
+ * @returns {boolean}
+ */
+function sameOrigin (a, b) {
+ try {
+ return new URL(String(a)).origin === new URL(String(b)).origin
+ } catch {
+ return String(a) === String(b)
+ }
+}
+
// Status codes that we can use some heuristics on to cache
const HEURISTICALLY_CACHEABLE_STATUS_CODES = [
200, 203, 204, 206, 300, 301, 308, 404, 405, 410, 414, 501
@@ -149,11 +207,24 @@ class CacheHandler {
*/
#handler
+ /**
+ * @type {CacheController | undefined}
+ */
+ #downstreamController
+
/**
* @type {import('node:stream').Writable | undefined}
*/
#writeStream
+ /**
+ * The URLs visited while following redirects, shared by reference from the
+ * redirect handler through the request context. Carries the suppressed hops'
+ * cache-control under {@link kRedirectCacheControl}.
+ * @type {URL[] | undefined}
+ */
+ #history
+
/**
* @param {import('../../types/cache-interceptor.d.ts').default.CacheHandlerOptions} opts
* @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} cacheKey
@@ -170,7 +241,15 @@ class CacheHandler {
onRequestStart (controller, context) {
this.#writeStream?.destroy()
this.#writeStream = undefined
- this.#handler.onRequestStart?.(controller, context)
+ this.#downstreamController = new CacheController(controller)
+ // The redirect handler threads the list of visited URLs through the
+ // handler-chain context. Keep a reference to it (it is mutated as redirects
+ // are followed) so onResponseStart can tell which request actually produced
+ // the response. Unlike the request options object, this reference is not
+ // broken by an interceptor that copies the options between the cache and
+ // the redirect.
+ this.#history = context?.history
+ this.#handler.onRequestStart?.(this.#downstreamController, context)
}
onBodySent (chunk) {
@@ -181,8 +260,8 @@ class CacheHandler {
this.#handler.onRequestSent?.()
}
- onRequestUpgrade (controller, statusCode, headers, socket) {
- this.#handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
+ onRequestUpgrade (_controller, statusCode, headers, socket) {
+ this.#handler.onRequestUpgrade?.(this.#downstreamController, statusCode, headers, socket)
}
/**
@@ -199,7 +278,7 @@ class CacheHandler {
) {
const downstreamOnHeaders = () =>
this.#handler.onResponseStart?.(
- controller,
+ this.#downstreamController,
statusCode,
resHeaders,
statusMessage
@@ -217,6 +296,35 @@ class CacheHandler {
return downstreamOnHeaders()
}
+ // A cross-origin redirect can change the origin that actually produced the
+ // final response. Keying that response on the original (trusted) origin
+ // would let a redirect target control an entry for a URL the application
+ // trusts. The final request is the last URL in the redirect history; only
+ // cache when its origin still matches the cache key origin.
+ if (this.#history && this.#history.length > 0) {
+ const finalUrl = this.#history[this.#history.length - 1]
+ if (!sameOrigin(finalUrl.origin, this.#cacheKey.origin)) {
+ return downstreamOnHeaders()
+ }
+ }
+
+ // A redirect hop that is not forwarded can still carry a restrictive
+ // storage policy (for example `no-store`, or `private` for a shared cache).
+ // Honor it, otherwise a redirect that must not be stored could be laundered
+ // into a cacheable final response under the original key.
+ const redirectCacheControl = this.#history?.[kRedirectCacheControl]
+ if (redirectCacheControl) {
+ for (const hopCacheControl of redirectCacheControl) {
+ const hopDirectives = hopCacheControl ? parseCacheControlHeader(hopCacheControl) : {}
+ if (
+ hopDirectives['no-store'] === true ||
+ (this.#cacheType === 'shared' && hopDirectives.private === true)
+ ) {
+ return downstreamOnHeaders()
+ }
+ }
+ }
+
const cacheControlHeader = resHeaders['cache-control']
const cacheControlDirectives = cacheControlHeader ? parseCacheControlHeader(cacheControlHeader) : {}
@@ -323,10 +431,21 @@ class CacheHandler {
// Not modified, re-use the cached value
// https://www.rfc-editor.org/rfc/rfc9111.html#name-handling-304-not-modified
if (statusCode === 304) {
+ let done = false
+ const finish304 = () => {
+ if (done) {
+ return
+ }
+ done = true
+ this.#downstreamController.release()
+ }
+
const handle304 = (cachedValue) => {
if (!cachedValue) {
// Do not create a new cache entry, as a 304 won't have a body - so cannot be cached.
- return downstreamOnHeaders()
+ downstreamOnHeaders()
+ finish304()
+ return
}
// Re-use the cached value: statuscode, statusmessage, headers and body
@@ -341,6 +460,7 @@ class CacheHandler {
this.#writeStream = this.#store.createWriteStream(this.#cacheKey, value)
if (!this.#writeStream || !cachedValue?.body) {
+ finish304()
return
}
@@ -348,20 +468,26 @@ class CacheHandler {
const bodyIterator = cachedValue.body.values()
const streamCachedBody = () => {
+ if (done) {
+ return
+ }
for (const chunk of bodyIterator) {
- const full = this.#writeStream.write(chunk) === false
- this.#handler.onResponseData?.(controller, chunk)
+ const full = this.#writeStream?.write(chunk) === false
+ this.#handler.onResponseData?.(this.#downstreamController, chunk)
// when stream is full stop writing until we get a 'drain' event
if (full) {
- break
+ return
}
}
+ finish304()
}
this.#writeStream
.on('error', function () {
handler.#writeStream = undefined
handler.#store.delete(handler.#cacheKey)
+ // Keep replaying downstream without the store
+ streamCachedBody()
})
.on('drain', () => {
streamCachedBody()
@@ -369,6 +495,8 @@ class CacheHandler {
.on('close', function () {
if (handler.#writeStream === this) {
handler.#writeStream = undefined
+ // Keep replaying downstream without the store
+ streamCachedBody()
}
})
@@ -377,15 +505,17 @@ class CacheHandler {
// Readable stream body (e.g. from async/remote cache stores)
cachedValue.body
.on('data', (chunk) => {
- this.#writeStream.write(chunk)
- this.#handler.onResponseData?.(controller, chunk)
+ this.#writeStream?.write(chunk)
+ this.#handler.onResponseData?.(this.#downstreamController, chunk)
})
.on('end', () => {
- this.#writeStream.end()
+ this.#writeStream?.end()
+ finish304()
})
.on('error', () => {
this.#writeStream = undefined
this.#store.delete(this.#cacheKey)
+ finish304()
})
this.#writeStream
@@ -398,6 +528,8 @@ class CacheHandler {
handler.#writeStream = undefined
}
})
+ } else {
+ finish304()
}
}
@@ -405,8 +537,14 @@ class CacheHandler {
* @type {import('../../types/cache-interceptor.d.ts').default.CacheValue}
*/
const result = this.#store.get(this.#cacheKey)
+ // A 304 ends before the cached body is replayed. Keep the origin
+ // response paused until replay is complete.
+ this.#downstreamController.block()
+ controller.pause()
if (result && typeof result.then === 'function') {
- result.then(handle304)
+ result.then(handle304, () => handle304(undefined)).catch((err) => {
+ controller.abort(err)
+ })
} else {
handle304(result)
}
@@ -449,18 +587,18 @@ class CacheHandler {
controller.pause()
}
- this.#handler.onResponseData?.(controller, chunk)
+ this.#handler.onResponseData?.(this.#downstreamController, chunk)
}
onResponseEnd (controller, trailers) {
this.#writeStream?.end()
- this.#handler.onResponseEnd?.(controller, trailers)
+ this.#handler.onResponseEnd?.(this.#downstreamController, trailers)
}
onResponseError (controller, err) {
this.#writeStream?.destroy(err)
this.#writeStream = undefined
- this.#handler.onResponseError?.(controller, err)
+ this.#handler.onResponseError?.(this.#downstreamController, err)
}
}
diff --git a/deps/undici/src/lib/handler/deduplication-handler.js b/deps/undici/src/lib/handler/deduplication-handler.js
index 27bd14d7468..dce39f67efe 100644
--- a/deps/undici/src/lib/handler/deduplication-handler.js
+++ b/deps/undici/src/lib/handler/deduplication-handler.js
@@ -16,6 +16,7 @@ const DEFAULT_MAX_BUFFER_SIZE = 5 * 1024 * 1024
* @property {number} bufferedBytes
* @property {object | null} pendingTrailers
* @property {boolean} done
+ * @property {boolean} [pendingStart] onRequestStart deferred until the primary request's context is known
*/
/**
@@ -30,6 +31,20 @@ class DeduplicationHandler {
*/
#primaryHandler
+ /**
+ * Whether the primary request has started (onRequestStart received). Until
+ * then the request context is unknown and cannot be given to waiting handlers.
+ * @type {boolean}
+ */
+ #requestStarted = false
+
+ /**
+ * The primary request context, replayed to waiting handlers so they observe
+ * the same redirect history as the primary.
+ * @type {any}
+ */
+ #context = null
+
/**
* @type {WaitingHandler[]}
*/
@@ -112,20 +127,30 @@ class DeduplicationHandler {
const waitingController = waitingHandler.controller
try {
- handler.onRequestStart?.(waitingController, null)
+ if (this.#requestStarted) {
+ // The primary request has started, so its context (including the
+ // redirect history) is known and can be delivered immediately.
+ handler.onRequestStart?.(waitingController, this.#context)
- if (waitingController.aborted) {
- waitingHandler.done = true
- return true
- }
+ if (waitingController.aborted) {
+ waitingHandler.done = true
+ return true
+ }
- if (this.#responseStarted) {
- handler.onResponseStart?.(
- waitingController,
- this.#statusCode,
- this.#headers,
- this.#statusMessage
- )
+ if (this.#responseStarted) {
+ handler.onResponseStart?.(
+ waitingController,
+ this.#statusCode,
+ this.#headers,
+ this.#statusMessage
+ )
+ }
+ } else {
+ // The primary request has not started yet. Defer onRequestStart until
+ // its context is known, so the waiting handler observes the same
+ // redirect history as the primary (a cache handler relies on it to
+ // reject cross-origin redirect responses).
+ waitingHandler.pendingStart = true
}
} catch {
// Ignore errors from waiting handlers
@@ -146,6 +171,24 @@ class DeduplicationHandler {
*/
onRequestStart (controller, context) {
this.#controller = controller
+ if (!this.#requestStarted) {
+ this.#requestStarted = true
+ this.#context = context
+ // Deliver the now-known context to handlers that joined before the
+ // primary request started.
+ for (const waitingHandler of this.#waitingHandlers) {
+ if (waitingHandler.pendingStart && !waitingHandler.done && !waitingHandler.controller.aborted) {
+ waitingHandler.pendingStart = false
+ try {
+ waitingHandler.handler.onRequestStart?.(waitingHandler.controller, context)
+ } catch {
+ // Ignore errors from waiting handlers
+ waitingHandler.done = true
+ }
+ }
+ }
+ this.#pruneDoneWaitingHandlers()
+ }
this.#primaryHandler.onRequestStart?.(controller, context)
}
@@ -251,40 +294,41 @@ class DeduplicationHandler {
return
}
- // Remove the entry before callbacks can synchronously dispatch a retry.
- this.#cleanup()
- this.#primaryHandler.onResponseEnd?.(controller, trailers)
- // A throwing end callback must still be handled by onResponseError.
this.#completed = true
+ // Remove the completed request before callbacks can redispatch into this
+ // interceptor. Cleanup must not depend on downstream handlers succeeding.
+ this.#cleanup()
- for (const waitingHandler of this.#waitingHandlers) {
- if (waitingHandler.done || waitingHandler.controller.aborted) {
- waitingHandler.done = true
- continue
- }
+ try {
+ this.#primaryHandler.onResponseEnd?.(controller, trailers)
+ } catch (err) {
+ // Completion callbacks may throw to initiate a retry. The transport's
+ // error callback would be ignored now that this handler is completed.
+ this.#primaryHandler.onResponseError?.(controller, err)
+ } finally {
+ for (const waitingHandler of this.#waitingHandlers) {
+ if (waitingHandler.done || waitingHandler.controller.aborted) {
+ waitingHandler.done = true
+ continue
+ }
- this.#flushWaitingHandler(waitingHandler)
+ this.#flushWaitingHandler(waitingHandler)
- if (waitingHandler.done || waitingHandler.controller.aborted) {
- waitingHandler.done = true
- continue
- }
+ if (waitingHandler.done || waitingHandler.controller.aborted) {
+ waitingHandler.done = true
+ continue
+ }
- if (waitingHandler.controller.paused) {
- waitingHandler.pendingTrailers = trailers
- continue
- }
+ if (waitingHandler.controller.paused) {
+ waitingHandler.pendingTrailers = trailers
+ continue
+ }
- try {
- waitingHandler.handler.onResponseEnd?.(waitingHandler.controller, trailers)
- } catch (err) {
- this.#errorWaitingHandler(waitingHandler, err)
+ this.#endWaitingHandler(waitingHandler, trailers)
}
- waitingHandler.done = true
+ this.#pruneDoneWaitingHandlers()
}
-
- this.#pruneDoneWaitingHandlers()
}
/**
@@ -300,13 +344,15 @@ class DeduplicationHandler {
this.#completed = true
this.#cleanup()
- this.#primaryHandler.onResponseError?.(controller, err)
+ try {
+ this.#primaryHandler.onResponseError?.(controller, err)
+ } finally {
+ for (const waitingHandler of this.#waitingHandlers) {
+ this.#errorWaitingHandler(waitingHandler, err)
+ }
- for (const waitingHandler of this.#waitingHandlers) {
- this.#errorWaitingHandler(waitingHandler, err)
+ this.#waitingHandlers = []
}
-
- this.#waitingHandlers = []
}
#cleanup () {
@@ -327,7 +373,8 @@ class DeduplicationHandler {
bufferedChunks: [],
bufferedBytes: 0,
pendingTrailers: null,
- done: false
+ done: false,
+ pendingStart: false
}
const state = {
@@ -352,14 +399,7 @@ class DeduplicationHandler {
!state.paused &&
!state.aborted
) {
- try {
- waitingHandler.handler.onResponseEnd?.(waitingHandler.controller, waitingHandler.pendingTrailers)
- } catch (err) {
- this.#errorWaitingHandler(waitingHandler, err)
- }
-
- waitingHandler.pendingTrailers = null
- waitingHandler.done = true
+ this.#endWaitingHandler(waitingHandler, waitingHandler.pendingTrailers)
}
this.#pruneDoneWaitingHandlers()
@@ -448,6 +488,27 @@ class DeduplicationHandler {
}
}
+ /**
+ * @param {WaitingHandler} waitingHandler
+ * @param {object} trailers
+ */
+ #endWaitingHandler (waitingHandler, trailers) {
+ waitingHandler.done = true
+ waitingHandler.pendingTrailers = null
+
+ try {
+ waitingHandler.handler.onResponseEnd?.(waitingHandler.controller, trailers)
+ } catch (err) {
+ // This is a response failure, not a consumer abort. Aborting the waiting
+ // controller here would prevent downstream handlers from retrying.
+ try {
+ waitingHandler.handler.onResponseError?.(waitingHandler.controller, err)
+ } catch {
+ // An error callback must not prevent other waiting handlers completing.
+ }
+ }
+ }
+
/**
* @param {WaitingHandler} waitingHandler
* @param {Error} err
diff --git a/deps/undici/src/lib/handler/redirect-handler.js b/deps/undici/src/lib/handler/redirect-handler.js
index 7b0a0cf927d..604be127637 100644
--- a/deps/undici/src/lib/handler/redirect-handler.js
+++ b/deps/undici/src/lib/handler/redirect-handler.js
@@ -2,8 +2,8 @@
const util = require('../core/util')
const assert = require('node:assert')
-const { InvalidArgumentError } = require('../core/errors')
-const { kRequestOrigin } = require('../core/symbols')
+const { InvalidArgumentError, MaxRedirectsError } = require('../core/errors')
+const { kRequestOrigin, kRedirectCacheControl } = require('../core/symbols')
const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
@@ -38,6 +38,15 @@ class RedirectHandler {
this.maxRedirections = maxRedirections
this.handler = handler
this.history = []
+ // `cache-control` of each intermediate (suppressed) redirect hop. An outer
+ // cache uses it to preserve a hop's storage policy (e.g. `no-store`) that
+ // would otherwise be lost because the hop's response is not forwarded. It
+ // travels as a non-enumerable property of the history array so it reaches
+ // the cache without becoming part of the public request/response context.
+ Object.defineProperty(this.history, kRedirectCacheControl, {
+ value: [],
+ enumerable: false
+ })
}
onRequestStart (controller, context) {
@@ -62,10 +71,6 @@ class RedirectHandler {
return
}
- if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) {
- throw new Error('max redirects')
- }
-
let removeContentHeaders = statusCode === 303
// https://tools.ietf.org/html/rfc7231#section-6.4.2
@@ -91,9 +96,19 @@ class RedirectHandler {
this.opts.body = null
}
- this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) || redirectableStatusCodes.indexOf(statusCode) === -1
+ this.location = util.isDisturbed(this.opts.body) || redirectableStatusCodes.indexOf(statusCode) === -1
? null
- : headers.location
+ : headers.location || null
+
+ // Only a redirect that would otherwise be followed counts against the
+ // limit. The final response after exactly maxRedirections redirects, or a
+ // 3xx without a Location header, is delivered as usual.
+ if (this.location && this.history.length >= this.maxRedirections) {
+ if (this.opts.throwOnMaxRedirect) {
+ throw new MaxRedirectsError()
+ }
+ this.location = null
+ }
const requestOrigin = this.opts[kRequestOrigin] === undefined
? this.opts.origin
@@ -108,6 +123,11 @@ class RedirectHandler {
return
}
+ // This hop's response is suppressed (only its Location is used). Record its
+ // cache-control so an outer cache can honor a restrictive policy that would
+ // otherwise be lost when the final response is stored.
+ this.history[kRedirectCacheControl].push(headers['cache-control'])
+
const baseUrl = requestOrigin
? new URL(this.opts.path, requestOrigin)
: undefined
diff --git a/deps/undici/src/lib/handler/retry-handler.js b/deps/undici/src/lib/handler/retry-handler.js
index 38b178d276e..b7c458b0ea5 100644
--- a/deps/undici/src/lib/handler/retry-handler.js
+++ b/deps/undici/src/lib/handler/retry-handler.js
@@ -4,6 +4,7 @@ const assert = require('node:assert')
const { kRetryHandlerDefaultRetry } = require('../core/symbols')
const { RequestRetryError, RequestAbortedError } = require('../core/errors')
const {
+ hasSafeIterator,
isDisturbed,
parseRangeHeader,
wrapRequestBody
@@ -554,19 +555,9 @@ class RetryHandler {
retry () {
if (this.start !== 0) {
- const headers = { range: `bytes=${this.start}-${this.end ?? ''}` }
-
- // Weak etag check - weak etags will make comparison algorithms never match
- if (this.etag != null) {
- headers['if-match'] = this.etag
- }
-
this.opts = {
...this.opts,
- headers: {
- ...this.opts.headers,
- ...headers
- }
+ headers: buildResumeHeaders(this.opts.headers, `bytes=${this.start}-${this.end ?? ''}`, this.etag)
}
}
@@ -650,4 +641,46 @@ class RetryHandler {
}
}
+function isReplacedHeader (key, etag) {
+ const name = key.toLowerCase()
+ return name === 'range' || (etag != null && name === 'if-match')
+}
+
+function buildResumeHeaders (headers, range, etag) {
+ if (Array.isArray(headers) || (headers && typeof headers === 'object' && hasSafeIterator(headers))) {
+ const ret = []
+ if (Array.isArray(headers)) {
+ for (let i = 0; i < headers.length; i += 2) {
+ if (!isReplacedHeader(headers[i], etag)) {
+ ret.push(headers[i], headers[i + 1])
+ }
+ }
+ } else {
+ for (const [key, value] of headers) {
+ if (!isReplacedHeader(key, etag)) {
+ ret.push(key, value)
+ }
+ }
+ }
+ ret.push('range', range)
+ // Weak etag check - weak etags will make comparison algorithms never match
+ if (etag != null) {
+ ret.push('if-match', etag)
+ }
+ return ret
+ }
+
+ const ret = {}
+ for (const key in headers) {
+ if (Object.hasOwn(headers, key) && !isReplacedHeader(key, etag)) {
+ ret[key] = headers[key]
+ }
+ }
+ ret.range = range
+ if (etag != null) {
+ ret['if-match'] = etag
+ }
+ return ret
+}
+
module.exports = RetryHandler
diff --git a/deps/undici/src/lib/interceptor/cache.js b/deps/undici/src/lib/interceptor/cache.js
index 42252028d3e..b16c8994338 100644
--- a/deps/undici/src/lib/interceptor/cache.js
+++ b/deps/undici/src/lib/interceptor/cache.js
@@ -210,7 +210,10 @@ function makeRevalidationHeaders (opts, result) {
*/
function isStale (result, cacheControlDirectives, cacheType) {
const now = Date.now()
- if (now > result.staleAt) {
+ // A zero freshness lifetime (e.g. max-age=0 with a validator) is never fresh,
+ // even when reused within the same millisecond or after a clock step back.
+ // https://www.rfc-editor.org/rfc/rfc9111.html#section-4.2
+ if (now > result.staleAt || result.staleAt <= result.cachedAt) {
// Response is stale
if (!staleResponseRequiresRevalidation(result, cacheType) && cacheControlDirectives?.['max-stale']) {
// There's a threshold where we can serve stale responses, let's see if
@@ -331,6 +334,7 @@ function sendCachedValue (handler, opts, result, age, context, isStale) {
assert(!stream.readableDidRead, 'stream should not be readableDidRead')
let aborted = false
+ let abortReason = null
const controller = {
rawHeaders: [],
@@ -348,11 +352,15 @@ function sendCachedValue (handler, opts, result, age, context, isStale) {
return aborted
},
get reason () {
- return stream.errored
+ return abortReason
},
abort (reason) {
+ if (aborted) {
+ return
+ }
aborted = true
- stream.destroy(reason ?? new AbortError())
+ abortReason = reason ?? new AbortError()
+ stream.destroy(abortReason)
}
}
diff --git a/deps/undici/src/lib/interceptor/decompress.js b/deps/undici/src/lib/interceptor/decompress.js
index ee02f91f897..0b6d2bcc0cf 100644
--- a/deps/undici/src/lib/interceptor/decompress.js
+++ b/deps/undici/src/lib/interceptor/decompress.js
@@ -1,6 +1,6 @@
'use strict'
-const { createInflate, createGunzip, createBrotliDecompress, createZstdDecompress } = require('node:zlib')
+const { createInflate, createGunzip, createBrotliDecompress, createZstdDecompress, constants } = require('node:zlib')
const { pipeline, Transform: TransformStream } = require('node:stream')
const { InvalidArgumentError, ResponseExceededMaxSizeError } = require('../core/errors')
const DecoratorHandler = require('../handler/decorator-handler')
@@ -63,6 +63,10 @@ class DecompressController {
}
}
+// `compress` and `x-compress` are deliberately absent. RFC 9110 section
+// 8.4.1.1 defines them as the UNIX compress (LZW) format, which zlib cannot
+// read, so inflating them turns a readable response into a Z_DATA_ERROR.
+// fetch() leaves them alone, and so does this interceptor.
/** @type {Record<string, () => DecompressorStream>} */
const supportedEncodings = {
__proto__: null,
@@ -70,9 +74,8 @@ const supportedEncodings = {
'x-gzip': createGunzip,
br: createBrotliDecompress,
deflate: createInflate,
- compress: createInflate,
- 'x-compress': createInflate,
- zstd: createZstdDecompress
+ // https://www.rfc-editor.org/rfc/rfc9659.html#section-3
+ zstd: createZstdDecompress.bind(null, { params: { [constants.ZSTD_d_windowLogMax]: 23 } })
}
const defaultSkipStatusCodes = /** @type {const} */ ([204, 304])
@@ -220,9 +223,14 @@ class DecompressHandler extends DecoratorHandler {
this.#decompressedSize = decompressedSize
}
- const result = super.onResponseData(this.#controller, chunk)
- if (result === false && !this.#controller.paused) {
- this.#controller.pause()
+ try {
+ const result = super.onResponseData(this.#controller, chunk)
+ if (result === false && !this.#controller.paused) {
+ this.#controller.pause()
+ }
+ } catch (err) {
+ this.#fail(err)
+ return
}
}
} while (this.#drainRequested && !this.#terminated && !this.#controller.paused)
@@ -239,9 +247,14 @@ class DecompressHandler extends DecoratorHandler {
return
}
- this.#terminated = true
this.#cleanupDecompressors()
- super.onResponseEnd(this.#controller, this.#trailers)
+ try {
+ super.onResponseEnd(this.#controller, this.#trailers)
+ } catch (err) {
+ this.#fail(err)
+ return
+ }
+ this.#terminated = true
}
#onDecompressionEnd () {
diff --git a/deps/undici/src/lib/interceptor/dns.js b/deps/undici/src/lib/interceptor/dns.js
index ecca6efeb66..54af2542e92 100644
--- a/deps/undici/src/lib/interceptor/dns.js
+++ b/deps/undici/src/lib/interceptor/dns.js
@@ -190,6 +190,16 @@ class DNSInstance {
newOpts.affinity
)
+ // The lookup succeeded, but nothing it returned is usable here: with
+ // dualStack disabled and an affinity set, records of the other family
+ // cannot be picked. Running the lookup again would return the same
+ // records, so report it the way an empty result is reported.
+ if (ip == null) {
+ this.storage.delete(origin.hostname)
+ cb(new InformationalError('No DNS entries found'))
+ return
+ }
+
let port
if (typeof ip.port === 'number') {
port = `:${ip.port}`
@@ -346,6 +356,7 @@ class DNSInstance {
// We delete expired records
// It is possible that they have different TTL, so we manage them individually
family.ips.splice(position, 1)
+ return this.pickFamily(origin, ipFamily)
}
return ip
diff --git a/deps/undici/src/lib/interceptor/response-error.js b/deps/undici/src/lib/interceptor/response-error.js
index a8105aa1437..5265d919e58 100644
--- a/deps/undici/src/lib/interceptor/response-error.js
+++ b/deps/undici/src/lib/interceptor/response-error.js
@@ -2,7 +2,9 @@
// const { parseHeaders } = require('../core/util')
const DecoratorHandler = require('../handler/decorator-handler')
-const { ResponseError } = require('../core/errors')
+const { InvalidArgumentError, ResponseError } = require('../core/errors')
+
+const defaultMaxSize = 1024 * 1024
class ResponseErrorHandler extends DecoratorHandler {
#statusCode
@@ -10,9 +12,13 @@ class ResponseErrorHandler extends DecoratorHandler {
#decoder
#headers
#body
+ #bodySize
+ #bodyTruncated
+ #maxSize
- constructor (_opts, { handler }) {
+ constructor ({ maxSize }, { handler }) {
super(handler)
+ this.#maxSize = maxSize
}
#checkContentType (contentType) {
@@ -25,6 +31,8 @@ class ResponseErrorHandler extends DecoratorHandler {
this.#decoder = null
this.#headers = null
this.#body = ''
+ this.#bodySize = 0
+ this.#bodyTruncated = false
return super.onRequestStart(controller, context)
}
@@ -43,39 +51,69 @@ class ResponseErrorHandler extends DecoratorHandler {
}
}
+ #createResponseError () {
+ this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? ''
+ this.#decoder = null
+
+ if (!this.#bodyTruncated && this.#checkContentType('application/json')) {
+ try {
+ this.#body = JSON.parse(this.#body)
+ } catch {
+ // Do nothing...
+ }
+ }
+
+ let err
+ const stackTraceLimit = Error.stackTraceLimit
+ Error.stackTraceLimit = 0
+ try {
+ err = new ResponseError('Response Error', this.#statusCode, {
+ body: this.#body,
+ bodyTruncated: this.#bodyTruncated,
+ headers: this.#headers
+ })
+ } finally {
+ Error.stackTraceLimit = stackTraceLimit
+ }
+
+ return err
+ }
+
onResponseData (controller, chunk) {
if (this.#statusCode < 400) {
return super.onResponseData(controller, chunk)
}
- this.#body += this.#decoder?.decode(chunk, { stream: true }) ?? ''
+ if (this.#decoder == null) {
+ return
+ }
+
+ if (this.#maxSize === 0) {
+ this.#body += this.#decoder.decode(chunk, { stream: true })
+ return
+ }
+
+ const remaining = this.#maxSize - this.#bodySize
+
+ if (chunk.length <= remaining) {
+ this.#bodySize += chunk.length
+ this.#body += this.#decoder.decode(chunk, { stream: true })
+ return
+ }
+
+ if (remaining > 0) {
+ this.#body += this.#decoder.decode(chunk.subarray(0, remaining), { stream: true })
+ this.#bodySize = this.#maxSize
+ }
+
+ this.#bodyTruncated = true
+ this.#body += this.#decoder.decode(undefined, { stream: false })
+ this.#decoder = null
}
onResponseEnd (controller, trailers) {
if (this.#statusCode >= 400) {
- this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? ''
-
- if (this.#checkContentType('application/json')) {
- try {
- this.#body = JSON.parse(this.#body)
- } catch {
- // Do nothing...
- }
- }
-
- let err
- const stackTraceLimit = Error.stackTraceLimit
- Error.stackTraceLimit = 0
- try {
- err = new ResponseError('Response Error', this.#statusCode, {
- body: this.#body,
- headers: this.#headers
- })
- } finally {
- Error.stackTraceLimit = stackTraceLimit
- }
-
- super.onResponseError(controller, err)
+ super.onResponseError(controller, this.#createResponseError())
} else {
super.onResponseEnd(controller, trailers)
}
@@ -86,10 +124,16 @@ class ResponseErrorHandler extends DecoratorHandler {
}
}
-module.exports = () => {
+module.exports = (opts = {}) => {
+ const { maxSize = defaultMaxSize } = opts
+
+ if (!Number.isSafeInteger(maxSize) || maxSize < 0) {
+ throw new InvalidArgumentError('maxSize must be a non-negative integer')
+ }
+
return (dispatch) => {
return function Intercept (opts, handler) {
- return dispatch(opts, new ResponseErrorHandler(opts, { handler }))
+ return dispatch(opts, new ResponseErrorHandler({ maxSize }, { handler }))
}
}
}
diff --git a/deps/undici/src/lib/llhttp/wasm_build_env.txt b/deps/undici/src/lib/llhttp/wasm_build_env.txt
index 1564ebae0de..df5bf2e5b0a 100644
--- a/deps/undici/src/lib/llhttp/wasm_build_env.txt
+++ b/deps/undici/src/lib/llhttp/wasm_build_env.txt
@@ -1,4 +1,4 @@
-> docker run --rm --platform=linux/x86_64 --user 1001:1001 --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/lib/llhttp,target=/home/node/build/lib/llhttp --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/build,target=/home/node/build/build --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/deps,target=/home/node/build/deps -t ghcr.io/nodejs/wasm-builder@sha256:975f391d907e42a75b8c72eb77c782181e941608687d4d8694c3e9df415a0970 node build/wasm.js
+> docker run --rm --platform=linux/x86_64 --user 1001:1001 --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/lib/llhttp,target=/home/node/build/lib/llhttp --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/build,target=/home/node/build/build --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/deps,target=/home/node/build/deps -t ghcr.io/nodejs/wasm-builder@sha256:975f391d907e42a75b8c72eb77c782181e941608687d4d8694c3e9df415a0970 node build/llhttp.js
alpine-baselayout-3.6.5-r0
diff --git a/deps/undici/src/lib/milo/LICENSE.md b/deps/undici/src/lib/milo/LICENSE.md
new file mode 100644
index 00000000000..c485e26f764
--- /dev/null
+++ b/deps/undici/src/lib/milo/LICENSE.md
@@ -0,0 +1,7 @@
+ISC License
+
+Copyright (c) 2023, and above Paolo Insogna, NearForm and other contributors
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/deps/undici/src/lib/milo/no-simd.js b/deps/undici/src/lib/milo/no-simd.js
new file mode 100644
index 00000000000..afbc55710c4
--- /dev/null
+++ b/deps/undici/src/lib/milo/no-simd.js
@@ -0,0 +1,1002 @@
+const wasmModule = new WebAssembly.Module(
+ Buffer.from(
+ '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',
+ 'base64'
+ )
+)
+
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+
+function log (logger, raw) {
+ const len = Number(BigInt.asUintN(32, raw))
+ const ptr = Number(raw >> 32n)
+
+ logger(textDecoder.decode(new Uint8Array(this.memory.buffer, ptr, len)))
+}
+
+function alloc (len) {
+ return this.alloc(len) >>> 0
+}
+
+function dealloc (ptr, len) {
+ return this.dealloc(ptr, len)
+}
+
+function create () {
+ return this.create() >>> 0
+}
+
+function destroy (parser) {
+ this.destroy(parser)
+}
+
+function parse (parser, data, limit) {
+ return this.parse(parser, data, limit) >>> 0
+}
+
+function fail (parser, code, description) {
+ const len = description.length
+ const ptr = this.alloc(len)
+ const buffer = new Uint8Array(this.memory.buffer, ptr, len)
+ textEncoder.encodeInto(description, buffer)
+
+ this.fail(parser, code, ptr, len)
+ this.dealloc(ptr, len)
+}
+
+function hasDebug () {
+ return this.milo_has_debug() !== 0
+}
+
+const Errors = Object.freeze({
+ NONE: 0,
+ USER: 1,
+ CALLBACK_ERROR: 2,
+ UNEXPECTED_STATE: 3,
+ UNEXPECTED_DATA: 4,
+ UNEXPECTED_EOF: 5,
+ UNEXPECTED_CHARACTER: 6,
+ UNEXPECTED_CONTENT_LENGTH: 7,
+ UNEXPECTED_TRANSFER_ENCODING: 8,
+ UNEXPECTED_CONTENT: 9,
+ UNEXPECTED_TRAILERS: 10,
+ INVALID_VERSION: 11,
+ INVALID_STATUS: 12,
+ INVALID_CONTENT_LENGTH: 13,
+ INVALID_TRANSFER_ENCODING: 14,
+ INVALID_CHUNK_SIZE: 15,
+ MISSING_CONNECTION_UPGRADE: 16,
+ UNSUPPORTED_HTTP_VERSION: 17,
+ 0: 'NONE',
+ 1: 'USER',
+ 2: 'CALLBACK_ERROR',
+ 3: 'UNEXPECTED_STATE',
+ 4: 'UNEXPECTED_DATA',
+ 5: 'UNEXPECTED_EOF',
+ 6: 'UNEXPECTED_CHARACTER',
+ 7: 'UNEXPECTED_CONTENT_LENGTH',
+ 8: 'UNEXPECTED_TRANSFER_ENCODING',
+ 9: 'UNEXPECTED_CONTENT',
+ 10: 'UNEXPECTED_TRAILERS',
+ 11: 'INVALID_VERSION',
+ 12: 'INVALID_STATUS',
+ 13: 'INVALID_CONTENT_LENGTH',
+ 14: 'INVALID_TRANSFER_ENCODING',
+ 15: 'INVALID_CHUNK_SIZE',
+ 16: 'MISSING_CONNECTION_UPGRADE',
+ 17: 'UNSUPPORTED_HTTP_VERSION'
+})
+
+const Methods = Object.freeze({
+ OTHER: 0,
+ GET: 1,
+ HEAD: 2,
+ POST: 3,
+ PUT: 4,
+ DELETE: 5,
+ CONNECT: 6,
+ OPTIONS: 7,
+ TRACE: 8,
+ PATCH: 9,
+ PRI: 10,
+ 0: 'OTHER',
+ 1: 'GET',
+ 2: 'HEAD',
+ 3: 'POST',
+ 4: 'PUT',
+ 5: 'DELETE',
+ 6: 'CONNECT',
+ 7: 'OPTIONS',
+ 8: 'TRACE',
+ 9: 'PATCH',
+ 10: 'PRI'
+})
+
+const Callbacks = Object.freeze({
+ ON_ERROR: 0,
+ ON_FINISH: 1,
+ ON_MESSAGE_START: 2,
+ ON_MESSAGE_COMPLETE: 3,
+ ON_REQUEST: 4,
+ ON_RESPONSE: 5,
+ ON_RESET: 6,
+ ON_METHOD: 7,
+ ON_URL: 8,
+ ON_PROTOCOL: 9,
+ ON_VERSION: 10,
+ ON_STATUS: 11,
+ ON_REASON: 12,
+ ON_HEADER_NAME: 13,
+ ON_HEADER_VALUE: 14,
+ ON_HEADERS: 15,
+ ON_CONNECT: 16,
+ ON_UPGRADE: 17,
+ ON_CHUNK_LENGTH: 18,
+ ON_CHUNK_EXTENSION_NAME: 19,
+ ON_CHUNK_EXTENSION_VALUE: 20,
+ ON_CHUNK: 21,
+ ON_BODY: 22,
+ ON_DATA: 23,
+ ON_TRAILER_NAME: 24,
+ ON_TRAILER_VALUE: 25,
+ ON_TRAILERS: 26,
+ ON_STATE_CHANGE: 27,
+ 0: 'ON_ERROR',
+ 1: 'ON_FINISH',
+ 2: 'ON_MESSAGE_START',
+ 3: 'ON_MESSAGE_COMPLETE',
+ 4: 'ON_REQUEST',
+ 5: 'ON_RESPONSE',
+ 6: 'ON_RESET',
+ 7: 'ON_METHOD',
+ 8: 'ON_URL',
+ 9: 'ON_PROTOCOL',
+ 10: 'ON_VERSION',
+ 11: 'ON_STATUS',
+ 12: 'ON_REASON',
+ 13: 'ON_HEADER_NAME',
+ 14: 'ON_HEADER_VALUE',
+ 15: 'ON_HEADERS',
+ 16: 'ON_CONNECT',
+ 17: 'ON_UPGRADE',
+ 18: 'ON_CHUNK_LENGTH',
+ 19: 'ON_CHUNK_EXTENSION_NAME',
+ 20: 'ON_CHUNK_EXTENSION_VALUE',
+ 21: 'ON_CHUNK',
+ 22: 'ON_BODY',
+ 23: 'ON_DATA',
+ 24: 'ON_TRAILER_NAME',
+ 25: 'ON_TRAILER_VALUE',
+ 26: 'ON_TRAILERS',
+ 27: 'ON_STATE_CHANGE'
+})
+
+const CallbackActives = Object.freeze({
+ NONE: 0n,
+ ON_ERROR: 1n,
+ ON_FINISH: 2n,
+ ON_MESSAGE_START: 4n,
+ ON_MESSAGE_COMPLETE: 8n,
+ ON_REQUEST: 16n,
+ ON_RESPONSE: 32n,
+ ON_RESET: 64n,
+ ON_METHOD: 128n,
+ ON_URL: 256n,
+ ON_PROTOCOL: 512n,
+ ON_VERSION: 1024n,
+ ON_STATUS: 2048n,
+ ON_REASON: 4096n,
+ ON_HEADER_NAME: 8192n,
+ ON_HEADER_VALUE: 16384n,
+ ON_HEADERS: 32768n,
+ ON_CONNECT: 65536n,
+ ON_UPGRADE: 131072n,
+ ON_CHUNK_LENGTH: 262144n,
+ ON_CHUNK_EXTENSION_NAME: 524288n,
+ ON_CHUNK_EXTENSION_VALUE: 1048576n,
+ ON_CHUNK: 2097152n,
+ ON_BODY: 4194304n,
+ ON_DATA: 8388608n,
+ ON_TRAILER_NAME: 16777216n,
+ ON_TRAILER_VALUE: 33554432n,
+ ON_TRAILERS: 67108864n,
+ ON_STATE_CHANGE: 134217728n,
+ ALL: 268435455n,
+ 0n: 'NONE',
+ 1n: 'ON_ERROR',
+ 2n: 'ON_FINISH',
+ 4n: 'ON_MESSAGE_START',
+ 8n: 'ON_MESSAGE_COMPLETE',
+ 16n: 'ON_REQUEST',
+ 32n: 'ON_RESPONSE',
+ 64n: 'ON_RESET',
+ 128n: 'ON_METHOD',
+ 256n: 'ON_URL',
+ 512n: 'ON_PROTOCOL',
+ 1024n: 'ON_VERSION',
+ 2048n: 'ON_STATUS',
+ 4096n: 'ON_REASON',
+ 8192n: 'ON_HEADER_NAME',
+ 16384n: 'ON_HEADER_VALUE',
+ 32768n: 'ON_HEADERS',
+ 65536n: 'ON_CONNECT',
+ 131072n: 'ON_UPGRADE',
+ 262144n: 'ON_CHUNK_LENGTH',
+ 524288n: 'ON_CHUNK_EXTENSION_NAME',
+ 1048576n: 'ON_CHUNK_EXTENSION_VALUE',
+ 2097152n: 'ON_CHUNK',
+ 4194304n: 'ON_BODY',
+ 8388608n: 'ON_DATA',
+ 16777216n: 'ON_TRAILER_NAME',
+ 33554432n: 'ON_TRAILER_VALUE',
+ 67108864n: 'ON_TRAILERS',
+ 134217728n: 'ON_STATE_CHANGE',
+ 268435455n: 'ALL'
+})
+
+const Events = Object.freeze({
+ END: 0,
+ ERROR: 1,
+ FINISH: 2,
+ MESSAGE_START: 3,
+ MESSAGE_COMPLETE: 4,
+ REQUEST: 5,
+ RESPONSE: 6,
+ RESET: 7,
+ METHOD: 8,
+ URL: 9,
+ PROTOCOL: 10,
+ VERSION: 11,
+ STATUS: 12,
+ REASON: 13,
+ HEADER_NAME: 14,
+ HEADER_VALUE: 15,
+ HEADERS: 16,
+ CONNECT: 17,
+ UPGRADE: 18,
+ CHUNK_LENGTH: 19,
+ CHUNK_EXTENSION_NAME: 20,
+ CHUNK_EXTENSION_VALUE: 21,
+ CHUNK: 22,
+ BODY: 23,
+ DATA: 24,
+ TRAILER_NAME: 25,
+ TRAILER_VALUE: 26,
+ TRAILERS: 27,
+ STATE_CHANGE: 28,
+ 0: 'END',
+ 1: 'ERROR',
+ 2: 'FINISH',
+ 3: 'MESSAGE_START',
+ 4: 'MESSAGE_COMPLETE',
+ 5: 'REQUEST',
+ 6: 'RESPONSE',
+ 7: 'RESET',
+ 8: 'METHOD',
+ 9: 'URL',
+ 10: 'PROTOCOL',
+ 11: 'VERSION',
+ 12: 'STATUS',
+ 13: 'REASON',
+ 14: 'HEADER_NAME',
+ 15: 'HEADER_VALUE',
+ 16: 'HEADERS',
+ 17: 'CONNECT',
+ 18: 'UPGRADE',
+ 19: 'CHUNK_LENGTH',
+ 20: 'CHUNK_EXTENSION_NAME',
+ 21: 'CHUNK_EXTENSION_VALUE',
+ 22: 'CHUNK',
+ 23: 'BODY',
+ 24: 'DATA',
+ 25: 'TRAILER_NAME',
+ 26: 'TRAILER_VALUE',
+ 27: 'TRAILERS',
+ 28: 'STATE_CHANGE'
+})
+
+const EventActives = Object.freeze({
+ NONE: 0n,
+ ON_ERROR: 1n,
+ ON_FINISH: 2n,
+ ON_MESSAGE_START: 4n,
+ ON_MESSAGE_COMPLETE: 8n,
+ ON_REQUEST: 16n,
+ ON_RESPONSE: 32n,
+ ON_RESET: 64n,
+ ON_METHOD: 128n,
+ ON_URL: 256n,
+ ON_PROTOCOL: 512n,
+ ON_VERSION: 1024n,
+ ON_STATUS: 2048n,
+ ON_REASON: 4096n,
+ ON_HEADER_NAME: 8192n,
+ ON_HEADER_VALUE: 16384n,
+ ON_HEADERS: 32768n,
+ ON_CONNECT: 65536n,
+ ON_UPGRADE: 131072n,
+ ON_CHUNK_LENGTH: 262144n,
+ ON_CHUNK_EXTENSION_NAME: 524288n,
+ ON_CHUNK_EXTENSION_VALUE: 1048576n,
+ ON_CHUNK: 2097152n,
+ ON_BODY: 4194304n,
+ ON_DATA: 8388608n,
+ ON_TRAILER_NAME: 16777216n,
+ ON_TRAILER_VALUE: 33554432n,
+ ON_TRAILERS: 67108864n,
+ ON_STATE_CHANGE: 134217728n,
+ ALL: 268435455n,
+ 0n: 'NONE',
+ 1n: 'ON_ERROR',
+ 2n: 'ON_FINISH',
+ 4n: 'ON_MESSAGE_START',
+ 8n: 'ON_MESSAGE_COMPLETE',
+ 16n: 'ON_REQUEST',
+ 32n: 'ON_RESPONSE',
+ 64n: 'ON_RESET',
+ 128n: 'ON_METHOD',
+ 256n: 'ON_URL',
+ 512n: 'ON_PROTOCOL',
+ 1024n: 'ON_VERSION',
+ 2048n: 'ON_STATUS',
+ 4096n: 'ON_REASON',
+ 8192n: 'ON_HEADER_NAME',
+ 16384n: 'ON_HEADER_VALUE',
+ 32768n: 'ON_HEADERS',
+ 65536n: 'ON_CONNECT',
+ 131072n: 'ON_UPGRADE',
+ 262144n: 'ON_CHUNK_LENGTH',
+ 524288n: 'ON_CHUNK_EXTENSION_NAME',
+ 1048576n: 'ON_CHUNK_EXTENSION_VALUE',
+ 2097152n: 'ON_CHUNK',
+ 4194304n: 'ON_BODY',
+ 8388608n: 'ON_DATA',
+ 16777216n: 'ON_TRAILER_NAME',
+ 33554432n: 'ON_TRAILER_VALUE',
+ 67108864n: 'ON_TRAILERS',
+ 134217728n: 'ON_STATE_CHANGE',
+ 268435455n: 'ALL'
+})
+
+const States = Object.freeze({
+ START: 0,
+ FINISH: 1,
+ ERROR: 2,
+ REQUEST_LINE: 3,
+ STATUS_LINE: 4,
+ HTTP2_PREFACE: 5,
+ HEADER: 6,
+ BODY_DECISION: 7,
+ BODY_VIA_CONTENT_LENGTH: 8,
+ BODY_WITH_NO_LENGTH: 9,
+ CHUNK_HEADER: 10,
+ CHUNK_EXTENSIONS: 11,
+ CHUNK_DATA: 12,
+ TRAILER: 13,
+ TUNNEL: 14,
+ 0: 'START',
+ 1: 'FINISH',
+ 2: 'ERROR',
+ 3: 'REQUEST_LINE',
+ 4: 'STATUS_LINE',
+ 5: 'HTTP2_PREFACE',
+ 6: 'HEADER',
+ 7: 'BODY_DECISION',
+ 8: 'BODY_VIA_CONTENT_LENGTH',
+ 9: 'BODY_WITH_NO_LENGTH',
+ 10: 'CHUNK_HEADER',
+ 11: 'CHUNK_EXTENSIONS',
+ 12: 'CHUNK_DATA',
+ 13: 'TRAILER',
+ 14: 'TUNNEL'
+})
+
+const ParserFields = Object.freeze({
+ MAX_START_LINE_LENGTH: 0,
+ MAX_HEADER_LENGTH: 4,
+ MAX_BODY_PAYLOAD: 8,
+ AUTODETECT: 16,
+ IS_REQUEST: 17,
+ SUSPEND_AFTER_HEADERS: 18,
+ MANAGE_UNCONSUMED: 19,
+ CONTINUE_WITHOUT_DATA: 20,
+ IS_CONNECT: 21,
+ SKIP_BODY: 22,
+ DEBUG: 23,
+ PARSED: 24,
+ POSITION: 32,
+ STATE: 36,
+ PAUSED: 37,
+ ERROR_CODE: 38,
+ CONTENT_LENGTH: 40,
+ CHUNK_SIZE: 48,
+ REMAINING_CONTENT_LENGTH: 56,
+ REMAINING_CHUNK_SIZE: 64,
+ STATUS: 72,
+ METHOD: 76,
+ HAS_CONTENT_LENGTH: 77,
+ HAS_TRANSFER_ENCODING: 78,
+ HAS_CHUNKED_TRANSFER_ENCODING: 79,
+ HAS_CONNECTION_CLOSE: 80,
+ HAS_CONNECTION_UPGRADE: 81,
+ HAS_UPGRADE: 82,
+ HAS_TRAILERS: 83,
+ ACTIVE_CALLBACKS: 88,
+ ACTIVE_EVENTS: 96,
+ PTR: 104,
+ ERROR_DESCRIPTION: 108,
+ UNCONSUMED: 364,
+ UNCONSUMED_LEN: 368,
+ ERROR_DESCRIPTION_LEN: 372,
+ EVENTS: 376,
+ 0: 'MAX_START_LINE_LENGTH',
+ 4: 'MAX_HEADER_LENGTH',
+ 8: 'MAX_BODY_PAYLOAD',
+ 16: 'AUTODETECT',
+ 17: 'IS_REQUEST',
+ 18: 'SUSPEND_AFTER_HEADERS',
+ 19: 'MANAGE_UNCONSUMED',
+ 20: 'CONTINUE_WITHOUT_DATA',
+ 21: 'IS_CONNECT',
+ 22: 'SKIP_BODY',
+ 23: 'DEBUG',
+ 24: 'PARSED',
+ 32: 'POSITION',
+ 36: 'STATE',
+ 37: 'PAUSED',
+ 38: 'ERROR_CODE',
+ 40: 'CONTENT_LENGTH',
+ 48: 'CHUNK_SIZE',
+ 56: 'REMAINING_CONTENT_LENGTH',
+ 64: 'REMAINING_CHUNK_SIZE',
+ 72: 'STATUS',
+ 76: 'METHOD',
+ 77: 'HAS_CONTENT_LENGTH',
+ 78: 'HAS_TRANSFER_ENCODING',
+ 79: 'HAS_CHUNKED_TRANSFER_ENCODING',
+ 80: 'HAS_CONNECTION_CLOSE',
+ 81: 'HAS_CONNECTION_UPGRADE',
+ 82: 'HAS_UPGRADE',
+ 83: 'HAS_TRAILERS',
+ 88: 'ACTIVE_CALLBACKS',
+ 96: 'ACTIVE_EVENTS',
+ 104: 'PTR',
+ 108: 'ERROR_DESCRIPTION',
+ 364: 'UNCONSUMED',
+ 368: 'UNCONSUMED_LEN',
+ 372: 'ERROR_DESCRIPTION_LEN',
+ 376: 'EVENTS'
+})
+
+function isAutodetect (parser) {
+ return this.is_autodetect(parser) !== 0
+}
+
+function isRequest (parser) {
+ return this.is_request(parser) !== 0
+}
+
+function isPaused (parser) {
+ return this.is_paused(parser) !== 0
+}
+
+function shouldManageUnconsumed (parser) {
+ return this.should_manage_unconsumed(parser) !== 0
+}
+
+function shouldSuspendAfterHeaders (parser) {
+ return this.should_suspend_after_headers(parser) !== 0
+}
+
+function getMaxStartLineLength (parser) {
+ return this.get_max_start_line_length(parser) >>> 0
+}
+
+function getMaxHeaderLength (parser) {
+ return this.get_max_header_length(parser) >>> 0
+}
+
+function getMaxBodyPayload (parser) {
+ return BigInt.asUintN(64, this.get_max_body_payload(parser))
+}
+
+function shouldContinueWithoutData (parser) {
+ return this.should_continue_without_data(parser) !== 0
+}
+
+function isConnect (parser) {
+ return this.is_connect(parser) !== 0
+}
+
+function isDebug (parser) {
+ return this.is_debug(parser) !== 0
+}
+
+function shouldSkipBody (parser) {
+ return this.should_skip_body(parser) !== 0
+}
+
+function getState (parser) {
+ return this.get_state(parser) >>> 0
+}
+
+function getPosition (parser) {
+ return this.get_position(parser) >>> 0
+}
+
+function getParsed (parser) {
+ return BigInt.asUintN(64, this.get_parsed(parser))
+}
+
+function getErrorCode (parser) {
+ return this.get_error_code(parser) >>> 0
+}
+
+function getMethod (parser) {
+ return this.get_method(parser) >>> 0
+}
+
+function getStatus (parser) {
+ return this.get_status(parser) >>> 0
+}
+
+function hasConnectionClose (parser) {
+ return this.has_connection_close(parser) !== 0
+}
+
+function hasConnectionUpgrade (parser) {
+ return this.has_connection_upgrade(parser) !== 0
+}
+
+function getContentLength (parser) {
+ return BigInt.asUintN(64, this.get_content_length(parser))
+}
+
+function getChunkSize (parser) {
+ return BigInt.asUintN(64, this.get_chunk_size(parser))
+}
+
+function getRemainingContentLength (parser) {
+ return BigInt.asUintN(64, this.get_remaining_content_length(parser))
+}
+
+function getRemainingChunkSize (parser) {
+ return BigInt.asUintN(64, this.get_remaining_chunk_size(parser))
+}
+
+function hasContentLength (parser) {
+ return this.has_content_length(parser) !== 0
+}
+
+function hasTransferEncoding (parser) {
+ return this.has_transfer_encoding(parser) !== 0
+}
+
+function hasChunkedTransferEncoding (parser) {
+ return this.has_chunked_transfer_encoding(parser) !== 0
+}
+
+function hasUpgrade (parser) {
+ return this.has_upgrade(parser) !== 0
+}
+
+function hasTrailers (parser) {
+ return this.has_trailers(parser) !== 0
+}
+
+function getErrorDescription (parser) {
+ const raw = this.get_error_description_raw(parser)
+ const len = Number(BigInt.asUintN(32, raw))
+ const ptr = Number(raw >> 32n)
+ return textDecoder.decode(new Uint8Array(this.memory.buffer, ptr, len))
+}
+
+function setShouldAutodetect (parser, value) {
+ this.set_should_autodetect(parser, value)
+}
+
+function setShouldContinueWithoutData (parser, value) {
+ this.set_should_continue_without_data(parser, value)
+}
+
+function setIsRequest (parser, value) {
+ this.set_is_request(parser, value)
+}
+
+function setIsConnect (parser, value) {
+ this.set_is_connect(parser, value)
+}
+
+function setDebug (parser, value) {
+ this.set_debug(parser, value)
+}
+
+function setShouldManageUnconsumed (parser, value) {
+ this.set_should_manage_unconsumed(parser, value)
+}
+
+function setShouldSuspendAfterHeaders (parser, value) {
+ this.set_should_suspend_after_headers(parser, value)
+}
+
+function setMaxStartLineLength (parser, value) {
+ this.set_max_start_line_length(parser, value)
+}
+
+function setMaxHeaderLength (parser, value) {
+ this.set_max_header_length(parser, value)
+}
+
+function setMaxBodyPayload (parser, value) {
+ this.set_max_body_payload(parser, value)
+}
+
+function setShouldSkipBody (parser, value) {
+ this.set_should_skip_body(parser, value)
+}
+
+function setActiveCallbacks (parser, value) {
+ this.set_active_callbacks(parser, value)
+}
+
+function setActiveEvents (parser, value) {
+ this.set_active_events(parser, value)
+}
+
+function simpleCreate (spans, create) {
+ const parser = create()
+ spans[parser] = []
+ this.setActiveCallbacks(parser, this.CALLBACK_ACTIVE_ALL)
+ return parser
+}
+
+function simpleDestroy (spans, destroy, parser) {
+ spans[parser] = undefined
+ destroy(parser)
+}
+
+function noop () {}
+
+function setup (env = {}) {
+ let { logger: logOption, ...instanceEnvironment } = env
+ let logger = noop
+ const context = {}
+
+ if (logOption) {
+ if (typeof logOption !== 'function') {
+ logOption = console.log
+ }
+
+ logger = log.bind(context, logOption)
+ }
+
+ // Create the WASM instance
+ /* eslint-disable-next-line no-undef */
+ const instance = new WebAssembly.Instance(wasmModule, {
+ env: {
+ logger,
+ on_error: noop,
+ on_finish: noop,
+ on_message_start: noop,
+ on_message_complete: noop,
+ on_request: noop,
+ on_response: noop,
+ on_reset: noop,
+ on_method: noop,
+ on_url: noop,
+ on_protocol: noop,
+ on_version: noop,
+ on_status: noop,
+ on_reason: noop,
+ on_header_name: noop,
+ on_header_value: noop,
+ on_headers: noop,
+ on_connect: noop,
+ on_upgrade: noop,
+ on_chunk_length: noop,
+ on_chunk_extension_name: noop,
+ on_chunk_extension_value: noop,
+ on_chunk: noop,
+ on_body: noop,
+ on_data: noop,
+ on_trailer_name: noop,
+ on_trailer_value: noop,
+ on_trailers: noop,
+ on_state_change: noop,
+ ...instanceEnvironment
+ }
+ })
+
+ const wasm = instance.exports
+ context.memory = wasm.memory
+
+ const milo = {
+ version: {
+ raw: '0.9.0',
+ major: 0,
+ minor: 9,
+ patch: 0,
+ prerelease: ''
+ },
+ METHOD_OTHER: 0,
+ METHOD_GET: 1,
+ METHOD_HEAD: 2,
+ METHOD_POST: 3,
+ METHOD_PUT: 4,
+ METHOD_DELETE: 5,
+ METHOD_CONNECT: 6,
+ METHOD_OPTIONS: 7,
+ METHOD_TRACE: 8,
+ METHOD_PATCH: 9,
+ METHOD_PRI: 10,
+ CALLBACK_ON_ERROR: 0,
+ CALLBACK_ON_FINISH: 1,
+ CALLBACK_ON_MESSAGE_START: 2,
+ CALLBACK_ON_MESSAGE_COMPLETE: 3,
+ CALLBACK_ON_REQUEST: 4,
+ CALLBACK_ON_RESPONSE: 5,
+ CALLBACK_ON_RESET: 6,
+ CALLBACK_ON_METHOD: 7,
+ CALLBACK_ON_URL: 8,
+ CALLBACK_ON_PROTOCOL: 9,
+ CALLBACK_ON_VERSION: 10,
+ CALLBACK_ON_STATUS: 11,
+ CALLBACK_ON_REASON: 12,
+ CALLBACK_ON_HEADER_NAME: 13,
+ CALLBACK_ON_HEADER_VALUE: 14,
+ CALLBACK_ON_HEADERS: 15,
+ CALLBACK_ON_CONNECT: 16,
+ CALLBACK_ON_UPGRADE: 17,
+ CALLBACK_ON_CHUNK_LENGTH: 18,
+ CALLBACK_ON_CHUNK_EXTENSION_NAME: 19,
+ CALLBACK_ON_CHUNK_EXTENSION_VALUE: 20,
+ CALLBACK_ON_CHUNK: 21,
+ CALLBACK_ON_BODY: 22,
+ CALLBACK_ON_DATA: 23,
+ CALLBACK_ON_TRAILER_NAME: 24,
+ CALLBACK_ON_TRAILER_VALUE: 25,
+ CALLBACK_ON_TRAILERS: 26,
+ CALLBACK_ON_STATE_CHANGE: 27,
+ EVENT_END: 0,
+ EVENT_ERROR: 1,
+ EVENT_FINISH: 2,
+ EVENT_MESSAGE_START: 3,
+ EVENT_MESSAGE_COMPLETE: 4,
+ EVENT_REQUEST: 5,
+ EVENT_RESPONSE: 6,
+ EVENT_RESET: 7,
+ EVENT_METHOD: 8,
+ EVENT_URL: 9,
+ EVENT_PROTOCOL: 10,
+ EVENT_VERSION: 11,
+ EVENT_STATUS: 12,
+ EVENT_REASON: 13,
+ EVENT_HEADER_NAME: 14,
+ EVENT_HEADER_VALUE: 15,
+ EVENT_HEADERS: 16,
+ EVENT_CONNECT: 17,
+ EVENT_UPGRADE: 18,
+ EVENT_CHUNK_LENGTH: 19,
+ EVENT_CHUNK_EXTENSION_NAME: 20,
+ EVENT_CHUNK_EXTENSION_VALUE: 21,
+ EVENT_CHUNK: 22,
+ EVENT_BODY: 23,
+ EVENT_DATA: 24,
+ EVENT_TRAILER_NAME: 25,
+ EVENT_TRAILER_VALUE: 26,
+ EVENT_TRAILERS: 27,
+ EVENT_STATE_CHANGE: 28,
+ CALLBACK_ACTIVE_NONE: 0n,
+ EVENT_ACTIVE_NONE: 0n,
+ CALLBACK_ACTIVE_ON_ERROR: 1n,
+ EVENT_ACTIVE_ON_ERROR: 1n,
+ CALLBACK_ACTIVE_ON_FINISH: 2n,
+ EVENT_ACTIVE_ON_FINISH: 2n,
+ CALLBACK_ACTIVE_ON_MESSAGE_START: 4n,
+ EVENT_ACTIVE_ON_MESSAGE_START: 4n,
+ CALLBACK_ACTIVE_ON_MESSAGE_COMPLETE: 8n,
+ EVENT_ACTIVE_ON_MESSAGE_COMPLETE: 8n,
+ CALLBACK_ACTIVE_ON_REQUEST: 16n,
+ EVENT_ACTIVE_ON_REQUEST: 16n,
+ CALLBACK_ACTIVE_ON_RESPONSE: 32n,
+ EVENT_ACTIVE_ON_RESPONSE: 32n,
+ CALLBACK_ACTIVE_ON_RESET: 64n,
+ EVENT_ACTIVE_ON_RESET: 64n,
+ CALLBACK_ACTIVE_ON_METHOD: 128n,
+ EVENT_ACTIVE_ON_METHOD: 128n,
+ CALLBACK_ACTIVE_ON_URL: 256n,
+ EVENT_ACTIVE_ON_URL: 256n,
+ CALLBACK_ACTIVE_ON_PROTOCOL: 512n,
+ EVENT_ACTIVE_ON_PROTOCOL: 512n,
+ CALLBACK_ACTIVE_ON_VERSION: 1024n,
+ EVENT_ACTIVE_ON_VERSION: 1024n,
+ CALLBACK_ACTIVE_ON_STATUS: 2048n,
+ EVENT_ACTIVE_ON_STATUS: 2048n,
+ CALLBACK_ACTIVE_ON_REASON: 4096n,
+ EVENT_ACTIVE_ON_REASON: 4096n,
+ CALLBACK_ACTIVE_ON_HEADER_NAME: 8192n,
+ EVENT_ACTIVE_ON_HEADER_NAME: 8192n,
+ CALLBACK_ACTIVE_ON_HEADER_VALUE: 16384n,
+ EVENT_ACTIVE_ON_HEADER_VALUE: 16384n,
+ CALLBACK_ACTIVE_ON_HEADERS: 32768n,
+ EVENT_ACTIVE_ON_HEADERS: 32768n,
+ CALLBACK_ACTIVE_ON_CONNECT: 65536n,
+ EVENT_ACTIVE_ON_CONNECT: 65536n,
+ CALLBACK_ACTIVE_ON_UPGRADE: 131072n,
+ EVENT_ACTIVE_ON_UPGRADE: 131072n,
+ CALLBACK_ACTIVE_ON_CHUNK_LENGTH: 262144n,
+ EVENT_ACTIVE_ON_CHUNK_LENGTH: 262144n,
+ CALLBACK_ACTIVE_ON_CHUNK_EXTENSION_NAME: 524288n,
+ EVENT_ACTIVE_ON_CHUNK_EXTENSION_NAME: 524288n,
+ CALLBACK_ACTIVE_ON_CHUNK_EXTENSION_VALUE: 1048576n,
+ EVENT_ACTIVE_ON_CHUNK_EXTENSION_VALUE: 1048576n,
+ CALLBACK_ACTIVE_ON_CHUNK: 2097152n,
+ EVENT_ACTIVE_ON_CHUNK: 2097152n,
+ CALLBACK_ACTIVE_ON_BODY: 4194304n,
+ EVENT_ACTIVE_ON_BODY: 4194304n,
+ CALLBACK_ACTIVE_ON_DATA: 8388608n,
+ EVENT_ACTIVE_ON_DATA: 8388608n,
+ CALLBACK_ACTIVE_ON_TRAILER_NAME: 16777216n,
+ EVENT_ACTIVE_ON_TRAILER_NAME: 16777216n,
+ CALLBACK_ACTIVE_ON_TRAILER_VALUE: 33554432n,
+ EVENT_ACTIVE_ON_TRAILER_VALUE: 33554432n,
+ CALLBACK_ACTIVE_ON_TRAILERS: 67108864n,
+ EVENT_ACTIVE_ON_TRAILERS: 67108864n,
+ CALLBACK_ACTIVE_ON_STATE_CHANGE: 134217728n,
+ EVENT_ACTIVE_ON_STATE_CHANGE: 134217728n,
+ CALLBACK_ACTIVE_ALL: 268435455n,
+ EVENT_ACTIVE_ALL: 268435455n,
+ ERROR_NONE: 0,
+ ERROR_USER: 1,
+ ERROR_CALLBACK_ERROR: 2,
+ ERROR_UNEXPECTED_STATE: 3,
+ ERROR_UNEXPECTED_DATA: 4,
+ ERROR_UNEXPECTED_EOF: 5,
+ ERROR_UNEXPECTED_CHARACTER: 6,
+ ERROR_UNEXPECTED_CONTENT_LENGTH: 7,
+ ERROR_UNEXPECTED_TRANSFER_ENCODING: 8,
+ ERROR_UNEXPECTED_CONTENT: 9,
+ ERROR_UNEXPECTED_TRAILERS: 10,
+ ERROR_INVALID_VERSION: 11,
+ ERROR_INVALID_STATUS: 12,
+ ERROR_INVALID_CONTENT_LENGTH: 13,
+ ERROR_INVALID_TRANSFER_ENCODING: 14,
+ ERROR_INVALID_CHUNK_SIZE: 15,
+ ERROR_MISSING_CONNECTION_UPGRADE: 16,
+ ERROR_UNSUPPORTED_HTTP_VERSION: 17,
+ STATE_START: 0,
+ STATE_FINISH: 1,
+ STATE_ERROR: 2,
+ STATE_REQUEST_LINE: 3,
+ STATE_STATUS_LINE: 4,
+ STATE_HTTP2_PREFACE: 5,
+ STATE_HEADER: 6,
+ STATE_BODY_DECISION: 7,
+ STATE_BODY_VIA_CONTENT_LENGTH: 8,
+ STATE_BODY_WITH_NO_LENGTH: 9,
+ STATE_CHUNK_HEADER: 10,
+ STATE_CHUNK_EXTENSIONS: 11,
+ STATE_CHUNK_DATA: 12,
+ STATE_TRAILER: 13,
+ STATE_TUNNEL: 14,
+ PARSER_FIELD_MAX_START_LINE_LENGTH: 0,
+ PARSER_FIELD_MAX_HEADER_LENGTH: 4,
+ PARSER_FIELD_MAX_BODY_PAYLOAD: 8,
+ PARSER_FIELD_AUTODETECT: 16,
+ PARSER_FIELD_IS_REQUEST: 17,
+ PARSER_FIELD_SUSPEND_AFTER_HEADERS: 18,
+ PARSER_FIELD_MANAGE_UNCONSUMED: 19,
+ PARSER_FIELD_CONTINUE_WITHOUT_DATA: 20,
+ PARSER_FIELD_IS_CONNECT: 21,
+ PARSER_FIELD_SKIP_BODY: 22,
+ PARSER_FIELD_DEBUG: 23,
+ PARSER_FIELD_PARSED: 24,
+ PARSER_FIELD_POSITION: 32,
+ PARSER_FIELD_STATE: 36,
+ PARSER_FIELD_PAUSED: 37,
+ PARSER_FIELD_ERROR_CODE: 38,
+ PARSER_FIELD_CONTENT_LENGTH: 40,
+ PARSER_FIELD_CHUNK_SIZE: 48,
+ PARSER_FIELD_REMAINING_CONTENT_LENGTH: 56,
+ PARSER_FIELD_REMAINING_CHUNK_SIZE: 64,
+ PARSER_FIELD_STATUS: 72,
+ PARSER_FIELD_METHOD: 76,
+ PARSER_FIELD_HAS_CONTENT_LENGTH: 77,
+ PARSER_FIELD_HAS_TRANSFER_ENCODING: 78,
+ PARSER_FIELD_HAS_CHUNKED_TRANSFER_ENCODING: 79,
+ PARSER_FIELD_HAS_CONNECTION_CLOSE: 80,
+ PARSER_FIELD_HAS_CONNECTION_UPGRADE: 81,
+ PARSER_FIELD_HAS_UPGRADE: 82,
+ PARSER_FIELD_HAS_TRAILERS: 83,
+ PARSER_FIELD_ACTIVE_CALLBACKS: 88,
+ PARSER_FIELD_ACTIVE_EVENTS: 96,
+ PARSER_FIELD_PTR: 104,
+ PARSER_FIELD_ERROR_DESCRIPTION: 108,
+ PARSER_FIELD_UNCONSUMED: 364,
+ PARSER_FIELD_UNCONSUMED_LEN: 368,
+ PARSER_FIELD_ERROR_DESCRIPTION_LEN: 372,
+ PARSER_FIELD_EVENTS: 376,
+ Errors,
+ Methods,
+ Callbacks,
+ CallbackActives,
+ Events,
+ EventActives,
+ States,
+ ParserFields,
+ isAutodetect: isAutodetect.bind(wasm),
+ isRequest: isRequest.bind(wasm),
+ isPaused: isPaused.bind(wasm),
+ shouldManageUnconsumed: shouldManageUnconsumed.bind(wasm),
+ shouldSuspendAfterHeaders: shouldSuspendAfterHeaders.bind(wasm),
+ getMaxStartLineLength: getMaxStartLineLength.bind(wasm),
+ getMaxHeaderLength: getMaxHeaderLength.bind(wasm),
+ getMaxBodyPayload: getMaxBodyPayload.bind(wasm),
+ shouldContinueWithoutData: shouldContinueWithoutData.bind(wasm),
+ isConnect: isConnect.bind(wasm),
+ isDebug: isDebug.bind(wasm),
+ shouldSkipBody: shouldSkipBody.bind(wasm),
+ getState: getState.bind(wasm),
+ getPosition: getPosition.bind(wasm),
+ getParsed: getParsed.bind(wasm),
+ getErrorCode: getErrorCode.bind(wasm),
+ getMethod: getMethod.bind(wasm),
+ getStatus: getStatus.bind(wasm),
+ hasConnectionClose: hasConnectionClose.bind(wasm),
+ hasConnectionUpgrade: hasConnectionUpgrade.bind(wasm),
+ getContentLength: getContentLength.bind(wasm),
+ getChunkSize: getChunkSize.bind(wasm),
+ getRemainingContentLength: getRemainingContentLength.bind(wasm),
+ getRemainingChunkSize: getRemainingChunkSize.bind(wasm),
+ hasContentLength: hasContentLength.bind(wasm),
+ hasTransferEncoding: hasTransferEncoding.bind(wasm),
+ hasChunkedTransferEncoding: hasChunkedTransferEncoding.bind(wasm),
+ hasUpgrade: hasUpgrade.bind(wasm),
+ hasTrailers: hasTrailers.bind(wasm),
+ getErrorDescription: getErrorDescription.bind(wasm),
+ setShouldAutodetect: setShouldAutodetect.bind(wasm),
+ setShouldContinueWithoutData: setShouldContinueWithoutData.bind(wasm),
+ setIsRequest: setIsRequest.bind(wasm),
+ setIsConnect: setIsConnect.bind(wasm),
+ setDebug: setDebug.bind(wasm),
+ setShouldManageUnconsumed: setShouldManageUnconsumed.bind(wasm),
+ setShouldSuspendAfterHeaders: setShouldSuspendAfterHeaders.bind(wasm),
+ setMaxStartLineLength: setMaxStartLineLength.bind(wasm),
+ setMaxHeaderLength: setMaxHeaderLength.bind(wasm),
+ setMaxBodyPayload: setMaxBodyPayload.bind(wasm),
+ setShouldSkipBody: setShouldSkipBody.bind(wasm),
+ setActiveCallbacks: setActiveCallbacks.bind(wasm),
+ setActiveEvents: setActiveEvents.bind(wasm),
+ memory: wasm.memory,
+ alloc: alloc.bind(wasm),
+ dealloc: dealloc.bind(wasm),
+ create: create.bind(wasm),
+ destroy: destroy.bind(wasm),
+ parse: parse.bind(wasm),
+ fail: fail.bind(wasm),
+ hasDebug: hasDebug.bind(wasm),
+ clear: wasm.clear,
+ complete: wasm.complete,
+ finish: wasm.finish,
+ pause: wasm.pause,
+ reset: wasm.reset,
+ resume: wasm.resume
+ }
+
+ return milo
+}
+
+function simple () {
+ const spans = {}
+
+ const milo = setup({/* REPLACE: callbacks:simple */})
+
+ milo.spans = spans
+ milo.create = simpleCreate.bind(milo, spans, milo.create)
+ milo.destroy = simpleDestroy.bind(milo, spans, milo.destroy)
+
+ return milo
+}
+
+module.exports = { wasmModule, noop, setup, simple }
diff --git a/deps/undici/src/lib/milo/simd.js b/deps/undici/src/lib/milo/simd.js
new file mode 100644
index 00000000000..9481d735fd4
--- /dev/null
+++ b/deps/undici/src/lib/milo/simd.js
@@ -0,0 +1,1002 @@
+const wasmModule = new WebAssembly.Module(
+ Buffer.from(
+ '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',
+ 'base64'
+ )
+)
+
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+
+function log (logger, raw) {
+ const len = Number(BigInt.asUintN(32, raw))
+ const ptr = Number(raw >> 32n)
+
+ logger(textDecoder.decode(new Uint8Array(this.memory.buffer, ptr, len)))
+}
+
+function alloc (len) {
+ return this.alloc(len) >>> 0
+}
+
+function dealloc (ptr, len) {
+ return this.dealloc(ptr, len)
+}
+
+function create () {
+ return this.create() >>> 0
+}
+
+function destroy (parser) {
+ this.destroy(parser)
+}
+
+function parse (parser, data, limit) {
+ return this.parse(parser, data, limit) >>> 0
+}
+
+function fail (parser, code, description) {
+ const len = description.length
+ const ptr = this.alloc(len)
+ const buffer = new Uint8Array(this.memory.buffer, ptr, len)
+ textEncoder.encodeInto(description, buffer)
+
+ this.fail(parser, code, ptr, len)
+ this.dealloc(ptr, len)
+}
+
+function hasDebug () {
+ return this.milo_has_debug() !== 0
+}
+
+const Errors = Object.freeze({
+ NONE: 0,
+ USER: 1,
+ CALLBACK_ERROR: 2,
+ UNEXPECTED_STATE: 3,
+ UNEXPECTED_DATA: 4,
+ UNEXPECTED_EOF: 5,
+ UNEXPECTED_CHARACTER: 6,
+ UNEXPECTED_CONTENT_LENGTH: 7,
+ UNEXPECTED_TRANSFER_ENCODING: 8,
+ UNEXPECTED_CONTENT: 9,
+ UNEXPECTED_TRAILERS: 10,
+ INVALID_VERSION: 11,
+ INVALID_STATUS: 12,
+ INVALID_CONTENT_LENGTH: 13,
+ INVALID_TRANSFER_ENCODING: 14,
+ INVALID_CHUNK_SIZE: 15,
+ MISSING_CONNECTION_UPGRADE: 16,
+ UNSUPPORTED_HTTP_VERSION: 17,
+ 0: 'NONE',
+ 1: 'USER',
+ 2: 'CALLBACK_ERROR',
+ 3: 'UNEXPECTED_STATE',
+ 4: 'UNEXPECTED_DATA',
+ 5: 'UNEXPECTED_EOF',
+ 6: 'UNEXPECTED_CHARACTER',
+ 7: 'UNEXPECTED_CONTENT_LENGTH',
+ 8: 'UNEXPECTED_TRANSFER_ENCODING',
+ 9: 'UNEXPECTED_CONTENT',
+ 10: 'UNEXPECTED_TRAILERS',
+ 11: 'INVALID_VERSION',
+ 12: 'INVALID_STATUS',
+ 13: 'INVALID_CONTENT_LENGTH',
+ 14: 'INVALID_TRANSFER_ENCODING',
+ 15: 'INVALID_CHUNK_SIZE',
+ 16: 'MISSING_CONNECTION_UPGRADE',
+ 17: 'UNSUPPORTED_HTTP_VERSION'
+})
+
+const Methods = Object.freeze({
+ OTHER: 0,
+ GET: 1,
+ HEAD: 2,
+ POST: 3,
+ PUT: 4,
+ DELETE: 5,
+ CONNECT: 6,
+ OPTIONS: 7,
+ TRACE: 8,
+ PATCH: 9,
+ PRI: 10,
+ 0: 'OTHER',
+ 1: 'GET',
+ 2: 'HEAD',
+ 3: 'POST',
+ 4: 'PUT',
+ 5: 'DELETE',
+ 6: 'CONNECT',
+ 7: 'OPTIONS',
+ 8: 'TRACE',
+ 9: 'PATCH',
+ 10: 'PRI'
+})
+
+const Callbacks = Object.freeze({
+ ON_ERROR: 0,
+ ON_FINISH: 1,
+ ON_MESSAGE_START: 2,
+ ON_MESSAGE_COMPLETE: 3,
+ ON_REQUEST: 4,
+ ON_RESPONSE: 5,
+ ON_RESET: 6,
+ ON_METHOD: 7,
+ ON_URL: 8,
+ ON_PROTOCOL: 9,
+ ON_VERSION: 10,
+ ON_STATUS: 11,
+ ON_REASON: 12,
+ ON_HEADER_NAME: 13,
+ ON_HEADER_VALUE: 14,
+ ON_HEADERS: 15,
+ ON_CONNECT: 16,
+ ON_UPGRADE: 17,
+ ON_CHUNK_LENGTH: 18,
+ ON_CHUNK_EXTENSION_NAME: 19,
+ ON_CHUNK_EXTENSION_VALUE: 20,
+ ON_CHUNK: 21,
+ ON_BODY: 22,
+ ON_DATA: 23,
+ ON_TRAILER_NAME: 24,
+ ON_TRAILER_VALUE: 25,
+ ON_TRAILERS: 26,
+ ON_STATE_CHANGE: 27,
+ 0: 'ON_ERROR',
+ 1: 'ON_FINISH',
+ 2: 'ON_MESSAGE_START',
+ 3: 'ON_MESSAGE_COMPLETE',
+ 4: 'ON_REQUEST',
+ 5: 'ON_RESPONSE',
+ 6: 'ON_RESET',
+ 7: 'ON_METHOD',
+ 8: 'ON_URL',
+ 9: 'ON_PROTOCOL',
+ 10: 'ON_VERSION',
+ 11: 'ON_STATUS',
+ 12: 'ON_REASON',
+ 13: 'ON_HEADER_NAME',
+ 14: 'ON_HEADER_VALUE',
+ 15: 'ON_HEADERS',
+ 16: 'ON_CONNECT',
+ 17: 'ON_UPGRADE',
+ 18: 'ON_CHUNK_LENGTH',
+ 19: 'ON_CHUNK_EXTENSION_NAME',
+ 20: 'ON_CHUNK_EXTENSION_VALUE',
+ 21: 'ON_CHUNK',
+ 22: 'ON_BODY',
+ 23: 'ON_DATA',
+ 24: 'ON_TRAILER_NAME',
+ 25: 'ON_TRAILER_VALUE',
+ 26: 'ON_TRAILERS',
+ 27: 'ON_STATE_CHANGE'
+})
+
+const CallbackActives = Object.freeze({
+ NONE: 0n,
+ ON_ERROR: 1n,
+ ON_FINISH: 2n,
+ ON_MESSAGE_START: 4n,
+ ON_MESSAGE_COMPLETE: 8n,
+ ON_REQUEST: 16n,
+ ON_RESPONSE: 32n,
+ ON_RESET: 64n,
+ ON_METHOD: 128n,
+ ON_URL: 256n,
+ ON_PROTOCOL: 512n,
+ ON_VERSION: 1024n,
+ ON_STATUS: 2048n,
+ ON_REASON: 4096n,
+ ON_HEADER_NAME: 8192n,
+ ON_HEADER_VALUE: 16384n,
+ ON_HEADERS: 32768n,
+ ON_CONNECT: 65536n,
+ ON_UPGRADE: 131072n,
+ ON_CHUNK_LENGTH: 262144n,
+ ON_CHUNK_EXTENSION_NAME: 524288n,
+ ON_CHUNK_EXTENSION_VALUE: 1048576n,
+ ON_CHUNK: 2097152n,
+ ON_BODY: 4194304n,
+ ON_DATA: 8388608n,
+ ON_TRAILER_NAME: 16777216n,
+ ON_TRAILER_VALUE: 33554432n,
+ ON_TRAILERS: 67108864n,
+ ON_STATE_CHANGE: 134217728n,
+ ALL: 268435455n,
+ 0n: 'NONE',
+ 1n: 'ON_ERROR',
+ 2n: 'ON_FINISH',
+ 4n: 'ON_MESSAGE_START',
+ 8n: 'ON_MESSAGE_COMPLETE',
+ 16n: 'ON_REQUEST',
+ 32n: 'ON_RESPONSE',
+ 64n: 'ON_RESET',
+ 128n: 'ON_METHOD',
+ 256n: 'ON_URL',
+ 512n: 'ON_PROTOCOL',
+ 1024n: 'ON_VERSION',
+ 2048n: 'ON_STATUS',
+ 4096n: 'ON_REASON',
+ 8192n: 'ON_HEADER_NAME',
+ 16384n: 'ON_HEADER_VALUE',
+ 32768n: 'ON_HEADERS',
+ 65536n: 'ON_CONNECT',
+ 131072n: 'ON_UPGRADE',
+ 262144n: 'ON_CHUNK_LENGTH',
+ 524288n: 'ON_CHUNK_EXTENSION_NAME',
+ 1048576n: 'ON_CHUNK_EXTENSION_VALUE',
+ 2097152n: 'ON_CHUNK',
+ 4194304n: 'ON_BODY',
+ 8388608n: 'ON_DATA',
+ 16777216n: 'ON_TRAILER_NAME',
+ 33554432n: 'ON_TRAILER_VALUE',
+ 67108864n: 'ON_TRAILERS',
+ 134217728n: 'ON_STATE_CHANGE',
+ 268435455n: 'ALL'
+})
+
+const Events = Object.freeze({
+ END: 0,
+ ERROR: 1,
+ FINISH: 2,
+ MESSAGE_START: 3,
+ MESSAGE_COMPLETE: 4,
+ REQUEST: 5,
+ RESPONSE: 6,
+ RESET: 7,
+ METHOD: 8,
+ URL: 9,
+ PROTOCOL: 10,
+ VERSION: 11,
+ STATUS: 12,
+ REASON: 13,
+ HEADER_NAME: 14,
+ HEADER_VALUE: 15,
+ HEADERS: 16,
+ CONNECT: 17,
+ UPGRADE: 18,
+ CHUNK_LENGTH: 19,
+ CHUNK_EXTENSION_NAME: 20,
+ CHUNK_EXTENSION_VALUE: 21,
+ CHUNK: 22,
+ BODY: 23,
+ DATA: 24,
+ TRAILER_NAME: 25,
+ TRAILER_VALUE: 26,
+ TRAILERS: 27,
+ STATE_CHANGE: 28,
+ 0: 'END',
+ 1: 'ERROR',
+ 2: 'FINISH',
+ 3: 'MESSAGE_START',
+ 4: 'MESSAGE_COMPLETE',
+ 5: 'REQUEST',
+ 6: 'RESPONSE',
+ 7: 'RESET',
+ 8: 'METHOD',
+ 9: 'URL',
+ 10: 'PROTOCOL',
+ 11: 'VERSION',
+ 12: 'STATUS',
+ 13: 'REASON',
+ 14: 'HEADER_NAME',
+ 15: 'HEADER_VALUE',
+ 16: 'HEADERS',
+ 17: 'CONNECT',
+ 18: 'UPGRADE',
+ 19: 'CHUNK_LENGTH',
+ 20: 'CHUNK_EXTENSION_NAME',
+ 21: 'CHUNK_EXTENSION_VALUE',
+ 22: 'CHUNK',
+ 23: 'BODY',
+ 24: 'DATA',
+ 25: 'TRAILER_NAME',
+ 26: 'TRAILER_VALUE',
+ 27: 'TRAILERS',
+ 28: 'STATE_CHANGE'
+})
+
+const EventActives = Object.freeze({
+ NONE: 0n,
+ ON_ERROR: 1n,
+ ON_FINISH: 2n,
+ ON_MESSAGE_START: 4n,
+ ON_MESSAGE_COMPLETE: 8n,
+ ON_REQUEST: 16n,
+ ON_RESPONSE: 32n,
+ ON_RESET: 64n,
+ ON_METHOD: 128n,
+ ON_URL: 256n,
+ ON_PROTOCOL: 512n,
+ ON_VERSION: 1024n,
+ ON_STATUS: 2048n,
+ ON_REASON: 4096n,
+ ON_HEADER_NAME: 8192n,
+ ON_HEADER_VALUE: 16384n,
+ ON_HEADERS: 32768n,
+ ON_CONNECT: 65536n,
+ ON_UPGRADE: 131072n,
+ ON_CHUNK_LENGTH: 262144n,
+ ON_CHUNK_EXTENSION_NAME: 524288n,
+ ON_CHUNK_EXTENSION_VALUE: 1048576n,
+ ON_CHUNK: 2097152n,
+ ON_BODY: 4194304n,
+ ON_DATA: 8388608n,
+ ON_TRAILER_NAME: 16777216n,
+ ON_TRAILER_VALUE: 33554432n,
+ ON_TRAILERS: 67108864n,
+ ON_STATE_CHANGE: 134217728n,
+ ALL: 268435455n,
+ 0n: 'NONE',
+ 1n: 'ON_ERROR',
+ 2n: 'ON_FINISH',
+ 4n: 'ON_MESSAGE_START',
+ 8n: 'ON_MESSAGE_COMPLETE',
+ 16n: 'ON_REQUEST',
+ 32n: 'ON_RESPONSE',
+ 64n: 'ON_RESET',
+ 128n: 'ON_METHOD',
+ 256n: 'ON_URL',
+ 512n: 'ON_PROTOCOL',
+ 1024n: 'ON_VERSION',
+ 2048n: 'ON_STATUS',
+ 4096n: 'ON_REASON',
+ 8192n: 'ON_HEADER_NAME',
+ 16384n: 'ON_HEADER_VALUE',
+ 32768n: 'ON_HEADERS',
+ 65536n: 'ON_CONNECT',
+ 131072n: 'ON_UPGRADE',
+ 262144n: 'ON_CHUNK_LENGTH',
+ 524288n: 'ON_CHUNK_EXTENSION_NAME',
+ 1048576n: 'ON_CHUNK_EXTENSION_VALUE',
+ 2097152n: 'ON_CHUNK',
+ 4194304n: 'ON_BODY',
+ 8388608n: 'ON_DATA',
+ 16777216n: 'ON_TRAILER_NAME',
+ 33554432n: 'ON_TRAILER_VALUE',
+ 67108864n: 'ON_TRAILERS',
+ 134217728n: 'ON_STATE_CHANGE',
+ 268435455n: 'ALL'
+})
+
+const States = Object.freeze({
+ START: 0,
+ FINISH: 1,
+ ERROR: 2,
+ REQUEST_LINE: 3,
+ STATUS_LINE: 4,
+ HTTP2_PREFACE: 5,
+ HEADER: 6,
+ BODY_DECISION: 7,
+ BODY_VIA_CONTENT_LENGTH: 8,
+ BODY_WITH_NO_LENGTH: 9,
+ CHUNK_HEADER: 10,
+ CHUNK_EXTENSIONS: 11,
+ CHUNK_DATA: 12,
+ TRAILER: 13,
+ TUNNEL: 14,
+ 0: 'START',
+ 1: 'FINISH',
+ 2: 'ERROR',
+ 3: 'REQUEST_LINE',
+ 4: 'STATUS_LINE',
+ 5: 'HTTP2_PREFACE',
+ 6: 'HEADER',
+ 7: 'BODY_DECISION',
+ 8: 'BODY_VIA_CONTENT_LENGTH',
+ 9: 'BODY_WITH_NO_LENGTH',
+ 10: 'CHUNK_HEADER',
+ 11: 'CHUNK_EXTENSIONS',
+ 12: 'CHUNK_DATA',
+ 13: 'TRAILER',
+ 14: 'TUNNEL'
+})
+
+const ParserFields = Object.freeze({
+ MAX_START_LINE_LENGTH: 0,
+ MAX_HEADER_LENGTH: 4,
+ MAX_BODY_PAYLOAD: 8,
+ AUTODETECT: 16,
+ IS_REQUEST: 17,
+ SUSPEND_AFTER_HEADERS: 18,
+ MANAGE_UNCONSUMED: 19,
+ CONTINUE_WITHOUT_DATA: 20,
+ IS_CONNECT: 21,
+ SKIP_BODY: 22,
+ DEBUG: 23,
+ PARSED: 24,
+ POSITION: 32,
+ STATE: 36,
+ PAUSED: 37,
+ ERROR_CODE: 38,
+ CONTENT_LENGTH: 40,
+ CHUNK_SIZE: 48,
+ REMAINING_CONTENT_LENGTH: 56,
+ REMAINING_CHUNK_SIZE: 64,
+ STATUS: 72,
+ METHOD: 76,
+ HAS_CONTENT_LENGTH: 77,
+ HAS_TRANSFER_ENCODING: 78,
+ HAS_CHUNKED_TRANSFER_ENCODING: 79,
+ HAS_CONNECTION_CLOSE: 80,
+ HAS_CONNECTION_UPGRADE: 81,
+ HAS_UPGRADE: 82,
+ HAS_TRAILERS: 83,
+ ACTIVE_CALLBACKS: 88,
+ ACTIVE_EVENTS: 96,
+ PTR: 104,
+ ERROR_DESCRIPTION: 108,
+ UNCONSUMED: 364,
+ UNCONSUMED_LEN: 368,
+ ERROR_DESCRIPTION_LEN: 372,
+ EVENTS: 376,
+ 0: 'MAX_START_LINE_LENGTH',
+ 4: 'MAX_HEADER_LENGTH',
+ 8: 'MAX_BODY_PAYLOAD',
+ 16: 'AUTODETECT',
+ 17: 'IS_REQUEST',
+ 18: 'SUSPEND_AFTER_HEADERS',
+ 19: 'MANAGE_UNCONSUMED',
+ 20: 'CONTINUE_WITHOUT_DATA',
+ 21: 'IS_CONNECT',
+ 22: 'SKIP_BODY',
+ 23: 'DEBUG',
+ 24: 'PARSED',
+ 32: 'POSITION',
+ 36: 'STATE',
+ 37: 'PAUSED',
+ 38: 'ERROR_CODE',
+ 40: 'CONTENT_LENGTH',
+ 48: 'CHUNK_SIZE',
+ 56: 'REMAINING_CONTENT_LENGTH',
+ 64: 'REMAINING_CHUNK_SIZE',
+ 72: 'STATUS',
+ 76: 'METHOD',
+ 77: 'HAS_CONTENT_LENGTH',
+ 78: 'HAS_TRANSFER_ENCODING',
+ 79: 'HAS_CHUNKED_TRANSFER_ENCODING',
+ 80: 'HAS_CONNECTION_CLOSE',
+ 81: 'HAS_CONNECTION_UPGRADE',
+ 82: 'HAS_UPGRADE',
+ 83: 'HAS_TRAILERS',
+ 88: 'ACTIVE_CALLBACKS',
+ 96: 'ACTIVE_EVENTS',
+ 104: 'PTR',
+ 108: 'ERROR_DESCRIPTION',
+ 364: 'UNCONSUMED',
+ 368: 'UNCONSUMED_LEN',
+ 372: 'ERROR_DESCRIPTION_LEN',
+ 376: 'EVENTS'
+})
+
+function isAutodetect (parser) {
+ return this.is_autodetect(parser) !== 0
+}
+
+function isRequest (parser) {
+ return this.is_request(parser) !== 0
+}
+
+function isPaused (parser) {
+ return this.is_paused(parser) !== 0
+}
+
+function shouldManageUnconsumed (parser) {
+ return this.should_manage_unconsumed(parser) !== 0
+}
+
+function shouldSuspendAfterHeaders (parser) {
+ return this.should_suspend_after_headers(parser) !== 0
+}
+
+function getMaxStartLineLength (parser) {
+ return this.get_max_start_line_length(parser) >>> 0
+}
+
+function getMaxHeaderLength (parser) {
+ return this.get_max_header_length(parser) >>> 0
+}
+
+function getMaxBodyPayload (parser) {
+ return BigInt.asUintN(64, this.get_max_body_payload(parser))
+}
+
+function shouldContinueWithoutData (parser) {
+ return this.should_continue_without_data(parser) !== 0
+}
+
+function isConnect (parser) {
+ return this.is_connect(parser) !== 0
+}
+
+function isDebug (parser) {
+ return this.is_debug(parser) !== 0
+}
+
+function shouldSkipBody (parser) {
+ return this.should_skip_body(parser) !== 0
+}
+
+function getState (parser) {
+ return this.get_state(parser) >>> 0
+}
+
+function getPosition (parser) {
+ return this.get_position(parser) >>> 0
+}
+
+function getParsed (parser) {
+ return BigInt.asUintN(64, this.get_parsed(parser))
+}
+
+function getErrorCode (parser) {
+ return this.get_error_code(parser) >>> 0
+}
+
+function getMethod (parser) {
+ return this.get_method(parser) >>> 0
+}
+
+function getStatus (parser) {
+ return this.get_status(parser) >>> 0
+}
+
+function hasConnectionClose (parser) {
+ return this.has_connection_close(parser) !== 0
+}
+
+function hasConnectionUpgrade (parser) {
+ return this.has_connection_upgrade(parser) !== 0
+}
+
+function getContentLength (parser) {
+ return BigInt.asUintN(64, this.get_content_length(parser))
+}
+
+function getChunkSize (parser) {
+ return BigInt.asUintN(64, this.get_chunk_size(parser))
+}
+
+function getRemainingContentLength (parser) {
+ return BigInt.asUintN(64, this.get_remaining_content_length(parser))
+}
+
+function getRemainingChunkSize (parser) {
+ return BigInt.asUintN(64, this.get_remaining_chunk_size(parser))
+}
+
+function hasContentLength (parser) {
+ return this.has_content_length(parser) !== 0
+}
+
+function hasTransferEncoding (parser) {
+ return this.has_transfer_encoding(parser) !== 0
+}
+
+function hasChunkedTransferEncoding (parser) {
+ return this.has_chunked_transfer_encoding(parser) !== 0
+}
+
+function hasUpgrade (parser) {
+ return this.has_upgrade(parser) !== 0
+}
+
+function hasTrailers (parser) {
+ return this.has_trailers(parser) !== 0
+}
+
+function getErrorDescription (parser) {
+ const raw = this.get_error_description_raw(parser)
+ const len = Number(BigInt.asUintN(32, raw))
+ const ptr = Number(raw >> 32n)
+ return textDecoder.decode(new Uint8Array(this.memory.buffer, ptr, len))
+}
+
+function setShouldAutodetect (parser, value) {
+ this.set_should_autodetect(parser, value)
+}
+
+function setShouldContinueWithoutData (parser, value) {
+ this.set_should_continue_without_data(parser, value)
+}
+
+function setIsRequest (parser, value) {
+ this.set_is_request(parser, value)
+}
+
+function setIsConnect (parser, value) {
+ this.set_is_connect(parser, value)
+}
+
+function setDebug (parser, value) {
+ this.set_debug(parser, value)
+}
+
+function setShouldManageUnconsumed (parser, value) {
+ this.set_should_manage_unconsumed(parser, value)
+}
+
+function setShouldSuspendAfterHeaders (parser, value) {
+ this.set_should_suspend_after_headers(parser, value)
+}
+
+function setMaxStartLineLength (parser, value) {
+ this.set_max_start_line_length(parser, value)
+}
+
+function setMaxHeaderLength (parser, value) {
+ this.set_max_header_length(parser, value)
+}
+
+function setMaxBodyPayload (parser, value) {
+ this.set_max_body_payload(parser, value)
+}
+
+function setShouldSkipBody (parser, value) {
+ this.set_should_skip_body(parser, value)
+}
+
+function setActiveCallbacks (parser, value) {
+ this.set_active_callbacks(parser, value)
+}
+
+function setActiveEvents (parser, value) {
+ this.set_active_events(parser, value)
+}
+
+function simpleCreate (spans, create) {
+ const parser = create()
+ spans[parser] = []
+ this.setActiveCallbacks(parser, this.CALLBACK_ACTIVE_ALL)
+ return parser
+}
+
+function simpleDestroy (spans, destroy, parser) {
+ spans[parser] = undefined
+ destroy(parser)
+}
+
+function noop () {}
+
+function setup (env = {}) {
+ let { logger: logOption, ...instanceEnvironment } = env
+ let logger = noop
+ const context = {}
+
+ if (logOption) {
+ if (typeof logOption !== 'function') {
+ logOption = console.log
+ }
+
+ logger = log.bind(context, logOption)
+ }
+
+ // Create the WASM instance
+ /* eslint-disable-next-line no-undef */
+ const instance = new WebAssembly.Instance(wasmModule, {
+ env: {
+ logger,
+ on_error: noop,
+ on_finish: noop,
+ on_message_start: noop,
+ on_message_complete: noop,
+ on_request: noop,
+ on_response: noop,
+ on_reset: noop,
+ on_method: noop,
+ on_url: noop,
+ on_protocol: noop,
+ on_version: noop,
+ on_status: noop,
+ on_reason: noop,
+ on_header_name: noop,
+ on_header_value: noop,
+ on_headers: noop,
+ on_connect: noop,
+ on_upgrade: noop,
+ on_chunk_length: noop,
+ on_chunk_extension_name: noop,
+ on_chunk_extension_value: noop,
+ on_chunk: noop,
+ on_body: noop,
+ on_data: noop,
+ on_trailer_name: noop,
+ on_trailer_value: noop,
+ on_trailers: noop,
+ on_state_change: noop,
+ ...instanceEnvironment
+ }
+ })
+
+ const wasm = instance.exports
+ context.memory = wasm.memory
+
+ const milo = {
+ version: {
+ raw: '0.9.0',
+ major: 0,
+ minor: 9,
+ patch: 0,
+ prerelease: ''
+ },
+ METHOD_OTHER: 0,
+ METHOD_GET: 1,
+ METHOD_HEAD: 2,
+ METHOD_POST: 3,
+ METHOD_PUT: 4,
+ METHOD_DELETE: 5,
+ METHOD_CONNECT: 6,
+ METHOD_OPTIONS: 7,
+ METHOD_TRACE: 8,
+ METHOD_PATCH: 9,
+ METHOD_PRI: 10,
+ CALLBACK_ON_ERROR: 0,
+ CALLBACK_ON_FINISH: 1,
+ CALLBACK_ON_MESSAGE_START: 2,
+ CALLBACK_ON_MESSAGE_COMPLETE: 3,
+ CALLBACK_ON_REQUEST: 4,
+ CALLBACK_ON_RESPONSE: 5,
+ CALLBACK_ON_RESET: 6,
+ CALLBACK_ON_METHOD: 7,
+ CALLBACK_ON_URL: 8,
+ CALLBACK_ON_PROTOCOL: 9,
+ CALLBACK_ON_VERSION: 10,
+ CALLBACK_ON_STATUS: 11,
+ CALLBACK_ON_REASON: 12,
+ CALLBACK_ON_HEADER_NAME: 13,
+ CALLBACK_ON_HEADER_VALUE: 14,
+ CALLBACK_ON_HEADERS: 15,
+ CALLBACK_ON_CONNECT: 16,
+ CALLBACK_ON_UPGRADE: 17,
+ CALLBACK_ON_CHUNK_LENGTH: 18,
+ CALLBACK_ON_CHUNK_EXTENSION_NAME: 19,
+ CALLBACK_ON_CHUNK_EXTENSION_VALUE: 20,
+ CALLBACK_ON_CHUNK: 21,
+ CALLBACK_ON_BODY: 22,
+ CALLBACK_ON_DATA: 23,
+ CALLBACK_ON_TRAILER_NAME: 24,
+ CALLBACK_ON_TRAILER_VALUE: 25,
+ CALLBACK_ON_TRAILERS: 26,
+ CALLBACK_ON_STATE_CHANGE: 27,
+ EVENT_END: 0,
+ EVENT_ERROR: 1,
+ EVENT_FINISH: 2,
+ EVENT_MESSAGE_START: 3,
+ EVENT_MESSAGE_COMPLETE: 4,
+ EVENT_REQUEST: 5,
+ EVENT_RESPONSE: 6,
+ EVENT_RESET: 7,
+ EVENT_METHOD: 8,
+ EVENT_URL: 9,
+ EVENT_PROTOCOL: 10,
+ EVENT_VERSION: 11,
+ EVENT_STATUS: 12,
+ EVENT_REASON: 13,
+ EVENT_HEADER_NAME: 14,
+ EVENT_HEADER_VALUE: 15,
+ EVENT_HEADERS: 16,
+ EVENT_CONNECT: 17,
+ EVENT_UPGRADE: 18,
+ EVENT_CHUNK_LENGTH: 19,
+ EVENT_CHUNK_EXTENSION_NAME: 20,
+ EVENT_CHUNK_EXTENSION_VALUE: 21,
+ EVENT_CHUNK: 22,
+ EVENT_BODY: 23,
+ EVENT_DATA: 24,
+ EVENT_TRAILER_NAME: 25,
+ EVENT_TRAILER_VALUE: 26,
+ EVENT_TRAILERS: 27,
+ EVENT_STATE_CHANGE: 28,
+ CALLBACK_ACTIVE_NONE: 0n,
+ EVENT_ACTIVE_NONE: 0n,
+ CALLBACK_ACTIVE_ON_ERROR: 1n,
+ EVENT_ACTIVE_ON_ERROR: 1n,
+ CALLBACK_ACTIVE_ON_FINISH: 2n,
+ EVENT_ACTIVE_ON_FINISH: 2n,
+ CALLBACK_ACTIVE_ON_MESSAGE_START: 4n,
+ EVENT_ACTIVE_ON_MESSAGE_START: 4n,
+ CALLBACK_ACTIVE_ON_MESSAGE_COMPLETE: 8n,
+ EVENT_ACTIVE_ON_MESSAGE_COMPLETE: 8n,
+ CALLBACK_ACTIVE_ON_REQUEST: 16n,
+ EVENT_ACTIVE_ON_REQUEST: 16n,
+ CALLBACK_ACTIVE_ON_RESPONSE: 32n,
+ EVENT_ACTIVE_ON_RESPONSE: 32n,
+ CALLBACK_ACTIVE_ON_RESET: 64n,
+ EVENT_ACTIVE_ON_RESET: 64n,
+ CALLBACK_ACTIVE_ON_METHOD: 128n,
+ EVENT_ACTIVE_ON_METHOD: 128n,
+ CALLBACK_ACTIVE_ON_URL: 256n,
+ EVENT_ACTIVE_ON_URL: 256n,
+ CALLBACK_ACTIVE_ON_PROTOCOL: 512n,
+ EVENT_ACTIVE_ON_PROTOCOL: 512n,
+ CALLBACK_ACTIVE_ON_VERSION: 1024n,
+ EVENT_ACTIVE_ON_VERSION: 1024n,
+ CALLBACK_ACTIVE_ON_STATUS: 2048n,
+ EVENT_ACTIVE_ON_STATUS: 2048n,
+ CALLBACK_ACTIVE_ON_REASON: 4096n,
+ EVENT_ACTIVE_ON_REASON: 4096n,
+ CALLBACK_ACTIVE_ON_HEADER_NAME: 8192n,
+ EVENT_ACTIVE_ON_HEADER_NAME: 8192n,
+ CALLBACK_ACTIVE_ON_HEADER_VALUE: 16384n,
+ EVENT_ACTIVE_ON_HEADER_VALUE: 16384n,
+ CALLBACK_ACTIVE_ON_HEADERS: 32768n,
+ EVENT_ACTIVE_ON_HEADERS: 32768n,
+ CALLBACK_ACTIVE_ON_CONNECT: 65536n,
+ EVENT_ACTIVE_ON_CONNECT: 65536n,
+ CALLBACK_ACTIVE_ON_UPGRADE: 131072n,
+ EVENT_ACTIVE_ON_UPGRADE: 131072n,
+ CALLBACK_ACTIVE_ON_CHUNK_LENGTH: 262144n,
+ EVENT_ACTIVE_ON_CHUNK_LENGTH: 262144n,
+ CALLBACK_ACTIVE_ON_CHUNK_EXTENSION_NAME: 524288n,
+ EVENT_ACTIVE_ON_CHUNK_EXTENSION_NAME: 524288n,
+ CALLBACK_ACTIVE_ON_CHUNK_EXTENSION_VALUE: 1048576n,
+ EVENT_ACTIVE_ON_CHUNK_EXTENSION_VALUE: 1048576n,
+ CALLBACK_ACTIVE_ON_CHUNK: 2097152n,
+ EVENT_ACTIVE_ON_CHUNK: 2097152n,
+ CALLBACK_ACTIVE_ON_BODY: 4194304n,
+ EVENT_ACTIVE_ON_BODY: 4194304n,
+ CALLBACK_ACTIVE_ON_DATA: 8388608n,
+ EVENT_ACTIVE_ON_DATA: 8388608n,
+ CALLBACK_ACTIVE_ON_TRAILER_NAME: 16777216n,
+ EVENT_ACTIVE_ON_TRAILER_NAME: 16777216n,
+ CALLBACK_ACTIVE_ON_TRAILER_VALUE: 33554432n,
+ EVENT_ACTIVE_ON_TRAILER_VALUE: 33554432n,
+ CALLBACK_ACTIVE_ON_TRAILERS: 67108864n,
+ EVENT_ACTIVE_ON_TRAILERS: 67108864n,
+ CALLBACK_ACTIVE_ON_STATE_CHANGE: 134217728n,
+ EVENT_ACTIVE_ON_STATE_CHANGE: 134217728n,
+ CALLBACK_ACTIVE_ALL: 268435455n,
+ EVENT_ACTIVE_ALL: 268435455n,
+ ERROR_NONE: 0,
+ ERROR_USER: 1,
+ ERROR_CALLBACK_ERROR: 2,
+ ERROR_UNEXPECTED_STATE: 3,
+ ERROR_UNEXPECTED_DATA: 4,
+ ERROR_UNEXPECTED_EOF: 5,
+ ERROR_UNEXPECTED_CHARACTER: 6,
+ ERROR_UNEXPECTED_CONTENT_LENGTH: 7,
+ ERROR_UNEXPECTED_TRANSFER_ENCODING: 8,
+ ERROR_UNEXPECTED_CONTENT: 9,
+ ERROR_UNEXPECTED_TRAILERS: 10,
+ ERROR_INVALID_VERSION: 11,
+ ERROR_INVALID_STATUS: 12,
+ ERROR_INVALID_CONTENT_LENGTH: 13,
+ ERROR_INVALID_TRANSFER_ENCODING: 14,
+ ERROR_INVALID_CHUNK_SIZE: 15,
+ ERROR_MISSING_CONNECTION_UPGRADE: 16,
+ ERROR_UNSUPPORTED_HTTP_VERSION: 17,
+ STATE_START: 0,
+ STATE_FINISH: 1,
+ STATE_ERROR: 2,
+ STATE_REQUEST_LINE: 3,
+ STATE_STATUS_LINE: 4,
+ STATE_HTTP2_PREFACE: 5,
+ STATE_HEADER: 6,
+ STATE_BODY_DECISION: 7,
+ STATE_BODY_VIA_CONTENT_LENGTH: 8,
+ STATE_BODY_WITH_NO_LENGTH: 9,
+ STATE_CHUNK_HEADER: 10,
+ STATE_CHUNK_EXTENSIONS: 11,
+ STATE_CHUNK_DATA: 12,
+ STATE_TRAILER: 13,
+ STATE_TUNNEL: 14,
+ PARSER_FIELD_MAX_START_LINE_LENGTH: 0,
+ PARSER_FIELD_MAX_HEADER_LENGTH: 4,
+ PARSER_FIELD_MAX_BODY_PAYLOAD: 8,
+ PARSER_FIELD_AUTODETECT: 16,
+ PARSER_FIELD_IS_REQUEST: 17,
+ PARSER_FIELD_SUSPEND_AFTER_HEADERS: 18,
+ PARSER_FIELD_MANAGE_UNCONSUMED: 19,
+ PARSER_FIELD_CONTINUE_WITHOUT_DATA: 20,
+ PARSER_FIELD_IS_CONNECT: 21,
+ PARSER_FIELD_SKIP_BODY: 22,
+ PARSER_FIELD_DEBUG: 23,
+ PARSER_FIELD_PARSED: 24,
+ PARSER_FIELD_POSITION: 32,
+ PARSER_FIELD_STATE: 36,
+ PARSER_FIELD_PAUSED: 37,
+ PARSER_FIELD_ERROR_CODE: 38,
+ PARSER_FIELD_CONTENT_LENGTH: 40,
+ PARSER_FIELD_CHUNK_SIZE: 48,
+ PARSER_FIELD_REMAINING_CONTENT_LENGTH: 56,
+ PARSER_FIELD_REMAINING_CHUNK_SIZE: 64,
+ PARSER_FIELD_STATUS: 72,
+ PARSER_FIELD_METHOD: 76,
+ PARSER_FIELD_HAS_CONTENT_LENGTH: 77,
+ PARSER_FIELD_HAS_TRANSFER_ENCODING: 78,
+ PARSER_FIELD_HAS_CHUNKED_TRANSFER_ENCODING: 79,
+ PARSER_FIELD_HAS_CONNECTION_CLOSE: 80,
+ PARSER_FIELD_HAS_CONNECTION_UPGRADE: 81,
+ PARSER_FIELD_HAS_UPGRADE: 82,
+ PARSER_FIELD_HAS_TRAILERS: 83,
+ PARSER_FIELD_ACTIVE_CALLBACKS: 88,
+ PARSER_FIELD_ACTIVE_EVENTS: 96,
+ PARSER_FIELD_PTR: 104,
+ PARSER_FIELD_ERROR_DESCRIPTION: 108,
+ PARSER_FIELD_UNCONSUMED: 364,
+ PARSER_FIELD_UNCONSUMED_LEN: 368,
+ PARSER_FIELD_ERROR_DESCRIPTION_LEN: 372,
+ PARSER_FIELD_EVENTS: 376,
+ Errors,
+ Methods,
+ Callbacks,
+ CallbackActives,
+ Events,
+ EventActives,
+ States,
+ ParserFields,
+ isAutodetect: isAutodetect.bind(wasm),
+ isRequest: isRequest.bind(wasm),
+ isPaused: isPaused.bind(wasm),
+ shouldManageUnconsumed: shouldManageUnconsumed.bind(wasm),
+ shouldSuspendAfterHeaders: shouldSuspendAfterHeaders.bind(wasm),
+ getMaxStartLineLength: getMaxStartLineLength.bind(wasm),
+ getMaxHeaderLength: getMaxHeaderLength.bind(wasm),
+ getMaxBodyPayload: getMaxBodyPayload.bind(wasm),
+ shouldContinueWithoutData: shouldContinueWithoutData.bind(wasm),
+ isConnect: isConnect.bind(wasm),
+ isDebug: isDebug.bind(wasm),
+ shouldSkipBody: shouldSkipBody.bind(wasm),
+ getState: getState.bind(wasm),
+ getPosition: getPosition.bind(wasm),
+ getParsed: getParsed.bind(wasm),
+ getErrorCode: getErrorCode.bind(wasm),
+ getMethod: getMethod.bind(wasm),
+ getStatus: getStatus.bind(wasm),
+ hasConnectionClose: hasConnectionClose.bind(wasm),
+ hasConnectionUpgrade: hasConnectionUpgrade.bind(wasm),
+ getContentLength: getContentLength.bind(wasm),
+ getChunkSize: getChunkSize.bind(wasm),
+ getRemainingContentLength: getRemainingContentLength.bind(wasm),
+ getRemainingChunkSize: getRemainingChunkSize.bind(wasm),
+ hasContentLength: hasContentLength.bind(wasm),
+ hasTransferEncoding: hasTransferEncoding.bind(wasm),
+ hasChunkedTransferEncoding: hasChunkedTransferEncoding.bind(wasm),
+ hasUpgrade: hasUpgrade.bind(wasm),
+ hasTrailers: hasTrailers.bind(wasm),
+ getErrorDescription: getErrorDescription.bind(wasm),
+ setShouldAutodetect: setShouldAutodetect.bind(wasm),
+ setShouldContinueWithoutData: setShouldContinueWithoutData.bind(wasm),
+ setIsRequest: setIsRequest.bind(wasm),
+ setIsConnect: setIsConnect.bind(wasm),
+ setDebug: setDebug.bind(wasm),
+ setShouldManageUnconsumed: setShouldManageUnconsumed.bind(wasm),
+ setShouldSuspendAfterHeaders: setShouldSuspendAfterHeaders.bind(wasm),
+ setMaxStartLineLength: setMaxStartLineLength.bind(wasm),
+ setMaxHeaderLength: setMaxHeaderLength.bind(wasm),
+ setMaxBodyPayload: setMaxBodyPayload.bind(wasm),
+ setShouldSkipBody: setShouldSkipBody.bind(wasm),
+ setActiveCallbacks: setActiveCallbacks.bind(wasm),
+ setActiveEvents: setActiveEvents.bind(wasm),
+ memory: wasm.memory,
+ alloc: alloc.bind(wasm),
+ dealloc: dealloc.bind(wasm),
+ create: create.bind(wasm),
+ destroy: destroy.bind(wasm),
+ parse: parse.bind(wasm),
+ fail: fail.bind(wasm),
+ hasDebug: hasDebug.bind(wasm),
+ clear: wasm.clear,
+ complete: wasm.complete,
+ finish: wasm.finish,
+ pause: wasm.pause,
+ reset: wasm.reset,
+ resume: wasm.resume
+ }
+
+ return milo
+}
+
+function simple () {
+ const spans = {}
+
+ const milo = setup({/* REPLACE: callbacks:simple */})
+
+ milo.spans = spans
+ milo.create = simpleCreate.bind(milo, spans, milo.create)
+ milo.destroy = simpleDestroy.bind(milo, spans, milo.destroy)
+
+ return milo
+}
+
+module.exports = { wasmModule, noop, setup, simple }
diff --git a/deps/undici/src/lib/mock/mock-agent.js b/deps/undici/src/lib/mock/mock-agent.js
index 6051d5aab7c..3868415698e 100644
--- a/deps/undici/src/lib/mock/mock-agent.js
+++ b/deps/undici/src/lib/mock/mock-agent.js
@@ -55,6 +55,17 @@ class MockAgent extends Dispatcher {
}
}
+ // WebSocket and EventSource read their receive limits from the dispatcher
+ // they are given, so report the settings of the agent that makes real
+ // connections.
+ get webSocketOptions () {
+ return this[kAgent].webSocketOptions
+ }
+
+ get eventSourceOptions () {
+ return this[kAgent].eventSourceOptions
+ }
+
get (origin) {
// Normalize origin to handle URL objects and case-insensitive hostnames
const normalizedOrigin = normalizeOrigin(origin)
diff --git a/deps/undici/src/lib/mock/snapshot-recorder.js b/deps/undici/src/lib/mock/snapshot-recorder.js
index 57a7e7a41dd..e69bcc5a777 100644
--- a/deps/undici/src/lib/mock/snapshot-recorder.js
+++ b/deps/undici/src/lib/mock/snapshot-recorder.js
@@ -4,6 +4,7 @@ const { writeFile, readFile, mkdir } = require('node:fs/promises')
const { dirname, resolve } = require('node:path')
const { setTimeout, clearTimeout } = require('node:timers')
const { InvalidArgumentError, UndiciError } = require('../core/errors')
+const { setHeader } = require('../core/util')
const { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require('./snapshot-utils')
/**
@@ -169,7 +170,7 @@ function filterHeadersForMatching (headers, headerFilters, matchOptions = {}) {
if (!match.has(headerKey)) continue
}
- filtered[headerKey] = value
+ setHeader(filtered, headerKey, value)
}
return filtered
@@ -198,7 +199,7 @@ function filterHeadersForStorage (headers, headerFilters, matchOptions = {}) {
// Skip if in exclude list (for security)
if (excludeSet.has(headerKey)) continue
- filtered[headerKey] = value
+ setHeader(filtered, headerKey, value)
}
return filtered
diff --git a/deps/undici/src/lib/mock/snapshot-utils.js b/deps/undici/src/lib/mock/snapshot-utils.js
index a14b69c15d4..c40f2f1caa2 100644
--- a/deps/undici/src/lib/mock/snapshot-utils.js
+++ b/deps/undici/src/lib/mock/snapshot-utils.js
@@ -1,6 +1,7 @@
'use strict'
const { InvalidArgumentError } = require('../core/errors')
+const { setHeader } = require('../core/util')
const { runtimeFeatures } = require('../util/runtime-features.js')
/**
@@ -116,7 +117,7 @@ function normalizeHeaders (headers) {
// Convert Buffers to strings if needed
const keyStr = Buffer.isBuffer(key) ? key.toString() : key
const valueStr = Buffer.isBuffer(value) ? value.toString() : value
- normalizedHeaders[keyStr.toLowerCase()] = valueStr
+ setHeader(normalizedHeaders, keyStr.toLowerCase(), valueStr)
}
}
return normalizedHeaders
@@ -126,7 +127,7 @@ function normalizeHeaders (headers) {
if (headers && typeof headers === 'object') {
for (const [key, value] of Object.entries(headers)) {
if (key && typeof key === 'string') {
- normalizedHeaders[key.toLowerCase()] = Array.isArray(value) ? value.join(', ') : String(value)
+ setHeader(normalizedHeaders, key.toLowerCase(), Array.isArray(value) ? value.join(', ') : String(value))
}
}
}
diff --git a/deps/undici/src/lib/util/cache.js b/deps/undici/src/lib/util/cache.js
index ad2524fad3a..12f29e9181f 100644
--- a/deps/undici/src/lib/util/cache.js
+++ b/deps/undici/src/lib/util/cache.js
@@ -4,7 +4,8 @@ const {
safeHTTPMethods,
pathHasQueryOrFragment,
hasSafeIterator,
- isValidHTTPToken
+ isValidHTTPToken,
+ setHeader
} = require('../core/util')
const { serializePathWithQuery } = require('../core/util')
@@ -206,15 +207,20 @@ function makeCacheKey (opts, origin = getRequestOrigin(opts)) {
function appendHeader (headers, key, val) {
const headerName = key.toLowerCase()
- const current = headers[headerName]
+ // Reading `headers[headerName]` directly would resolve `__proto__` (and any
+ // other inherited name) through the prototype chain rather than report the
+ // header as absent.
+ const current = Object.hasOwn(headers, headerName)
+ ? headers[headerName]
+ : undefined
const values = Array.isArray(val) ? val : [val]
if (current === undefined) {
- headers[headerName] = Array.isArray(val) ? val.slice() : val
+ setHeader(headers, headerName, Array.isArray(val) ? val.slice() : val)
} else if (Array.isArray(current)) {
current.push(...values)
} else {
- headers[headerName] = [current, ...values]
+ setHeader(headers, headerName, [current, ...values])
}
}
@@ -732,7 +738,7 @@ function makeDeduplicationKey (cacheKey, excludeHeaders) {
if (excludeHeaders?.has(header.toLowerCase())) {
continue
}
- headers[header] = cacheKey.headers[header]
+ setHeader(headers, header, cacheKey.headers[header])
}
}
diff --git a/deps/undici/src/lib/web/cookies/util.js b/deps/undici/src/lib/web/cookies/util.js
index 78680118788..3d7f6f33bc9 100644
--- a/deps/undici/src/lib/web/cookies/util.js
+++ b/deps/undici/src/lib/web/cookies/util.js
@@ -317,8 +317,25 @@ function stringify (cookie) {
// A numeric 0 is the Unix epoch, not an absent value -- the same reason the
// Max-Age check above tests the type rather than truthiness.
- if (cookie.expires != null && cookie.expires.toString() !== 'Invalid Date') {
- out.push(`Expires=${toIMFDate(cookie.expires)}`)
+ //
+ // expires is Date | number, so the "Invalid Date" check only guards the Date
+ // form. A number that is not a valid time value (NaN, +/-Infinity, or outside
+ // the Date range) would otherwise reach toIMFDate, which splices undefined and
+ // NaN into the header value instead of failing.
+ if (cookie.expires != null) {
+ const expiresMs = cookie.expires instanceof Date
+ ? cookie.expires.getTime()
+ : cookie.expires
+
+ // The largest time value a Date can represent, in milliseconds, i.e.
+ // 100,000,000 days either side of the epoch (ECMA-262 Date Time Values).
+ // Anything within it is safe for toIMFDate to format; anything beyond it
+ // produces an invalid Date and must be ignored instead.
+ const maxTimeValue = 8640000000000000
+
+ if (typeof expiresMs === 'number' && Number.isFinite(expiresMs) && Math.abs(expiresMs) <= maxTimeValue) {
+ out.push(`Expires=${toIMFDate(cookie.expires)}`)
+ }
}
if (cookie.sameSite) {
diff --git a/deps/undici/src/lib/web/eventsource/eventsource-stream.js b/deps/undici/src/lib/web/eventsource/eventsource-stream.js
index 03000e67dd0..e5f38604873 100644
--- a/deps/undici/src/lib/web/eventsource/eventsource-stream.js
+++ b/deps/undici/src/lib/web/eventsource/eventsource-stream.js
@@ -31,6 +31,12 @@ const EVENT = Buffer.from('event')
const ID = Buffer.from('id')
const RETRY = Buffer.from('retry')
+// Each data field creates a string node, and each unconsumed input chunk keeps
+// a Buffer wrapper. The absolute ceiling protects the large default byte limit.
+const minParserItems = 1024
+const maxParserItems = 131072
+const bytesPerParserItem = 128
+
function isASCIINumberBytes (buffer, start) {
if (start >= buffer.length) {
return false
@@ -123,8 +129,13 @@ class EventSourceStream extends Transform {
pos = 0
lineChunkIndex = 0
linePos = 0
- eventDataSize = 0
+ lineLength = 0
+ eventSize = 0
+ eventFieldSizes = { data: 0, event: 0, id: 0, retry: 0 }
+ dataLineCount = 0
maxEventSize
+ maxDataLines
+ maxBufferedChunks
event = {
data: undefined,
@@ -149,6 +160,11 @@ class EventSourceStream extends Transform {
this.state = options.eventSourceSettings || {}
this.maxEventSize = options.maxEventSize ?? defaultMaxEventSize
+ const parserItemLimit = this.maxEventSize > 0
+ ? Math.min(maxParserItems, Math.max(minParserItems, Math.floor(this.maxEventSize / bytesPerParserItem)))
+ : 0
+ this.maxDataLines = parserItemLimit
+ this.maxBufferedChunks = parserItemLimit
if (options.push) {
this.push = options.push
}
@@ -166,6 +182,14 @@ class EventSourceStream extends Transform {
return
}
+ // A leading line ending can immediately release the currently buffered
+ // line, even when it uses the final allowed chunk slot.
+ if (this.maxEventSize > 0 &&
+ this.chunks.length >= this.maxBufferedChunks &&
+ chunk[0] !== LF && chunk[0] !== CR) {
+ callback(createMaxEventSizeExceededError())
+ return
+ }
this.chunks.push(chunk)
// Strip leading byte-order-mark if we opened the stream and started
@@ -258,12 +282,25 @@ class EventSourceStream extends Transform {
continue
}
+ // readLine() is only called after CR or LF. Reject an unfinished line
+ // before it can retain an unbounded number of decoded chunks. The seven
+ // extra bytes allow the longest field prefix ("event: " or "retry: ").
+ if (this.maxEventSize > 0 && ++this.lineLength > this.maxEventSize + 7) {
+ callback(createMaxEventSizeExceededError())
+ return
+ }
this.advanceCursor()
}
callback()
}
+ _destroy (error, callback) {
+ this.chunks.length = 0
+ this.clearEvent()
+ super._destroy(error, callback)
+ }
+
/**
* @param {Buffer} line
* @param {EventSourceStreamEvent} event
@@ -300,12 +337,12 @@ class EventSourceStream extends Transform {
}
if (isFieldName(line, fieldLength, DATA)) {
- const valueBytes = line.length - valueStart
- const eventDataSize = this.eventDataSize + (event.data === undefined ? 0 : 1) + valueBytes
-
- if (this.maxEventSize > 0 && eventDataSize > this.maxEventSize) {
+ if (this.maxEventSize > 0 && this.dataLineCount >= this.maxDataLines) {
throw createMaxEventSizeExceededError()
}
+ const valueBytes = line.length - valueStart
+ const dataSize = this.eventFieldSizes.data + (event.data === undefined ? 0 : 1) + valueBytes
+ this.setEventFieldSize('data', dataSize)
const value = line.toString('utf8', valueStart)
@@ -314,12 +351,13 @@ class EventSourceStream extends Transform {
} else {
event.data += `\n${value}`
}
- this.eventDataSize = eventDataSize
+ this.dataLineCount++
return
}
if (isFieldName(line, fieldLength, RETRY)) {
if (isASCIINumberBytes(line, valueStart)) {
+ this.setEventFieldSize('retry', line.length - valueStart)
event.retry = line.toString('utf8', valueStart)
}
return
@@ -327,20 +365,29 @@ class EventSourceStream extends Transform {
if (isFieldName(line, fieldLength, ID)) {
if (isValidLastEventIdBytes(line, valueStart)) {
+ this.setEventFieldSize('id', line.length - valueStart)
event.id = line.toString('utf8', valueStart)
}
return
}
if (isFieldName(line, fieldLength, EVENT)) {
- const value = line.toString('utf8', valueStart)
-
- if (value.length > 0) {
- event.event = value
+ if (valueStart < line.length) {
+ this.setEventFieldSize('event', line.length - valueStart)
+ event.event = line.toString('utf8', valueStart)
}
}
}
+ setEventFieldSize (field, size) {
+ const eventSize = this.eventSize - this.eventFieldSizes[field] + size
+ if (this.maxEventSize > 0 && eventSize > this.maxEventSize) {
+ throw createMaxEventSizeExceededError()
+ }
+ this.eventSize = eventSize
+ this.eventFieldSizes[field] = size
+ }
+
/**
* @param {EventSourceStreamEvent} event
*/
@@ -371,7 +418,12 @@ class EventSourceStream extends Transform {
this.event.event = undefined
this.event.id = undefined
this.event.retry = undefined
- this.eventDataSize = 0
+ this.eventSize = 0
+ this.dataLineCount = 0
+ this.eventFieldSizes.data = 0
+ this.eventFieldSizes.event = 0
+ this.eventFieldSizes.id = 0
+ this.eventFieldSizes.retry = 0
}
hasPendingEvent () {
@@ -407,14 +459,16 @@ class EventSourceStream extends Transform {
syncLineStartToCursor () {
this.lineChunkIndex = this.chunkIndex
this.linePos = this.pos
+ this.lineLength = 0
this.dropConsumedChunks()
}
dropConsumedChunks () {
- while (this.lineChunkIndex > 0) {
- this.chunks.shift()
- this.lineChunkIndex--
- this.chunkIndex--
+ if (this.lineChunkIndex > 0) {
+ const consumed = this.lineChunkIndex
+ this.chunks.splice(0, consumed)
+ this.lineChunkIndex = 0
+ this.chunkIndex -= consumed
}
if (this.chunkIndex === this.chunks.length) {
diff --git a/deps/undici/src/lib/web/eventsource/eventsource.js b/deps/undici/src/lib/web/eventsource/eventsource.js
index 93fb1f23436..f6b2ca6f16b 100644
--- a/deps/undici/src/lib/web/eventsource/eventsource.js
+++ b/deps/undici/src/lib/web/eventsource/eventsource.js
@@ -7,6 +7,7 @@ const { EventSourceStream } = require('./eventsource-stream')
const { parseMIMEType } = require('../fetch/data-url')
const { createFastMessageEvent } = require('../websocket/events')
const { isNetworkError } = require('../fetch/response')
+const { cloneRequest } = require('../fetch/request')
const { isValidHeaderValue, kEnumerableProperty } = require('../../core/util')
const { environmentSettingsObject } = require('../fetch/util')
const { createPotentialCORSRequest } = require('./util')
@@ -29,6 +30,14 @@ let experimentalWarned = false
*/
const defaultReconnectionTime = 3000
+/**
+ * The largest delay setTimeout supports. Larger values (including Infinity)
+ * make Node.js fire the timer after 1 ms instead, which would turn a large
+ * reconnection time into a reconnect storm.
+ * @type {number}
+ */
+const maxReconnectionTime = 2 ** 31 - 1
+
/**
* The readyState attribute represents the state of the connection.
* @typedef ReadyState
@@ -222,8 +231,22 @@ class EventSource extends EventTarget {
this.#readyState = CONNECTING
+ // Fetch a copy of the request so that every connection starts from the
+ // original request. Fetch mutates the request it is given (URL list,
+ // redirect count, response tainting and, on cross-origin redirects,
+ // headers), so reusing it makes reconnects go to the last redirect
+ // target and, after 20 redirects in total, fail forever.
+ // cloneRequest() shares the URL list, so copy it as well.
+ // 301/308 permanent redirects are handled the same as 302/307 temporary
+ // redirects. While the original EventSource spec required that permanent
+ // redirects be handled, WHATWG removed that requirement and has not
+ // yet opted to restore it... therefore all redirects gets handled the
+ // same.
+ const request = cloneRequest(this.#request)
+ request.urlList = [...this.#request.urlList]
+
const fetchParams = {
- request: this.#request,
+ request,
dispatcher: this.#dispatcher
}
@@ -361,7 +384,7 @@ class EventSource extends EventTarget {
// 4. Fetch request and process the response obtained in this fashion, if any, as described earlier in this section.
this.#connect()
- }, this.#state.reconnectionTime)?.unref()
+ }, Math.min(this.#state.reconnectionTime, maxReconnectionTime))?.unref()
}
/**
diff --git a/deps/undici/src/lib/web/fetch/body.js b/deps/undici/src/lib/web/fetch/body.js
index 9c2f4df1b8f..28124d018c0 100644
--- a/deps/undici/src/lib/web/fetch/body.js
+++ b/deps/undici/src/lib/web/fetch/body.js
@@ -39,7 +39,6 @@ const streamRegistry = new FinalizationRegistry((weakRef) => {
function extractBody (object, keepalive = false) {
// 1. Let stream be null.
let stream = null
- let controller = null
// 2. If object is a ReadableStream object, then set stream to object.
if (webidl.is.ReadableStream(object)) {
@@ -52,11 +51,44 @@ function extractBody (object, keepalive = false) {
// 4. Otherwise, set stream to a new ReadableStream object, and set
// up stream with byte reading support.
stream = new ReadableStream({
- pull () {},
- start (c) {
- controller = c
+ start () {},
+ async pull (controller) {
+ // 19.1. Run action.
+ const result = action()
+
+ const iterator = result?.[Symbol.asyncIterator]?.()
+ if (iterator == null) {
+ // 19.2. Whenever one or more bytes are available and stream is not errored,
+ // enqueue the result of creating a Uint8Array from the available bytes into stream.
+ if (result?.length && !isErrored(stream)) {
+ controller.enqueue(typeof result === 'string' ? textEncoder.encode(result) : new Uint8Array(result))
+ }
+
+ // 19.3. When running action is done, close stream.
+ queueMicrotask(() => readableStreamClose(controller))
+ return
+ }
+
+ while (true) {
+ const { value, done } = await iterator.next()
+
+ // 19.3. When running action is done, close stream.
+ if (done) {
+ queueMicrotask(() => readableStreamClose(controller))
+ return
+ }
+
+ // 19.2. Whenever one or more bytes are available and stream is not errored,
+ // enqueue the result of creating a Uint8Array from the available bytes into stream.
+ if (value.length && !isErrored(stream)) {
+ controller.enqueue(new Uint8Array(value))
+ return
+ }
+ }
+ },
+ cancel (reason) {
+ return action()[Symbol.asyncIterator]?.().return(reason)
},
- cancel () {},
type: 'bytes'
})
}
@@ -155,7 +187,7 @@ function extractBody (object, keepalive = false) {
// Set source to object.
source = object
- action = async function * () {
+ const parts = (async function * () {
for (const part of blobParts) {
if (part.stream) {
yield * part.stream()
@@ -163,7 +195,8 @@ function extractBody (object, keepalive = false) {
yield part
}
}
- }
+ })()
+ action = () => parts
// Set type to `multipart/form-data; boundary=`,
// followed by the multipart/form-data boundary string generated
@@ -208,45 +241,21 @@ function extractBody (object, keepalive = false) {
}))
}
- // 11. If source is a byte sequence, then set action to a
+ // 18. If source is a byte sequence, then set action to a
// step that returns source and length to source’s length.
if (typeof source === 'string' || isUint8Array(source)) {
- action = () => {
- length = typeof source === 'string' ? Buffer.byteLength(source) : source.length
- return source
- }
+ action = () => source
+ length = typeof source === 'string' ? Buffer.byteLength(source) : source.length
}
- // 12. If action is non-null, then run these steps in parallel:
- if (action != null) {
- ;(async () => {
- // 1. Run action.
- const result = action()
-
- // 2. Whenever one or more bytes are available and stream is not errored,
- // enqueue the result of creating a Uint8Array from the available bytes into stream.
- const iterator = result?.[Symbol.asyncIterator]?.()
- if (iterator) {
- for await (const bytes of iterator) {
- if (isErrored(stream)) break
- if (bytes.length) {
- controller.enqueue(new Uint8Array(bytes))
- }
- }
- } else if (result?.length && !isErrored(stream)) {
- controller.enqueue(typeof result === 'string' ? textEncoder.encode(result) : new Uint8Array(result))
- }
-
- // 3. When running action is done, close stream.
- queueMicrotask(() => readableStreamClose(controller))
- })()
- }
+ // 19. If action is non-null, then run these steps in parallel:
+ // Note: this is done in the pull method of the stream created above
- // 13. Let body be a body whose stream is stream, source is source,
+ // 20. Let body be a body whose stream is stream, source is source,
// and length is length.
const body = { stream, source, length }
- // 14. Return (body, type).
+ // 21. Return (body, type).
return [body, type]
}
diff --git a/deps/undici/src/lib/web/fetch/formdata-parser.js b/deps/undici/src/lib/web/fetch/formdata-parser.js
index a4622ae10a3..379029beda3 100644
--- a/deps/undici/src/lib/web/fetch/formdata-parser.js
+++ b/deps/undici/src/lib/web/fetch/formdata-parser.js
@@ -261,19 +261,27 @@ function parseContentDispositionAttribute (input, position) {
position
)
- // Check for utf-8'' prefix (case insensitive)
+ const charsetSeparator = headerValue.indexOf(0x27)
+ const languageSeparator = charsetSeparator === -1
+ ? -1
+ : headerValue.indexOf(0x27, charsetSeparator + 1)
+
+ if (charsetSeparator === -1 || languageSeparator === -1) {
+ throw parsingError('expected charset and language separators in extended value')
+ }
+
if (
+ charsetSeparator !== 5 ||
(headerValue[0] !== 0x75 && headerValue[0] !== 0x55) || // u or U
(headerValue[1] !== 0x74 && headerValue[1] !== 0x54) || // t or T
(headerValue[2] !== 0x66 && headerValue[2] !== 0x46) || // f or F
headerValue[3] !== 0x2d || // -
headerValue[4] !== 0x38 // 8
) {
- throw parsingError('unknown encoding, expected utf-8\'\'')
+ throw parsingError('unknown charset, expected utf-8')
}
- // Skip utf-8'' and decode the rest
- value = decodeURIComponent(decoder.decode(headerValue.subarray(7)))
+ value = decodeURIComponent(decoder.decode(headerValue.subarray(languageSeparator + 1)))
} else if (input[position.position] === 0x22 /* " */) {
// Quoted string
position.position++ // skip opening quote
diff --git a/deps/undici/src/lib/web/fetch/headers.js b/deps/undici/src/lib/web/fetch/headers.js
index 8f9fdfb327e..fdf6213bcbb 100644
--- a/deps/undici/src/lib/web/fetch/headers.js
+++ b/deps/undici/src/lib/web/fetch/headers.js
@@ -3,7 +3,7 @@
'use strict'
const { kConstruct } = require('../../core/symbols')
-const { kEnumerableProperty } = require('../../core/util')
+const { kEnumerableProperty, setHeader } = require('../../core/util')
const {
iteratorMixin,
isValidHeaderName,
@@ -320,7 +320,7 @@ class HeadersList {
if (this.headersMap.size !== 0) {
for (const { name, value } of this.headersMap.values()) {
- headers[name] = value
+ setHeader(headers, name, value)
}
}
diff --git a/deps/undici/src/lib/web/fetch/index.js b/deps/undici/src/lib/web/fetch/index.js
index 81fd8bb279c..a9382ca325b 100644
--- a/deps/undici/src/lib/web/fetch/index.js
+++ b/deps/undici/src/lib/web/fetch/index.js
@@ -2280,8 +2280,6 @@ async function httpNetworkFetch (
appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders)
const location = headersList.get('location', true)
- this.body = new Readable({ read: () => controller.resume() })
-
const willFollow = location && request.redirect === 'follow' &&
redirectStatusSet.has(status)
@@ -2299,7 +2297,7 @@ async function httpNetworkFetch (
// CVE fix similar to urllib3 (GHSA-gm62-xv2j-4w53) and curl (CVE-2022-32206).
const maxContentEncodings = 5
if (codings.length > maxContentEncodings) {
- reject(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`))
+ controller.abort(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`))
return
}
@@ -2328,7 +2326,11 @@ async function httpNetworkFetch (
} else if (coding === 'zstd') {
decoders.push(zlib.createZstdDecompress({
flush: zlib.constants.ZSTD_e_continue,
- finishFlush: zlib.constants.ZSTD_e_end
+ finishFlush: zlib.constants.ZSTD_e_end,
+ params: {
+ // https://www.rfc-editor.org/rfc/rfc9659.html#section-3
+ [zlib.constants.ZSTD_d_windowLogMax]: 23
+ }
}))
} else {
decoders.length = 0
@@ -2337,6 +2339,8 @@ async function httpNetworkFetch (
}
}
+ this.body = new Readable({ read: () => controller.resume() })
+
const onError = (err) => this.onResponseError(controller, err)
resolve({
diff --git a/deps/undici/src/lib/web/subresource-integrity/subresource-integrity.js b/deps/undici/src/lib/web/subresource-integrity/subresource-integrity.js
index 8c8f6c4d88f..f7d165a9534 100644
--- a/deps/undici/src/lib/web/subresource-integrity/subresource-integrity.js
+++ b/deps/undici/src/lib/web/subresource-integrity/subresource-integrity.js
@@ -2,6 +2,7 @@
const assert = require('node:assert')
const { runtimeFeatures } = require('../../util/runtime-features.js')
+const { asciiLowercase } = require('../infra/index.js')
/**
* @typedef {object} Metadata
@@ -66,14 +67,12 @@ const getSRIHashAlgorithmIndex = /** @type {GetSRIHashAlgorithmIndex} */ (Map.pr
/**
* @typedef IsValidSRIHashAlgorithm
+ * @see https://w3c.github.io/webappsec-subresource-integrity/#valid-sri-hash-algorithm-token
* @type {(algorithm: string) => algorithm is SRIHashAlgorithm}
* @param {*} algorithm
* @returns {algorithm is SRIHashAlgorithm}
*/
-
-const isValidSRIHashAlgorithm = /** @type {IsValidSRIHashAlgorithm} */ (
- Map.prototype.has.bind(validSRIHashAlgorithmTokenSet)
-)
+const isValidSRIHashAlgorithm = (algorithm) => validSRIHashAlgorithmTokenSet.has(asciiLowercase(algorithm))
/**
* @param {Uint8Array} bytes
@@ -229,7 +228,8 @@ function parseMetadata (metadata) {
// 8. Let metadata be the ordered map
// «["alg" → algorithm, "val" → base64-value]».
const metadata = {
- alg: algorithm,
+ // Possible spec bug?
+ alg: asciiLowercase(algorithm),
val: base64Value
}
diff --git a/deps/undici/src/lib/web/websocket/receiver.js b/deps/undici/src/lib/web/websocket/receiver.js
index 63a5a2e7a52..bb368a118b0 100644
--- a/deps/undici/src/lib/web/websocket/receiver.js
+++ b/deps/undici/src/lib/web/websocket/receiver.js
@@ -16,6 +16,7 @@ const { failWebsocketConnection } = require('./connection')
const { WebsocketFrameSend } = require('./frame')
const { PerMessageDeflate } = require('./permessage-deflate')
const { MessageSizeExceededError } = require('../../core/errors')
+const { defaultWebSocketMaxFragments, defaultWebSocketMaxPayloadSize } = require('../../core/constants')
// This code was influenced by ws released under the MIT license.
// Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
@@ -48,18 +49,25 @@ class ByteParser extends Writable {
/**
* @param {import('./websocket').Handler} handler
* @param {Map<string, string>|null} extensions
- * @param {{ maxPayloadSize?: number }} [options]
+ * @param {{ maxFragments?: number, maxPayloadSize?: number }} [options]
+ * A missing value uses the default limit; `0` disables the limit.
*/
constructor (handler, extensions, options = {}) {
super()
this.#handler = handler
this.#extensions = extensions == null ? new Map() : extensions
- this.#maxFragments = options.maxFragments ?? 0
- this.#maxPayloadSize = options.maxPayloadSize ?? 0
+ // Options come from the dispatcher's `webSocketOptions`, which only
+ // DispatcherBase provides. Fall back to the defaults rather than to no
+ // limit, so RetryAgent, MockAgent or a custom dispatcher can't turn off
+ // the payload and decompression limits by accident.
+ this.#maxFragments = options.maxFragments ?? defaultWebSocketMaxFragments
+ this.#maxPayloadSize = options.maxPayloadSize ?? defaultWebSocketMaxPayloadSize
if (this.#extensions.has('permessage-deflate')) {
- this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, options))
+ this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, {
+ maxPayloadSize: this.#maxPayloadSize
+ }))
}
}
@@ -244,6 +252,19 @@ class ByteParser extends Writable {
if (isControlFrame(this.#info.opcode)) {
this.#loop = this.parseControlFrame(body)
this.#state = parserStates.INFO
+
+ // If the automatic PONG/CLOSE reply filled the socket's write buffer,
+ // stop parsing and resume on drain so a PING flood cannot grow the
+ // outbound queue without bound.
+ if (this.#loop && this.#handler.socket.writableNeedDrain) {
+ this.#loop = false
+ this.#handler.socket.once('drain', () => {
+ if (this.destroyed) return
+ this.#loop = true
+ this.run(callback)
+ })
+ return
+ }
} else {
if (!this.#info.compressed) {
if (!this.writeFragments(body)) {
diff --git a/deps/undici/src/package-lock.json b/deps/undici/src/package-lock.json
index b4b31465c51..37f1634b83c 100644
--- a/deps/undici/src/package-lock.json
+++ b/deps/undici/src/package-lock.json
@@ -1,15 +1,15 @@
{
"name": "undici",
- "version": "8.11.2",
+ "version": "8.12.2",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "undici",
- "version": "8.11.2",
+ "version": "8.12.2",
"license": "MIT",
"devDependencies": {
- "@fastify/busboy": "3.2.2",
+ "@fastify/busboy": "3.2.3",
"@matteo.collina/tspl": "^0.2.0",
"@metcoder95/https-pem": "^1.0.0",
"@sinonjs/fake-timers": "^12.0.0",
@@ -1209,9 +1209,9 @@
}
},
"node_modules/@fastify/busboy": {
- "version": "3.2.2",
- "resolved": "https://registry.npmjs.org/@fastify/busboy/-/busboy-3.2.2.tgz",
- "integrity": "sha512-yXSS27qPExaXeuLvMRMXOLtpipzfQYNjG3FkunDWKGfMYjKuhFXko9CVzqxm8jcF+lmtS9Fd89QNdh9XDjnbNg==",
+ "version": "3.2.3",
+ "resolved": "https://registry.npmjs.org/@fastify/busboy/-/busboy-3.2.3.tgz",
+ "integrity": "sha512-fmo/IKgkenPzz3qTKG+sIUXdF/Kv83AkvvOXJHPTHJeKJbat8SsL1ihUaFaDotqoEl4UZ1Lf8Eb/3vK6eaWX2A==",
"dev": true,
"license": "MIT"
},
@@ -2806,9 +2806,9 @@
}
},
"node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
- "version": "5.0.9",
- "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
- "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
+ "version": "5.0.12",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz",
+ "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==",
"dev": true,
"license": "MIT",
"dependencies": {
@@ -3887,9 +3887,9 @@
}
},
"node_modules/borp/node_modules/brace-expansion": {
- "version": "5.0.9",
- "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
- "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
+ "version": "5.0.12",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz",
+ "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==",
"dev": true,
"license": "MIT",
"dependencies": {
@@ -4024,9 +4024,9 @@
}
},
"node_modules/brace-expansion": {
- "version": "1.1.18",
- "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.18.tgz",
- "integrity": "sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==",
+ "version": "1.1.21",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.21.tgz",
+ "integrity": "sha512-9zeA+KLZNNzglF2TPKRQEDyx6Yby7daAkuy8MiPzpXPsYDWi/DRM8jmwUDxokQjYqBpv5DgPiwD4h4ZZSy1Ujw==",
"dev": true,
"license": "MIT",
"dependencies": {
@@ -5697,9 +5697,9 @@
}
},
"node_modules/fast-check": {
- "version": "4.10.1",
- "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-4.10.1.tgz",
- "integrity": "sha512-sB5Vghiu8MyCyToHoBVGsT0baZg3sZWNIY+a6Ct2EDrQJlT4YdH6MC1BSLNe3kX1k5i5g0q1O52XFgcKK/rGHg==",
+ "version": "4.10.2",
+ "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-4.10.2.tgz",
+ "integrity": "sha512-iK2f+YrcmoeGqk6fA0ea2bptcu/itMIm4NfEozq6N25+aG6h7s5HZbB/k1aV7b5w5sFLMCbbtRUsTVR+BgC3xw==",
"dev": true,
"funding": [
{
@@ -6139,9 +6139,9 @@
}
},
"node_modules/glob/node_modules/brace-expansion": {
- "version": "2.1.4",
- "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.4.tgz",
- "integrity": "sha512-hGfVzPxthbf3+2yjg/RBs60cB0FhqBS/zvdV/4wn4/BmN0bNMMHPc4V/BbFieqf1TKAGGAHnY4eSjajCl0f2Xg==",
+ "version": "2.1.7",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.7.tgz",
+ "integrity": "sha512-uZbew1NqdmPDTMJ8ah1y+b+9QEJrfkXFk3RcTQw3X0jW/xRUvFKsg1CfQdSYGdTbXZWExtU3J3ccxtnfw1Fi0g==",
"dev": true,
"license": "MIT",
"dependencies": {
@@ -7962,10 +7962,20 @@
"license": "MIT"
},
"node_modules/js-yaml": {
- "version": "4.1.1",
- "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
- "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+ "version": "4.3.2",
+ "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.2.tgz",
+ "integrity": "sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA==",
"dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/puzrin"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/nodeca"
+ }
+ ],
"license": "MIT",
"dependencies": {
"argparse": "^2.0.1"
@@ -10363,9 +10373,9 @@
}
},
"node_modules/test-exclude/node_modules/brace-expansion": {
- "version": "5.0.9",
- "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
- "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
+ "version": "5.0.12",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz",
+ "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==",
"dev": true,
"license": "MIT",
"dependencies": {
@@ -10798,9 +10808,9 @@
}
},
"node_modules/undici": {
- "version": "6.28.0",
- "resolved": "https://registry.npmjs.org/undici/-/undici-6.28.0.tgz",
- "integrity": "sha512-LIY910g9TI13YS95lrMFrs8Rm/u/irgHeTWoKCoteeJ04CUJ92eEfj0rVn+7VKMPBpUPiUoBKfhNyLI23EE/KA==",
+ "version": "6.29.0",
+ "resolved": "https://registry.npmjs.org/undici/-/undici-6.29.0.tgz",
+ "integrity": "sha512-R+RODBqp6i2pPflGdq+xIOUkl+RNfGgHwoinecKu/JCuf2uO06cOKoDbI2P7Dn6KcswdKwrczbU6IYJ6K8X+wg==",
"dev": true,
"license": "MIT",
"engines": {
@@ -11157,9 +11167,9 @@
}
},
"node_modules/ws": {
- "version": "8.21.3",
- "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.3.tgz",
- "integrity": "sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw==",
+ "version": "8.22.0",
+ "resolved": "https://registry.npmjs.org/ws/-/ws-8.22.0.tgz",
+ "integrity": "sha512-Ydggc987+RO0AnWtZ/7Wq9FtNvcrL1b/RO0ud9mWjUPgDrsAAwQSF51sm2hm1XofbU/4jkpGEsLFsZZxU+1DOg==",
"dev": true,
"license": "MIT",
"engines": {
diff --git a/deps/undici/src/package.json b/deps/undici/src/package.json
index fd425598742..e41371501ec 100644
--- a/deps/undici/src/package.json
+++ b/deps/undici/src/package.json
@@ -1,6 +1,6 @@
{
"name": "undici",
- "version": "8.11.2",
+ "version": "8.12.2",
"description": "An HTTP/1.1 client, written from scratch for Node.js",
"homepage": "https://undici.nodejs.org",
"bugs": {
@@ -63,13 +63,15 @@
"types": "index.d.ts",
"scripts": {
"build:node": "esbuild index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
- "build:wasm": "node build/wasm.js --docker",
+ "build:milo": "node build/milo.js",
+ "build:llhttp": "node build/llhttp.js --docker",
+ "build:wasm": "node build/llhttp.js --docker",
"generate-pem": "node scripts/generate-pem.js",
"lint": "eslint --cache",
"lint:fix": "eslint --fix --cache",
"test": "npm run test:javascript && cross-env NODE_V8_COVERAGE= npm run test:typescript",
"test:javascript": "npm run test:javascript:no-jest && npm run test:jest",
- "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
+ "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
"test:javascript:without-intl": "npm run test:javascript:no-jest",
"test:busboy": "borp --timeout 180000 -p \"test/busboy/*.js\"",
"test:cache": "borp --timeout 180000 -p \"test/cache/*.js\"",
@@ -97,7 +99,7 @@
"test:websocket:autobahn": "node test/autobahn/client.js",
"test:websocket:autobahn:report": "node test/autobahn/report.js",
"test:wpt:setup": "node test/web-platform-tests/wpt-runner.mjs setup",
- "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource",
+ "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource /service-workers",
"test:cache-tests": "node test/cache-interceptor/cache-tests.mjs --ci",
"coverage": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report",
"coverage:ci": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report:ci",
@@ -109,7 +111,7 @@
"prepare": "husky && node ./scripts/platform-shell.js"
},
"devDependencies": {
- "@fastify/busboy": "3.2.2",
+ "@fastify/busboy": "3.2.3",
"@matteo.collina/tspl": "^0.2.0",
"@metcoder95/https-pem": "^1.0.0",
"@sinonjs/fake-timers": "^12.0.0",
diff --git a/deps/undici/src/pnpm-workspace.yaml b/deps/undici/src/pnpm-workspace.yaml
new file mode 100644
index 00000000000..210b17e417c
--- /dev/null
+++ b/deps/undici/src/pnpm-workspace.yaml
@@ -0,0 +1,5 @@
+allowBuilds:
+ '@metcoder95/https-pem': set this to true or false
+ '@parcel/watcher': set this to true or false
+ esbuild: set this to true or false
+ unrs-resolver: set this to true or false
diff --git a/deps/undici/src/scripts/release.js b/deps/undici/src/scripts/release.js
index 111b1daac93..3185fdefe94 100644
--- a/deps/undici/src/scripts/release.js
+++ b/deps/undici/src/scripts/release.js
@@ -75,8 +75,11 @@ const release = async ({ github, context, versionTag, commitHash }) => {
ref: `heads/release/${versionTag}`
})
} catch (err) {
- console.log("Couldn't delete release PR ref")
- console.log(err)
+ if (err.status === 422 && err.response?.data?.message === 'Reference does not exist') {
+ return
+ }
+
+ throw err
}
}
diff --git a/deps/undici/src/types/cache-interceptor.d.ts b/deps/undici/src/types/cache-interceptor.d.ts
index 8588ccdcb35..27372882cf5 100644
--- a/deps/undici/src/types/cache-interceptor.d.ts
+++ b/deps/undici/src/types/cache-interceptor.d.ts
@@ -160,6 +160,16 @@ declare namespace CacheHandler {
* @default Infinity
*/
maxEntrySize?: number
+
+ /**
+ * Responses whose body size, in bytes, is greater than this value are
+ * stored compressed with zstd. Responses with an easily compressible
+ * Content-Type (e.g. json, xml, plain text) are compressed regardless of
+ * size. Requires Node with zstd support
+ * (22.19+).
+ * @default 1048576 (1 MiB)
+ */
+ compressThreshold?: number
}
export class SqliteCacheStore implements CacheStore {
diff --git a/deps/undici/src/types/client.d.ts b/deps/undici/src/types/client.d.ts
index 1edaeb05f1e..80ff8f21ab6 100644
--- a/deps/undici/src/types/client.d.ts
+++ b/deps/undici/src/types/client.d.ts
@@ -92,7 +92,7 @@ export declare namespace Client {
*/
allowH2?: boolean;
/**
- * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+ * @description Dictates the maximum number of concurrent streams for a single H2 session. The server's SETTINGS_MAX_CONCURRENT_STREAMS can lower it, but not raise it.
* @default 100
* @deprecated Use h2Options.maxConcurrentStreams instead
*/
@@ -119,6 +119,8 @@ export declare namespace Client {
* @description HTTP/2 configuration options
*/
h2Options?: Client.H2Options;
+ /** @experimental Enables the experimental Milo HTTP/1 parser for this client. Defaults to the `UNDICI_USE_MILO` environment variable. */
+ useMilo?: boolean;
}
export interface SocketInfo {
localAddress?: string
@@ -157,7 +159,7 @@ export declare namespace Client {
*/
pingInterval?: number;
/**
- * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+ * @description Dictates the maximum number of concurrent streams for a single H2 session. The server's SETTINGS_MAX_CONCURRENT_STREAMS can lower it, but not raise it.
* @default 100
*/
maxConcurrentStreams?: number;
@@ -173,8 +175,12 @@ export declare namespace Client {
}
export interface EventSourceOptions {
/**
- * Maximum allowed event size in bytes for EventSource messages.
- * Set to 0 to disable the limit.
+ * Maximum total bytes of data and metadata field values retained for a
+ * pending EventSource event. Each unfinished line is separately bounded
+ * to this value plus seven syntax bytes. The number of data lines per
+ * event and buffered input chunks are each limited to
+ * min(131072, max(1024, floor(maxEventSize / 128))).
+ * Set to 0 to disable these limits.
* @default buffer.kStringMaxLength
*/
maxEventSize?: number;
diff --git a/deps/undici/src/types/errors.d.ts b/deps/undici/src/types/errors.d.ts
index 7155b9c0b1a..7280324d4eb 100644
--- a/deps/undici/src/types/errors.d.ts
+++ b/deps/undici/src/types/errors.d.ts
@@ -39,13 +39,15 @@ declare namespace Errors {
code: number,
options: {
headers?: IncomingHttpHeaders | string[] | null,
- body?: null | Record<string, any> | string
+ body?: null | Record<string, any> | string,
+ bodyTruncated?: boolean
}
)
name: 'ResponseError'
code: 'UND_ERR_RESPONSE'
statusCode: number
body: null | Record<string, any> | string
+ bodyTruncated: boolean
headers: IncomingHttpHeaders | string[] | null
}
@@ -121,6 +123,13 @@ declare namespace Errors {
code: string
}
+ /** WebAssembly is unavailable when initializing the HTTP/1 parser. */
+ export class WebAssemblyNotSupportedError extends Error {
+ constructor (message?: string)
+ name: 'Error'
+ code: 'ERR_WEBASSEMBLY_NOT_SUPPORTED'
+ }
+
/** The response exceed the length allowed. */
export class ResponseExceededMaxSizeError extends UndiciError {
name: 'ResponseExceededMaxSizeError'
@@ -169,6 +178,12 @@ declare namespace Errors {
code: 'UND_ERR_MAX_ORIGINS_REACHED'
}
+ /** The maximum number of redirects has been reached. */
+ export class MaxRedirectsError extends UndiciError {
+ name: 'MaxRedirectsError'
+ code: 'UND_ERR_REDIRECT_MAX'
+ }
+
/** SOCKS5 proxy related error. */
export class Socks5ProxyError extends UndiciError {
constructor (
diff --git a/deps/undici/src/types/h2c-client.d.ts b/deps/undici/src/types/h2c-client.d.ts
index b921a347112..331cc1d71b4 100644
--- a/deps/undici/src/types/h2c-client.d.ts
+++ b/deps/undici/src/types/h2c-client.d.ts
@@ -63,7 +63,7 @@ export declare namespace H2CClient {
/** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
autoSelectFamilyAttemptTimeout?: number;
/**
- * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+ * @description Dictates the maximum number of concurrent streams for a single H2 session. The server's SETTINGS_MAX_CONCURRENT_STREAMS can lower it, but not raise it.
* @default 100
*/
maxConcurrentStreams?: number
diff --git a/deps/undici/src/types/interceptors.d.ts b/deps/undici/src/types/interceptors.d.ts
index 4383454baf5..10db9ef91a7 100644
--- a/deps/undici/src/types/interceptors.d.ts
+++ b/deps/undici/src/types/interceptors.d.ts
@@ -16,7 +16,12 @@ declare namespace Interceptors {
maxSize?: number
}
- export type ResponseErrorInterceptorOpts = { throwOnError: boolean }
+ export type ResponseErrorInterceptorOpts = {
+ /** @deprecated This option is ignored. The interceptor always throws on error responses. */
+ throwOnError?: boolean
+ /** Maximum number of response body bytes to include in the error. 0 disables the limit. @default 1048576 */
+ maxSize?: number
+ }
export type CacheInterceptorOpts = CacheHandler.CacheOptions
// DNS interceptor
diff --git a/deps/undici/undici.js b/deps/undici/undici.js
index 944a6fa5fce..beb9b305605 100644
--- a/deps/undici/undici.js
+++ b/deps/undici/undici.js
@@ -320,6 +320,22 @@ var require_errors = __commonJS({
return true;
}
};
+ var kWebAssemblyNotSupportedError = /* @__PURE__ */ Symbol.for("undici.error.ERR_WEBASSEMBLY_NOT_SUPPORTED");
+ var WebAssemblyNotSupportedError = class extends Error {
+ static {
+ __name(this, "WebAssemblyNotSupportedError");
+ }
+ constructor(message) {
+ super(message || "WebAssembly is not supported in this environment, but is required for HTTP/1 parsing");
+ this.code = "ERR_WEBASSEMBLY_NOT_SUPPORTED";
+ }
+ static [Symbol.hasInstance](instance) {
+ return instance && instance[kWebAssemblyNotSupportedError] === true;
+ }
+ get [kWebAssemblyNotSupportedError]() {
+ return true;
+ }
+ };
var kHTTPParserError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HTTP_PARSER");
var HTTPParserError = class extends Error {
static {
@@ -382,13 +398,14 @@ var require_errors = __commonJS({
static {
__name(this, "ResponseError");
}
- constructor(message, code, { headers, body }) {
+ constructor(message, code, { headers, body, bodyTruncated = false }) {
super(message);
this.name = "ResponseError";
this.message = message || "Response error";
this.code = "UND_ERR_RESPONSE";
this.statusCode = code;
this.body = body;
+ this.bodyTruncated = bodyTruncated;
this.headers = headers;
}
static [Symbol.hasInstance](instance) {
@@ -436,6 +453,24 @@ var require_errors = __commonJS({
return true;
}
};
+ var kMaxRedirectsError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_REDIRECT_MAX");
+ var MaxRedirectsError = class extends UndiciError {
+ static {
+ __name(this, "MaxRedirectsError");
+ }
+ constructor(message) {
+ super(message);
+ this.name = "MaxRedirectsError";
+ this.message = message || "max redirects";
+ this.code = "UND_ERR_REDIRECT_MAX";
+ }
+ static [Symbol.hasInstance](instance) {
+ return instance && instance[kMaxRedirectsError] === true;
+ }
+ get [kMaxRedirectsError]() {
+ return true;
+ }
+ };
var kMaxOriginsReachedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_MAX_ORIGINS_REACHED");
var MaxOriginsReachedError = class extends UndiciError {
static {
@@ -485,6 +520,7 @@ var require_errors = __commonJS({
};
module2.exports = {
AbortError,
+ WebAssemblyNotSupportedError,
HTTPParserError,
UndiciError,
HeadersTimeoutError,
@@ -508,6 +544,7 @@ var require_errors = __commonJS({
SecureProxyConnectionError,
ProxyConnectionError,
MaxOriginsReachedError,
+ MaxRedirectsError,
Socks5ProxyError,
MessageSizeExceededError
};
@@ -524,6 +561,7 @@ var require_symbols = __commonJS({
kDispatch: /* @__PURE__ */ Symbol("dispatch"),
kUrl: /* @__PURE__ */ Symbol("url"),
kRequestOrigin: /* @__PURE__ */ Symbol("request origin"),
+ kRedirectCacheControl: /* @__PURE__ */ Symbol("redirect cache control"),
kOriginless: /* @__PURE__ */ Symbol("originless"),
kWriting: /* @__PURE__ */ Symbol("writing"),
kResuming: /* @__PURE__ */ Symbol("resuming"),
@@ -590,6 +628,7 @@ var require_symbols = __commonJS({
kRemoteSettings: /* @__PURE__ */ Symbol("http2session remote settings"),
kHTTP2Stream: /* @__PURE__ */ Symbol("http2session client stream"),
kPingInterval: /* @__PURE__ */ Symbol("ping interval"),
+ kUseMilo: /* @__PURE__ */ Symbol("use milo"),
kNoProxyAgent: /* @__PURE__ */ Symbol("no proxy agent"),
kHttpProxyAgent: /* @__PURE__ */ Symbol("http proxy agent"),
kHttpsProxyAgent: /* @__PURE__ */ Symbol("https proxy agent"),
@@ -650,6 +689,128 @@ var require_dispatcher = __commonJS({
}
});
+// lib/core/constants.js
+var require_constants = __commonJS({
+ "lib/core/constants.js"(exports2, module2) {
+ "use strict";
+ var wellknownHeaderNames = (
+ /** @type {const} */
+ [
+ "Accept",
+ "Accept-Encoding",
+ "Accept-Language",
+ "Accept-Ranges",
+ "Access-Control-Allow-Credentials",
+ "Access-Control-Allow-Headers",
+ "Access-Control-Allow-Methods",
+ "Access-Control-Allow-Origin",
+ "Access-Control-Expose-Headers",
+ "Access-Control-Max-Age",
+ "Access-Control-Request-Headers",
+ "Access-Control-Request-Method",
+ "Age",
+ "Allow",
+ "Alt-Svc",
+ "Alt-Used",
+ "Authorization",
+ "Cache-Control",
+ "Clear-Site-Data",
+ "Connection",
+ "Content-Disposition",
+ "Content-Encoding",
+ "Content-Language",
+ "Content-Length",
+ "Content-Location",
+ "Content-Range",
+ "Content-Security-Policy",
+ "Content-Security-Policy-Report-Only",
+ "Content-Type",
+ "Cookie",
+ "Cross-Origin-Embedder-Policy",
+ "Cross-Origin-Opener-Policy",
+ "Cross-Origin-Resource-Policy",
+ "Date",
+ "Device-Memory",
+ "Downlink",
+ "ECT",
+ "ETag",
+ "Expect",
+ "Expect-CT",
+ "Expires",
+ "Forwarded",
+ "From",
+ "Host",
+ "If-Match",
+ "If-Modified-Since",
+ "If-None-Match",
+ "If-Range",
+ "If-Unmodified-Since",
+ "Keep-Alive",
+ "Last-Modified",
+ "Link",
+ "Location",
+ "Max-Forwards",
+ "Origin",
+ "Permissions-Policy",
+ "Pragma",
+ "Proxy-Authenticate",
+ "Proxy-Authorization",
+ "RTT",
+ "Range",
+ "Referer",
+ "Referrer-Policy",
+ "Refresh",
+ "Retry-After",
+ "Sec-WebSocket-Accept",
+ "Sec-WebSocket-Extensions",
+ "Sec-WebSocket-Key",
+ "Sec-WebSocket-Protocol",
+ "Sec-WebSocket-Version",
+ "Server",
+ "Server-Timing",
+ "Service-Worker-Allowed",
+ "Service-Worker-Navigation-Preload",
+ "Set-Cookie",
+ "SourceMap",
+ "Strict-Transport-Security",
+ "Supports-Loading-Mode",
+ "TE",
+ "Timing-Allow-Origin",
+ "Trailer",
+ "Transfer-Encoding",
+ "Upgrade",
+ "Upgrade-Insecure-Requests",
+ "User-Agent",
+ "Vary",
+ "Via",
+ "WWW-Authenticate",
+ "X-Content-Type-Options",
+ "X-DNS-Prefetch-Control",
+ "X-Frame-Options",
+ "X-Permitted-Cross-Domain-Policies",
+ "X-Powered-By",
+ "X-Requested-With",
+ "X-XSS-Protection"
+ ]
+ );
+ var headerNameLowerCasedRecord = {};
+ Object.setPrototypeOf(headerNameLowerCasedRecord, null);
+ for (let i = 0; i < wellknownHeaderNames.length; ++i) {
+ const key = wellknownHeaderNames[i];
+ const lowerCasedKey = key.toLowerCase();
+ headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
+ }
+ var defaultWebSocketMaxFragments = 131072;
+ var defaultWebSocketMaxPayloadSize = 128 * 1024 * 1024;
+ module2.exports = {
+ wellknownHeaderNames,
+ headerNameLowerCasedRecord,
+ defaultWebSocketMaxFragments,
+ defaultWebSocketMaxPayloadSize
+ };
+ }
+});
+
// lib/dispatcher/dispatcher-base.js
var require_dispatcher_base = __commonJS({
"lib/dispatcher/dispatcher-base.js"(exports2, module2) {
@@ -662,6 +823,7 @@ var require_dispatcher_base = __commonJS({
InvalidArgumentError
} = require_errors();
var { kDestroy, kClose, kClosed, kDestroyed, kDispatch } = require_symbols();
+ var { defaultWebSocketMaxFragments, defaultWebSocketMaxPayloadSize } = require_constants();
var kOnDestroyed = /* @__PURE__ */ Symbol("onDestroyed");
var kOnClosed = /* @__PURE__ */ Symbol("onClosed");
var kWebSocketOptions = /* @__PURE__ */ Symbol("webSocketOptions");
@@ -691,9 +853,8 @@ var require_dispatcher_base = __commonJS({
*/
get webSocketOptions() {
return {
- maxFragments: this[kWebSocketOptions].maxFragments ?? 131072,
- maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? 128 * 1024 * 1024
- // 128 MB default
+ maxFragments: this[kWebSocketOptions].maxFragments ?? defaultWebSocketMaxFragments,
+ maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? defaultWebSocketMaxPayloadSize
};
}
/**
@@ -957,6 +1118,22 @@ var require_pool_base = __commonJS({
var kHasDispatcher = /* @__PURE__ */ Symbol("has dispatcher");
var kAddClient = /* @__PURE__ */ Symbol("add client");
var kRemoveClient = /* @__PURE__ */ Symbol("remove client");
+ var kRetireClient = /* @__PURE__ */ Symbol("retire client");
+ var kRetiring = /* @__PURE__ */ Symbol("retiring clients");
+ function closeClients(pool) {
+ const closeAll = [];
+ for (let i = 0; i < pool[kClients].length; i++) {
+ const client = pool[kClients][i];
+ if (!client.destroyed) {
+ closeAll.push(client.close());
+ }
+ }
+ for (const closed of pool[kRetiring].values()) {
+ closeAll.push(closed);
+ }
+ return Promise.all(closeAll);
+ }
+ __name(closeClients, "closeClients");
var PoolBase = class extends DispatcherBase {
static {
__name(this, "PoolBase");
@@ -964,6 +1141,9 @@ var require_pool_base = __commonJS({
[kQueue] = new FixedQueue();
[kQueued] = 0;
[kClients] = [];
+ // Clients removed from kClients that have not finished closing,
+ // mapped to a promise that settles once they have.
+ [kRetiring] = /* @__PURE__ */ new Map();
[kNeedDrain] = false;
[kOnDrain](client, origin, targets) {
if (client.closed || client.destroyed) {
@@ -983,20 +1163,16 @@ var require_pool_base = __commonJS({
client[kNeedDrain] = needDrain;
if (needDrain) {
this[kOnClientBusy](client);
+ if (!queue.isEmpty()) {
+ return this[kDrainQueue](origin, targets);
+ }
}
if (!needDrain && this[kNeedDrain]) {
this[kNeedDrain] = false;
this.emit("drain", origin, [this, ...targets]);
}
if (this[kClosedResolve] && queue.isEmpty()) {
- const closeAll = [];
- for (let i = 0; i < this[kClients].length; i++) {
- const client2 = this[kClients][i];
- if (!client2.destroyed) {
- closeAll.push(client2.close());
- }
- }
- return Promise.all(closeAll).then(this[kClosedResolve]);
+ return closeClients(this).then(this[kClosedResolve]);
}
}
[kOnClientBusy]() {
@@ -1028,14 +1204,7 @@ var require_pool_base = __commonJS({
this.emit("drain", origin, [this, ...targets]);
}
if (this[kClosedResolve] && queue.isEmpty()) {
- const closeAll = [];
- for (let i = 0; i < this[kClients].length; i++) {
- const client = this[kClients][i];
- if (!client.destroyed) {
- closeAll.push(client.close());
- }
- }
- return Promise.all(closeAll).then(this[kClosedResolve]);
+ return closeClients(this).then(this[kClosedResolve]);
}
}
[kOnConnect] = (origin, targets) => {
@@ -1090,14 +1259,7 @@ var require_pool_base = __commonJS({
}
[kClose]() {
if (this[kQueue].isEmpty()) {
- const closeAll = [];
- for (let i = 0; i < this[kClients].length; i++) {
- const client = this[kClients][i];
- if (!client.destroyed) {
- closeAll.push(client.close());
- }
- }
- return Promise.all(closeAll);
+ return closeClients(this);
} else {
return new Promise((resolve) => {
this[kClosedResolve] = resolve;
@@ -1116,6 +1278,9 @@ var require_pool_base = __commonJS({
for (let i = 0; i < this[kClients].length; i++) {
destroyAll[i] = this[kClients][i].destroy(err);
}
+ for (const client of this[kRetiring].keys()) {
+ destroyAll.push(client.destroy(err));
+ }
return Promise.all(destroyAll);
}
[kDispatch](opts, handler) {
@@ -1152,13 +1317,34 @@ var require_pool_base = __commonJS({
}
return this;
}
- [kRemoveClient](client) {
+ // Takes a client out of rotation. A closed client no longer takes requests
+ // from the pool queue (see kOnDrain), but it finishes the requests it
+ // already has. Until it has, pool.close() waits for it and pool.destroy()
+ // destroys it.
+ [kRetireClient](client) {
const idx = this[kClients].indexOf(client);
if (idx !== -1) {
this[kClients].splice(idx, 1);
}
+ if (client.destroyed || this[kRetiring].has(client)) {
+ return;
+ }
+ let done = false;
+ let resolveClosed;
+ const closed = new Promise((resolve) => {
+ resolveClosed = resolve;
+ });
+ this[kRetiring].set(client, closed);
client.close(() => {
+ if (!done) {
+ done = true;
+ this[kRetiring].delete(client);
+ resolveClosed();
+ }
});
+ }
+ [kRemoveClient](client) {
+ this[kRetireClient](client);
this[kNeedDrain] = !this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
}
};
@@ -1168,6 +1354,7 @@ var require_pool_base = __commonJS({
kNeedDrain,
kAddClient,
kRemoveClient,
+ kRetireClient,
kDrainQueue,
kOnClientBusy,
kOnClientDrain,
@@ -1411,127 +1598,9 @@ var require_timers = __commonJS({
}
});
-// lib/core/constants.js
-var require_constants = __commonJS({
- "lib/core/constants.js"(exports2, module2) {
- "use strict";
- var wellknownHeaderNames = (
- /** @type {const} */
- [
- "Accept",
- "Accept-Encoding",
- "Accept-Language",
- "Accept-Ranges",
- "Access-Control-Allow-Credentials",
- "Access-Control-Allow-Headers",
- "Access-Control-Allow-Methods",
- "Access-Control-Allow-Origin",
- "Access-Control-Expose-Headers",
- "Access-Control-Max-Age",
- "Access-Control-Request-Headers",
- "Access-Control-Request-Method",
- "Age",
- "Allow",
- "Alt-Svc",
- "Alt-Used",
- "Authorization",
- "Cache-Control",
- "Clear-Site-Data",
- "Connection",
- "Content-Disposition",
- "Content-Encoding",
- "Content-Language",
- "Content-Length",
- "Content-Location",
- "Content-Range",
- "Content-Security-Policy",
- "Content-Security-Policy-Report-Only",
- "Content-Type",
- "Cookie",
- "Cross-Origin-Embedder-Policy",
- "Cross-Origin-Opener-Policy",
- "Cross-Origin-Resource-Policy",
- "Date",
- "Device-Memory",
- "Downlink",
- "ECT",
- "ETag",
- "Expect",
- "Expect-CT",
- "Expires",
- "Forwarded",
- "From",
- "Host",
- "If-Match",
- "If-Modified-Since",
- "If-None-Match",
- "If-Range",
- "If-Unmodified-Since",
- "Keep-Alive",
- "Last-Modified",
- "Link",
- "Location",
- "Max-Forwards",
- "Origin",
- "Permissions-Policy",
- "Pragma",
- "Proxy-Authenticate",
- "Proxy-Authorization",
- "RTT",
- "Range",
- "Referer",
- "Referrer-Policy",
- "Refresh",
- "Retry-After",
- "Sec-WebSocket-Accept",
- "Sec-WebSocket-Extensions",
- "Sec-WebSocket-Key",
- "Sec-WebSocket-Protocol",
- "Sec-WebSocket-Version",
- "Server",
- "Server-Timing",
- "Service-Worker-Allowed",
- "Service-Worker-Navigation-Preload",
- "Set-Cookie",
- "SourceMap",
- "Strict-Transport-Security",
- "Supports-Loading-Mode",
- "TE",
- "Timing-Allow-Origin",
- "Trailer",
- "Transfer-Encoding",
- "Upgrade",
- "Upgrade-Insecure-Requests",
- "User-Agent",
- "Vary",
- "Via",
- "WWW-Authenticate",
- "X-Content-Type-Options",
- "X-DNS-Prefetch-Control",
- "X-Frame-Options",
- "X-Permitted-Cross-Domain-Policies",
- "X-Powered-By",
- "X-Requested-With",
- "X-XSS-Protection"
- ]
- );
- var headerNameLowerCasedRecord = {};
- Object.setPrototypeOf(headerNameLowerCasedRecord, null);
- for (let i = 0; i < wellknownHeaderNames.length; ++i) {
- const key = wellknownHeaderNames[i];
- const lowerCasedKey = key.toLowerCase();
- headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
- }
- module2.exports = {
- wellknownHeaderNames,
- headerNameLowerCasedRecord
- };
- }
-});
-
-// lib/core/tree.js
-var require_tree = __commonJS({
- "lib/core/tree.js"(exports2, module2) {
+// lib/core/tree.js
+var require_tree = __commonJS({
+ "lib/core/tree.js"(exports2, module2) {
"use strict";
var {
wellknownHeaderNames,
@@ -1902,7 +1971,7 @@ var require_util = __commonJS({
}
}
__name(destroy, "destroy");
- var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
+ var KEEPALIVE_TIMEOUT_EXPR = /(?:^|,)[\t ]*timeout=(\d+)/i;
function parseKeepAliveTimeout(val) {
const m = val.match(KEEPALIVE_TIMEOUT_EXPR);
return m ? parseInt(m[1], 10) * 1e3 : null;
@@ -1916,6 +1985,19 @@ var require_util = __commonJS({
return tree.lookup(value) ?? value.toString("latin1").toLowerCase();
}
__name(bufferToLowerCasedHeaderName, "bufferToLowerCasedHeaderName");
+ function setHeader(obj, key, value) {
+ if (key === "__proto__") {
+ Object.defineProperty(obj, key, {
+ value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+ }
+ __name(setHeader, "setHeader");
function parseHeaders(headers, obj) {
if (obj === void 0) obj = {};
for (let i = 0; i < headers.length; i += 2) {
@@ -2524,6 +2606,7 @@ var require_util = __commonJS({
toRawHeaders,
encodeRawHeaders,
parseHeaders,
+ setHeader,
parseKeepAliveTimeout,
destroy,
bodyLength,
@@ -2771,2962 +2854,1668 @@ var require_diagnostics = __commonJS({
}
});
-// lib/core/request.js
-var require_request = __commonJS({
- "lib/core/request.js"(exports2, module2) {
+// lib/web/fetch/constants.js
+var require_constants2 = __commonJS({
+ "lib/web/fetch/constants.js"(exports2, module2) {
"use strict";
- var {
- InvalidArgumentError,
- NotSupportedError
- } = require_errors();
- var assert = require("node:assert");
- var {
- isValidHTTPToken,
- isValidHeaderValue,
- isStream,
- destroy,
- isBuffer,
- isFormDataLike,
- isIterable,
- hasSafeIterator,
- isBlobLike,
- serializePathWithQuery,
- parseHeaders,
- assertRequestHandler,
- getServerName,
- normalizedMethodRecords,
- getProtocolFromUrlString
- } = require_util();
- var { channels } = require_diagnostics();
- var { headerNameLowerCasedRecord } = require_constants();
- var invalidPathRegex = /[^\u0021-\u00ff]/;
- function isValidContentLengthHeaderValue(val) {
- if (typeof val !== "string" || val.length === 0) {
- return false;
- }
- for (let i = 0; i < val.length; i++) {
- const charCode = val.charCodeAt(i);
- if (charCode < 48 || charCode > 57) {
- return false;
- }
- }
- return true;
- }
- __name(isValidContentLengthHeaderValue, "isValidContentLengthHeaderValue");
- var kHandler = /* @__PURE__ */ Symbol("handler");
- var kController = /* @__PURE__ */ Symbol("controller");
- var kResume = /* @__PURE__ */ Symbol("resume");
- var RequestController = class {
- static {
- __name(this, "RequestController");
- }
- #paused = false;
- #reason = null;
- #aborted = false;
- #abort;
- [kResume] = null;
- rawHeaders = null;
- rawTrailers = null;
- constructor(abort) {
- this.#abort = abort;
- }
- pause() {
- this.#paused = true;
- }
- resume() {
- if (this.#paused) {
- this.#paused = false;
- this[kResume]?.();
- }
- }
- abort(reason) {
- if (!this.#aborted) {
- this.#aborted = true;
- this.#reason = reason;
- this.#abort(reason);
- }
- }
- get aborted() {
- return this.#aborted;
- }
- get reason() {
- return this.#reason;
- }
- get paused() {
- return this.#paused;
- }
- };
- var Request = class {
- static {
- __name(this, "Request");
- }
- constructor(origin, {
- path,
- method,
- body,
- headers,
- query,
- idempotent,
- blocking,
- upgrade,
- headersTimeout,
- bodyTimeout,
- reset,
- expectContinue,
- servername,
- throwOnError,
- maxRedirections,
- typeOfService
- }, handler) {
- if (typeof path !== "string") {
- throw new InvalidArgumentError("path must be a string");
- } else if (path[0] !== "/" && !(path.startsWith("http://") || path.startsWith("https://")) && method !== "CONNECT") {
- throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
- } else if (invalidPathRegex.test(path)) {
- throw new InvalidArgumentError("invalid request path");
- }
- if (typeof method !== "string") {
- throw new InvalidArgumentError("method must be a string");
- } else if (normalizedMethodRecords[method] === void 0 && !isValidHTTPToken(method)) {
- throw new InvalidArgumentError("invalid request method");
- }
- if (upgrade && typeof upgrade !== "string") {
- throw new InvalidArgumentError("upgrade must be a string");
- }
- if (upgrade && !isValidHeaderValue(upgrade)) {
- throw new InvalidArgumentError("invalid upgrade header");
- }
- if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
- throw new InvalidArgumentError("invalid headersTimeout");
- }
- if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
- throw new InvalidArgumentError("invalid bodyTimeout");
- }
- if (reset != null && typeof reset !== "boolean") {
- throw new InvalidArgumentError("invalid reset");
- }
- if (expectContinue != null && typeof expectContinue !== "boolean") {
- throw new InvalidArgumentError("invalid expectContinue");
- }
- if (throwOnError != null) {
- throw new InvalidArgumentError("invalid throwOnError");
- }
- if (maxRedirections != null && maxRedirections !== 0) {
- throw new InvalidArgumentError("maxRedirections is not supported, use the redirect interceptor");
- }
- if (typeOfService != null && (!Number.isInteger(typeOfService) || typeOfService < 0 || typeOfService > 255)) {
- throw new InvalidArgumentError("typeOfService must be an integer between 0 and 255");
- }
- this.headersTimeout = headersTimeout;
- this.bodyTimeout = bodyTimeout;
- this.method = method;
- this.typeOfService = typeOfService;
- this.abort = null;
- if (body == null) {
- this.body = null;
- } else if (isStream(body)) {
- this.body = body;
- const rState = this.body._readableState;
- if (!rState || !rState.autoDestroy) {
- this.endHandler = /* @__PURE__ */ __name(function autoDestroy() {
- destroy(this);
- }, "autoDestroy");
- this.body.on("end", this.endHandler);
- }
- this.errorHandler = (err) => {
- if (this.abort) {
- this.abort(err);
- } else {
- this.error = err;
- }
- };
- this.body.on("error", this.errorHandler);
- } else if (isBuffer(body)) {
- this.body = body.byteLength ? body : null;
- } else if (ArrayBuffer.isView(body)) {
- this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
- } else if (body instanceof ArrayBuffer) {
- this.body = body.byteLength ? Buffer.from(body) : null;
- } else if (typeof body === "string") {
- this.body = body.length ? Buffer.from(body) : null;
- } else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) {
- this.body = body;
- } else {
- throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");
- }
- this.completed = false;
- this.aborted = false;
- this.upgrade = upgrade || null;
- this.path = query ? serializePathWithQuery(path, query) : path;
- this.origin = origin;
- this.protocol = getProtocolFromUrlString(origin);
- this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" || method === "QUERY" : idempotent;
- this.blocking = blocking ?? this.method !== "HEAD";
- this.reset = reset == null ? null : reset;
- this.host = null;
- this.contentLength = null;
- this.contentType = null;
- this.headers = [];
- this.expectContinue = expectContinue != null ? expectContinue : false;
- if (Array.isArray(headers)) {
- if (headers.length % 2 !== 0) {
- throw new InvalidArgumentError("headers array must be even");
- }
- for (let i = 0; i < headers.length; i += 2) {
- processHeader(this, headers[i], headers[i + 1]);
- }
- } else if (headers && typeof headers === "object") {
- if (hasSafeIterator(headers)) {
- for (const header of headers) {
- if (!Array.isArray(header) || header.length !== 2) {
- throw new InvalidArgumentError("headers must be in key-value pair format");
- }
- processHeader(this, header[0], header[1]);
- }
- } else {
- const keys = Object.keys(headers);
- for (let i = 0; i < keys.length; ++i) {
- processHeader(this, keys[i], headers[keys[i]]);
- }
- }
- } else if (headers != null) {
- throw new InvalidArgumentError("headers must be an object or an array");
- }
- assertRequestHandler(handler, method, upgrade);
- this.servername = servername || getServerName(this.host) || null;
- this[kHandler] = handler;
- if (channels.create.hasSubscribers) {
- channels.create.publish({ request: this });
- }
+ var corsSafeListedMethods = (
+ /** @type {const} */
+ ["GET", "HEAD", "POST"]
+ );
+ var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
+ var nullBodyStatus = (
+ /** @type {const} */
+ [101, 204, 205, 304]
+ );
+ var redirectStatus = (
+ /** @type {const} */
+ [301, 302, 303, 307, 308]
+ );
+ var redirectStatusSet = new Set(redirectStatus);
+ var badPorts = (
+ /** @type {const} */
+ [
+ "1",
+ "7",
+ "9",
+ "11",
+ "13",
+ "15",
+ "17",
+ "19",
+ "20",
+ "21",
+ "22",
+ "23",
+ "25",
+ "37",
+ "42",
+ "43",
+ "53",
+ "69",
+ "77",
+ "79",
+ "87",
+ "95",
+ "101",
+ "102",
+ "103",
+ "104",
+ "109",
+ "110",
+ "111",
+ "113",
+ "115",
+ "117",
+ "119",
+ "123",
+ "135",
+ "137",
+ "139",
+ "143",
+ "161",
+ "179",
+ "389",
+ "427",
+ "465",
+ "512",
+ "513",
+ "514",
+ "515",
+ "526",
+ "530",
+ "531",
+ "532",
+ "540",
+ "548",
+ "554",
+ "556",
+ "563",
+ "587",
+ "601",
+ "636",
+ "989",
+ "990",
+ "993",
+ "995",
+ "1719",
+ "1720",
+ "1723",
+ "2049",
+ "3659",
+ "4045",
+ "4190",
+ "5060",
+ "5061",
+ "6000",
+ "6566",
+ "6665",
+ "6666",
+ "6667",
+ "6668",
+ "6669",
+ "6679",
+ "6697",
+ "10080"
+ ]
+ );
+ var badPortsSet = new Set(badPorts);
+ var referrerPolicyTokens = (
+ /** @type {const} */
+ [
+ "no-referrer",
+ "no-referrer-when-downgrade",
+ "same-origin",
+ "origin",
+ "strict-origin",
+ "origin-when-cross-origin",
+ "strict-origin-when-cross-origin",
+ "unsafe-url"
+ ]
+ );
+ var referrerPolicy = (
+ /** @type {const} */
+ [
+ "",
+ ...referrerPolicyTokens
+ ]
+ );
+ var referrerPolicyTokensSet = new Set(referrerPolicyTokens);
+ var requestRedirect = (
+ /** @type {const} */
+ ["follow", "manual", "error"]
+ );
+ var safeMethods = (
+ /** @type {const} */
+ ["GET", "HEAD", "OPTIONS", "TRACE", "QUERY"]
+ );
+ var safeMethodsSet = new Set(safeMethods);
+ var requestMode = (
+ /** @type {const} */
+ ["navigate", "same-origin", "no-cors", "cors"]
+ );
+ var requestCredentials = (
+ /** @type {const} */
+ ["omit", "same-origin", "include"]
+ );
+ var requestCache = (
+ /** @type {const} */
+ [
+ "default",
+ "no-store",
+ "reload",
+ "no-cache",
+ "force-cache",
+ "only-if-cached"
+ ]
+ );
+ var requestBodyHeader = (
+ /** @type {const} */
+ [
+ "content-encoding",
+ "content-language",
+ "content-location",
+ "content-type",
+ // See https://github.com/nodejs/undici/issues/2021
+ // 'Content-Length' is a forbidden header name, which is typically
+ // removed in the Headers implementation. However, undici doesn't
+ // filter out headers, so we add it here.
+ "content-length"
+ ]
+ );
+ var requestDuplex = (
+ /** @type {const} */
+ [
+ "half"
+ ]
+ );
+ var forbiddenMethods = (
+ /** @type {const} */
+ ["CONNECT", "TRACE", "TRACK"]
+ );
+ var forbiddenMethodsSet = new Set(forbiddenMethods);
+ var subresource = (
+ /** @type {const} */
+ [
+ "audio",
+ "audioworklet",
+ "font",
+ "image",
+ "manifest",
+ "paintworklet",
+ "script",
+ "style",
+ "track",
+ "video",
+ "xslt",
+ ""
+ ]
+ );
+ var subresourceSet = new Set(subresource);
+ module2.exports = {
+ subresource,
+ forbiddenMethods,
+ requestBodyHeader,
+ referrerPolicy,
+ requestRedirect,
+ requestMode,
+ requestCredentials,
+ requestCache,
+ redirectStatus,
+ corsSafeListedMethods,
+ nullBodyStatus,
+ safeMethods,
+ badPorts,
+ requestDuplex,
+ subresourceSet,
+ badPortsSet,
+ redirectStatusSet,
+ corsSafeListedMethodsSet,
+ safeMethodsSet,
+ forbiddenMethodsSet,
+ referrerPolicyTokens: referrerPolicyTokensSet
+ };
+ }
+});
+
+// lib/web/fetch/global.js
+var require_global = __commonJS({
+ "lib/web/fetch/global.js"(exports2, module2) {
+ "use strict";
+ var globalOrigin = /* @__PURE__ */ Symbol.for("undici.globalOrigin.1");
+ function getGlobalOrigin() {
+ return globalThis[globalOrigin];
+ }
+ __name(getGlobalOrigin, "getGlobalOrigin");
+ function setGlobalOrigin(newOrigin) {
+ if (newOrigin === void 0) {
+ Object.defineProperty(globalThis, globalOrigin, {
+ value: void 0,
+ writable: true,
+ enumerable: false,
+ configurable: false
+ });
+ return;
}
- onBodySent(chunk) {
- if (channels.bodyChunkSent.hasSubscribers) {
- channels.bodyChunkSent.publish({ request: this, chunk });
- }
- if (this[kHandler].onBodySent) {
- try {
- return this[kHandler].onBodySent(chunk);
- } catch (err) {
- this.abort(err);
- }
- }
+ const parsedURL = new URL(newOrigin);
+ if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") {
+ throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
}
- onRequestSent() {
- if (channels.bodySent.hasSubscribers) {
- channels.bodySent.publish({ request: this });
- }
- if (this[kHandler].onRequestSent) {
- try {
- return this[kHandler].onRequestSent();
- } catch (err) {
- this.abort(err);
- }
- }
- }
- onRequestStart(abort, context) {
- assert(!this.aborted);
- assert(!this.completed);
- this[kController] = new RequestController(abort);
- if (this.error) {
- this[kController].abort(this.error);
- return;
- }
- this.abort = abort;
- return this[kHandler].onRequestStart(this[kController], context);
+ Object.defineProperty(globalThis, globalOrigin, {
+ value: parsedURL,
+ writable: true,
+ enumerable: false,
+ configurable: false
+ });
+ }
+ __name(setGlobalOrigin, "setGlobalOrigin");
+ module2.exports = {
+ getGlobalOrigin,
+ setGlobalOrigin
+ };
+ }
+});
+
+// lib/encoding/index.js
+var require_encoding = __commonJS({
+ "lib/encoding/index.js"(exports2, module2) {
+ "use strict";
+ var textDecoder = new TextDecoder();
+ function utf8DecodeBytes(buffer) {
+ if (buffer.length === 0) {
+ return "";
}
- onResponseStarted() {
- return this[kHandler].onResponseStarted?.();
+ if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
+ buffer = buffer.subarray(3);
}
- onResponseStart(statusCode, headers, resume, statusText) {
- assert(!this.aborted);
- assert(!this.completed);
- if (channels.headers.hasSubscribers) {
- channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
- }
- const controller = this[kController];
- if (controller) {
- controller[kResume] = resume;
- controller.rawHeaders = headers;
- }
- const parsedHeaders = Array.isArray(headers) ? parseHeaders(headers) : headers;
- try {
- this[kHandler].onResponseStart?.(controller, statusCode, parsedHeaders, statusText);
- return !controller?.paused;
- } catch (err) {
- this.abort(err);
- return false;
- }
+ const output = textDecoder.decode(buffer);
+ return output;
+ }
+ __name(utf8DecodeBytes, "utf8DecodeBytes");
+ module2.exports = {
+ utf8DecodeBytes
+ };
+ }
+});
+
+// lib/web/infra/index.js
+var require_infra = __commonJS({
+ "lib/web/infra/index.js"(exports2, module2) {
+ "use strict";
+ var assert = require("node:assert");
+ var { utf8DecodeBytes } = require_encoding();
+ function collectASequenceOfCodePoints(condition, input, position) {
+ let result = "";
+ while (position.position < input.length && condition(input[position.position])) {
+ result += input[position.position];
+ position.position++;
}
- onResponseData(chunk) {
- assert(!this.aborted);
- assert(!this.completed);
- if (channels.bodyChunkReceived.hasSubscribers) {
- channels.bodyChunkReceived.publish({ request: this, chunk });
- }
- const controller = this[kController];
- try {
- this[kHandler].onResponseData?.(controller, chunk);
- return !controller?.paused;
- } catch (err) {
- this.abort(err);
- return false;
- }
+ return result;
+ }
+ __name(collectASequenceOfCodePoints, "collectASequenceOfCodePoints");
+ function collectASequenceOfCodePointsFast(char, input, position) {
+ const idx = input.indexOf(char, position.position);
+ const start = position.position;
+ if (idx === -1) {
+ position.position = input.length;
+ return input.slice(start);
}
- /**
- * @param {number} statusCode
- * @param {Buffer[]|string[]|import('../../types/header.d.ts').IncomingHttpHeaders} headers
- * @param {import('node:stream').Duplex} socket
- * @param {string} [statusText]
- */
- onRequestUpgrade(statusCode, headers, socket, statusText = "") {
- this.onFinally();
- assert(!this.aborted);
- assert(!this.completed);
- if (channels.headers.hasSubscribers) {
- channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
- }
- const controller = this[kController];
- if (controller) {
- controller.rawHeaders = headers;
- }
- const parsedHeaders = Array.isArray(headers) ? parseHeaders(headers) : headers;
- const result = this[kHandler].onRequestUpgrade?.(controller, statusCode, parsedHeaders, socket);
- if (!this.aborted) {
- this.completed = true;
- if (channels.trailers.hasSubscribers) {
- channels.trailers.publish({ request: this, trailers: [] });
+ position.position = idx;
+ return input.slice(start, position.position);
+ }
+ __name(collectASequenceOfCodePointsFast, "collectASequenceOfCodePointsFast");
+ var ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g;
+ function forgivingBase64(data) {
+ data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, "");
+ let dataLength = data.length;
+ if (dataLength % 4 === 0) {
+ if (data.charCodeAt(dataLength - 1) === 61) {
+ --dataLength;
+ if (data.charCodeAt(dataLength - 1) === 61) {
+ --dataLength;
}
}
- return result;
}
- onResponseEnd(trailers) {
- this.onFinally();
- assert(!this.aborted);
- assert(!this.completed);
- this.completed = true;
- if (channels.trailers.hasSubscribers) {
- channels.trailers.publish({ request: this, trailers });
- }
- const controller = this[kController];
- if (controller) {
- controller.rawTrailers = trailers;
- }
- const parsedTrailers = Array.isArray(trailers) ? parseHeaders(trailers) : trailers;
- try {
- return this[kHandler].onResponseEnd?.(controller, parsedTrailers);
- } catch (err) {
- this.onResponseError(err);
- }
+ if (dataLength % 4 === 1) {
+ return "failure";
}
- onResponseError(error) {
- this.onFinally();
- if (channels.error.hasSubscribers) {
- channels.error.publish({ request: this, error });
- }
- if (this.aborted) {
- return;
- }
- this.aborted = true;
- const controller = this[kController];
- return this[kHandler].onResponseError?.(controller, error);
+ if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) {
+ return "failure";
}
- onFinally() {
- if (this.errorHandler) {
- this.body.off("error", this.errorHandler);
- this.errorHandler = null;
- }
- if (this.endHandler) {
- this.body.off("end", this.endHandler);
- this.endHandler = null;
+ const buffer = Buffer.from(data, "base64");
+ return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+ }
+ __name(forgivingBase64, "forgivingBase64");
+ function isASCIIWhitespace(char) {
+ return char === 9 || // \t
+ char === 10 || // \n
+ char === 12 || // \f
+ char === 13 || // \r
+ char === 32;
+ }
+ __name(isASCIIWhitespace, "isASCIIWhitespace");
+ function isomorphicDecode(input) {
+ const length = input.length;
+ if ((2 << 15) - 1 > length) {
+ return String.fromCharCode.apply(null, input);
+ }
+ let result = "";
+ let i = 0;
+ let addition = (2 << 15) - 1;
+ while (i < length) {
+ if (i + addition > length) {
+ addition = length - i;
}
+ result += String.fromCharCode.apply(null, input.subarray(i, i += addition));
}
- addHeader(key, value) {
- processHeader(this, key, value);
- return this;
+ return result;
+ }
+ __name(isomorphicDecode, "isomorphicDecode");
+ var invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/;
+ function isomorphicEncode(input) {
+ assert(!invalidIsomorphicEncodeValueRegex.test(input));
+ return input;
+ }
+ __name(isomorphicEncode, "isomorphicEncode");
+ var nonASCIIRegex = /[^\x00-\x7F]/;
+ function asciiLowercase(str) {
+ return nonASCIIRegex.test(str) ? str.replace(/[A-Z]+/g, (upper) => upper.toLowerCase()) : str.toLowerCase();
+ }
+ __name(asciiLowercase, "asciiLowercase");
+ function parseJSONFromBytes(bytes) {
+ return JSON.parse(utf8DecodeBytes(bytes));
+ }
+ __name(parseJSONFromBytes, "parseJSONFromBytes");
+ function removeASCIIWhitespace(str, leading = true, trailing = true) {
+ return removeChars(str, leading, trailing, isASCIIWhitespace);
+ }
+ __name(removeASCIIWhitespace, "removeASCIIWhitespace");
+ function removeChars(str, leading, trailing, predicate) {
+ let lead = 0;
+ let trail = str.length - 1;
+ if (leading) {
+ while (lead < str.length && predicate(str.charCodeAt(lead))) lead++;
}
- };
- function processHeader(request, key, val) {
- if (val && (typeof val === "object" && !Array.isArray(val))) {
- throw new InvalidArgumentError(`invalid ${key} header`);
- } else if (val === void 0) {
- return;
+ if (trailing) {
+ while (trail >= lead && predicate(str.charCodeAt(trail))) trail--;
}
- let headerName = headerNameLowerCasedRecord[key];
- if (headerName === void 0) {
- headerName = key.toLowerCase();
- if (headerNameLowerCasedRecord[headerName] === void 0 && !isValidHTTPToken(headerName)) {
- throw new InvalidArgumentError("invalid header key");
- }
- }
- if (Array.isArray(val)) {
- const arr = [];
- for (let i = 0; i < val.length; i++) {
- if (typeof val[i] === "string") {
- if (!isValidHeaderValue(val[i])) {
- throw new InvalidArgumentError(`invalid ${key} header`);
- }
- arr.push(val[i]);
- } else if (val[i] === null) {
- arr.push("");
- } else if (typeof val[i] === "object") {
- throw new InvalidArgumentError(`invalid ${key} header`);
- } else {
- const str = `${val[i]}`;
- if (!isValidHeaderValue(str)) {
- throw new InvalidArgumentError(`invalid ${key} header`);
- }
- arr.push(str);
- }
- }
- val = arr;
- } else if (typeof val === "string") {
- if (!isValidHeaderValue(val)) {
- throw new InvalidArgumentError(`invalid ${key} header`);
- }
- } else if (val === null) {
- val = "";
- } else {
- val = `${val}`;
- if (!isValidHeaderValue(val)) {
- throw new InvalidArgumentError(`invalid ${key} header`);
- }
- }
- if (headerName === "host") {
- if (request.host !== null) {
- throw new InvalidArgumentError("duplicate host header");
- }
- if (typeof val !== "string") {
- throw new InvalidArgumentError("invalid host header");
- }
- request.host = val;
- } else if (headerName === "content-length") {
- if (request.contentLength !== null) {
- throw new InvalidArgumentError("duplicate content-length header");
- }
- if (!isValidContentLengthHeaderValue(val)) {
- throw new InvalidArgumentError("invalid content-length header");
- }
- request.contentLength = parseInt(val, 10);
- } else if (request.contentType === null && headerName === "content-type") {
- request.contentType = val;
- request.headers.push(key, val);
- } else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade") {
- throw new InvalidArgumentError(`invalid ${headerName} header`);
- } else if (headerName === "connection") {
- const value = typeof val === "string" ? val : null;
- if (value === null) {
- throw new InvalidArgumentError("invalid connection header");
- }
- for (const token of value.toLowerCase().split(",")) {
- const trimmed = token.trim();
- if (!isValidHTTPToken(trimmed)) {
- throw new InvalidArgumentError("invalid connection header");
- }
- if (trimmed === "close") {
- request.reset = true;
- }
- }
- } else if (headerName === "expect") {
- throw new NotSupportedError("expect header not supported");
- } else {
- request.headers.push(key, val);
+ return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1);
+ }
+ __name(removeChars, "removeChars");
+ function serializeJavascriptValueToJSONString(value) {
+ const result = JSON.stringify(value);
+ if (result === void 0) {
+ throw new TypeError("Value is not JSON serializable");
}
+ assert(typeof result === "string");
+ return result;
}
- __name(processHeader, "processHeader");
- module2.exports = Request;
+ __name(serializeJavascriptValueToJSONString, "serializeJavascriptValueToJSONString");
+ module2.exports = {
+ asciiLowercase,
+ collectASequenceOfCodePoints,
+ collectASequenceOfCodePointsFast,
+ forgivingBase64,
+ isASCIIWhitespace,
+ isomorphicDecode,
+ isomorphicEncode,
+ parseJSONFromBytes,
+ removeASCIIWhitespace,
+ removeChars,
+ serializeJavascriptValueToJSONString
+ };
}
});
-// lib/core/connect.js
-var require_connect = __commonJS({
- "lib/core/connect.js"(exports2, module2) {
+// lib/web/fetch/data-url.js
+var require_data_url = __commonJS({
+ "lib/web/fetch/data-url.js"(exports2, module2) {
"use strict";
- var net = require("node:net");
var assert = require("node:assert");
- var util = require_util();
- var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
- var tls;
- var SessionCache = class WeakSessionCache {
- static {
- __name(this, "WeakSessionCache");
+ var { asciiLowercase, forgivingBase64, collectASequenceOfCodePoints, collectASequenceOfCodePointsFast, isomorphicDecode, removeASCIIWhitespace, removeChars } = require_infra();
+ var encoder = new TextEncoder();
+ var HTTP_TOKEN_CODEPOINTS = /^[-!#$%&'*+.^_`|~A-Za-z0-9]+$/u;
+ var HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/u;
+ var HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/u;
+ function dataURLProcessor(dataURL) {
+ assert(dataURL.protocol === "data:");
+ let input = URLSerializer(dataURL, true);
+ input = input.slice(5);
+ const position = { position: 0 };
+ let mimeType = collectASequenceOfCodePointsFast(
+ ",",
+ input,
+ position
+ );
+ const mimeTypeLength = mimeType.length;
+ mimeType = removeASCIIWhitespace(mimeType, true, true);
+ if (position.position >= input.length) {
+ return "failure";
}
- constructor(maxCachedSessions) {
- this._maxCachedSessions = maxCachedSessions;
- this._sessionCache = /* @__PURE__ */ new Map();
- this._sessionRegistry = new FinalizationRegistry((key) => {
- if (this._sessionCache.size < this._maxCachedSessions) {
- return;
- }
- const ref = this._sessionCache.get(key);
- if (ref !== void 0 && ref.deref() === void 0) {
- this._sessionCache.delete(key);
- }
- });
+ position.position++;
+ const encodedBody = input.slice(mimeTypeLength + 1);
+ let body = stringPercentDecode(encodedBody);
+ if (/;\u0020*[Bb][Aa][Ss][Ee]64$/u.test(mimeType)) {
+ const stringBody = isomorphicDecode(body);
+ body = forgivingBase64(stringBody);
+ if (body === "failure") {
+ return "failure";
+ }
+ mimeType = mimeType.slice(0, -6);
+ mimeType = mimeType.replace(/(\u0020+)$/u, "");
+ mimeType = mimeType.slice(0, -1);
}
- get(sessionKey) {
- const ref = this._sessionCache.get(sessionKey);
- return ref ? ref.deref() : null;
+ if (mimeType.startsWith(";")) {
+ mimeType = "text/plain" + mimeType;
}
- set(sessionKey, session) {
- if (this._maxCachedSessions === 0) {
- return;
- }
- if (this._sessionCache.has(sessionKey)) {
- this._sessionCache.delete(sessionKey);
- } else if (this._sessionCache.size >= this._maxCachedSessions) {
- for (const [key, ref] of this._sessionCache) {
- if (ref.deref() === void 0) {
- this._sessionCache.delete(key);
- return;
- }
- }
- const oldest = this._sessionCache.keys().next();
- if (!oldest.done) {
- this._sessionCache.delete(oldest.value);
- }
- }
- this._sessionCache.set(sessionKey, new WeakRef(session));
- this._sessionRegistry.register(session, sessionKey);
+ let mimeTypeRecord = parseMIMEType(mimeType);
+ if (mimeTypeRecord === "failure") {
+ mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII");
}
- };
- function buildConnector({ allowH2, preferH2, useH2c, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
- if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
- throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
+ return { mimeType: mimeTypeRecord, body };
+ }
+ __name(dataURLProcessor, "dataURLProcessor");
+ function URLSerializer(url, excludeFragment = false) {
+ if (!excludeFragment) {
+ return url.href;
}
- const options = { path: socketPath, ...opts };
- const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
- timeout = timeout == null ? 1e4 : timeout;
- allowH2 = allowH2 != null ? allowH2 : true;
- return /* @__PURE__ */ __name(function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
- let socket;
- if (protocol === "https:") {
- if (!tls) {
- tls = require("node:tls");
- }
- servername = servername || options.servername || util.getServerName(host) || null;
- const sessionKey = servername || hostname;
- assert(sessionKey);
- const session = customSession || sessionCache.get(sessionKey) || null;
- port = port || 443;
- socket = tls.connect({
- highWaterMark: 16384,
- // TLS in node can't have bigger HWM anyway...
- ...options,
- servername,
- session,
- localAddress,
- ALPNProtocols: allowH2 ? preferH2 ? ["h2", "http/1.1"] : ["http/1.1", "h2"] : ["http/1.1"],
- socket: httpSocket,
- // upgrade socket connection
- port,
- host: hostname
- });
- socket.on("session", function(session2) {
- sessionCache.set(sessionKey, session2);
- });
+ const href = url.href;
+ const hashLength = url.hash.length;
+ const serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength);
+ if (!hashLength && href.endsWith("#")) {
+ return serialized.slice(0, -1);
+ }
+ return serialized;
+ }
+ __name(URLSerializer, "URLSerializer");
+ function stringPercentDecode(input) {
+ const bytes = encoder.encode(input);
+ return percentDecode(bytes);
+ }
+ __name(stringPercentDecode, "stringPercentDecode");
+ function isHexCharByte(byte) {
+ return byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102;
+ }
+ __name(isHexCharByte, "isHexCharByte");
+ function hexByteToNumber(byte) {
+ return (
+ // 0-9
+ byte >= 48 && byte <= 57 ? byte - 48 : (byte & 223) - 55
+ );
+ }
+ __name(hexByteToNumber, "hexByteToNumber");
+ function percentDecode(input) {
+ const length = input.length;
+ const output = new Uint8Array(length);
+ let j = 0;
+ let i = 0;
+ while (i < length) {
+ const byte = input[i];
+ if (byte !== 37) {
+ output[j++] = byte;
+ } else if (byte === 37 && !(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2]))) {
+ output[j++] = 37;
} else {
- assert(!httpSocket, "httpSocket can only be sent on TLS update");
- port = port || 80;
- const connectOptions = {
- highWaterMark: 64 * 1024,
- // Same as nodejs fs streams.
- ...options,
- localAddress,
- port,
- host: hostname
- };
- const family = net.isIP(hostname);
- if (family !== 0 && servername && servername !== hostname) {
- connectOptions.host = servername;
- connectOptions.lookup = (_hostname, lookupOptions, cb) => {
- if (lookupOptions.all) {
- cb(null, [{ address: hostname, family }]);
- } else {
- cb(null, hostname, family);
- }
- };
- }
- socket = net.connect(connectOptions);
- if (useH2c === true) {
- socket.alpnProtocol = "h2";
+ output[j++] = hexByteToNumber(input[i + 1]) << 4 | hexByteToNumber(input[i + 2]);
+ i += 2;
+ }
+ ++i;
+ }
+ return length === j ? output : output.subarray(0, j);
+ }
+ __name(percentDecode, "percentDecode");
+ function parseMIMEType(input) {
+ input = removeHTTPWhitespace(input, true, true);
+ const position = { position: 0 };
+ const type = collectASequenceOfCodePointsFast(
+ "/",
+ input,
+ position
+ );
+ if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
+ return "failure";
+ }
+ if (position.position >= input.length) {
+ return "failure";
+ }
+ position.position++;
+ let subtype = collectASequenceOfCodePointsFast(
+ ";",
+ input,
+ position
+ );
+ subtype = removeHTTPWhitespace(subtype, false, true);
+ if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
+ return "failure";
+ }
+ const typeLowercase = asciiLowercase(type);
+ const subtypeLowercase = asciiLowercase(subtype);
+ const mimeType = {
+ type: typeLowercase,
+ subtype: subtypeLowercase,
+ /** @type {Map<string, string>} */
+ parameters: /* @__PURE__ */ new Map(),
+ // https://mimesniff.spec.whatwg.org/#mime-type-essence
+ essence: `${typeLowercase}/${subtypeLowercase}`
+ };
+ while (position.position < input.length) {
+ position.position++;
+ collectASequenceOfCodePoints(
+ // https://fetch.spec.whatwg.org/#http-whitespace
+ (char) => HTTP_WHITESPACE_REGEX.test(char),
+ input,
+ position
+ );
+ let parameterName = collectASequenceOfCodePoints(
+ (char) => char !== ";" && char !== "=",
+ input,
+ position
+ );
+ parameterName = asciiLowercase(parameterName);
+ if (position.position < input.length) {
+ if (input[position.position] === ";") {
+ continue;
}
+ position.position++;
}
- if (options.keepAlive == null || options.keepAlive) {
- const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay;
- socket.setKeepAlive(true, keepAliveInitialDelay);
+ if (position.position >= input.length) {
+ break;
}
- const clearConnectTimeout = util.setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port });
- socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() {
- queueMicrotask(clearConnectTimeout);
- if (callback) {
- const cb = callback;
- callback = null;
- cb(null, this);
- }
- }).on("error", function(err) {
- queueMicrotask(clearConnectTimeout);
- if (callback) {
- const cb = callback;
- callback = null;
- cb(maybeNormalizeConnectError(err, this, { timeout, hostname, port }));
+ let parameterValue = null;
+ if (input[position.position] === '"') {
+ parameterValue = collectAnHTTPQuotedString(input, position, true);
+ collectASequenceOfCodePointsFast(
+ ";",
+ input,
+ position
+ );
+ } else {
+ parameterValue = collectASequenceOfCodePointsFast(
+ ";",
+ input,
+ position
+ );
+ parameterValue = removeHTTPWhitespace(parameterValue, false, true);
+ if (parameterValue.length === 0) {
+ continue;
}
- });
- return socket;
- }, "connect");
+ }
+ if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) {
+ mimeType.parameters.set(parameterName, parameterValue);
+ }
+ }
+ return mimeType;
}
- __name(buildConnector, "buildConnector");
- function maybeNormalizeConnectError(err, socket, opts) {
- if (err instanceof AggregateError && (err.code === "ETIMEDOUT" || err.errors.some((e) => e != null && e.code === "ETIMEDOUT"))) {
- let message = "Connect Timeout Error";
- if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
- message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")},`;
+ __name(parseMIMEType, "parseMIMEType");
+ function collectAnHTTPQuotedString(input, position, extractValue = false) {
+ const positionStart = position.position;
+ let value = "";
+ assert(input[position.position] === '"');
+ position.position++;
+ while (true) {
+ value += collectASequenceOfCodePoints(
+ (char) => char !== '"' && char !== "\\",
+ input,
+ position
+ );
+ if (position.position >= input.length) {
+ break;
+ }
+ const quoteOrBackslash = input[position.position];
+ position.position++;
+ if (quoteOrBackslash === "\\") {
+ if (position.position >= input.length) {
+ value += "\\";
+ break;
+ }
+ value += input[position.position];
+ position.position++;
} else {
- message += ` (attempted address: ${opts.hostname}:${opts.port},`;
+ assert(quoteOrBackslash === '"');
+ break;
}
- message += ` timeout: ${opts.timeout}ms)`;
- const wrapped = new ConnectTimeoutError(message);
- wrapped.cause = err;
- return wrapped;
}
- return err;
+ if (extractValue) {
+ return value;
+ }
+ return input.slice(positionStart, position.position);
}
- __name(maybeNormalizeConnectError, "maybeNormalizeConnectError");
- module2.exports = buildConnector;
+ __name(collectAnHTTPQuotedString, "collectAnHTTPQuotedString");
+ function serializeAMimeType(mimeType) {
+ assert(mimeType !== "failure");
+ const { parameters, essence } = mimeType;
+ let serialization = essence;
+ for (let [name, value] of parameters.entries()) {
+ serialization += ";";
+ serialization += name;
+ serialization += "=";
+ if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
+ value = value.replace(/[\\"]/ug, "\\$&");
+ value = '"' + value;
+ value += '"';
+ }
+ serialization += value;
+ }
+ return serialization;
+ }
+ __name(serializeAMimeType, "serializeAMimeType");
+ function isHTTPWhiteSpace(char) {
+ return char === 13 || char === 10 || char === 9 || char === 32;
+ }
+ __name(isHTTPWhiteSpace, "isHTTPWhiteSpace");
+ function removeHTTPWhitespace(str, leading = true, trailing = true) {
+ return removeChars(str, leading, trailing, isHTTPWhiteSpace);
+ }
+ __name(removeHTTPWhitespace, "removeHTTPWhitespace");
+ function minimizeSupportedMimeType(mimeType) {
+ switch (mimeType.essence) {
+ case "application/ecmascript":
+ case "application/javascript":
+ case "application/x-ecmascript":
+ case "application/x-javascript":
+ case "text/ecmascript":
+ case "text/javascript":
+ case "text/javascript1.0":
+ case "text/javascript1.1":
+ case "text/javascript1.2":
+ case "text/javascript1.3":
+ case "text/javascript1.4":
+ case "text/javascript1.5":
+ case "text/jscript":
+ case "text/livescript":
+ case "text/x-ecmascript":
+ case "text/x-javascript":
+ return "text/javascript";
+ case "application/json":
+ case "text/json":
+ return "application/json";
+ case "image/svg+xml":
+ return "image/svg+xml";
+ case "text/xml":
+ case "application/xml":
+ return "application/xml";
+ }
+ if (mimeType.subtype.endsWith("+json")) {
+ return "application/json";
+ }
+ if (mimeType.subtype.endsWith("+xml")) {
+ return "application/xml";
+ }
+ return "";
+ }
+ __name(minimizeSupportedMimeType, "minimizeSupportedMimeType");
+ module2.exports = {
+ dataURLProcessor,
+ URLSerializer,
+ stringPercentDecode,
+ parseMIMEType,
+ collectAnHTTPQuotedString,
+ serializeAMimeType,
+ removeHTTPWhitespace,
+ minimizeSupportedMimeType,
+ HTTP_TOKEN_CODEPOINTS
+ };
}
});
-// lib/llhttp/utils.js
-var require_utils = __commonJS({
- "lib/llhttp/utils.js"(exports2) {
+// lib/web/webidl/index.js
+var require_webidl = __commonJS({
+ "lib/web/webidl/index.js"(exports2, module2) {
"use strict";
- Object.defineProperty(exports2, "__esModule", { value: true });
- exports2.enumToMap = enumToMap;
- function enumToMap(obj, filter = [], exceptions = []) {
- const emptyFilter = (filter?.length ?? 0) === 0;
- const emptyExceptions = (exceptions?.length ?? 0) === 0;
- return Object.fromEntries(Object.entries(obj).filter(([, value]) => {
- return typeof value === "number" && (emptyFilter || filter.includes(value)) && (emptyExceptions || !exceptions.includes(value));
- }));
- }
- __name(enumToMap, "enumToMap");
- }
-});
-
-// lib/llhttp/constants.js
-var require_constants2 = __commonJS({
- "lib/llhttp/constants.js"(exports2) {
- "use strict";
- Object.defineProperty(exports2, "__esModule", { value: true });
- exports2.SPECIAL_HEADERS = exports2.MINOR = exports2.MAJOR = exports2.HTAB_SP_VCHAR_OBS_TEXT = exports2.QUOTED_STRING = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.STATUSES_HTTP = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.HEADER_STATE = exports2.FINISH = exports2.STATUSES = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0;
- var utils_1 = require_utils();
- exports2.ERROR = {
- OK: 0,
- INTERNAL: 1,
- STRICT: 2,
- CR_EXPECTED: 25,
- LF_EXPECTED: 3,
- UNEXPECTED_CONTENT_LENGTH: 4,
- UNEXPECTED_SPACE: 30,
- CLOSED_CONNECTION: 5,
- INVALID_METHOD: 6,
- INVALID_URL: 7,
- INVALID_CONSTANT: 8,
- INVALID_VERSION: 9,
- INVALID_HEADER_TOKEN: 10,
- INVALID_CONTENT_LENGTH: 11,
- INVALID_CHUNK_SIZE: 12,
- INVALID_STATUS: 13,
- INVALID_EOF_STATE: 14,
- INVALID_TRANSFER_ENCODING: 15,
- CB_MESSAGE_BEGIN: 16,
- CB_HEADERS_COMPLETE: 17,
- CB_MESSAGE_COMPLETE: 18,
- CB_CHUNK_HEADER: 19,
- CB_CHUNK_COMPLETE: 20,
- PAUSED: 21,
- PAUSED_UPGRADE: 22,
- PAUSED_H2_UPGRADE: 23,
- USER: 24,
- CB_URL_COMPLETE: 26,
- CB_STATUS_COMPLETE: 27,
- CB_METHOD_COMPLETE: 32,
- CB_VERSION_COMPLETE: 33,
- CB_HEADER_FIELD_COMPLETE: 28,
- CB_HEADER_VALUE_COMPLETE: 29,
- CB_CHUNK_EXTENSION_NAME_COMPLETE: 34,
- CB_CHUNK_EXTENSION_VALUE_COMPLETE: 35,
- CB_RESET: 31,
- CB_PROTOCOL_COMPLETE: 38
+ var assert = require("node:assert");
+ var { types, inspect } = require("node:util");
+ var { markAsUncloneable } = require("node:worker_threads");
+ var UNDEFINED = 1;
+ var BOOLEAN = 2;
+ var STRING = 3;
+ var SYMBOL = 4;
+ var NUMBER = 5;
+ var BIGINT = 6;
+ var NULL = 7;
+ var OBJECT = 8;
+ var FunctionPrototypeSymbolHasInstance = Function.call.bind(Function.prototype[Symbol.hasInstance]);
+ var webidl = {
+ converters: {},
+ util: {},
+ errors: {},
+ is: {}
};
- exports2.TYPE = {
- BOTH: 0,
- // default
- REQUEST: 1,
- RESPONSE: 2
+ webidl.errors.exception = function(message) {
+ return new TypeError(`${message.header}: ${message.message}`);
};
- exports2.FLAGS = {
- CONNECTION_KEEP_ALIVE: 1 << 0,
- CONNECTION_CLOSE: 1 << 1,
- CONNECTION_UPGRADE: 1 << 2,
- CHUNKED: 1 << 3,
- UPGRADE: 1 << 4,
- CONTENT_LENGTH: 1 << 5,
- SKIPBODY: 1 << 6,
- TRAILING: 1 << 7,
- // 1 << 8 is unused
- TRANSFER_ENCODING: 1 << 9
+ webidl.errors.conversionFailed = function(opts) {
+ const plural = opts.types.length === 1 ? "" : " one of";
+ const message = `${opts.argument} could not be converted to${plural}: ${opts.types.join(", ")}.`;
+ return webidl.errors.exception({
+ header: opts.prefix,
+ message
+ });
};
- exports2.LENIENT_FLAGS = {
- HEADERS: 1 << 0,
- CHUNKED_LENGTH: 1 << 1,
- KEEP_ALIVE: 1 << 2,
- TRANSFER_ENCODING: 1 << 3,
- VERSION: 1 << 4,
- DATA_AFTER_CLOSE: 1 << 5,
- OPTIONAL_LF_AFTER_CR: 1 << 6,
- OPTIONAL_CRLF_AFTER_CHUNK: 1 << 7,
- OPTIONAL_CR_BEFORE_LF: 1 << 8,
- SPACES_AFTER_CHUNK_SIZE: 1 << 9
+ webidl.errors.invalidArgument = function(context) {
+ return webidl.errors.exception({
+ header: context.prefix,
+ message: `"${context.value}" is an invalid ${context.type}.`
+ });
};
- exports2.METHODS = {
- "DELETE": 0,
- "GET": 1,
- "HEAD": 2,
- "POST": 3,
- "PUT": 4,
- /* pathological */
- "CONNECT": 5,
- "OPTIONS": 6,
- "TRACE": 7,
- /* WebDAV */
- "COPY": 8,
- "LOCK": 9,
- "MKCOL": 10,
- "MOVE": 11,
- "PROPFIND": 12,
- "PROPPATCH": 13,
- "SEARCH": 14,
- "UNLOCK": 15,
- "BIND": 16,
- "REBIND": 17,
- "UNBIND": 18,
- "ACL": 19,
- /* subversion */
- "REPORT": 20,
- "MKACTIVITY": 21,
- "CHECKOUT": 22,
- "MERGE": 23,
- /* upnp */
- "M-SEARCH": 24,
- "NOTIFY": 25,
- "SUBSCRIBE": 26,
- "UNSUBSCRIBE": 27,
- /* RFC-5789 */
- "PATCH": 28,
- "PURGE": 29,
- /* CalDAV */
- "MKCALENDAR": 30,
- /* RFC-2068, section 19.6.1.2 */
- "LINK": 31,
- "UNLINK": 32,
- /* icecast */
- "SOURCE": 33,
- /* RFC-7540, section 11.6 */
- "PRI": 34,
- /* RFC-2326 RTSP */
- "DESCRIBE": 35,
- "ANNOUNCE": 36,
- "SETUP": 37,
- "PLAY": 38,
- "PAUSE": 39,
- "TEARDOWN": 40,
- "GET_PARAMETER": 41,
- "SET_PARAMETER": 42,
- "REDIRECT": 43,
- "RECORD": 44,
- /* RAOP */
- "FLUSH": 45,
- /* DRAFT https://www.ietf.org/archive/id/draft-ietf-httpbis-safe-method-w-body-02.html */
- "QUERY": 46
+ webidl.brandCheck = function(V, is) {
+ if (!is(V)) {
+ const err = new TypeError("Illegal invocation");
+ err.code = "ERR_INVALID_THIS";
+ throw err;
+ }
};
- exports2.STATUSES = {
- CONTINUE: 100,
- SWITCHING_PROTOCOLS: 101,
- PROCESSING: 102,
- EARLY_HINTS: 103,
- RESPONSE_IS_STALE: 110,
- // Unofficial
- REVALIDATION_FAILED: 111,
- // Unofficial
- DISCONNECTED_OPERATION: 112,
- // Unofficial
- HEURISTIC_EXPIRATION: 113,
- // Unofficial
- MISCELLANEOUS_WARNING: 199,
- // Unofficial
- OK: 200,
- CREATED: 201,
- ACCEPTED: 202,
- NON_AUTHORITATIVE_INFORMATION: 203,
- NO_CONTENT: 204,
- RESET_CONTENT: 205,
- PARTIAL_CONTENT: 206,
- MULTI_STATUS: 207,
- ALREADY_REPORTED: 208,
- TRANSFORMATION_APPLIED: 214,
- // Unofficial
- IM_USED: 226,
- MISCELLANEOUS_PERSISTENT_WARNING: 299,
- // Unofficial
- MULTIPLE_CHOICES: 300,
- MOVED_PERMANENTLY: 301,
- FOUND: 302,
- SEE_OTHER: 303,
- NOT_MODIFIED: 304,
- USE_PROXY: 305,
- SWITCH_PROXY: 306,
- // No longer used
- TEMPORARY_REDIRECT: 307,
- PERMANENT_REDIRECT: 308,
- BAD_REQUEST: 400,
- UNAUTHORIZED: 401,
- PAYMENT_REQUIRED: 402,
- FORBIDDEN: 403,
- NOT_FOUND: 404,
- METHOD_NOT_ALLOWED: 405,
- NOT_ACCEPTABLE: 406,
- PROXY_AUTHENTICATION_REQUIRED: 407,
- REQUEST_TIMEOUT: 408,
- CONFLICT: 409,
- GONE: 410,
- LENGTH_REQUIRED: 411,
- PRECONDITION_FAILED: 412,
- PAYLOAD_TOO_LARGE: 413,
- URI_TOO_LONG: 414,
- UNSUPPORTED_MEDIA_TYPE: 415,
- RANGE_NOT_SATISFIABLE: 416,
- EXPECTATION_FAILED: 417,
- IM_A_TEAPOT: 418,
- PAGE_EXPIRED: 419,
- // Unofficial
- ENHANCE_YOUR_CALM: 420,
- // Unofficial
- MISDIRECTED_REQUEST: 421,
- UNPROCESSABLE_ENTITY: 422,
- LOCKED: 423,
- FAILED_DEPENDENCY: 424,
- TOO_EARLY: 425,
- UPGRADE_REQUIRED: 426,
- PRECONDITION_REQUIRED: 428,
- TOO_MANY_REQUESTS: 429,
- REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL: 430,
- // Unofficial
- REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
- LOGIN_TIMEOUT: 440,
- // Unofficial
- NO_RESPONSE: 444,
- // Unofficial
- RETRY_WITH: 449,
- // Unofficial
- BLOCKED_BY_PARENTAL_CONTROL: 450,
- // Unofficial
- UNAVAILABLE_FOR_LEGAL_REASONS: 451,
- CLIENT_CLOSED_LOAD_BALANCED_REQUEST: 460,
- // Unofficial
- INVALID_X_FORWARDED_FOR: 463,
- // Unofficial
- REQUEST_HEADER_TOO_LARGE: 494,
- // Unofficial
- SSL_CERTIFICATE_ERROR: 495,
- // Unofficial
- SSL_CERTIFICATE_REQUIRED: 496,
- // Unofficial
- HTTP_REQUEST_SENT_TO_HTTPS_PORT: 497,
- // Unofficial
- INVALID_TOKEN: 498,
- // Unofficial
- CLIENT_CLOSED_REQUEST: 499,
- // Unofficial
- INTERNAL_SERVER_ERROR: 500,
- NOT_IMPLEMENTED: 501,
- BAD_GATEWAY: 502,
- SERVICE_UNAVAILABLE: 503,
- GATEWAY_TIMEOUT: 504,
- HTTP_VERSION_NOT_SUPPORTED: 505,
- VARIANT_ALSO_NEGOTIATES: 506,
- INSUFFICIENT_STORAGE: 507,
- LOOP_DETECTED: 508,
- BANDWIDTH_LIMIT_EXCEEDED: 509,
- NOT_EXTENDED: 510,
- NETWORK_AUTHENTICATION_REQUIRED: 511,
- WEB_SERVER_UNKNOWN_ERROR: 520,
- // Unofficial
- WEB_SERVER_IS_DOWN: 521,
- // Unofficial
- CONNECTION_TIMEOUT: 522,
- // Unofficial
- ORIGIN_IS_UNREACHABLE: 523,
- // Unofficial
- TIMEOUT_OCCURED: 524,
- // Unofficial
- SSL_HANDSHAKE_FAILED: 525,
- // Unofficial
- INVALID_SSL_CERTIFICATE: 526,
- // Unofficial
- RAILGUN_ERROR: 527,
- // Unofficial
- SITE_IS_OVERLOADED: 529,
- // Unofficial
- SITE_IS_FROZEN: 530,
- // Unofficial
- IDENTITY_PROVIDER_AUTHENTICATION_ERROR: 561,
- // Unofficial
- NETWORK_READ_TIMEOUT: 598,
- // Unofficial
- NETWORK_CONNECT_TIMEOUT: 599
- // Unofficial
+ webidl.argumentLengthCheck = function({ length }, min, ctx) {
+ if (length < min) {
+ throw webidl.errors.exception({
+ message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`,
+ header: ctx
+ });
+ }
};
- exports2.FINISH = {
- SAFE: 0,
- SAFE_WITH_CB: 1,
- UNSAFE: 2
+ webidl.illegalConstructor = function() {
+ throw webidl.errors.exception({
+ header: "TypeError",
+ message: "Illegal constructor"
+ });
};
- exports2.HEADER_STATE = {
- GENERAL: 0,
- CONNECTION: 1,
- CONTENT_LENGTH: 2,
- TRANSFER_ENCODING: 3,
- UPGRADE: 4,
- CONNECTION_KEEP_ALIVE: 5,
- CONNECTION_CLOSE: 6,
- CONNECTION_UPGRADE: 7,
- TRANSFER_ENCODING_CHUNKED: 8
+ webidl.util.MakeTypeAssertion = function(I) {
+ return (O) => FunctionPrototypeSymbolHasInstance(I, O);
};
- exports2.METHODS_HTTP = [
- exports2.METHODS.DELETE,
- exports2.METHODS.GET,
- exports2.METHODS.HEAD,
- exports2.METHODS.POST,
- exports2.METHODS.PUT,
- exports2.METHODS.CONNECT,
- exports2.METHODS.OPTIONS,
- exports2.METHODS.TRACE,
- exports2.METHODS.COPY,
- exports2.METHODS.LOCK,
- exports2.METHODS.MKCOL,
- exports2.METHODS.MOVE,
- exports2.METHODS.PROPFIND,
- exports2.METHODS.PROPPATCH,
- exports2.METHODS.SEARCH,
- exports2.METHODS.UNLOCK,
- exports2.METHODS.BIND,
- exports2.METHODS.REBIND,
- exports2.METHODS.UNBIND,
- exports2.METHODS.ACL,
- exports2.METHODS.REPORT,
- exports2.METHODS.MKACTIVITY,
- exports2.METHODS.CHECKOUT,
- exports2.METHODS.MERGE,
- exports2.METHODS["M-SEARCH"],
- exports2.METHODS.NOTIFY,
- exports2.METHODS.SUBSCRIBE,
- exports2.METHODS.UNSUBSCRIBE,
- exports2.METHODS.PATCH,
- exports2.METHODS.PURGE,
- exports2.METHODS.MKCALENDAR,
- exports2.METHODS.LINK,
- exports2.METHODS.UNLINK,
- exports2.METHODS.PRI,
- // TODO(indutny): should we allow it with HTTP?
- exports2.METHODS.SOURCE,
- exports2.METHODS.QUERY
- ];
- exports2.METHODS_ICE = [
- exports2.METHODS.SOURCE
- ];
- exports2.METHODS_RTSP = [
- exports2.METHODS.OPTIONS,
- exports2.METHODS.DESCRIBE,
- exports2.METHODS.ANNOUNCE,
- exports2.METHODS.SETUP,
- exports2.METHODS.PLAY,
- exports2.METHODS.PAUSE,
- exports2.METHODS.TEARDOWN,
- exports2.METHODS.GET_PARAMETER,
- exports2.METHODS.SET_PARAMETER,
- exports2.METHODS.REDIRECT,
- exports2.METHODS.RECORD,
- exports2.METHODS.FLUSH,
- // For AirPlay
- exports2.METHODS.GET,
- exports2.METHODS.POST
- ];
- exports2.METHOD_MAP = (0, utils_1.enumToMap)(exports2.METHODS);
- exports2.H_METHOD_MAP = Object.fromEntries(Object.entries(exports2.METHODS).filter(([k]) => k.startsWith("H")));
- exports2.STATUSES_HTTP = [
- exports2.STATUSES.CONTINUE,
- exports2.STATUSES.SWITCHING_PROTOCOLS,
- exports2.STATUSES.PROCESSING,
- exports2.STATUSES.EARLY_HINTS,
- exports2.STATUSES.RESPONSE_IS_STALE,
- exports2.STATUSES.REVALIDATION_FAILED,
- exports2.STATUSES.DISCONNECTED_OPERATION,
- exports2.STATUSES.HEURISTIC_EXPIRATION,
- exports2.STATUSES.MISCELLANEOUS_WARNING,
- exports2.STATUSES.OK,
- exports2.STATUSES.CREATED,
- exports2.STATUSES.ACCEPTED,
- exports2.STATUSES.NON_AUTHORITATIVE_INFORMATION,
- exports2.STATUSES.NO_CONTENT,
- exports2.STATUSES.RESET_CONTENT,
- exports2.STATUSES.PARTIAL_CONTENT,
- exports2.STATUSES.MULTI_STATUS,
- exports2.STATUSES.ALREADY_REPORTED,
- exports2.STATUSES.TRANSFORMATION_APPLIED,
- exports2.STATUSES.IM_USED,
- exports2.STATUSES.MISCELLANEOUS_PERSISTENT_WARNING,
- exports2.STATUSES.MULTIPLE_CHOICES,
- exports2.STATUSES.MOVED_PERMANENTLY,
- exports2.STATUSES.FOUND,
- exports2.STATUSES.SEE_OTHER,
- exports2.STATUSES.NOT_MODIFIED,
- exports2.STATUSES.USE_PROXY,
- exports2.STATUSES.SWITCH_PROXY,
- exports2.STATUSES.TEMPORARY_REDIRECT,
- exports2.STATUSES.PERMANENT_REDIRECT,
- exports2.STATUSES.BAD_REQUEST,
- exports2.STATUSES.UNAUTHORIZED,
- exports2.STATUSES.PAYMENT_REQUIRED,
- exports2.STATUSES.FORBIDDEN,
- exports2.STATUSES.NOT_FOUND,
- exports2.STATUSES.METHOD_NOT_ALLOWED,
- exports2.STATUSES.NOT_ACCEPTABLE,
- exports2.STATUSES.PROXY_AUTHENTICATION_REQUIRED,
- exports2.STATUSES.REQUEST_TIMEOUT,
- exports2.STATUSES.CONFLICT,
- exports2.STATUSES.GONE,
- exports2.STATUSES.LENGTH_REQUIRED,
- exports2.STATUSES.PRECONDITION_FAILED,
- exports2.STATUSES.PAYLOAD_TOO_LARGE,
- exports2.STATUSES.URI_TOO_LONG,
- exports2.STATUSES.UNSUPPORTED_MEDIA_TYPE,
- exports2.STATUSES.RANGE_NOT_SATISFIABLE,
- exports2.STATUSES.EXPECTATION_FAILED,
- exports2.STATUSES.IM_A_TEAPOT,
- exports2.STATUSES.PAGE_EXPIRED,
- exports2.STATUSES.ENHANCE_YOUR_CALM,
- exports2.STATUSES.MISDIRECTED_REQUEST,
- exports2.STATUSES.UNPROCESSABLE_ENTITY,
- exports2.STATUSES.LOCKED,
- exports2.STATUSES.FAILED_DEPENDENCY,
- exports2.STATUSES.TOO_EARLY,
- exports2.STATUSES.UPGRADE_REQUIRED,
- exports2.STATUSES.PRECONDITION_REQUIRED,
- exports2.STATUSES.TOO_MANY_REQUESTS,
- exports2.STATUSES.REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL,
- exports2.STATUSES.REQUEST_HEADER_FIELDS_TOO_LARGE,
- exports2.STATUSES.LOGIN_TIMEOUT,
- exports2.STATUSES.NO_RESPONSE,
- exports2.STATUSES.RETRY_WITH,
- exports2.STATUSES.BLOCKED_BY_PARENTAL_CONTROL,
- exports2.STATUSES.UNAVAILABLE_FOR_LEGAL_REASONS,
- exports2.STATUSES.CLIENT_CLOSED_LOAD_BALANCED_REQUEST,
- exports2.STATUSES.INVALID_X_FORWARDED_FOR,
- exports2.STATUSES.REQUEST_HEADER_TOO_LARGE,
- exports2.STATUSES.SSL_CERTIFICATE_ERROR,
- exports2.STATUSES.SSL_CERTIFICATE_REQUIRED,
- exports2.STATUSES.HTTP_REQUEST_SENT_TO_HTTPS_PORT,
- exports2.STATUSES.INVALID_TOKEN,
- exports2.STATUSES.CLIENT_CLOSED_REQUEST,
- exports2.STATUSES.INTERNAL_SERVER_ERROR,
- exports2.STATUSES.NOT_IMPLEMENTED,
- exports2.STATUSES.BAD_GATEWAY,
- exports2.STATUSES.SERVICE_UNAVAILABLE,
- exports2.STATUSES.GATEWAY_TIMEOUT,
- exports2.STATUSES.HTTP_VERSION_NOT_SUPPORTED,
- exports2.STATUSES.VARIANT_ALSO_NEGOTIATES,
- exports2.STATUSES.INSUFFICIENT_STORAGE,
- exports2.STATUSES.LOOP_DETECTED,
- exports2.STATUSES.BANDWIDTH_LIMIT_EXCEEDED,
- exports2.STATUSES.NOT_EXTENDED,
- exports2.STATUSES.NETWORK_AUTHENTICATION_REQUIRED,
- exports2.STATUSES.WEB_SERVER_UNKNOWN_ERROR,
- exports2.STATUSES.WEB_SERVER_IS_DOWN,
- exports2.STATUSES.CONNECTION_TIMEOUT,
- exports2.STATUSES.ORIGIN_IS_UNREACHABLE,
- exports2.STATUSES.TIMEOUT_OCCURED,
- exports2.STATUSES.SSL_HANDSHAKE_FAILED,
- exports2.STATUSES.INVALID_SSL_CERTIFICATE,
- exports2.STATUSES.RAILGUN_ERROR,
- exports2.STATUSES.SITE_IS_OVERLOADED,
- exports2.STATUSES.SITE_IS_FROZEN,
- exports2.STATUSES.IDENTITY_PROVIDER_AUTHENTICATION_ERROR,
- exports2.STATUSES.NETWORK_READ_TIMEOUT,
- exports2.STATUSES.NETWORK_CONNECT_TIMEOUT
- ];
- exports2.ALPHA = [];
- for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) {
- exports2.ALPHA.push(String.fromCharCode(i));
- exports2.ALPHA.push(String.fromCharCode(i + 32));
- }
- exports2.NUM_MAP = {
- 0: 0,
- 1: 1,
- 2: 2,
- 3: 3,
- 4: 4,
- 5: 5,
- 6: 6,
- 7: 7,
- 8: 8,
- 9: 9
+ webidl.util.Type = function(V) {
+ switch (typeof V) {
+ case "undefined":
+ return UNDEFINED;
+ case "boolean":
+ return BOOLEAN;
+ case "string":
+ return STRING;
+ case "symbol":
+ return SYMBOL;
+ case "number":
+ return NUMBER;
+ case "bigint":
+ return BIGINT;
+ case "function":
+ case "object": {
+ if (V === null) {
+ return NULL;
+ }
+ return OBJECT;
+ }
+ }
};
- exports2.HEX_MAP = {
- 0: 0,
- 1: 1,
- 2: 2,
- 3: 3,
- 4: 4,
- 5: 5,
- 6: 6,
- 7: 7,
- 8: 8,
- 9: 9,
- A: 10,
- B: 11,
- C: 12,
- D: 13,
- E: 14,
- F: 15,
- a: 10,
- b: 11,
- c: 12,
- d: 13,
- e: 14,
- f: 15
+ webidl.util.Types = {
+ UNDEFINED,
+ BOOLEAN,
+ STRING,
+ SYMBOL,
+ NUMBER,
+ BIGINT,
+ NULL,
+ OBJECT
};
- exports2.NUM = [
- "0",
- "1",
- "2",
- "3",
- "4",
- "5",
- "6",
- "7",
- "8",
- "9"
- ];
- exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM);
- exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
- exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
- exports2.URL_CHAR = [
- "!",
- '"',
- "$",
- "%",
- "&",
- "'",
- "(",
- ")",
- "*",
- "+",
- ",",
- "-",
- ".",
- "/",
- ":",
- ";",
- "<",
- "=",
- ">",
- "@",
- "[",
- "\\",
- "]",
- "^",
- "_",
- "`",
- "{",
- "|",
- "}",
- "~"
- ].concat(exports2.ALPHANUM);
- exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
- exports2.TOKEN = [
- "!",
- "#",
- "$",
- "%",
- "&",
- "'",
- "*",
- "+",
- "-",
- ".",
- "^",
- "_",
- "`",
- "|",
- "~"
- ].concat(exports2.ALPHANUM);
- exports2.HEADER_CHARS = [" "];
- for (let i = 32; i <= 255; i++) {
- if (i !== 127) {
- exports2.HEADER_CHARS.push(i);
+ webidl.util.TypeValueToString = function(o) {
+ switch (webidl.util.Type(o)) {
+ case UNDEFINED:
+ return "Undefined";
+ case BOOLEAN:
+ return "Boolean";
+ case STRING:
+ return "String";
+ case SYMBOL:
+ return "Symbol";
+ case NUMBER:
+ return "Number";
+ case BIGINT:
+ return "BigInt";
+ case NULL:
+ return "Null";
+ case OBJECT:
+ return "Object";
}
- }
- exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44);
- exports2.QUOTED_STRING = [" ", " "];
- for (let i = 33; i <= 255; i++) {
- if (i !== 34 && i !== 92) {
- exports2.QUOTED_STRING.push(i);
+ };
+ webidl.util.markAsUncloneable = markAsUncloneable;
+ webidl.util.ConvertToInt = function(V, bitLength, signedness, flags) {
+ let upperBound;
+ let lowerBound;
+ if (bitLength === 64) {
+ upperBound = Math.pow(2, 53) - 1;
+ if (signedness === "unsigned") {
+ lowerBound = 0;
+ } else {
+ lowerBound = Math.pow(-2, 53) + 1;
+ }
+ } else if (signedness === "unsigned") {
+ lowerBound = 0;
+ upperBound = Math.pow(2, bitLength) - 1;
+ } else {
+ lowerBound = -Math.pow(2, bitLength - 1);
+ upperBound = Math.pow(2, bitLength - 1) - 1;
}
- }
- exports2.HTAB_SP_VCHAR_OBS_TEXT = [" ", " "];
- for (let i = 33; i <= 126; i++) {
- exports2.HTAB_SP_VCHAR_OBS_TEXT.push(i);
- }
- for (let i = 128; i <= 255; i++) {
- exports2.HTAB_SP_VCHAR_OBS_TEXT.push(i);
- }
- exports2.MAJOR = exports2.NUM_MAP;
- exports2.MINOR = exports2.MAJOR;
- exports2.SPECIAL_HEADERS = {
- "connection": exports2.HEADER_STATE.CONNECTION,
- "content-length": exports2.HEADER_STATE.CONTENT_LENGTH,
- "proxy-connection": exports2.HEADER_STATE.CONNECTION,
- "transfer-encoding": exports2.HEADER_STATE.TRANSFER_ENCODING,
- "upgrade": exports2.HEADER_STATE.UPGRADE
+ let x = Number(V);
+ if (x === 0) {
+ x = 0;
+ }
+ if (webidl.util.HasFlag(flags, webidl.attributes.EnforceRange)) {
+ if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
+ throw webidl.errors.exception({
+ header: "Integer conversion",
+ message: `Could not convert ${webidl.util.Stringify(V)} to an integer.`
+ });
+ }
+ x = webidl.util.IntegerPart(x);
+ if (x < lowerBound || x > upperBound) {
+ throw webidl.errors.exception({
+ header: "Integer conversion",
+ message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.`
+ });
+ }
+ return x;
+ }
+ if (!Number.isNaN(x) && webidl.util.HasFlag(flags, webidl.attributes.Clamp)) {
+ x = Math.min(Math.max(x, lowerBound), upperBound);
+ if (Math.floor(x) % 2 === 0) {
+ x = Math.floor(x);
+ } else {
+ x = Math.ceil(x);
+ }
+ return x;
+ }
+ if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
+ return 0;
+ }
+ x = webidl.util.IntegerPart(x);
+ x = x % Math.pow(2, bitLength);
+ if (signedness === "signed" && x >= Math.pow(2, bitLength - 1)) {
+ return x - Math.pow(2, bitLength);
+ }
+ return x;
};
- exports2.default = {
- ERROR: exports2.ERROR,
- TYPE: exports2.TYPE,
- FLAGS: exports2.FLAGS,
- LENIENT_FLAGS: exports2.LENIENT_FLAGS,
- METHODS: exports2.METHODS,
- STATUSES: exports2.STATUSES,
- FINISH: exports2.FINISH,
- HEADER_STATE: exports2.HEADER_STATE,
- ALPHA: exports2.ALPHA,
- NUM_MAP: exports2.NUM_MAP,
- HEX_MAP: exports2.HEX_MAP,
- NUM: exports2.NUM,
- ALPHANUM: exports2.ALPHANUM,
- MARK: exports2.MARK,
- USERINFO_CHARS: exports2.USERINFO_CHARS,
- URL_CHAR: exports2.URL_CHAR,
- HEX: exports2.HEX,
- TOKEN: exports2.TOKEN,
- HEADER_CHARS: exports2.HEADER_CHARS,
- CONNECTION_TOKEN_CHARS: exports2.CONNECTION_TOKEN_CHARS,
- QUOTED_STRING: exports2.QUOTED_STRING,
- HTAB_SP_VCHAR_OBS_TEXT: exports2.HTAB_SP_VCHAR_OBS_TEXT,
- MAJOR: exports2.MAJOR,
- MINOR: exports2.MINOR,
- SPECIAL_HEADERS: exports2.SPECIAL_HEADERS,
- METHODS_HTTP: exports2.METHODS_HTTP,
- METHODS_ICE: exports2.METHODS_ICE,
- METHODS_RTSP: exports2.METHODS_RTSP,
- METHOD_MAP: exports2.METHOD_MAP,
- H_METHOD_MAP: exports2.H_METHOD_MAP,
- STATUSES_HTTP: exports2.STATUSES_HTTP
+ webidl.util.IntegerPart = function(n) {
+ const r = Math.floor(Math.abs(n));
+ if (n < 0) {
+ return -1 * r;
+ }
+ return r;
};
- }
-});
-
-// lib/llhttp/llhttp-wasm.js
-var require_llhttp_wasm = __commonJS({
- "lib/llhttp/llhttp-wasm.js"(exports2, module2) {
- "use strict";
- var { Buffer: Buffer2 } = require("node:buffer");
- var wasmBase64 = "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";
- var wasmBuffer;
- Object.defineProperty(module2, "exports", {
- get: /* @__PURE__ */ __name(() => {
- return wasmBuffer ? wasmBuffer : wasmBuffer = Buffer2.from(wasmBase64, "base64");
- }, "get")
- });
- }
-});
-
-// lib/llhttp/llhttp_simd-wasm.js
-var require_llhttp_simd_wasm = __commonJS({
- "lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) {
- "use strict";
- var { Buffer: Buffer2 } = require("node:buffer");
- var wasmBase64 = "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";
- var wasmBuffer;
- Object.defineProperty(module2, "exports", {
- get: /* @__PURE__ */ __name(() => {
- return wasmBuffer ? wasmBuffer : wasmBuffer = Buffer2.from(wasmBase64, "base64");
- }, "get")
- });
- }
-});
-
-// lib/web/fetch/constants.js
-var require_constants3 = __commonJS({
- "lib/web/fetch/constants.js"(exports2, module2) {
- "use strict";
- var corsSafeListedMethods = (
- /** @type {const} */
- ["GET", "HEAD", "POST"]
- );
- var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
- var nullBodyStatus = (
- /** @type {const} */
- [101, 204, 205, 304]
- );
- var redirectStatus = (
- /** @type {const} */
- [301, 302, 303, 307, 308]
- );
- var redirectStatusSet = new Set(redirectStatus);
- var badPorts = (
- /** @type {const} */
- [
- "1",
- "7",
- "9",
- "11",
- "13",
- "15",
- "17",
- "19",
- "20",
- "21",
- "22",
- "23",
- "25",
- "37",
- "42",
- "43",
- "53",
- "69",
- "77",
- "79",
- "87",
- "95",
- "101",
- "102",
- "103",
- "104",
- "109",
- "110",
- "111",
- "113",
- "115",
- "117",
- "119",
- "123",
- "135",
- "137",
- "139",
- "143",
- "161",
- "179",
- "389",
- "427",
- "465",
- "512",
- "513",
- "514",
- "515",
- "526",
- "530",
- "531",
- "532",
- "540",
- "548",
- "554",
- "556",
- "563",
- "587",
- "601",
- "636",
- "989",
- "990",
- "993",
- "995",
- "1719",
- "1720",
- "1723",
- "2049",
- "3659",
- "4045",
- "4190",
- "5060",
- "5061",
- "6000",
- "6566",
- "6665",
- "6666",
- "6667",
- "6668",
- "6669",
- "6679",
- "6697",
- "10080"
- ]
- );
- var badPortsSet = new Set(badPorts);
- var referrerPolicyTokens = (
- /** @type {const} */
- [
- "no-referrer",
- "no-referrer-when-downgrade",
- "same-origin",
- "origin",
- "strict-origin",
- "origin-when-cross-origin",
- "strict-origin-when-cross-origin",
- "unsafe-url"
- ]
- );
- var referrerPolicy = (
- /** @type {const} */
- [
- "",
- ...referrerPolicyTokens
- ]
- );
- var referrerPolicyTokensSet = new Set(referrerPolicyTokens);
- var requestRedirect = (
- /** @type {const} */
- ["follow", "manual", "error"]
- );
- var safeMethods = (
- /** @type {const} */
- ["GET", "HEAD", "OPTIONS", "TRACE", "QUERY"]
- );
- var safeMethodsSet = new Set(safeMethods);
- var requestMode = (
- /** @type {const} */
- ["navigate", "same-origin", "no-cors", "cors"]
- );
- var requestCredentials = (
- /** @type {const} */
- ["omit", "same-origin", "include"]
- );
- var requestCache = (
- /** @type {const} */
- [
- "default",
- "no-store",
- "reload",
- "no-cache",
- "force-cache",
- "only-if-cached"
- ]
- );
- var requestBodyHeader = (
- /** @type {const} */
- [
- "content-encoding",
- "content-language",
- "content-location",
- "content-type",
- // See https://github.com/nodejs/undici/issues/2021
- // 'Content-Length' is a forbidden header name, which is typically
- // removed in the Headers implementation. However, undici doesn't
- // filter out headers, so we add it here.
- "content-length"
- ]
- );
- var requestDuplex = (
- /** @type {const} */
- [
- "half"
- ]
- );
- var forbiddenMethods = (
- /** @type {const} */
- ["CONNECT", "TRACE", "TRACK"]
- );
- var forbiddenMethodsSet = new Set(forbiddenMethods);
- var subresource = (
- /** @type {const} */
- [
- "audio",
- "audioworklet",
- "font",
- "image",
- "manifest",
- "paintworklet",
- "script",
- "style",
- "track",
- "video",
- "xslt",
- ""
- ]
- );
- var subresourceSet = new Set(subresource);
- module2.exports = {
- subresource,
- forbiddenMethods,
- requestBodyHeader,
- referrerPolicy,
- requestRedirect,
- requestMode,
- requestCredentials,
- requestCache,
- redirectStatus,
- corsSafeListedMethods,
- nullBodyStatus,
- safeMethods,
- badPorts,
- requestDuplex,
- subresourceSet,
- badPortsSet,
- redirectStatusSet,
- corsSafeListedMethodsSet,
- safeMethodsSet,
- forbiddenMethodsSet,
- referrerPolicyTokens: referrerPolicyTokensSet
+ webidl.util.Stringify = function(V) {
+ const type = webidl.util.Type(V);
+ switch (type) {
+ case SYMBOL:
+ return `Symbol(${V.description})`;
+ case OBJECT:
+ return inspect(V);
+ case STRING:
+ return `"${V}"`;
+ case BIGINT:
+ return `${V}n`;
+ default:
+ return `${V}`;
+ }
};
- }
-});
-
-// lib/web/fetch/global.js
-var require_global = __commonJS({
- "lib/web/fetch/global.js"(exports2, module2) {
- "use strict";
- var globalOrigin = /* @__PURE__ */ Symbol.for("undici.globalOrigin.1");
- function getGlobalOrigin() {
- return globalThis[globalOrigin];
- }
- __name(getGlobalOrigin, "getGlobalOrigin");
- function setGlobalOrigin(newOrigin) {
- if (newOrigin === void 0) {
- Object.defineProperty(globalThis, globalOrigin, {
- value: void 0,
- writable: true,
- enumerable: false,
- configurable: false
- });
- return;
+ webidl.util.IsResizableArrayBuffer = function(V) {
+ if (types.isArrayBuffer(V)) {
+ return V.resizable;
}
- const parsedURL = new URL(newOrigin);
- if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") {
- throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
+ if (types.isSharedArrayBuffer(V)) {
+ return V.growable;
}
- Object.defineProperty(globalThis, globalOrigin, {
- value: parsedURL,
- writable: true,
- enumerable: false,
- configurable: false
+ throw webidl.errors.exception({
+ header: "IsResizableArrayBuffer",
+ message: `"${webidl.util.Stringify(V)}" is not an array buffer.`
});
- }
- __name(setGlobalOrigin, "setGlobalOrigin");
- module2.exports = {
- getGlobalOrigin,
- setGlobalOrigin
};
- }
-});
-
-// lib/encoding/index.js
-var require_encoding = __commonJS({
- "lib/encoding/index.js"(exports2, module2) {
- "use strict";
- var textDecoder = new TextDecoder();
- function utf8DecodeBytes(buffer) {
- if (buffer.length === 0) {
- return "";
- }
- if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
- buffer = buffer.subarray(3);
- }
- const output = textDecoder.decode(buffer);
- return output;
- }
- __name(utf8DecodeBytes, "utf8DecodeBytes");
- module2.exports = {
- utf8DecodeBytes
+ webidl.util.HasFlag = function(flags, attributes) {
+ return typeof flags === "number" && (flags & attributes) === attributes;
};
- }
-});
-
-// lib/web/infra/index.js
-var require_infra = __commonJS({
- "lib/web/infra/index.js"(exports2, module2) {
- "use strict";
- var assert = require("node:assert");
- var { utf8DecodeBytes } = require_encoding();
- function collectASequenceOfCodePoints(condition, input, position) {
- let result = "";
- while (position.position < input.length && condition(input[position.position])) {
- result += input[position.position];
- position.position++;
- }
- return result;
- }
- __name(collectASequenceOfCodePoints, "collectASequenceOfCodePoints");
- function collectASequenceOfCodePointsFast(char, input, position) {
- const idx = input.indexOf(char, position.position);
- const start = position.position;
- if (idx === -1) {
- position.position = input.length;
- return input.slice(start);
- }
- position.position = idx;
- return input.slice(start, position.position);
- }
- __name(collectASequenceOfCodePointsFast, "collectASequenceOfCodePointsFast");
- var ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g;
- function forgivingBase64(data) {
- data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, "");
- let dataLength = data.length;
- if (dataLength % 4 === 0) {
- if (data.charCodeAt(dataLength - 1) === 61) {
- --dataLength;
- if (data.charCodeAt(dataLength - 1) === 61) {
- --dataLength;
- }
+ webidl.sequenceConverter = function(converter) {
+ return (V, prefix, argument, Iterable) => {
+ if (webidl.util.Type(V) !== OBJECT) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.`
+ });
}
- }
- if (dataLength % 4 === 1) {
- return "failure";
- }
- if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) {
- return "failure";
- }
- const buffer = Buffer.from(data, "base64");
- return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
- }
- __name(forgivingBase64, "forgivingBase64");
- function isASCIIWhitespace(char) {
- return char === 9 || // \t
- char === 10 || // \n
- char === 12 || // \f
- char === 13 || // \r
- char === 32;
- }
- __name(isASCIIWhitespace, "isASCIIWhitespace");
- function isomorphicDecode(input) {
- const length = input.length;
- if ((2 << 15) - 1 > length) {
- return String.fromCharCode.apply(null, input);
- }
- let result = "";
- let i = 0;
- let addition = (2 << 15) - 1;
- while (i < length) {
- if (i + addition > length) {
- addition = length - i;
+ const method = typeof Iterable === "function" ? Iterable() : V?.[Symbol.iterator]?.();
+ const seq = [];
+ let index = 0;
+ if (method === void 0 || typeof method.next !== "function") {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} is not iterable.`
+ });
}
- result += String.fromCharCode.apply(null, input.subarray(i, i += addition));
- }
- return result;
- }
- __name(isomorphicDecode, "isomorphicDecode");
- var invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/;
- function isomorphicEncode(input) {
- assert(!invalidIsomorphicEncodeValueRegex.test(input));
- return input;
- }
- __name(isomorphicEncode, "isomorphicEncode");
- var nonASCIIRegex = /[^\x00-\x7F]/;
- function asciiLowercase(str) {
- return nonASCIIRegex.test(str) ? str.replace(/[A-Z]+/g, (upper) => upper.toLowerCase()) : str.toLowerCase();
- }
- __name(asciiLowercase, "asciiLowercase");
- function parseJSONFromBytes(bytes) {
- return JSON.parse(utf8DecodeBytes(bytes));
- }
- __name(parseJSONFromBytes, "parseJSONFromBytes");
- function removeASCIIWhitespace(str, leading = true, trailing = true) {
- return removeChars(str, leading, trailing, isASCIIWhitespace);
- }
- __name(removeASCIIWhitespace, "removeASCIIWhitespace");
- function removeChars(str, leading, trailing, predicate) {
- let lead = 0;
- let trail = str.length - 1;
- if (leading) {
- while (lead < str.length && predicate(str.charCodeAt(lead))) lead++;
- }
- if (trailing) {
- while (trail >= lead && predicate(str.charCodeAt(trail))) trail--;
- }
- return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1);
- }
- __name(removeChars, "removeChars");
- function serializeJavascriptValueToJSONString(value) {
- const result = JSON.stringify(value);
- if (result === void 0) {
- throw new TypeError("Value is not JSON serializable");
- }
- assert(typeof result === "string");
- return result;
- }
- __name(serializeJavascriptValueToJSONString, "serializeJavascriptValueToJSONString");
- module2.exports = {
- asciiLowercase,
- collectASequenceOfCodePoints,
- collectASequenceOfCodePointsFast,
- forgivingBase64,
- isASCIIWhitespace,
- isomorphicDecode,
- isomorphicEncode,
- parseJSONFromBytes,
- removeASCIIWhitespace,
- removeChars,
- serializeJavascriptValueToJSONString
+ while (true) {
+ const { done, value } = method.next();
+ if (done) {
+ break;
+ }
+ seq.push(converter(value, prefix, `${argument}[${index++}]`));
+ }
+ return seq;
+ };
};
- }
-});
-
-// lib/web/fetch/data-url.js
-var require_data_url = __commonJS({
- "lib/web/fetch/data-url.js"(exports2, module2) {
- "use strict";
- var assert = require("node:assert");
- var { asciiLowercase, forgivingBase64, collectASequenceOfCodePoints, collectASequenceOfCodePointsFast, isomorphicDecode, removeASCIIWhitespace, removeChars } = require_infra();
- var encoder = new TextEncoder();
- var HTTP_TOKEN_CODEPOINTS = /^[-!#$%&'*+.^_`|~A-Za-z0-9]+$/u;
- var HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/u;
- var HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/u;
- function dataURLProcessor(dataURL) {
- assert(dataURL.protocol === "data:");
- let input = URLSerializer(dataURL, true);
- input = input.slice(5);
- const position = { position: 0 };
- let mimeType = collectASequenceOfCodePointsFast(
- ",",
- input,
- position
- );
- const mimeTypeLength = mimeType.length;
- mimeType = removeASCIIWhitespace(mimeType, true, true);
- if (position.position >= input.length) {
- return "failure";
- }
- position.position++;
- const encodedBody = input.slice(mimeTypeLength + 1);
- let body = stringPercentDecode(encodedBody);
- if (/;\u0020*[Bb][Aa][Ss][Ee]64$/u.test(mimeType)) {
- const stringBody = isomorphicDecode(body);
- body = forgivingBase64(stringBody);
- if (body === "failure") {
- return "failure";
- }
- mimeType = mimeType.slice(0, -6);
- mimeType = mimeType.replace(/(\u0020+)$/u, "");
- mimeType = mimeType.slice(0, -1);
- }
- if (mimeType.startsWith(";")) {
- mimeType = "text/plain" + mimeType;
- }
- let mimeTypeRecord = parseMIMEType(mimeType);
- if (mimeTypeRecord === "failure") {
- mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII");
- }
- return { mimeType: mimeTypeRecord, body };
- }
- __name(dataURLProcessor, "dataURLProcessor");
- function URLSerializer(url, excludeFragment = false) {
- if (!excludeFragment) {
- return url.href;
- }
- const href = url.href;
- const hashLength = url.hash.length;
- const serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength);
- if (!hashLength && href.endsWith("#")) {
- return serialized.slice(0, -1);
- }
- return serialized;
- }
- __name(URLSerializer, "URLSerializer");
- function stringPercentDecode(input) {
- const bytes = encoder.encode(input);
- return percentDecode(bytes);
- }
- __name(stringPercentDecode, "stringPercentDecode");
- function isHexCharByte(byte) {
- return byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102;
- }
- __name(isHexCharByte, "isHexCharByte");
- function hexByteToNumber(byte) {
- return (
- // 0-9
- byte >= 48 && byte <= 57 ? byte - 48 : (byte & 223) - 55
- );
- }
- __name(hexByteToNumber, "hexByteToNumber");
- function percentDecode(input) {
- const length = input.length;
- const output = new Uint8Array(length);
- let j = 0;
- let i = 0;
- while (i < length) {
- const byte = input[i];
- if (byte !== 37) {
- output[j++] = byte;
- } else if (byte === 37 && !(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2]))) {
- output[j++] = 37;
- } else {
- output[j++] = hexByteToNumber(input[i + 1]) << 4 | hexByteToNumber(input[i + 2]);
- i += 2;
+ webidl.recordConverter = function(keyConverter, valueConverter) {
+ return (O, prefix, argument) => {
+ if (webidl.util.Type(O) !== OBJECT) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} ("${webidl.util.TypeValueToString(O)}") is not an Object.`
+ });
}
- ++i;
- }
- return length === j ? output : output.subarray(0, j);
- }
- __name(percentDecode, "percentDecode");
- function parseMIMEType(input) {
- input = removeHTTPWhitespace(input, true, true);
- const position = { position: 0 };
- const type = collectASequenceOfCodePointsFast(
- "/",
- input,
- position
- );
- if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
- return "failure";
- }
- if (position.position >= input.length) {
- return "failure";
- }
- position.position++;
- let subtype = collectASequenceOfCodePointsFast(
- ";",
- input,
- position
- );
- subtype = removeHTTPWhitespace(subtype, false, true);
- if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
- return "failure";
- }
- const typeLowercase = asciiLowercase(type);
- const subtypeLowercase = asciiLowercase(subtype);
- const mimeType = {
- type: typeLowercase,
- subtype: subtypeLowercase,
- /** @type {Map<string, string>} */
- parameters: /* @__PURE__ */ new Map(),
- // https://mimesniff.spec.whatwg.org/#mime-type-essence
- essence: `${typeLowercase}/${subtypeLowercase}`
- };
- while (position.position < input.length) {
- position.position++;
- collectASequenceOfCodePoints(
- // https://fetch.spec.whatwg.org/#http-whitespace
- (char) => HTTP_WHITESPACE_REGEX.test(char),
- input,
- position
- );
- let parameterName = collectASequenceOfCodePoints(
- (char) => char !== ";" && char !== "=",
- input,
- position
- );
- parameterName = asciiLowercase(parameterName);
- if (position.position < input.length) {
- if (input[position.position] === ";") {
- continue;
+ const result = {};
+ if (!types.isProxy(O)) {
+ const keys2 = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)];
+ for (const key of keys2) {
+ const keyName = webidl.util.Stringify(key);
+ const typedKey = keyConverter(key, prefix, `Key ${keyName} in ${argument}`);
+ const typedValue = valueConverter(O[key], prefix, `${argument}[${keyName}]`);
+ result[typedKey] = typedValue;
}
- position.position++;
- }
- if (position.position >= input.length) {
- break;
+ return result;
}
- let parameterValue = null;
- if (input[position.position] === '"') {
- parameterValue = collectAnHTTPQuotedString(input, position, true);
- collectASequenceOfCodePointsFast(
- ";",
- input,
- position
- );
- } else {
- parameterValue = collectASequenceOfCodePointsFast(
- ";",
- input,
- position
- );
- parameterValue = removeHTTPWhitespace(parameterValue, false, true);
- if (parameterValue.length === 0) {
- continue;
+ const keys = Reflect.ownKeys(O);
+ for (const key of keys) {
+ const desc = Reflect.getOwnPropertyDescriptor(O, key);
+ if (desc?.enumerable) {
+ const typedKey = keyConverter(key, prefix, argument);
+ const typedValue = valueConverter(O[key], prefix, argument);
+ result[typedKey] = typedValue;
}
}
- if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) {
- mimeType.parameters.set(parameterName, parameterValue);
+ return result;
+ };
+ };
+ webidl.interfaceConverter = function(TypeCheck, name) {
+ return (V, prefix, argument) => {
+ if (!TypeCheck(V)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${name}.`
+ });
}
- }
- return mimeType;
- }
- __name(parseMIMEType, "parseMIMEType");
- function collectAnHTTPQuotedString(input, position, extractValue = false) {
- const positionStart = position.position;
- let value = "";
- assert(input[position.position] === '"');
- position.position++;
- while (true) {
- value += collectASequenceOfCodePoints(
- (char) => char !== '"' && char !== "\\",
- input,
- position
- );
- if (position.position >= input.length) {
- break;
+ return V;
+ };
+ };
+ webidl.dictionaryConverter = function(converters) {
+ converters.sort((a, b) => (a.key > b.key) - (a.key < b.key));
+ return (dictionary, prefix, argument) => {
+ const dict = {};
+ if (dictionary != null && webidl.util.Type(dictionary) !== OBJECT) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
+ });
}
- const quoteOrBackslash = input[position.position];
- position.position++;
- if (quoteOrBackslash === "\\") {
- if (position.position >= input.length) {
- value += "\\";
- break;
+ for (const options of converters) {
+ const { key, defaultValue, required, converter } = options;
+ if (required === true) {
+ if (dictionary == null || !Object.hasOwn(dictionary, key)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `Missing required key "${key}".`
+ });
+ }
+ }
+ let value = dictionary?.[key];
+ const hasDefault = defaultValue !== void 0;
+ if (hasDefault && value === void 0) {
+ value = defaultValue();
+ }
+ if (required || hasDefault || value !== void 0) {
+ value = converter(value, prefix, `${argument}.${key}`);
+ if (options.allowedValues && !options.allowedValues.includes(value)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.`
+ });
+ }
+ dict[key] = value;
}
- value += input[position.position];
- position.position++;
- } else {
- assert(quoteOrBackslash === '"');
- break;
}
- }
- if (extractValue) {
- return value;
- }
- return input.slice(positionStart, position.position);
- }
- __name(collectAnHTTPQuotedString, "collectAnHTTPQuotedString");
- function serializeAMimeType(mimeType) {
- assert(mimeType !== "failure");
- const { parameters, essence } = mimeType;
- let serialization = essence;
- for (let [name, value] of parameters.entries()) {
- serialization += ";";
- serialization += name;
- serialization += "=";
- if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
- value = value.replace(/[\\"]/ug, "\\$&");
- value = '"' + value;
- value += '"';
+ return dict;
+ };
+ };
+ webidl.nullableConverter = function(converter) {
+ return (V, prefix, argument) => {
+ if (V === null) {
+ return V;
}
- serialization += value;
+ return converter(V, prefix, argument);
+ };
+ };
+ webidl.is.USVString = function(value) {
+ return typeof value === "string" && value.isWellFormed();
+ };
+ webidl.is.ReadableStream = webidl.util.MakeTypeAssertion(ReadableStream);
+ webidl.is.Blob = webidl.util.MakeTypeAssertion(Blob);
+ webidl.is.URLSearchParams = webidl.util.MakeTypeAssertion(URLSearchParams);
+ webidl.is.File = webidl.util.MakeTypeAssertion(File);
+ webidl.is.URL = webidl.util.MakeTypeAssertion(URL);
+ webidl.is.AbortSignal = webidl.util.MakeTypeAssertion(AbortSignal);
+ webidl.is.MessagePort = webidl.util.MakeTypeAssertion(MessagePort);
+ webidl.is.BufferSource = function(V) {
+ return types.isArrayBuffer(V) || ArrayBuffer.isView(V) && types.isArrayBuffer(V.buffer);
+ };
+ webidl.util.getCopyOfBytesHeldByBufferSource = function(bufferSource) {
+ const jsBufferSource = bufferSource;
+ let jsArrayBuffer = jsBufferSource;
+ let offset = 0;
+ let length = 0;
+ if (types.isTypedArray(jsBufferSource) || types.isDataView(jsBufferSource)) {
+ jsArrayBuffer = jsBufferSource.buffer;
+ offset = jsBufferSource.byteOffset;
+ length = jsBufferSource.byteLength;
+ } else {
+ assert(types.isAnyArrayBuffer(jsBufferSource));
+ length = jsBufferSource.byteLength;
}
- return serialization;
- }
- __name(serializeAMimeType, "serializeAMimeType");
- function isHTTPWhiteSpace(char) {
- return char === 13 || char === 10 || char === 9 || char === 32;
- }
- __name(isHTTPWhiteSpace, "isHTTPWhiteSpace");
- function removeHTTPWhitespace(str, leading = true, trailing = true) {
- return removeChars(str, leading, trailing, isHTTPWhiteSpace);
- }
- __name(removeHTTPWhitespace, "removeHTTPWhitespace");
- function minimizeSupportedMimeType(mimeType) {
- switch (mimeType.essence) {
- case "application/ecmascript":
- case "application/javascript":
- case "application/x-ecmascript":
- case "application/x-javascript":
- case "text/ecmascript":
- case "text/javascript":
- case "text/javascript1.0":
- case "text/javascript1.1":
- case "text/javascript1.2":
- case "text/javascript1.3":
- case "text/javascript1.4":
- case "text/javascript1.5":
- case "text/jscript":
- case "text/livescript":
- case "text/x-ecmascript":
- case "text/x-javascript":
- return "text/javascript";
- case "application/json":
- case "text/json":
- return "application/json";
- case "image/svg+xml":
- return "image/svg+xml";
- case "text/xml":
- case "application/xml":
- return "application/xml";
+ if (jsArrayBuffer.detached) {
+ return new Uint8Array(0);
}
- if (mimeType.subtype.endsWith("+json")) {
- return "application/json";
+ const bytes = new Uint8Array(length);
+ const view = new Uint8Array(jsArrayBuffer, offset, length);
+ bytes.set(view);
+ return bytes;
+ };
+ webidl.converters.DOMString = function(V, prefix, argument, flags) {
+ if (V === null && webidl.util.HasFlag(flags, webidl.attributes.LegacyNullToEmptyString)) {
+ return "";
}
- if (mimeType.subtype.endsWith("+xml")) {
- return "application/xml";
+ if (typeof V === "symbol") {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} is a symbol, which cannot be converted to a DOMString.`
+ });
}
- return "";
- }
- __name(minimizeSupportedMimeType, "minimizeSupportedMimeType");
- module2.exports = {
- dataURLProcessor,
- URLSerializer,
- stringPercentDecode,
- parseMIMEType,
- collectAnHTTPQuotedString,
- serializeAMimeType,
- removeHTTPWhitespace,
- minimizeSupportedMimeType,
- HTTP_TOKEN_CODEPOINTS
+ return String(V);
};
- }
-});
-
-// lib/web/webidl/index.js
-var require_webidl = __commonJS({
- "lib/web/webidl/index.js"(exports2, module2) {
- "use strict";
- var assert = require("node:assert");
- var { types, inspect } = require("node:util");
- var { markAsUncloneable } = require("node:worker_threads");
- var UNDEFINED = 1;
- var BOOLEAN = 2;
- var STRING = 3;
- var SYMBOL = 4;
- var NUMBER = 5;
- var BIGINT = 6;
- var NULL = 7;
- var OBJECT = 8;
- var FunctionPrototypeSymbolHasInstance = Function.call.bind(Function.prototype[Symbol.hasInstance]);
- var webidl = {
- converters: {},
- util: {},
- errors: {},
- is: {}
+ webidl.converters.ByteString = function(V, prefix, argument) {
+ if (typeof V === "symbol") {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} is a symbol, which cannot be converted to a ByteString.`
+ });
+ }
+ const x = String(V);
+ for (let index = 0; index < x.length; index++) {
+ if (x.charCodeAt(index) > 255) {
+ throw new TypeError(
+ `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`
+ );
+ }
+ }
+ return x;
};
- webidl.errors.exception = function(message) {
- return new TypeError(`${message.header}: ${message.message}`);
+ webidl.converters.USVString = function(value) {
+ if (typeof value === "string") {
+ return value.toWellFormed();
+ }
+ return `${value}`.toWellFormed();
};
- webidl.errors.conversionFailed = function(opts) {
- const plural = opts.types.length === 1 ? "" : " one of";
- const message = `${opts.argument} could not be converted to${plural}: ${opts.types.join(", ")}.`;
- return webidl.errors.exception({
- header: opts.prefix,
- message
- });
+ webidl.converters.boolean = function(V) {
+ const x = Boolean(V);
+ return x;
};
- webidl.errors.invalidArgument = function(context) {
- return webidl.errors.exception({
- header: context.prefix,
- message: `"${context.value}" is an invalid ${context.type}.`
- });
+ webidl.converters.any = function(V) {
+ return V;
};
- webidl.brandCheck = function(V, is) {
- if (!is(V)) {
- const err = new TypeError("Illegal invocation");
- err.code = "ERR_INVALID_THIS";
- throw err;
- }
+ webidl.converters["long long"] = function(V, prefix, argument) {
+ const x = webidl.util.ConvertToInt(V, 64, "signed", 0, prefix, argument);
+ return x;
};
- webidl.argumentLengthCheck = function({ length }, min, ctx) {
- if (length < min) {
- throw webidl.errors.exception({
- message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`,
- header: ctx
- });
- }
+ webidl.converters["unsigned long long"] = function(V, prefix, argument) {
+ const x = webidl.util.ConvertToInt(V, 64, "unsigned", 0, prefix, argument);
+ return x;
};
- webidl.illegalConstructor = function() {
- throw webidl.errors.exception({
- header: "TypeError",
- message: "Illegal constructor"
- });
+ webidl.converters["unsigned long"] = function(V, prefix, argument) {
+ const x = webidl.util.ConvertToInt(V, 32, "unsigned", 0, prefix, argument);
+ return x;
};
- webidl.util.MakeTypeAssertion = function(I) {
- return (O) => FunctionPrototypeSymbolHasInstance(I, O);
+ webidl.converters["unsigned short"] = function(V, prefix, argument, flags) {
+ const x = webidl.util.ConvertToInt(V, 16, "unsigned", flags, prefix, argument);
+ return x;
};
- webidl.util.Type = function(V) {
- switch (typeof V) {
- case "undefined":
- return UNDEFINED;
- case "boolean":
- return BOOLEAN;
- case "string":
- return STRING;
- case "symbol":
- return SYMBOL;
- case "number":
- return NUMBER;
- case "bigint":
- return BIGINT;
- case "function":
- case "object": {
- if (V === null) {
- return NULL;
- }
- return OBJECT;
- }
+ webidl.converters.ArrayBuffer = function(V, prefix, argument, flags) {
+ if (webidl.util.Type(V) !== OBJECT || !types.isArrayBuffer(V)) {
+ throw webidl.errors.conversionFailed({
+ prefix,
+ argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+ types: ["ArrayBuffer"]
+ });
+ }
+ if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} cannot be a resizable ArrayBuffer.`
+ });
}
+ return V;
};
- webidl.util.Types = {
- UNDEFINED,
- BOOLEAN,
- STRING,
- SYMBOL,
- NUMBER,
- BIGINT,
- NULL,
- OBJECT
- };
- webidl.util.TypeValueToString = function(o) {
- switch (webidl.util.Type(o)) {
- case UNDEFINED:
- return "Undefined";
- case BOOLEAN:
- return "Boolean";
- case STRING:
- return "String";
- case SYMBOL:
- return "Symbol";
- case NUMBER:
- return "Number";
- case BIGINT:
- return "BigInt";
- case NULL:
- return "Null";
- case OBJECT:
- return "Object";
+ webidl.converters.SharedArrayBuffer = function(V, prefix, argument, flags) {
+ if (webidl.util.Type(V) !== OBJECT || !types.isSharedArrayBuffer(V)) {
+ throw webidl.errors.conversionFailed({
+ prefix,
+ argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+ types: ["SharedArrayBuffer"]
+ });
+ }
+ if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} cannot be a resizable SharedArrayBuffer.`
+ });
}
+ return V;
};
- webidl.util.markAsUncloneable = markAsUncloneable;
- webidl.util.ConvertToInt = function(V, bitLength, signedness, flags) {
- let upperBound;
- let lowerBound;
- if (bitLength === 64) {
- upperBound = Math.pow(2, 53) - 1;
- if (signedness === "unsigned") {
- lowerBound = 0;
- } else {
- lowerBound = Math.pow(-2, 53) + 1;
- }
- } else if (signedness === "unsigned") {
- lowerBound = 0;
- upperBound = Math.pow(2, bitLength) - 1;
- } else {
- lowerBound = -Math.pow(2, bitLength - 1);
- upperBound = Math.pow(2, bitLength - 1) - 1;
+ webidl.converters.TypedArray = function(V, T, prefix, argument, flags) {
+ if (webidl.util.Type(V) !== OBJECT || !types.isTypedArray(V) || V.constructor.name !== T.name) {
+ throw webidl.errors.conversionFailed({
+ prefix,
+ argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+ types: [T.name]
+ });
}
- let x = Number(V);
- if (x === 0) {
- x = 0;
+ if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} cannot be a view on a shared array buffer.`
+ });
}
- if (webidl.util.HasFlag(flags, webidl.attributes.EnforceRange)) {
- if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
- throw webidl.errors.exception({
- header: "Integer conversion",
- message: `Could not convert ${webidl.util.Stringify(V)} to an integer.`
- });
- }
- x = webidl.util.IntegerPart(x);
- if (x < lowerBound || x > upperBound) {
- throw webidl.errors.exception({
- header: "Integer conversion",
- message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.`
- });
- }
- return x;
+ if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} cannot be a view on a resizable array buffer.`
+ });
}
- if (!Number.isNaN(x) && webidl.util.HasFlag(flags, webidl.attributes.Clamp)) {
- x = Math.min(Math.max(x, lowerBound), upperBound);
- if (Math.floor(x) % 2 === 0) {
- x = Math.floor(x);
- } else {
- x = Math.ceil(x);
- }
- return x;
+ return V;
+ };
+ webidl.converters.DataView = function(V, prefix, argument, flags) {
+ if (webidl.util.Type(V) !== OBJECT || !types.isDataView(V)) {
+ throw webidl.errors.conversionFailed({
+ prefix,
+ argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+ types: ["DataView"]
+ });
}
- if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
- return 0;
+ if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} cannot be a view on a shared array buffer.`
+ });
}
- x = webidl.util.IntegerPart(x);
- x = x % Math.pow(2, bitLength);
- if (signedness === "signed" && x >= Math.pow(2, bitLength - 1)) {
- return x - Math.pow(2, bitLength);
+ if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} cannot be a view on a resizable array buffer.`
+ });
}
- return x;
+ return V;
};
- webidl.util.IntegerPart = function(n) {
- const r = Math.floor(Math.abs(n));
- if (n < 0) {
- return -1 * r;
+ webidl.converters.ArrayBufferView = function(V, prefix, argument, flags) {
+ if (webidl.util.Type(V) !== OBJECT || !types.isArrayBufferView(V)) {
+ throw webidl.errors.conversionFailed({
+ prefix,
+ argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+ types: ["ArrayBufferView"]
+ });
}
- return r;
- };
- webidl.util.Stringify = function(V) {
- const type = webidl.util.Type(V);
- switch (type) {
- case SYMBOL:
- return `Symbol(${V.description})`;
- case OBJECT:
- return inspect(V);
- case STRING:
- return `"${V}"`;
- case BIGINT:
- return `${V}n`;
- default:
- return `${V}`;
+ if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} cannot be a view on a shared array buffer.`
+ });
+ }
+ if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} cannot be a view on a resizable array buffer.`
+ });
}
+ return V;
};
- webidl.util.IsResizableArrayBuffer = function(V) {
+ webidl.converters.BufferSource = function(V, prefix, argument, flags) {
if (types.isArrayBuffer(V)) {
- return V.resizable;
+ return webidl.converters.ArrayBuffer(V, prefix, argument, flags);
+ }
+ if (types.isArrayBufferView(V)) {
+ flags &= ~webidl.attributes.AllowShared;
+ return webidl.converters.ArrayBufferView(V, prefix, argument, flags);
}
if (types.isSharedArrayBuffer(V)) {
- return V.growable;
+ throw webidl.errors.exception({
+ header: prefix,
+ message: `${argument} cannot be a SharedArrayBuffer.`
+ });
}
- throw webidl.errors.exception({
- header: "IsResizableArrayBuffer",
- message: `"${webidl.util.Stringify(V)}" is not an array buffer.`
+ throw webidl.errors.conversionFailed({
+ prefix,
+ argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+ types: ["ArrayBuffer", "ArrayBufferView"]
});
};
- webidl.util.HasFlag = function(flags, attributes) {
- return typeof flags === "number" && (flags & attributes) === attributes;
+ webidl.converters.AllowSharedBufferSource = function(V, prefix, argument, flags) {
+ if (types.isArrayBuffer(V)) {
+ return webidl.converters.ArrayBuffer(V, prefix, argument, flags);
+ }
+ if (types.isSharedArrayBuffer(V)) {
+ return webidl.converters.SharedArrayBuffer(V, prefix, argument, flags);
+ }
+ if (types.isArrayBufferView(V)) {
+ flags |= webidl.attributes.AllowShared;
+ return webidl.converters.ArrayBufferView(V, prefix, argument, flags);
+ }
+ throw webidl.errors.conversionFailed({
+ prefix,
+ argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+ types: ["ArrayBuffer", "SharedArrayBuffer", "ArrayBufferView"]
+ });
};
- webidl.sequenceConverter = function(converter) {
- return (V, prefix, argument, Iterable) => {
- if (webidl.util.Type(V) !== OBJECT) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.`
- });
- }
- const method = typeof Iterable === "function" ? Iterable() : V?.[Symbol.iterator]?.();
- const seq = [];
- let index = 0;
- if (method === void 0 || typeof method.next !== "function") {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} is not iterable.`
- });
- }
- while (true) {
- const { done, value } = method.next();
- if (done) {
- break;
- }
- seq.push(converter(value, prefix, `${argument}[${index++}]`));
- }
- return seq;
+ webidl.converters["sequence<ByteString>"] = webidl.sequenceConverter(
+ webidl.converters.ByteString
+ );
+ webidl.converters["sequence<sequence<ByteString>>"] = webidl.sequenceConverter(
+ webidl.converters["sequence<ByteString>"]
+ );
+ webidl.converters["record<ByteString, ByteString>"] = webidl.recordConverter(
+ webidl.converters.ByteString,
+ webidl.converters.ByteString
+ );
+ webidl.converters.Blob = webidl.interfaceConverter(webidl.is.Blob, "Blob");
+ webidl.converters.AbortSignal = webidl.interfaceConverter(
+ webidl.is.AbortSignal,
+ "AbortSignal"
+ );
+ webidl.converters.EventHandlerNonNull = function(V) {
+ if (webidl.util.Type(V) !== OBJECT) {
+ return null;
+ }
+ if (typeof V === "function") {
+ return V;
+ }
+ return () => {
};
};
- webidl.recordConverter = function(keyConverter, valueConverter) {
- return (O, prefix, argument) => {
- if (webidl.util.Type(O) !== OBJECT) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} ("${webidl.util.TypeValueToString(O)}") is not an Object.`
- });
- }
- const result = {};
- if (!types.isProxy(O)) {
- const keys2 = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)];
- for (const key of keys2) {
- const keyName = webidl.util.Stringify(key);
- const typedKey = keyConverter(key, prefix, `Key ${keyName} in ${argument}`);
- const typedValue = valueConverter(O[key], prefix, `${argument}[${keyName}]`);
- result[typedKey] = typedValue;
- }
- return result;
- }
- const keys = Reflect.ownKeys(O);
- for (const key of keys) {
- const desc = Reflect.getOwnPropertyDescriptor(O, key);
- if (desc?.enumerable) {
- const typedKey = keyConverter(key, prefix, argument);
- const typedValue = valueConverter(O[key], prefix, argument);
- result[typedKey] = typedValue;
- }
- }
- return result;
- };
- };
- webidl.interfaceConverter = function(TypeCheck, name) {
- return (V, prefix, argument) => {
- if (!TypeCheck(V)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${name}.`
- });
- }
- return V;
- };
+ webidl.attributes = {
+ Clamp: 1 << 0,
+ EnforceRange: 1 << 1,
+ AllowShared: 1 << 2,
+ AllowResizable: 1 << 3,
+ LegacyNullToEmptyString: 1 << 4
};
- webidl.dictionaryConverter = function(converters) {
- converters.sort((a, b) => (a.key > b.key) - (a.key < b.key));
- return (dictionary, prefix, argument) => {
- const dict = {};
- if (dictionary != null && webidl.util.Type(dictionary) !== OBJECT) {
- throw webidl.errors.exception({
- header: prefix,
- message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
- });
- }
- for (const options of converters) {
- const { key, defaultValue, required, converter } = options;
- if (required === true) {
- if (dictionary == null || !Object.hasOwn(dictionary, key)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `Missing required key "${key}".`
- });
- }
- }
- let value = dictionary?.[key];
- const hasDefault = defaultValue !== void 0;
- if (hasDefault && value === void 0) {
- value = defaultValue();
- }
- if (required || hasDefault || value !== void 0) {
- value = converter(value, prefix, `${argument}.${key}`);
- if (options.allowedValues && !options.allowedValues.includes(value)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.`
- });
- }
- dict[key] = value;
- }
- }
- return dict;
- };
+ module2.exports = {
+ webidl
};
- webidl.nullableConverter = function(converter) {
- return (V, prefix, argument) => {
- if (V === null) {
- return V;
+ }
+});
+
+// lib/web/fetch/util.js
+var require_util2 = __commonJS({
+ "lib/web/fetch/util.js"(exports2, module2) {
+ "use strict";
+ var { Transform } = require("node:stream");
+ var zlib = require("node:zlib");
+ var { redirectStatusSet, referrerPolicyTokens, badPortsSet } = require_constants2();
+ var { getGlobalOrigin } = require_global();
+ var { collectAnHTTPQuotedString, parseMIMEType } = require_data_url();
+ var { performance: performance2 } = require("node:perf_hooks");
+ var { isValidHTTPToken, normalizedMethodRecordsBase } = require_util();
+ var assert = require("node:assert");
+ var { isUint8Array } = require("node:util/types");
+ var { webidl } = require_webidl();
+ var { isomorphicEncode, collectASequenceOfCodePoints, removeChars } = require_infra();
+ function responseURL(response) {
+ const urlList = response.urlList;
+ const length = urlList.length;
+ return length === 0 ? null : urlList[length - 1].toString();
+ }
+ __name(responseURL, "responseURL");
+ function responseLocationURL(response, requestFragment) {
+ if (!redirectStatusSet.has(response.status)) {
+ return null;
+ }
+ let location = response.headersList.get("location", true);
+ if (location !== null && isValidHeaderValue(location)) {
+ if (!isValidEncodedURL(location)) {
+ location = normalizeBinaryStringToUtf8(location);
}
- return converter(V, prefix, argument);
- };
- };
- webidl.is.USVString = function(value) {
- return typeof value === "string" && value.isWellFormed();
- };
- webidl.is.ReadableStream = webidl.util.MakeTypeAssertion(ReadableStream);
- webidl.is.Blob = webidl.util.MakeTypeAssertion(Blob);
- webidl.is.URLSearchParams = webidl.util.MakeTypeAssertion(URLSearchParams);
- webidl.is.File = webidl.util.MakeTypeAssertion(File);
- webidl.is.URL = webidl.util.MakeTypeAssertion(URL);
- webidl.is.AbortSignal = webidl.util.MakeTypeAssertion(AbortSignal);
- webidl.is.MessagePort = webidl.util.MakeTypeAssertion(MessagePort);
- webidl.is.BufferSource = function(V) {
- return types.isArrayBuffer(V) || ArrayBuffer.isView(V) && types.isArrayBuffer(V.buffer);
- };
- webidl.util.getCopyOfBytesHeldByBufferSource = function(bufferSource) {
- const jsBufferSource = bufferSource;
- let jsArrayBuffer = jsBufferSource;
- let offset = 0;
- let length = 0;
- if (types.isTypedArray(jsBufferSource) || types.isDataView(jsBufferSource)) {
- jsArrayBuffer = jsBufferSource.buffer;
- offset = jsBufferSource.byteOffset;
- length = jsBufferSource.byteLength;
- } else {
- assert(types.isAnyArrayBuffer(jsBufferSource));
- length = jsBufferSource.byteLength;
+ location = new URL(location, responseURL(response));
}
- if (jsArrayBuffer.detached) {
- return new Uint8Array(0);
+ if (location && !location.hash) {
+ location.hash = requestFragment;
}
- const bytes = new Uint8Array(length);
- const view = new Uint8Array(jsArrayBuffer, offset, length);
- bytes.set(view);
- return bytes;
- };
- webidl.converters.DOMString = function(V, prefix, argument, flags) {
- if (V === null && webidl.util.HasFlag(flags, webidl.attributes.LegacyNullToEmptyString)) {
- return "";
+ return location;
+ }
+ __name(responseLocationURL, "responseLocationURL");
+ function isValidEncodedURL(url) {
+ for (let i = 0; i < url.length; ++i) {
+ const code = url.charCodeAt(i);
+ if (code > 126 || // Non-US-ASCII + DEL
+ code < 32) {
+ return false;
+ }
}
- if (typeof V === "symbol") {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} is a symbol, which cannot be converted to a DOMString.`
- });
+ return true;
+ }
+ __name(isValidEncodedURL, "isValidEncodedURL");
+ function normalizeBinaryStringToUtf8(value) {
+ return Buffer.from(value, "binary").toString("utf8");
+ }
+ __name(normalizeBinaryStringToUtf8, "normalizeBinaryStringToUtf8");
+ function requestCurrentURL(request) {
+ return request.urlList[request.urlList.length - 1];
+ }
+ __name(requestCurrentURL, "requestCurrentURL");
+ function requestBadPort(request) {
+ const url = requestCurrentURL(request);
+ if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
+ return "blocked";
}
- return String(V);
- };
- webidl.converters.ByteString = function(V, prefix, argument) {
- if (typeof V === "symbol") {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} is a symbol, which cannot be converted to a ByteString.`
- });
+ return "allowed";
+ }
+ __name(requestBadPort, "requestBadPort");
+ function isErrorLike(object) {
+ return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
+ }
+ __name(isErrorLike, "isErrorLike");
+ function isValidReasonPhrase(statusText) {
+ for (let i = 0; i < statusText.length; ++i) {
+ const c = statusText.charCodeAt(i);
+ if (!(c === 9 || // HTAB
+ c >= 32 && c <= 126 || // SP / VCHAR
+ c >= 128 && c <= 255)) {
+ return false;
+ }
}
- const x = String(V);
- for (let index = 0; index < x.length; index++) {
- if (x.charCodeAt(index) > 255) {
- throw new TypeError(
- `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`
- );
+ return true;
+ }
+ __name(isValidReasonPhrase, "isValidReasonPhrase");
+ var isValidHeaderName = isValidHTTPToken;
+ function isValidHeaderValue(potentialValue) {
+ return (potentialValue[0] === " " || potentialValue[0] === " " || potentialValue[potentialValue.length - 1] === " " || potentialValue[potentialValue.length - 1] === " " || potentialValue.includes("\n") || potentialValue.includes("\r") || potentialValue.includes("\0")) === false;
+ }
+ __name(isValidHeaderValue, "isValidHeaderValue");
+ function parseReferrerPolicy(actualResponse) {
+ const policyHeader = (actualResponse.headersList.get("referrer-policy", true) ?? "").split(",");
+ let policy = "";
+ if (policyHeader.length) {
+ for (let i = policyHeader.length; i !== 0; i--) {
+ const token = policyHeader[i - 1].trim();
+ if (referrerPolicyTokens.has(token)) {
+ policy = token;
+ break;
+ }
}
}
- return x;
- };
- webidl.converters.USVString = function(value) {
- if (typeof value === "string") {
- return value.toWellFormed();
+ return policy;
+ }
+ __name(parseReferrerPolicy, "parseReferrerPolicy");
+ function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
+ const policy = parseReferrerPolicy(actualResponse);
+ if (policy !== "") {
+ request.referrerPolicy = policy;
}
- return `${value}`.toWellFormed();
- };
- webidl.converters.boolean = function(V) {
- const x = Boolean(V);
- return x;
- };
- webidl.converters.any = function(V) {
- return V;
- };
- webidl.converters["long long"] = function(V, prefix, argument) {
- const x = webidl.util.ConvertToInt(V, 64, "signed", 0, prefix, argument);
- return x;
- };
- webidl.converters["unsigned long long"] = function(V, prefix, argument) {
- const x = webidl.util.ConvertToInt(V, 64, "unsigned", 0, prefix, argument);
- return x;
- };
- webidl.converters["unsigned long"] = function(V, prefix, argument) {
- const x = webidl.util.ConvertToInt(V, 32, "unsigned", 0, prefix, argument);
- return x;
- };
- webidl.converters["unsigned short"] = function(V, prefix, argument, flags) {
- const x = webidl.util.ConvertToInt(V, 16, "unsigned", flags, prefix, argument);
- return x;
- };
- webidl.converters.ArrayBuffer = function(V, prefix, argument, flags) {
- if (webidl.util.Type(V) !== OBJECT || !types.isArrayBuffer(V)) {
- throw webidl.errors.conversionFailed({
- prefix,
- argument: `${argument} ("${webidl.util.Stringify(V)}")`,
- types: ["ArrayBuffer"]
- });
+ }
+ __name(setRequestReferrerPolicyOnRedirect, "setRequestReferrerPolicyOnRedirect");
+ function crossOriginResourcePolicyCheck() {
+ return "allowed";
+ }
+ __name(crossOriginResourcePolicyCheck, "crossOriginResourcePolicyCheck");
+ function corsCheck() {
+ return "success";
+ }
+ __name(corsCheck, "corsCheck");
+ function TAOCheck() {
+ return "success";
+ }
+ __name(TAOCheck, "TAOCheck");
+ function appendFetchMetadata(httpRequest) {
+ if (!isURLPotentiallyTrustworthy(requestCurrentURL(httpRequest))) {
+ return;
}
- if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} cannot be a resizable ArrayBuffer.`
- });
+ let header = null;
+ header = httpRequest.mode;
+ httpRequest.headersList.set("sec-fetch-mode", header, true);
+ }
+ __name(appendFetchMetadata, "appendFetchMetadata");
+ function appendRequestOriginHeader(request) {
+ let serializedOrigin = request.origin;
+ if (serializedOrigin === "client" || serializedOrigin === void 0) {
+ return;
}
- return V;
- };
- webidl.converters.SharedArrayBuffer = function(V, prefix, argument, flags) {
- if (webidl.util.Type(V) !== OBJECT || !types.isSharedArrayBuffer(V)) {
- throw webidl.errors.conversionFailed({
- prefix,
- argument: `${argument} ("${webidl.util.Stringify(V)}")`,
- types: ["SharedArrayBuffer"]
- });
+ if (request.responseTainting === "cors" || request.mode === "websocket") {
+ request.headersList.append("origin", serializedOrigin, true);
+ } else if (request.method !== "GET" && request.method !== "HEAD") {
+ switch (request.referrerPolicy) {
+ case "no-referrer":
+ serializedOrigin = null;
+ break;
+ case "no-referrer-when-downgrade":
+ case "strict-origin":
+ case "strict-origin-when-cross-origin":
+ if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) {
+ serializedOrigin = null;
+ }
+ break;
+ case "same-origin":
+ if (!sameOrigin(request, requestCurrentURL(request))) {
+ serializedOrigin = null;
+ }
+ break;
+ default:
+ }
+ request.headersList.append("origin", serializedOrigin, true);
}
- if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} cannot be a resizable SharedArrayBuffer.`
- });
+ }
+ __name(appendRequestOriginHeader, "appendRequestOriginHeader");
+ function coarsenTime(timestamp, crossOriginIsolatedCapability) {
+ return timestamp;
+ }
+ __name(coarsenTime, "coarsenTime");
+ function clampAndCoarsenConnectionTimingInfo(connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) {
+ if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) {
+ return {
+ domainLookupStartTime: defaultStartTime,
+ domainLookupEndTime: defaultStartTime,
+ connectionStartTime: defaultStartTime,
+ connectionEndTime: defaultStartTime,
+ secureConnectionStartTime: defaultStartTime,
+ ALPNNegotiatedProtocol: connectionTimingInfo?.ALPNNegotiatedProtocol
+ };
}
- return V;
- };
- webidl.converters.TypedArray = function(V, T, prefix, argument, flags) {
- if (webidl.util.Type(V) !== OBJECT || !types.isTypedArray(V) || V.constructor.name !== T.name) {
- throw webidl.errors.conversionFailed({
- prefix,
- argument: `${argument} ("${webidl.util.Stringify(V)}")`,
- types: [T.name]
- });
+ return {
+ domainLookupStartTime: coarsenTime(connectionTimingInfo.domainLookupStartTime, crossOriginIsolatedCapability),
+ domainLookupEndTime: coarsenTime(connectionTimingInfo.domainLookupEndTime, crossOriginIsolatedCapability),
+ connectionStartTime: coarsenTime(connectionTimingInfo.connectionStartTime, crossOriginIsolatedCapability),
+ connectionEndTime: coarsenTime(connectionTimingInfo.connectionEndTime, crossOriginIsolatedCapability),
+ secureConnectionStartTime: coarsenTime(connectionTimingInfo.secureConnectionStartTime, crossOriginIsolatedCapability),
+ ALPNNegotiatedProtocol: connectionTimingInfo.ALPNNegotiatedProtocol
+ };
+ }
+ __name(clampAndCoarsenConnectionTimingInfo, "clampAndCoarsenConnectionTimingInfo");
+ function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
+ return coarsenTime(performance2.now(), crossOriginIsolatedCapability);
+ }
+ __name(coarsenedSharedCurrentTime, "coarsenedSharedCurrentTime");
+ function createOpaqueTimingInfo(timingInfo) {
+ return {
+ startTime: timingInfo.startTime ?? 0,
+ redirectStartTime: 0,
+ redirectEndTime: 0,
+ postRedirectStartTime: timingInfo.startTime ?? 0,
+ finalServiceWorkerStartTime: 0,
+ finalNetworkResponseStartTime: 0,
+ finalNetworkRequestStartTime: 0,
+ endTime: 0,
+ encodedBodySize: 0,
+ decodedBodySize: 0,
+ finalConnectionTimingInfo: null
+ };
+ }
+ __name(createOpaqueTimingInfo, "createOpaqueTimingInfo");
+ function makePolicyContainer() {
+ return {
+ referrerPolicy: "strict-origin-when-cross-origin"
+ };
+ }
+ __name(makePolicyContainer, "makePolicyContainer");
+ function clonePolicyContainer(policyContainer) {
+ return {
+ referrerPolicy: policyContainer.referrerPolicy
+ };
+ }
+ __name(clonePolicyContainer, "clonePolicyContainer");
+ function determineRequestsReferrer(request) {
+ const policy = request.referrerPolicy;
+ assert(policy);
+ let referrerSource = null;
+ if (request.referrer === "client") {
+ const globalOrigin = getGlobalOrigin();
+ if (!globalOrigin || globalOrigin.origin === "null") {
+ return "no-referrer";
+ }
+ referrerSource = new URL(globalOrigin);
+ } else if (webidl.is.URL(request.referrer)) {
+ referrerSource = request.referrer;
}
- if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} cannot be a view on a shared array buffer.`
- });
+ let referrerURL = stripURLForReferrer(referrerSource);
+ const referrerOrigin = stripURLForReferrer(referrerSource, true);
+ if (referrerURL.toString().length > 4096) {
+ referrerURL = referrerOrigin;
}
- if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} cannot be a view on a resizable array buffer.`
- });
+ switch (policy) {
+ case "no-referrer":
+ return "no-referrer";
+ case "origin":
+ if (referrerOrigin != null) {
+ return referrerOrigin;
+ }
+ return stripURLForReferrer(referrerSource, true);
+ case "unsafe-url":
+ return referrerURL;
+ case "strict-origin": {
+ const currentURL = requestCurrentURL(request);
+ if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
+ return "no-referrer";
+ }
+ return referrerOrigin;
+ }
+ case "strict-origin-when-cross-origin": {
+ const currentURL = requestCurrentURL(request);
+ if (sameOrigin(referrerURL, currentURL)) {
+ return referrerURL;
+ }
+ if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
+ return "no-referrer";
+ }
+ return referrerOrigin;
+ }
+ case "same-origin":
+ if (sameOrigin(request, referrerURL)) {
+ return referrerURL;
+ }
+ return "no-referrer";
+ case "origin-when-cross-origin":
+ if (sameOrigin(request, referrerURL)) {
+ return referrerURL;
+ }
+ return referrerOrigin;
+ case "no-referrer-when-downgrade": {
+ const currentURL = requestCurrentURL(request);
+ if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
+ return "no-referrer";
+ }
+ return referrerURL;
+ }
}
- return V;
- };
- webidl.converters.DataView = function(V, prefix, argument, flags) {
- if (webidl.util.Type(V) !== OBJECT || !types.isDataView(V)) {
- throw webidl.errors.conversionFailed({
- prefix,
- argument: `${argument} ("${webidl.util.Stringify(V)}")`,
- types: ["DataView"]
- });
+ }
+ __name(determineRequestsReferrer, "determineRequestsReferrer");
+ function stripURLForReferrer(url, originOnly = false) {
+ assert(webidl.is.URL(url));
+ url = new URL(url);
+ if (urlIsLocal(url)) {
+ return "no-referrer";
}
- if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} cannot be a view on a shared array buffer.`
- });
+ url.username = "";
+ url.password = "";
+ url.hash = "";
+ if (originOnly === true) {
+ url.pathname = "";
+ url.search = "";
}
- if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} cannot be a view on a resizable array buffer.`
- });
- }
- return V;
- };
- webidl.converters.ArrayBufferView = function(V, prefix, argument, flags) {
- if (webidl.util.Type(V) !== OBJECT || !types.isArrayBufferView(V)) {
- throw webidl.errors.conversionFailed({
- prefix,
- argument: `${argument} ("${webidl.util.Stringify(V)}")`,
- types: ["ArrayBufferView"]
- });
- }
- if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} cannot be a view on a shared array buffer.`
- });
- }
- if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} cannot be a view on a resizable array buffer.`
- });
- }
- return V;
- };
- webidl.converters.BufferSource = function(V, prefix, argument, flags) {
- if (types.isArrayBuffer(V)) {
- return webidl.converters.ArrayBuffer(V, prefix, argument, flags);
- }
- if (types.isArrayBufferView(V)) {
- flags &= ~webidl.attributes.AllowShared;
- return webidl.converters.ArrayBufferView(V, prefix, argument, flags);
- }
- if (types.isSharedArrayBuffer(V)) {
- throw webidl.errors.exception({
- header: prefix,
- message: `${argument} cannot be a SharedArrayBuffer.`
- });
- }
- throw webidl.errors.conversionFailed({
- prefix,
- argument: `${argument} ("${webidl.util.Stringify(V)}")`,
- types: ["ArrayBuffer", "ArrayBufferView"]
- });
- };
- webidl.converters.AllowSharedBufferSource = function(V, prefix, argument, flags) {
- if (types.isArrayBuffer(V)) {
- return webidl.converters.ArrayBuffer(V, prefix, argument, flags);
- }
- if (types.isSharedArrayBuffer(V)) {
- return webidl.converters.SharedArrayBuffer(V, prefix, argument, flags);
+ return url;
+ }
+ __name(stripURLForReferrer, "stripURLForReferrer");
+ var isPotentialleTrustworthyIPv4 = RegExp.prototype.test.bind(/^127\.(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){2}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)$/);
+ var isPotentiallyTrustworthyIPv6 = RegExp.prototype.test.bind(/^(?:(?:0{1,4}:){7}|(?:0{1,4}:){1,6}:|::)0{0,3}1$/);
+ function isOriginIPPotentiallyTrustworthy(origin) {
+ if (origin.includes(":")) {
+ if (origin[0] === "[" && origin[origin.length - 1] === "]") {
+ origin = origin.slice(1, -1);
+ }
+ return isPotentiallyTrustworthyIPv6(origin);
}
- if (types.isArrayBufferView(V)) {
- flags |= webidl.attributes.AllowShared;
- return webidl.converters.ArrayBufferView(V, prefix, argument, flags);
+ return isPotentialleTrustworthyIPv4(origin);
+ }
+ __name(isOriginIPPotentiallyTrustworthy, "isOriginIPPotentiallyTrustworthy");
+ function isOriginPotentiallyTrustworthy(origin) {
+ if (origin == null || origin === "null") {
+ return false;
}
- throw webidl.errors.conversionFailed({
- prefix,
- argument: `${argument} ("${webidl.util.Stringify(V)}")`,
- types: ["ArrayBuffer", "SharedArrayBuffer", "ArrayBufferView"]
- });
- };
- webidl.converters["sequence<ByteString>"] = webidl.sequenceConverter(
- webidl.converters.ByteString
- );
- webidl.converters["sequence<sequence<ByteString>>"] = webidl.sequenceConverter(
- webidl.converters["sequence<ByteString>"]
- );
- webidl.converters["record<ByteString, ByteString>"] = webidl.recordConverter(
- webidl.converters.ByteString,
- webidl.converters.ByteString
- );
- webidl.converters.Blob = webidl.interfaceConverter(webidl.is.Blob, "Blob");
- webidl.converters.AbortSignal = webidl.interfaceConverter(
- webidl.is.AbortSignal,
- "AbortSignal"
- );
- webidl.converters.EventHandlerNonNull = function(V) {
- if (webidl.util.Type(V) !== OBJECT) {
- return null;
+ origin = new URL(origin);
+ if (origin.protocol === "https:" || origin.protocol === "wss:") {
+ return true;
}
- if (typeof V === "function") {
- return V;
+ if (isOriginIPPotentiallyTrustworthy(origin.hostname)) {
+ return true;
}
- return () => {
- };
- };
- webidl.attributes = {
- Clamp: 1 << 0,
- EnforceRange: 1 << 1,
- AllowShared: 1 << 2,
- AllowResizable: 1 << 3,
- LegacyNullToEmptyString: 1 << 4
- };
- module2.exports = {
- webidl
- };
- }
-});
-
-// lib/web/fetch/util.js
-var require_util2 = __commonJS({
- "lib/web/fetch/util.js"(exports2, module2) {
- "use strict";
- var { Transform } = require("node:stream");
- var zlib = require("node:zlib");
- var { redirectStatusSet, referrerPolicyTokens, badPortsSet } = require_constants3();
- var { getGlobalOrigin } = require_global();
- var { collectAnHTTPQuotedString, parseMIMEType } = require_data_url();
- var { performance: performance2 } = require("node:perf_hooks");
- var { isValidHTTPToken, normalizedMethodRecordsBase } = require_util();
- var assert = require("node:assert");
- var { isUint8Array } = require("node:util/types");
- var { webidl } = require_webidl();
- var { isomorphicEncode, collectASequenceOfCodePoints, removeChars } = require_infra();
- function responseURL(response) {
- const urlList = response.urlList;
- const length = urlList.length;
- return length === 0 ? null : urlList[length - 1].toString();
- }
- __name(responseURL, "responseURL");
- function responseLocationURL(response, requestFragment) {
- if (!redirectStatusSet.has(response.status)) {
- return null;
+ if (origin.hostname === "localhost" || origin.hostname === "localhost.") {
+ return true;
}
- let location = response.headersList.get("location", true);
- if (location !== null && isValidHeaderValue(location)) {
- if (!isValidEncodedURL(location)) {
- location = normalizeBinaryStringToUtf8(location);
- }
- location = new URL(location, responseURL(response));
+ if (origin.hostname.endsWith(".localhost") || origin.hostname.endsWith(".localhost.")) {
+ return true;
}
- if (location && !location.hash) {
- location.hash = requestFragment;
+ if (origin.protocol === "file:") {
+ return true;
}
- return location;
+ return false;
}
- __name(responseLocationURL, "responseLocationURL");
- function isValidEncodedURL(url) {
- for (let i = 0; i < url.length; ++i) {
- const code = url.charCodeAt(i);
- if (code > 126 || // Non-US-ASCII + DEL
- code < 32) {
- return false;
- }
+ __name(isOriginPotentiallyTrustworthy, "isOriginPotentiallyTrustworthy");
+ function isURLPotentiallyTrustworthy(url) {
+ if (!webidl.is.URL(url)) {
+ return false;
}
- return true;
- }
- __name(isValidEncodedURL, "isValidEncodedURL");
- function normalizeBinaryStringToUtf8(value) {
- return Buffer.from(value, "binary").toString("utf8");
- }
- __name(normalizeBinaryStringToUtf8, "normalizeBinaryStringToUtf8");
- function requestCurrentURL(request) {
- return request.urlList[request.urlList.length - 1];
- }
- __name(requestCurrentURL, "requestCurrentURL");
- function requestBadPort(request) {
- const url = requestCurrentURL(request);
- if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
- return "blocked";
+ if (url.href === "about:blank" || url.href === "about:srcdoc") {
+ return true;
}
- return "allowed";
+ if (url.protocol === "data:") return true;
+ if (url.protocol === "blob:") return true;
+ return isOriginPotentiallyTrustworthy(url.origin);
}
- __name(requestBadPort, "requestBadPort");
- function isErrorLike(object) {
- return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
+ __name(isURLPotentiallyTrustworthy, "isURLPotentiallyTrustworthy");
+ function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {
}
- __name(isErrorLike, "isErrorLike");
- function isValidReasonPhrase(statusText) {
- for (let i = 0; i < statusText.length; ++i) {
- const c = statusText.charCodeAt(i);
- if (!(c === 9 || // HTAB
- c >= 32 && c <= 126 || // SP / VCHAR
- c >= 128 && c <= 255)) {
- return false;
- }
+ __name(tryUpgradeRequestToAPotentiallyTrustworthyURL, "tryUpgradeRequestToAPotentiallyTrustworthyURL");
+ function sameOrigin(A, B) {
+ if (A.origin === B.origin && A.origin === "null") {
+ return true;
}
- return true;
- }
- __name(isValidReasonPhrase, "isValidReasonPhrase");
- var isValidHeaderName = isValidHTTPToken;
- function isValidHeaderValue(potentialValue) {
- return (potentialValue[0] === " " || potentialValue[0] === " " || potentialValue[potentialValue.length - 1] === " " || potentialValue[potentialValue.length - 1] === " " || potentialValue.includes("\n") || potentialValue.includes("\r") || potentialValue.includes("\0")) === false;
- }
- __name(isValidHeaderValue, "isValidHeaderValue");
- function parseReferrerPolicy(actualResponse) {
- const policyHeader = (actualResponse.headersList.get("referrer-policy", true) ?? "").split(",");
- let policy = "";
- if (policyHeader.length) {
- for (let i = policyHeader.length; i !== 0; i--) {
- const token = policyHeader[i - 1].trim();
- if (referrerPolicyTokens.has(token)) {
- policy = token;
- break;
- }
- }
+ if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
+ return true;
}
- return policy;
+ return false;
}
- __name(parseReferrerPolicy, "parseReferrerPolicy");
- function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
- const policy = parseReferrerPolicy(actualResponse);
- if (policy !== "") {
- request.referrerPolicy = policy;
- }
+ __name(sameOrigin, "sameOrigin");
+ function isAborted(fetchParams) {
+ return fetchParams.controller.state === "aborted";
}
- __name(setRequestReferrerPolicyOnRedirect, "setRequestReferrerPolicyOnRedirect");
- function crossOriginResourcePolicyCheck() {
- return "allowed";
+ __name(isAborted, "isAborted");
+ function isCancelled(fetchParams) {
+ return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
}
- __name(crossOriginResourcePolicyCheck, "crossOriginResourcePolicyCheck");
- function corsCheck() {
- return "success";
- }
- __name(corsCheck, "corsCheck");
- function TAOCheck() {
- return "success";
- }
- __name(TAOCheck, "TAOCheck");
- function appendFetchMetadata(httpRequest) {
- if (!isURLPotentiallyTrustworthy(requestCurrentURL(httpRequest))) {
- return;
- }
- let header = null;
- header = httpRequest.mode;
- httpRequest.headersList.set("sec-fetch-mode", header, true);
- }
- __name(appendFetchMetadata, "appendFetchMetadata");
- function appendRequestOriginHeader(request) {
- let serializedOrigin = request.origin;
- if (serializedOrigin === "client" || serializedOrigin === void 0) {
- return;
- }
- if (request.responseTainting === "cors" || request.mode === "websocket") {
- request.headersList.append("origin", serializedOrigin, true);
- } else if (request.method !== "GET" && request.method !== "HEAD") {
- switch (request.referrerPolicy) {
- case "no-referrer":
- serializedOrigin = null;
- break;
- case "no-referrer-when-downgrade":
- case "strict-origin":
- case "strict-origin-when-cross-origin":
- if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) {
- serializedOrigin = null;
- }
- break;
- case "same-origin":
- if (!sameOrigin(request, requestCurrentURL(request))) {
- serializedOrigin = null;
- }
- break;
- default:
- }
- request.headersList.append("origin", serializedOrigin, true);
- }
- }
- __name(appendRequestOriginHeader, "appendRequestOriginHeader");
- function coarsenTime(timestamp, crossOriginIsolatedCapability) {
- return timestamp;
- }
- __name(coarsenTime, "coarsenTime");
- function clampAndCoarsenConnectionTimingInfo(connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) {
- if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) {
- return {
- domainLookupStartTime: defaultStartTime,
- domainLookupEndTime: defaultStartTime,
- connectionStartTime: defaultStartTime,
- connectionEndTime: defaultStartTime,
- secureConnectionStartTime: defaultStartTime,
- ALPNNegotiatedProtocol: connectionTimingInfo?.ALPNNegotiatedProtocol
- };
- }
- return {
- domainLookupStartTime: coarsenTime(connectionTimingInfo.domainLookupStartTime, crossOriginIsolatedCapability),
- domainLookupEndTime: coarsenTime(connectionTimingInfo.domainLookupEndTime, crossOriginIsolatedCapability),
- connectionStartTime: coarsenTime(connectionTimingInfo.connectionStartTime, crossOriginIsolatedCapability),
- connectionEndTime: coarsenTime(connectionTimingInfo.connectionEndTime, crossOriginIsolatedCapability),
- secureConnectionStartTime: coarsenTime(connectionTimingInfo.secureConnectionStartTime, crossOriginIsolatedCapability),
- ALPNNegotiatedProtocol: connectionTimingInfo.ALPNNegotiatedProtocol
- };
- }
- __name(clampAndCoarsenConnectionTimingInfo, "clampAndCoarsenConnectionTimingInfo");
- function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
- return coarsenTime(performance2.now(), crossOriginIsolatedCapability);
- }
- __name(coarsenedSharedCurrentTime, "coarsenedSharedCurrentTime");
- function createOpaqueTimingInfo(timingInfo) {
- return {
- startTime: timingInfo.startTime ?? 0,
- redirectStartTime: 0,
- redirectEndTime: 0,
- postRedirectStartTime: timingInfo.startTime ?? 0,
- finalServiceWorkerStartTime: 0,
- finalNetworkResponseStartTime: 0,
- finalNetworkRequestStartTime: 0,
- endTime: 0,
- encodedBodySize: 0,
- decodedBodySize: 0,
- finalConnectionTimingInfo: null
- };
- }
- __name(createOpaqueTimingInfo, "createOpaqueTimingInfo");
- function makePolicyContainer() {
- return {
- referrerPolicy: "strict-origin-when-cross-origin"
- };
- }
- __name(makePolicyContainer, "makePolicyContainer");
- function clonePolicyContainer(policyContainer) {
- return {
- referrerPolicy: policyContainer.referrerPolicy
- };
- }
- __name(clonePolicyContainer, "clonePolicyContainer");
- function determineRequestsReferrer(request) {
- const policy = request.referrerPolicy;
- assert(policy);
- let referrerSource = null;
- if (request.referrer === "client") {
- const globalOrigin = getGlobalOrigin();
- if (!globalOrigin || globalOrigin.origin === "null") {
- return "no-referrer";
- }
- referrerSource = new URL(globalOrigin);
- } else if (webidl.is.URL(request.referrer)) {
- referrerSource = request.referrer;
- }
- let referrerURL = stripURLForReferrer(referrerSource);
- const referrerOrigin = stripURLForReferrer(referrerSource, true);
- if (referrerURL.toString().length > 4096) {
- referrerURL = referrerOrigin;
- }
- switch (policy) {
- case "no-referrer":
- return "no-referrer";
- case "origin":
- if (referrerOrigin != null) {
- return referrerOrigin;
- }
- return stripURLForReferrer(referrerSource, true);
- case "unsafe-url":
- return referrerURL;
- case "strict-origin": {
- const currentURL = requestCurrentURL(request);
- if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
- return "no-referrer";
- }
- return referrerOrigin;
- }
- case "strict-origin-when-cross-origin": {
- const currentURL = requestCurrentURL(request);
- if (sameOrigin(referrerURL, currentURL)) {
- return referrerURL;
- }
- if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
- return "no-referrer";
- }
- return referrerOrigin;
- }
- case "same-origin":
- if (sameOrigin(request, referrerURL)) {
- return referrerURL;
- }
- return "no-referrer";
- case "origin-when-cross-origin":
- if (sameOrigin(request, referrerURL)) {
- return referrerURL;
- }
- return referrerOrigin;
- case "no-referrer-when-downgrade": {
- const currentURL = requestCurrentURL(request);
- if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
- return "no-referrer";
- }
- return referrerURL;
- }
- }
- }
- __name(determineRequestsReferrer, "determineRequestsReferrer");
- function stripURLForReferrer(url, originOnly = false) {
- assert(webidl.is.URL(url));
- url = new URL(url);
- if (urlIsLocal(url)) {
- return "no-referrer";
- }
- url.username = "";
- url.password = "";
- url.hash = "";
- if (originOnly === true) {
- url.pathname = "";
- url.search = "";
- }
- return url;
- }
- __name(stripURLForReferrer, "stripURLForReferrer");
- var isPotentialleTrustworthyIPv4 = RegExp.prototype.test.bind(/^127\.(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){2}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)$/);
- var isPotentiallyTrustworthyIPv6 = RegExp.prototype.test.bind(/^(?:(?:0{1,4}:){7}|(?:0{1,4}:){1,6}:|::)0{0,3}1$/);
- function isOriginIPPotentiallyTrustworthy(origin) {
- if (origin.includes(":")) {
- if (origin[0] === "[" && origin[origin.length - 1] === "]") {
- origin = origin.slice(1, -1);
- }
- return isPotentiallyTrustworthyIPv6(origin);
- }
- return isPotentialleTrustworthyIPv4(origin);
- }
- __name(isOriginIPPotentiallyTrustworthy, "isOriginIPPotentiallyTrustworthy");
- function isOriginPotentiallyTrustworthy(origin) {
- if (origin == null || origin === "null") {
- return false;
- }
- origin = new URL(origin);
- if (origin.protocol === "https:" || origin.protocol === "wss:") {
- return true;
- }
- if (isOriginIPPotentiallyTrustworthy(origin.hostname)) {
- return true;
- }
- if (origin.hostname === "localhost" || origin.hostname === "localhost.") {
- return true;
- }
- if (origin.hostname.endsWith(".localhost") || origin.hostname.endsWith(".localhost.")) {
- return true;
- }
- if (origin.protocol === "file:") {
- return true;
- }
- return false;
- }
- __name(isOriginPotentiallyTrustworthy, "isOriginPotentiallyTrustworthy");
- function isURLPotentiallyTrustworthy(url) {
- if (!webidl.is.URL(url)) {
- return false;
- }
- if (url.href === "about:blank" || url.href === "about:srcdoc") {
- return true;
- }
- if (url.protocol === "data:") return true;
- if (url.protocol === "blob:") return true;
- return isOriginPotentiallyTrustworthy(url.origin);
- }
- __name(isURLPotentiallyTrustworthy, "isURLPotentiallyTrustworthy");
- function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {
- }
- __name(tryUpgradeRequestToAPotentiallyTrustworthyURL, "tryUpgradeRequestToAPotentiallyTrustworthyURL");
- function sameOrigin(A, B) {
- if (A.origin === B.origin && A.origin === "null") {
- return true;
- }
- if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
- return true;
- }
- return false;
- }
- __name(sameOrigin, "sameOrigin");
- function isAborted(fetchParams) {
- return fetchParams.controller.state === "aborted";
- }
- __name(isAborted, "isAborted");
- function isCancelled(fetchParams) {
- return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
- }
- __name(isCancelled, "isCancelled");
- function normalizeMethod(method) {
- return normalizedMethodRecordsBase[method.toLowerCase()] ?? method;
+ __name(isCancelled, "isCancelled");
+ function normalizeMethod(method) {
+ return normalizedMethodRecordsBase[method.toLowerCase()] ?? method;
}
__name(normalizeMethod, "normalizeMethod");
var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
@@ -6002,438 +4791,1750 @@ var require_util2 = __commonJS({
contentRange += isomorphicEncode(`${fullLength}`);
return contentRange;
}
- __name(buildContentRange, "buildContentRange");
- var InflateStream = class extends Transform {
- static {
- __name(this, "InflateStream");
- }
- #zlibOptions;
- /** @param {zlib.ZlibOptions} [zlibOptions] */
- constructor(zlibOptions) {
- super();
- this.#zlibOptions = zlibOptions;
- }
- _transform(chunk, encoding, callback) {
- if (!this._inflateStream) {
- if (chunk.length === 0) {
- callback();
- return;
- }
- this._inflateStream = (chunk[0] & 15) === 8 ? zlib.createInflate(this.#zlibOptions) : zlib.createInflateRaw(this.#zlibOptions);
- this._inflateStream.on("data", this.push.bind(this));
- this._inflateStream.on("end", () => this.push(null));
- this._inflateStream.on("error", (err) => this.destroy(err));
- }
- this._inflateStream.write(chunk, encoding, callback);
- }
- _final(callback) {
- if (this._inflateStream) {
- this._inflateStream.end();
- this._inflateStream = null;
- }
- callback();
- }
+ __name(buildContentRange, "buildContentRange");
+ var InflateStream = class extends Transform {
+ static {
+ __name(this, "InflateStream");
+ }
+ #zlibOptions;
+ /** @param {zlib.ZlibOptions} [zlibOptions] */
+ constructor(zlibOptions) {
+ super();
+ this.#zlibOptions = zlibOptions;
+ }
+ _transform(chunk, encoding, callback) {
+ if (!this._inflateStream) {
+ if (chunk.length === 0) {
+ callback();
+ return;
+ }
+ this._inflateStream = (chunk[0] & 15) === 8 ? zlib.createInflate(this.#zlibOptions) : zlib.createInflateRaw(this.#zlibOptions);
+ this._inflateStream.on("data", this.push.bind(this));
+ this._inflateStream.on("end", () => this.push(null));
+ this._inflateStream.on("error", (err) => this.destroy(err));
+ }
+ this._inflateStream.write(chunk, encoding, callback);
+ }
+ _final(callback) {
+ if (this._inflateStream) {
+ this._inflateStream.end();
+ this._inflateStream = null;
+ }
+ callback();
+ }
+ };
+ function createInflate(zlibOptions) {
+ return new InflateStream(zlibOptions);
+ }
+ __name(createInflate, "createInflate");
+ function extractMimeType(headers) {
+ let charset = null;
+ let essence = null;
+ let mimeType = null;
+ const values = getDecodeSplit("content-type", headers);
+ if (values === null) {
+ return "failure";
+ }
+ for (const value of values) {
+ const temporaryMimeType = parseMIMEType(value);
+ if (temporaryMimeType === "failure" || temporaryMimeType.essence === "*/*") {
+ continue;
+ }
+ mimeType = temporaryMimeType;
+ if (mimeType.essence !== essence) {
+ charset = null;
+ if (mimeType.parameters.has("charset")) {
+ charset = mimeType.parameters.get("charset");
+ }
+ essence = mimeType.essence;
+ } else if (!mimeType.parameters.has("charset") && charset !== null) {
+ mimeType.parameters.set("charset", charset);
+ }
+ }
+ if (mimeType == null) {
+ return "failure";
+ }
+ return mimeType;
+ }
+ __name(extractMimeType, "extractMimeType");
+ function gettingDecodingSplitting(value) {
+ const input = value;
+ const position = { position: 0 };
+ const values = [];
+ let temporaryValue = "";
+ while (position.position < input.length) {
+ temporaryValue += collectASequenceOfCodePoints(
+ (char) => char !== '"' && char !== ",",
+ input,
+ position
+ );
+ if (position.position < input.length) {
+ if (input.charCodeAt(position.position) === 34) {
+ temporaryValue += collectAnHTTPQuotedString(
+ input,
+ position
+ );
+ if (position.position < input.length) {
+ continue;
+ }
+ } else {
+ assert(input.charCodeAt(position.position) === 44);
+ position.position++;
+ }
+ }
+ temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 9 || char === 32);
+ values.push(temporaryValue);
+ temporaryValue = "";
+ }
+ return values;
+ }
+ __name(gettingDecodingSplitting, "gettingDecodingSplitting");
+ function getDecodeSplit(name, list) {
+ const value = list.get(name, true);
+ if (value === null) {
+ return null;
+ }
+ return gettingDecodingSplitting(value);
+ }
+ __name(getDecodeSplit, "getDecodeSplit");
+ function hasAuthenticationEntry(request) {
+ return false;
+ }
+ __name(hasAuthenticationEntry, "hasAuthenticationEntry");
+ function includesCredentials(url) {
+ return !!(url.username || url.password);
+ }
+ __name(includesCredentials, "includesCredentials");
+ function isTraversableNavigable(navigable) {
+ return navigable != null && navigable !== "client" && navigable !== "no-traversable";
+ }
+ __name(isTraversableNavigable, "isTraversableNavigable");
+ var EnvironmentSettingsObjectBase = class {
+ static {
+ __name(this, "EnvironmentSettingsObjectBase");
+ }
+ get baseUrl() {
+ return getGlobalOrigin();
+ }
+ get origin() {
+ return this.baseUrl?.origin;
+ }
+ policyContainer = makePolicyContainer();
+ };
+ var EnvironmentSettingsObject = class {
+ static {
+ __name(this, "EnvironmentSettingsObject");
+ }
+ settingsObject = new EnvironmentSettingsObjectBase();
+ };
+ var environmentSettingsObject = new EnvironmentSettingsObject();
+ module2.exports = {
+ isAborted,
+ isCancelled,
+ isValidEncodedURL,
+ tryUpgradeRequestToAPotentiallyTrustworthyURL,
+ clampAndCoarsenConnectionTimingInfo,
+ coarsenedSharedCurrentTime,
+ determineRequestsReferrer,
+ makePolicyContainer,
+ clonePolicyContainer,
+ appendFetchMetadata,
+ appendRequestOriginHeader,
+ TAOCheck,
+ corsCheck,
+ crossOriginResourcePolicyCheck,
+ createOpaqueTimingInfo,
+ setRequestReferrerPolicyOnRedirect,
+ isValidHTTPToken,
+ requestBadPort,
+ requestCurrentURL,
+ responseURL,
+ responseLocationURL,
+ isURLPotentiallyTrustworthy,
+ isValidReasonPhrase,
+ sameOrigin,
+ normalizeMethod,
+ iteratorMixin,
+ createIterator,
+ isValidHeaderName,
+ isValidHeaderValue,
+ isErrorLike,
+ fullyReadBody,
+ readableStreamClose,
+ urlIsLocal,
+ urlHasHttpsScheme,
+ urlIsHttpHttpsScheme,
+ readAllBytes,
+ simpleRangeHeaderValue,
+ buildContentRange,
+ createInflate,
+ extractMimeType,
+ getDecodeSplit,
+ environmentSettingsObject,
+ isOriginIPPotentiallyTrustworthy,
+ hasAuthenticationEntry,
+ includesCredentials,
+ isTraversableNavigable
+ };
+ }
+});
+
+// lib/util/runtime-features.js
+var require_runtime_features = __commonJS({
+ "lib/util/runtime-features.js"(exports2, module2) {
+ "use strict";
+ var lazyLoaders = {
+ __proto__: null,
+ "node:crypto": /* @__PURE__ */ __name(() => require("node:crypto"), "node:crypto"),
+ "node:sqlite": /* @__PURE__ */ __name(() => require("node:sqlite"), "node:sqlite")
+ };
+ function detectRuntimeFeatureByNodeModule(moduleName) {
+ try {
+ lazyLoaders[moduleName]();
+ return true;
+ } catch (err) {
+ if (err.code !== "ERR_UNKNOWN_BUILTIN_MODULE" && err.code !== "ERR_NO_CRYPTO") {
+ throw err;
+ }
+ return false;
+ }
+ }
+ __name(detectRuntimeFeatureByNodeModule, "detectRuntimeFeatureByNodeModule");
+ var runtimeFeaturesAsNodeModule = (
+ /** @type {const} */
+ ["crypto", "sqlite"]
+ );
+ function detectRuntimeFeature(feature) {
+ if (runtimeFeaturesAsNodeModule.includes(
+ /** @type {RuntimeFeatureByNodeModule} */
+ feature
+ )) {
+ return detectRuntimeFeatureByNodeModule(`node:${feature}`);
+ }
+ throw new TypeError(`unknown feature: ${feature}`);
+ }
+ __name(detectRuntimeFeature, "detectRuntimeFeature");
+ var RuntimeFeatures = class {
+ static {
+ __name(this, "RuntimeFeatures");
+ }
+ /** @type {Map<Feature, boolean>} */
+ #map = /* @__PURE__ */ new Map();
+ /**
+ * Clears all cached feature detections.
+ */
+ clear() {
+ this.#map.clear();
+ }
+ /**
+ * @param {Feature} feature
+ * @returns {boolean}
+ */
+ has(feature) {
+ return this.#map.get(feature) ?? this.#detectRuntimeFeature(feature);
+ }
+ /**
+ * @param {Feature} feature
+ * @param {boolean} value
+ */
+ set(feature, value) {
+ if (runtimeFeaturesAsNodeModule.includes(feature) === false) {
+ throw new TypeError(`unknown feature: ${feature}`);
+ }
+ this.#map.set(feature, value);
+ }
+ /**
+ * @param {Feature} feature
+ * @returns {boolean}
+ */
+ #detectRuntimeFeature(feature) {
+ const result = detectRuntimeFeature(feature);
+ this.#map.set(feature, result);
+ return result;
+ }
+ };
+ var instance = new RuntimeFeatures();
+ module2.exports.runtimeFeatures = instance;
+ module2.exports.default = instance;
+ }
+});
+
+// lib/web/fetch/formdata.js
+var require_formdata = __commonJS({
+ "lib/web/fetch/formdata.js"(exports2, module2) {
+ "use strict";
+ var { iteratorMixin } = require_util2();
+ var { kEnumerableProperty } = require_util();
+ var { webidl } = require_webidl();
+ var nodeUtil = require("node:util");
+ var { runtimeFeatures } = require_runtime_features();
+ var random = runtimeFeatures.has("crypto") ? require("node:crypto").randomInt : (max) => Math.floor(Math.random() * max);
+ var getFormDataState;
+ var setFormDataState;
+ var getFormDataBoundary;
+ var FormData = class {
+ static {
+ __name(this, "FormData");
+ }
+ #state = [];
+ #boundary = null;
+ constructor(form = void 0) {
+ webidl.util.markAsUncloneable(this);
+ if (form !== void 0) {
+ throw webidl.errors.conversionFailed({
+ prefix: "FormData constructor",
+ argument: "Argument 1",
+ types: ["undefined"]
+ });
+ }
+ }
+ append(name, value, filename = void 0) {
+ webidl.brandCheck(this, webidl.is.FormData);
+ const prefix = "FormData.append";
+ webidl.argumentLengthCheck(arguments, 2, prefix);
+ name = webidl.converters.USVString(name);
+ if (arguments.length === 3 || webidl.is.Blob(value)) {
+ value = webidl.converters.Blob(value, prefix, "value");
+ if (filename !== void 0) {
+ filename = webidl.converters.USVString(filename);
+ }
+ } else {
+ value = webidl.converters.USVString(value);
+ }
+ const entry = makeEntry(name, value, filename);
+ this.#state.push(entry);
+ }
+ delete(name) {
+ webidl.brandCheck(this, webidl.is.FormData);
+ const prefix = "FormData.delete";
+ webidl.argumentLengthCheck(arguments, 1, prefix);
+ name = webidl.converters.USVString(name);
+ this.#state = this.#state.filter((entry) => entry.name !== name);
+ }
+ get(name) {
+ webidl.brandCheck(this, webidl.is.FormData);
+ const prefix = "FormData.get";
+ webidl.argumentLengthCheck(arguments, 1, prefix);
+ name = webidl.converters.USVString(name);
+ const idx = this.#state.findIndex((entry) => entry.name === name);
+ if (idx === -1) {
+ return null;
+ }
+ return this.#state[idx].value;
+ }
+ getAll(name) {
+ webidl.brandCheck(this, webidl.is.FormData);
+ const prefix = "FormData.getAll";
+ webidl.argumentLengthCheck(arguments, 1, prefix);
+ name = webidl.converters.USVString(name);
+ return this.#state.filter((entry) => entry.name === name).map((entry) => entry.value);
+ }
+ has(name) {
+ webidl.brandCheck(this, webidl.is.FormData);
+ const prefix = "FormData.has";
+ webidl.argumentLengthCheck(arguments, 1, prefix);
+ name = webidl.converters.USVString(name);
+ return this.#state.findIndex((entry) => entry.name === name) !== -1;
+ }
+ set(name, value, filename = void 0) {
+ webidl.brandCheck(this, webidl.is.FormData);
+ const prefix = "FormData.set";
+ webidl.argumentLengthCheck(arguments, 2, prefix);
+ name = webidl.converters.USVString(name);
+ if (arguments.length === 3 || webidl.is.Blob(value)) {
+ value = webidl.converters.Blob(value, prefix, "value");
+ if (filename !== void 0) {
+ filename = webidl.converters.USVString(filename);
+ }
+ } else {
+ value = webidl.converters.USVString(value);
+ }
+ const entry = makeEntry(name, value, filename);
+ const idx = this.#state.findIndex((entry2) => entry2.name === name);
+ if (idx !== -1) {
+ this.#state = [
+ ...this.#state.slice(0, idx),
+ entry,
+ ...this.#state.slice(idx + 1).filter((entry2) => entry2.name !== name)
+ ];
+ } else {
+ this.#state.push(entry);
+ }
+ }
+ [nodeUtil.inspect.custom](depth, options) {
+ const state = this.#state.reduce((a, b) => {
+ if (a[b.name]) {
+ if (Array.isArray(a[b.name])) {
+ a[b.name].push(b.value);
+ } else {
+ a[b.name] = [a[b.name], b.value];
+ }
+ } else {
+ a[b.name] = b.value;
+ }
+ return a;
+ }, { __proto__: null });
+ options.depth ??= depth;
+ options.colors ??= true;
+ const output = nodeUtil.formatWithOptions(options, state);
+ return `FormData ${output.slice(output.indexOf("]") + 2)}`;
+ }
+ static {
+ getFormDataState = /* @__PURE__ */ __name((formData) => formData.#state, "getFormDataState");
+ setFormDataState = /* @__PURE__ */ __name((formData, newState) => {
+ formData.#state = newState;
+ }, "setFormDataState");
+ getFormDataBoundary = /* @__PURE__ */ __name((formData) => {
+ return formData.#boundary ??= `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
+ }, "getFormDataBoundary");
+ webidl.is.FormData = (arg) => {
+ return arg != null && typeof arg === "object" && #state in arg;
+ };
+ }
+ };
+ iteratorMixin("FormData", FormData, getFormDataState, "name", "value", webidl.is.FormData);
+ Object.defineProperties(FormData.prototype, {
+ append: kEnumerableProperty,
+ delete: kEnumerableProperty,
+ get: kEnumerableProperty,
+ getAll: kEnumerableProperty,
+ has: kEnumerableProperty,
+ set: kEnumerableProperty,
+ [Symbol.toStringTag]: {
+ value: "FormData",
+ configurable: true
+ }
+ });
+ function makeEntry(name, value, filename) {
+ if (typeof value === "string") {
+ } else {
+ if (!webidl.is.File(value)) {
+ value = new File([value], "blob", { type: value.type });
+ }
+ if (filename !== void 0) {
+ const options = {
+ type: value.type,
+ lastModified: value.lastModified
+ };
+ value = new File([value], filename, options);
+ }
+ }
+ return { name, value };
+ }
+ __name(makeEntry, "makeEntry");
+ module2.exports = { FormData, makeEntry, setFormDataState, getFormDataBoundary };
+ }
+});
+
+// lib/core/request.js
+var require_request = __commonJS({
+ "lib/core/request.js"(exports2, module2) {
+ "use strict";
+ var {
+ InvalidArgumentError,
+ NotSupportedError
+ } = require_errors();
+ var assert = require("node:assert");
+ var {
+ isValidHTTPToken,
+ isValidHeaderValue,
+ isStream,
+ destroy,
+ isBuffer,
+ isFormDataLike,
+ isIterable,
+ hasSafeIterator,
+ isBlobLike,
+ serializePathWithQuery,
+ parseHeaders,
+ assertRequestHandler,
+ getServerName,
+ normalizedMethodRecords,
+ getProtocolFromUrlString
+ } = require_util();
+ var { channels } = require_diagnostics();
+ var { headerNameLowerCasedRecord } = require_constants();
+ var invalidPathRegex = /[^\u0021-\u00ff]/;
+ function isValidContentLengthHeaderValue(val) {
+ if (typeof val !== "string" || val.length === 0) {
+ return false;
+ }
+ for (let i = 0; i < val.length; i++) {
+ const charCode = val.charCodeAt(i);
+ if (charCode < 48 || charCode > 57) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(isValidContentLengthHeaderValue, "isValidContentLengthHeaderValue");
+ var kHandler = /* @__PURE__ */ Symbol("handler");
+ var kController = /* @__PURE__ */ Symbol("controller");
+ var kResume = /* @__PURE__ */ Symbol("resume");
+ var RequestController = class {
+ static {
+ __name(this, "RequestController");
+ }
+ #paused = false;
+ #reason = null;
+ #aborted = false;
+ #abort;
+ [kResume] = null;
+ rawHeaders = null;
+ rawTrailers = null;
+ constructor(abort) {
+ this.#abort = abort;
+ }
+ pause() {
+ this.#paused = true;
+ }
+ resume() {
+ if (this.#paused) {
+ this.#paused = false;
+ this[kResume]?.();
+ }
+ }
+ abort(reason) {
+ if (!this.#aborted) {
+ this.#aborted = true;
+ this.#reason = reason;
+ this.#abort(reason);
+ }
+ }
+ get aborted() {
+ return this.#aborted;
+ }
+ get reason() {
+ return this.#reason;
+ }
+ get paused() {
+ return this.#paused;
+ }
+ };
+ var Request = class {
+ static {
+ __name(this, "Request");
+ }
+ constructor(origin, {
+ path,
+ method,
+ body,
+ headers,
+ query,
+ idempotent,
+ blocking,
+ upgrade,
+ headersTimeout,
+ bodyTimeout,
+ reset,
+ expectContinue,
+ servername,
+ throwOnError,
+ maxRedirections,
+ typeOfService
+ }, handler) {
+ if (typeof path !== "string") {
+ throw new InvalidArgumentError("path must be a string");
+ } else if (path[0] !== "/" && !(path.startsWith("http://") || path.startsWith("https://")) && method !== "CONNECT") {
+ throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
+ } else if (invalidPathRegex.test(path)) {
+ throw new InvalidArgumentError("invalid request path");
+ }
+ if (typeof method !== "string") {
+ throw new InvalidArgumentError("method must be a string");
+ } else if (normalizedMethodRecords[method] === void 0 && !isValidHTTPToken(method)) {
+ throw new InvalidArgumentError("invalid request method");
+ }
+ if (upgrade && typeof upgrade !== "string") {
+ throw new InvalidArgumentError("upgrade must be a string");
+ }
+ if (upgrade && !isValidHeaderValue(upgrade)) {
+ throw new InvalidArgumentError("invalid upgrade header");
+ }
+ if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
+ throw new InvalidArgumentError("invalid headersTimeout");
+ }
+ if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
+ throw new InvalidArgumentError("invalid bodyTimeout");
+ }
+ if (reset != null && typeof reset !== "boolean") {
+ throw new InvalidArgumentError("invalid reset");
+ }
+ if (expectContinue != null && typeof expectContinue !== "boolean") {
+ throw new InvalidArgumentError("invalid expectContinue");
+ }
+ if (throwOnError != null) {
+ throw new InvalidArgumentError("invalid throwOnError");
+ }
+ if (maxRedirections != null && maxRedirections !== 0) {
+ throw new InvalidArgumentError("maxRedirections is not supported, use the redirect interceptor");
+ }
+ if (typeOfService != null && (!Number.isInteger(typeOfService) || typeOfService < 0 || typeOfService > 255)) {
+ throw new InvalidArgumentError("typeOfService must be an integer between 0 and 255");
+ }
+ this.headersTimeout = headersTimeout;
+ this.bodyTimeout = bodyTimeout;
+ this.method = method;
+ this.typeOfService = typeOfService;
+ this.abort = null;
+ if (body == null) {
+ this.body = null;
+ } else if (isStream(body)) {
+ this.body = body;
+ const rState = this.body._readableState;
+ if (!rState || !rState.autoDestroy) {
+ this.endHandler = /* @__PURE__ */ __name(function autoDestroy() {
+ destroy(this);
+ }, "autoDestroy");
+ this.body.on("end", this.endHandler);
+ }
+ this.errorHandler = (err) => {
+ if (this.abort) {
+ this.abort(err);
+ } else {
+ this.error = err;
+ }
+ };
+ this.body.on("error", this.errorHandler);
+ } else if (isBuffer(body)) {
+ this.body = body.byteLength ? body : null;
+ } else if (ArrayBuffer.isView(body)) {
+ this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
+ } else if (body instanceof ArrayBuffer) {
+ this.body = body.byteLength ? Buffer.from(body) : null;
+ } else if (typeof body === "string") {
+ this.body = body.length ? Buffer.from(body) : null;
+ } else if (isFormDataLike(body)) {
+ if (!isUndiciFormData(body)) {
+ throw new InvalidArgumentError("body must be a FormData created by this undici package instance; FormData from other sources, such as the built-in FormData provided by Node.js, is not supported");
+ }
+ this.body = body;
+ } else if (isIterable(body) || isBlobLike(body)) {
+ this.body = body;
+ } else {
+ throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");
+ }
+ this.completed = false;
+ this.aborted = false;
+ this.upgrade = upgrade || null;
+ this.path = query ? serializePathWithQuery(path, query) : path;
+ this.origin = origin;
+ this.protocol = getProtocolFromUrlString(origin);
+ this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" || method === "QUERY" : idempotent;
+ this.blocking = blocking ?? this.method !== "HEAD";
+ this.reset = reset == null ? null : reset;
+ this.host = null;
+ this.contentLength = null;
+ this.contentType = null;
+ this.headers = [];
+ this.expectContinue = expectContinue != null ? expectContinue : false;
+ if (Array.isArray(headers)) {
+ if (headers.length % 2 !== 0) {
+ throw new InvalidArgumentError("headers array must be even");
+ }
+ for (let i = 0; i < headers.length; i += 2) {
+ processHeader(this, headers[i], headers[i + 1]);
+ }
+ } else if (headers && typeof headers === "object") {
+ if (hasSafeIterator(headers)) {
+ for (const header of headers) {
+ if (!Array.isArray(header) || header.length !== 2) {
+ throw new InvalidArgumentError("headers must be in key-value pair format");
+ }
+ processHeader(this, header[0], header[1]);
+ }
+ } else {
+ const keys = Object.keys(headers);
+ for (let i = 0; i < keys.length; ++i) {
+ processHeader(this, keys[i], headers[keys[i]]);
+ }
+ }
+ } else if (headers != null) {
+ throw new InvalidArgumentError("headers must be an object or an array");
+ }
+ assertRequestHandler(handler, method, upgrade);
+ this.servername = servername || getServerName(this.host) || null;
+ this[kHandler] = handler;
+ if (channels.create.hasSubscribers) {
+ channels.create.publish({ request: this });
+ }
+ }
+ onBodySent(chunk) {
+ if (channels.bodyChunkSent.hasSubscribers) {
+ channels.bodyChunkSent.publish({ request: this, chunk });
+ }
+ if (this[kHandler].onBodySent) {
+ try {
+ return this[kHandler].onBodySent(chunk);
+ } catch (err) {
+ this.abort(err);
+ }
+ }
+ }
+ onRequestSent() {
+ if (channels.bodySent.hasSubscribers) {
+ channels.bodySent.publish({ request: this });
+ }
+ if (this[kHandler].onRequestSent) {
+ try {
+ return this[kHandler].onRequestSent();
+ } catch (err) {
+ this.abort(err);
+ }
+ }
+ }
+ onRequestStart(abort, context) {
+ assert(!this.aborted);
+ assert(!this.completed);
+ this[kController] = new RequestController(abort);
+ if (this.error) {
+ this[kController].abort(this.error);
+ return;
+ }
+ this.abort = abort;
+ return this[kHandler].onRequestStart(this[kController], context);
+ }
+ onResponseStarted() {
+ return this[kHandler].onResponseStarted?.();
+ }
+ onResponseStart(statusCode, headers, resume, statusText) {
+ assert(!this.aborted);
+ assert(!this.completed);
+ if (channels.headers.hasSubscribers) {
+ channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
+ }
+ const controller = this[kController];
+ if (controller) {
+ controller[kResume] = resume;
+ controller.rawHeaders = headers;
+ }
+ const parsedHeaders = Array.isArray(headers) ? parseHeaders(headers) : headers;
+ try {
+ this[kHandler].onResponseStart?.(controller, statusCode, parsedHeaders, statusText);
+ return !controller?.paused;
+ } catch (err) {
+ this.abort(err);
+ return false;
+ }
+ }
+ onResponseData(chunk) {
+ assert(!this.aborted);
+ assert(!this.completed);
+ if (channels.bodyChunkReceived.hasSubscribers) {
+ channels.bodyChunkReceived.publish({ request: this, chunk });
+ }
+ const controller = this[kController];
+ try {
+ this[kHandler].onResponseData?.(controller, chunk);
+ return !controller?.paused;
+ } catch (err) {
+ this.abort(err);
+ return false;
+ }
+ }
+ /**
+ * @param {number} statusCode
+ * @param {Buffer[]|string[]|import('../../types/header.d.ts').IncomingHttpHeaders} headers
+ * @param {import('node:stream').Duplex} socket
+ * @param {string} [statusText]
+ */
+ onRequestUpgrade(statusCode, headers, socket, statusText = "") {
+ this.onFinally();
+ assert(!this.aborted);
+ assert(!this.completed);
+ if (channels.headers.hasSubscribers) {
+ channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
+ }
+ const controller = this[kController];
+ if (controller) {
+ controller.rawHeaders = headers;
+ }
+ const parsedHeaders = Array.isArray(headers) ? parseHeaders(headers) : headers;
+ const result = this[kHandler].onRequestUpgrade?.(controller, statusCode, parsedHeaders, socket);
+ if (!this.aborted) {
+ this.completed = true;
+ if (channels.trailers.hasSubscribers) {
+ channels.trailers.publish({ request: this, trailers: [] });
+ }
+ }
+ return result;
+ }
+ onResponseEnd(trailers) {
+ this.onFinally();
+ assert(!this.aborted);
+ assert(!this.completed);
+ this.completed = true;
+ if (channels.trailers.hasSubscribers) {
+ channels.trailers.publish({ request: this, trailers });
+ }
+ const controller = this[kController];
+ if (controller) {
+ controller.rawTrailers = trailers;
+ }
+ const parsedTrailers = Array.isArray(trailers) ? parseHeaders(trailers) : trailers;
+ try {
+ return this[kHandler].onResponseEnd?.(controller, parsedTrailers);
+ } catch (err) {
+ this.onResponseError(err);
+ }
+ }
+ onResponseError(error) {
+ this.onFinally();
+ if (channels.error.hasSubscribers) {
+ channels.error.publish({ request: this, error });
+ }
+ if (this.aborted) {
+ return;
+ }
+ this.aborted = true;
+ const controller = this[kController];
+ return this[kHandler].onResponseError?.(controller, error);
+ }
+ onFinally() {
+ if (this.errorHandler) {
+ this.body.off("error", this.errorHandler);
+ this.errorHandler = null;
+ }
+ if (this.endHandler) {
+ this.body.off("end", this.endHandler);
+ this.endHandler = null;
+ }
+ }
+ addHeader(key, value) {
+ processHeader(this, key, value);
+ return this;
+ }
+ };
+ function processHeader(request, key, val) {
+ if (val && (typeof val === "object" && !Array.isArray(val))) {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ } else if (val === void 0) {
+ return;
+ }
+ let headerName = headerNameLowerCasedRecord[key];
+ if (headerName === void 0) {
+ headerName = key.toLowerCase();
+ if (headerNameLowerCasedRecord[headerName] === void 0 && !isValidHTTPToken(headerName)) {
+ throw new InvalidArgumentError("invalid header key");
+ }
+ }
+ if (Array.isArray(val)) {
+ const arr = [];
+ for (let i = 0; i < val.length; i++) {
+ if (typeof val[i] === "string") {
+ if (!isValidHeaderValue(val[i])) {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ }
+ arr.push(val[i]);
+ } else if (val[i] === null) {
+ arr.push("");
+ } else if (typeof val[i] === "object") {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ } else {
+ const str = `${val[i]}`;
+ if (!isValidHeaderValue(str)) {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ }
+ arr.push(str);
+ }
+ }
+ val = arr;
+ } else if (typeof val === "string") {
+ if (!isValidHeaderValue(val)) {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ }
+ } else if (val === null) {
+ val = "";
+ } else {
+ val = `${val}`;
+ if (!isValidHeaderValue(val)) {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ }
+ }
+ if (headerName === "host") {
+ if (request.host !== null) {
+ throw new InvalidArgumentError("duplicate host header");
+ }
+ if (typeof val !== "string") {
+ throw new InvalidArgumentError("invalid host header");
+ }
+ request.host = val;
+ } else if (headerName === "content-length") {
+ if (request.contentLength !== null) {
+ throw new InvalidArgumentError("duplicate content-length header");
+ }
+ if (!isValidContentLengthHeaderValue(val)) {
+ throw new InvalidArgumentError("invalid content-length header");
+ }
+ request.contentLength = parseInt(val, 10);
+ } else if (request.contentType === null && headerName === "content-type") {
+ request.contentType = val;
+ request.headers.push(key, val);
+ } else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade") {
+ throw new InvalidArgumentError(`invalid ${headerName} header`);
+ } else if (headerName === "connection") {
+ const value = typeof val === "string" ? val : null;
+ if (value === null) {
+ throw new InvalidArgumentError("invalid connection header");
+ }
+ for (const token of value.toLowerCase().split(",")) {
+ const trimmed = token.trim();
+ if (!isValidHTTPToken(trimmed)) {
+ throw new InvalidArgumentError("invalid connection header");
+ }
+ if (trimmed === "close") {
+ request.reset = true;
+ }
+ }
+ } else if (headerName === "expect") {
+ throw new NotSupportedError("expect header not supported");
+ } else {
+ request.headers.push(key, val);
+ }
+ }
+ __name(processHeader, "processHeader");
+ var isFormData;
+ function isUndiciFormData(body) {
+ if (isFormData === void 0) {
+ require_formdata();
+ isFormData = require_webidl().webidl.is.FormData;
+ }
+ return isFormData(body);
+ }
+ __name(isUndiciFormData, "isUndiciFormData");
+ module2.exports = Request;
+ }
+});
+
+// lib/core/connect.js
+var require_connect = __commonJS({
+ "lib/core/connect.js"(exports2, module2) {
+ "use strict";
+ var net = require("node:net");
+ var assert = require("node:assert");
+ var util = require_util();
+ var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
+ var tls;
+ var SessionCache = class WeakSessionCache {
+ static {
+ __name(this, "WeakSessionCache");
+ }
+ constructor(maxCachedSessions) {
+ this._maxCachedSessions = maxCachedSessions;
+ this._sessionCache = /* @__PURE__ */ new Map();
+ this._sessionRegistry = new FinalizationRegistry((key) => {
+ if (this._sessionCache.size < this._maxCachedSessions) {
+ return;
+ }
+ const ref = this._sessionCache.get(key);
+ if (ref !== void 0 && ref.deref() === void 0) {
+ this._sessionCache.delete(key);
+ }
+ });
+ }
+ get(sessionKey) {
+ const ref = this._sessionCache.get(sessionKey);
+ return ref ? ref.deref() : null;
+ }
+ set(sessionKey, session) {
+ if (this._maxCachedSessions === 0) {
+ return;
+ }
+ if (this._sessionCache.has(sessionKey)) {
+ this._sessionCache.delete(sessionKey);
+ } else if (this._sessionCache.size >= this._maxCachedSessions) {
+ let evicted = false;
+ for (const [key, ref] of this._sessionCache) {
+ if (ref.deref() === void 0) {
+ this._sessionCache.delete(key);
+ evicted = true;
+ break;
+ }
+ }
+ if (!evicted) {
+ const oldest = this._sessionCache.keys().next();
+ if (!oldest.done) {
+ this._sessionCache.delete(oldest.value);
+ }
+ }
+ }
+ this._sessionCache.set(sessionKey, new WeakRef(session));
+ this._sessionRegistry.register(session, sessionKey);
+ }
+ };
+ function buildConnector({ allowH2, preferH2, useH2c, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
+ if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
+ throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
+ }
+ const options = { path: socketPath, ...opts };
+ const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
+ timeout = timeout == null ? 1e4 : timeout;
+ allowH2 = allowH2 != null ? allowH2 : true;
+ return /* @__PURE__ */ __name(function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
+ let socket;
+ if (protocol === "https:") {
+ if (!tls) {
+ tls = require("node:tls");
+ }
+ servername = servername || options.servername || util.getServerName(host) || null;
+ const sessionKey = servername || hostname;
+ assert(sessionKey);
+ const session = customSession || sessionCache.get(sessionKey) || null;
+ port = port || 443;
+ socket = tls.connect({
+ highWaterMark: 16384,
+ // TLS in node can't have bigger HWM anyway...
+ ...options,
+ servername,
+ session,
+ localAddress,
+ ALPNProtocols: allowH2 ? preferH2 ? ["h2", "http/1.1"] : ["http/1.1", "h2"] : ["http/1.1"],
+ socket: httpSocket,
+ // upgrade socket connection
+ port,
+ host: hostname
+ });
+ socket.on("session", function(session2) {
+ sessionCache.set(sessionKey, session2);
+ });
+ } else {
+ assert(!httpSocket, "httpSocket can only be sent on TLS update");
+ port = port || 80;
+ const connectOptions = {
+ highWaterMark: 64 * 1024,
+ // Same as nodejs fs streams.
+ ...options,
+ localAddress,
+ port,
+ host: hostname
+ };
+ const family = net.isIP(hostname);
+ if (family !== 0 && servername && servername !== hostname) {
+ connectOptions.host = servername;
+ connectOptions.lookup = (_hostname, lookupOptions, cb) => {
+ if (lookupOptions.all) {
+ cb(null, [{ address: hostname, family }]);
+ } else {
+ cb(null, hostname, family);
+ }
+ };
+ }
+ socket = net.connect(connectOptions);
+ if (useH2c === true) {
+ socket.alpnProtocol = "h2";
+ }
+ }
+ if (options.keepAlive == null || options.keepAlive) {
+ const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay;
+ socket.setKeepAlive(true, keepAliveInitialDelay);
+ }
+ const clearConnectTimeout = util.setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port });
+ socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() {
+ queueMicrotask(clearConnectTimeout);
+ if (callback) {
+ const cb = callback;
+ callback = null;
+ cb(null, this);
+ }
+ }).on("error", function(err) {
+ queueMicrotask(clearConnectTimeout);
+ if (callback) {
+ const cb = callback;
+ callback = null;
+ cb(maybeNormalizeConnectError(err, this, { timeout, hostname, port }));
+ }
+ });
+ return socket;
+ }, "connect");
+ }
+ __name(buildConnector, "buildConnector");
+ function maybeNormalizeConnectError(err, socket, opts) {
+ if (err instanceof AggregateError && (err.code === "ETIMEDOUT" || err.errors.some((e) => e != null && e.code === "ETIMEDOUT"))) {
+ let message = "Connect Timeout Error";
+ if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
+ message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")},`;
+ } else {
+ message += ` (attempted address: ${opts.hostname}:${opts.port},`;
+ }
+ message += ` timeout: ${opts.timeout}ms)`;
+ const wrapped = new ConnectTimeoutError(message);
+ wrapped.cause = err;
+ return wrapped;
+ }
+ return err;
+ }
+ __name(maybeNormalizeConnectError, "maybeNormalizeConnectError");
+ module2.exports = buildConnector;
+ }
+});
+
+// lib/llhttp/utils.js
+var require_utils = __commonJS({
+ "lib/llhttp/utils.js"(exports2) {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.enumToMap = enumToMap;
+ function enumToMap(obj, filter = [], exceptions = []) {
+ const emptyFilter = (filter?.length ?? 0) === 0;
+ const emptyExceptions = (exceptions?.length ?? 0) === 0;
+ return Object.fromEntries(Object.entries(obj).filter(([, value]) => {
+ return typeof value === "number" && (emptyFilter || filter.includes(value)) && (emptyExceptions || !exceptions.includes(value));
+ }));
+ }
+ __name(enumToMap, "enumToMap");
+ }
+});
+
+// lib/llhttp/constants.js
+var require_constants3 = __commonJS({
+ "lib/llhttp/constants.js"(exports2) {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.SPECIAL_HEADERS = exports2.MINOR = exports2.MAJOR = exports2.HTAB_SP_VCHAR_OBS_TEXT = exports2.QUOTED_STRING = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.STATUSES_HTTP = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.HEADER_STATE = exports2.FINISH = exports2.STATUSES = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0;
+ var utils_1 = require_utils();
+ exports2.ERROR = {
+ OK: 0,
+ INTERNAL: 1,
+ STRICT: 2,
+ CR_EXPECTED: 25,
+ LF_EXPECTED: 3,
+ UNEXPECTED_CONTENT_LENGTH: 4,
+ UNEXPECTED_SPACE: 30,
+ CLOSED_CONNECTION: 5,
+ INVALID_METHOD: 6,
+ INVALID_URL: 7,
+ INVALID_CONSTANT: 8,
+ INVALID_VERSION: 9,
+ INVALID_HEADER_TOKEN: 10,
+ INVALID_CONTENT_LENGTH: 11,
+ INVALID_CHUNK_SIZE: 12,
+ INVALID_STATUS: 13,
+ INVALID_EOF_STATE: 14,
+ INVALID_TRANSFER_ENCODING: 15,
+ CB_MESSAGE_BEGIN: 16,
+ CB_HEADERS_COMPLETE: 17,
+ CB_MESSAGE_COMPLETE: 18,
+ CB_CHUNK_HEADER: 19,
+ CB_CHUNK_COMPLETE: 20,
+ PAUSED: 21,
+ PAUSED_UPGRADE: 22,
+ PAUSED_H2_UPGRADE: 23,
+ USER: 24,
+ CB_URL_COMPLETE: 26,
+ CB_STATUS_COMPLETE: 27,
+ CB_METHOD_COMPLETE: 32,
+ CB_VERSION_COMPLETE: 33,
+ CB_HEADER_FIELD_COMPLETE: 28,
+ CB_HEADER_VALUE_COMPLETE: 29,
+ CB_CHUNK_EXTENSION_NAME_COMPLETE: 34,
+ CB_CHUNK_EXTENSION_VALUE_COMPLETE: 35,
+ CB_RESET: 31,
+ CB_PROTOCOL_COMPLETE: 38
+ };
+ exports2.TYPE = {
+ BOTH: 0,
+ // default
+ REQUEST: 1,
+ RESPONSE: 2
+ };
+ exports2.FLAGS = {
+ CONNECTION_KEEP_ALIVE: 1 << 0,
+ CONNECTION_CLOSE: 1 << 1,
+ CONNECTION_UPGRADE: 1 << 2,
+ CHUNKED: 1 << 3,
+ UPGRADE: 1 << 4,
+ CONTENT_LENGTH: 1 << 5,
+ SKIPBODY: 1 << 6,
+ TRAILING: 1 << 7,
+ // 1 << 8 is unused
+ TRANSFER_ENCODING: 1 << 9
+ };
+ exports2.LENIENT_FLAGS = {
+ HEADERS: 1 << 0,
+ CHUNKED_LENGTH: 1 << 1,
+ KEEP_ALIVE: 1 << 2,
+ TRANSFER_ENCODING: 1 << 3,
+ VERSION: 1 << 4,
+ DATA_AFTER_CLOSE: 1 << 5,
+ OPTIONAL_LF_AFTER_CR: 1 << 6,
+ OPTIONAL_CRLF_AFTER_CHUNK: 1 << 7,
+ OPTIONAL_CR_BEFORE_LF: 1 << 8,
+ SPACES_AFTER_CHUNK_SIZE: 1 << 9
+ };
+ exports2.METHODS = {
+ "DELETE": 0,
+ "GET": 1,
+ "HEAD": 2,
+ "POST": 3,
+ "PUT": 4,
+ /* pathological */
+ "CONNECT": 5,
+ "OPTIONS": 6,
+ "TRACE": 7,
+ /* WebDAV */
+ "COPY": 8,
+ "LOCK": 9,
+ "MKCOL": 10,
+ "MOVE": 11,
+ "PROPFIND": 12,
+ "PROPPATCH": 13,
+ "SEARCH": 14,
+ "UNLOCK": 15,
+ "BIND": 16,
+ "REBIND": 17,
+ "UNBIND": 18,
+ "ACL": 19,
+ /* subversion */
+ "REPORT": 20,
+ "MKACTIVITY": 21,
+ "CHECKOUT": 22,
+ "MERGE": 23,
+ /* upnp */
+ "M-SEARCH": 24,
+ "NOTIFY": 25,
+ "SUBSCRIBE": 26,
+ "UNSUBSCRIBE": 27,
+ /* RFC-5789 */
+ "PATCH": 28,
+ "PURGE": 29,
+ /* CalDAV */
+ "MKCALENDAR": 30,
+ /* RFC-2068, section 19.6.1.2 */
+ "LINK": 31,
+ "UNLINK": 32,
+ /* icecast */
+ "SOURCE": 33,
+ /* RFC-7540, section 11.6 */
+ "PRI": 34,
+ /* RFC-2326 RTSP */
+ "DESCRIBE": 35,
+ "ANNOUNCE": 36,
+ "SETUP": 37,
+ "PLAY": 38,
+ "PAUSE": 39,
+ "TEARDOWN": 40,
+ "GET_PARAMETER": 41,
+ "SET_PARAMETER": 42,
+ "REDIRECT": 43,
+ "RECORD": 44,
+ /* RAOP */
+ "FLUSH": 45,
+ /* DRAFT https://www.ietf.org/archive/id/draft-ietf-httpbis-safe-method-w-body-02.html */
+ "QUERY": 46
+ };
+ exports2.STATUSES = {
+ CONTINUE: 100,
+ SWITCHING_PROTOCOLS: 101,
+ PROCESSING: 102,
+ EARLY_HINTS: 103,
+ RESPONSE_IS_STALE: 110,
+ // Unofficial
+ REVALIDATION_FAILED: 111,
+ // Unofficial
+ DISCONNECTED_OPERATION: 112,
+ // Unofficial
+ HEURISTIC_EXPIRATION: 113,
+ // Unofficial
+ MISCELLANEOUS_WARNING: 199,
+ // Unofficial
+ OK: 200,
+ CREATED: 201,
+ ACCEPTED: 202,
+ NON_AUTHORITATIVE_INFORMATION: 203,
+ NO_CONTENT: 204,
+ RESET_CONTENT: 205,
+ PARTIAL_CONTENT: 206,
+ MULTI_STATUS: 207,
+ ALREADY_REPORTED: 208,
+ TRANSFORMATION_APPLIED: 214,
+ // Unofficial
+ IM_USED: 226,
+ MISCELLANEOUS_PERSISTENT_WARNING: 299,
+ // Unofficial
+ MULTIPLE_CHOICES: 300,
+ MOVED_PERMANENTLY: 301,
+ FOUND: 302,
+ SEE_OTHER: 303,
+ NOT_MODIFIED: 304,
+ USE_PROXY: 305,
+ SWITCH_PROXY: 306,
+ // No longer used
+ TEMPORARY_REDIRECT: 307,
+ PERMANENT_REDIRECT: 308,
+ BAD_REQUEST: 400,
+ UNAUTHORIZED: 401,
+ PAYMENT_REQUIRED: 402,
+ FORBIDDEN: 403,
+ NOT_FOUND: 404,
+ METHOD_NOT_ALLOWED: 405,
+ NOT_ACCEPTABLE: 406,
+ PROXY_AUTHENTICATION_REQUIRED: 407,
+ REQUEST_TIMEOUT: 408,
+ CONFLICT: 409,
+ GONE: 410,
+ LENGTH_REQUIRED: 411,
+ PRECONDITION_FAILED: 412,
+ PAYLOAD_TOO_LARGE: 413,
+ URI_TOO_LONG: 414,
+ UNSUPPORTED_MEDIA_TYPE: 415,
+ RANGE_NOT_SATISFIABLE: 416,
+ EXPECTATION_FAILED: 417,
+ IM_A_TEAPOT: 418,
+ PAGE_EXPIRED: 419,
+ // Unofficial
+ ENHANCE_YOUR_CALM: 420,
+ // Unofficial
+ MISDIRECTED_REQUEST: 421,
+ UNPROCESSABLE_ENTITY: 422,
+ LOCKED: 423,
+ FAILED_DEPENDENCY: 424,
+ TOO_EARLY: 425,
+ UPGRADE_REQUIRED: 426,
+ PRECONDITION_REQUIRED: 428,
+ TOO_MANY_REQUESTS: 429,
+ REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL: 430,
+ // Unofficial
+ REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+ LOGIN_TIMEOUT: 440,
+ // Unofficial
+ NO_RESPONSE: 444,
+ // Unofficial
+ RETRY_WITH: 449,
+ // Unofficial
+ BLOCKED_BY_PARENTAL_CONTROL: 450,
+ // Unofficial
+ UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+ CLIENT_CLOSED_LOAD_BALANCED_REQUEST: 460,
+ // Unofficial
+ INVALID_X_FORWARDED_FOR: 463,
+ // Unofficial
+ REQUEST_HEADER_TOO_LARGE: 494,
+ // Unofficial
+ SSL_CERTIFICATE_ERROR: 495,
+ // Unofficial
+ SSL_CERTIFICATE_REQUIRED: 496,
+ // Unofficial
+ HTTP_REQUEST_SENT_TO_HTTPS_PORT: 497,
+ // Unofficial
+ INVALID_TOKEN: 498,
+ // Unofficial
+ CLIENT_CLOSED_REQUEST: 499,
+ // Unofficial
+ INTERNAL_SERVER_ERROR: 500,
+ NOT_IMPLEMENTED: 501,
+ BAD_GATEWAY: 502,
+ SERVICE_UNAVAILABLE: 503,
+ GATEWAY_TIMEOUT: 504,
+ HTTP_VERSION_NOT_SUPPORTED: 505,
+ VARIANT_ALSO_NEGOTIATES: 506,
+ INSUFFICIENT_STORAGE: 507,
+ LOOP_DETECTED: 508,
+ BANDWIDTH_LIMIT_EXCEEDED: 509,
+ NOT_EXTENDED: 510,
+ NETWORK_AUTHENTICATION_REQUIRED: 511,
+ WEB_SERVER_UNKNOWN_ERROR: 520,
+ // Unofficial
+ WEB_SERVER_IS_DOWN: 521,
+ // Unofficial
+ CONNECTION_TIMEOUT: 522,
+ // Unofficial
+ ORIGIN_IS_UNREACHABLE: 523,
+ // Unofficial
+ TIMEOUT_OCCURED: 524,
+ // Unofficial
+ SSL_HANDSHAKE_FAILED: 525,
+ // Unofficial
+ INVALID_SSL_CERTIFICATE: 526,
+ // Unofficial
+ RAILGUN_ERROR: 527,
+ // Unofficial
+ SITE_IS_OVERLOADED: 529,
+ // Unofficial
+ SITE_IS_FROZEN: 530,
+ // Unofficial
+ IDENTITY_PROVIDER_AUTHENTICATION_ERROR: 561,
+ // Unofficial
+ NETWORK_READ_TIMEOUT: 598,
+ // Unofficial
+ NETWORK_CONNECT_TIMEOUT: 599
+ // Unofficial
+ };
+ exports2.FINISH = {
+ SAFE: 0,
+ SAFE_WITH_CB: 1,
+ UNSAFE: 2
+ };
+ exports2.HEADER_STATE = {
+ GENERAL: 0,
+ CONNECTION: 1,
+ CONTENT_LENGTH: 2,
+ TRANSFER_ENCODING: 3,
+ UPGRADE: 4,
+ CONNECTION_KEEP_ALIVE: 5,
+ CONNECTION_CLOSE: 6,
+ CONNECTION_UPGRADE: 7,
+ TRANSFER_ENCODING_CHUNKED: 8
+ };
+ exports2.METHODS_HTTP = [
+ exports2.METHODS.DELETE,
+ exports2.METHODS.GET,
+ exports2.METHODS.HEAD,
+ exports2.METHODS.POST,
+ exports2.METHODS.PUT,
+ exports2.METHODS.CONNECT,
+ exports2.METHODS.OPTIONS,
+ exports2.METHODS.TRACE,
+ exports2.METHODS.COPY,
+ exports2.METHODS.LOCK,
+ exports2.METHODS.MKCOL,
+ exports2.METHODS.MOVE,
+ exports2.METHODS.PROPFIND,
+ exports2.METHODS.PROPPATCH,
+ exports2.METHODS.SEARCH,
+ exports2.METHODS.UNLOCK,
+ exports2.METHODS.BIND,
+ exports2.METHODS.REBIND,
+ exports2.METHODS.UNBIND,
+ exports2.METHODS.ACL,
+ exports2.METHODS.REPORT,
+ exports2.METHODS.MKACTIVITY,
+ exports2.METHODS.CHECKOUT,
+ exports2.METHODS.MERGE,
+ exports2.METHODS["M-SEARCH"],
+ exports2.METHODS.NOTIFY,
+ exports2.METHODS.SUBSCRIBE,
+ exports2.METHODS.UNSUBSCRIBE,
+ exports2.METHODS.PATCH,
+ exports2.METHODS.PURGE,
+ exports2.METHODS.MKCALENDAR,
+ exports2.METHODS.LINK,
+ exports2.METHODS.UNLINK,
+ exports2.METHODS.PRI,
+ // TODO(indutny): should we allow it with HTTP?
+ exports2.METHODS.SOURCE,
+ exports2.METHODS.QUERY
+ ];
+ exports2.METHODS_ICE = [
+ exports2.METHODS.SOURCE
+ ];
+ exports2.METHODS_RTSP = [
+ exports2.METHODS.OPTIONS,
+ exports2.METHODS.DESCRIBE,
+ exports2.METHODS.ANNOUNCE,
+ exports2.METHODS.SETUP,
+ exports2.METHODS.PLAY,
+ exports2.METHODS.PAUSE,
+ exports2.METHODS.TEARDOWN,
+ exports2.METHODS.GET_PARAMETER,
+ exports2.METHODS.SET_PARAMETER,
+ exports2.METHODS.REDIRECT,
+ exports2.METHODS.RECORD,
+ exports2.METHODS.FLUSH,
+ // For AirPlay
+ exports2.METHODS.GET,
+ exports2.METHODS.POST
+ ];
+ exports2.METHOD_MAP = (0, utils_1.enumToMap)(exports2.METHODS);
+ exports2.H_METHOD_MAP = Object.fromEntries(Object.entries(exports2.METHODS).filter(([k]) => k.startsWith("H")));
+ exports2.STATUSES_HTTP = [
+ exports2.STATUSES.CONTINUE,
+ exports2.STATUSES.SWITCHING_PROTOCOLS,
+ exports2.STATUSES.PROCESSING,
+ exports2.STATUSES.EARLY_HINTS,
+ exports2.STATUSES.RESPONSE_IS_STALE,
+ exports2.STATUSES.REVALIDATION_FAILED,
+ exports2.STATUSES.DISCONNECTED_OPERATION,
+ exports2.STATUSES.HEURISTIC_EXPIRATION,
+ exports2.STATUSES.MISCELLANEOUS_WARNING,
+ exports2.STATUSES.OK,
+ exports2.STATUSES.CREATED,
+ exports2.STATUSES.ACCEPTED,
+ exports2.STATUSES.NON_AUTHORITATIVE_INFORMATION,
+ exports2.STATUSES.NO_CONTENT,
+ exports2.STATUSES.RESET_CONTENT,
+ exports2.STATUSES.PARTIAL_CONTENT,
+ exports2.STATUSES.MULTI_STATUS,
+ exports2.STATUSES.ALREADY_REPORTED,
+ exports2.STATUSES.TRANSFORMATION_APPLIED,
+ exports2.STATUSES.IM_USED,
+ exports2.STATUSES.MISCELLANEOUS_PERSISTENT_WARNING,
+ exports2.STATUSES.MULTIPLE_CHOICES,
+ exports2.STATUSES.MOVED_PERMANENTLY,
+ exports2.STATUSES.FOUND,
+ exports2.STATUSES.SEE_OTHER,
+ exports2.STATUSES.NOT_MODIFIED,
+ exports2.STATUSES.USE_PROXY,
+ exports2.STATUSES.SWITCH_PROXY,
+ exports2.STATUSES.TEMPORARY_REDIRECT,
+ exports2.STATUSES.PERMANENT_REDIRECT,
+ exports2.STATUSES.BAD_REQUEST,
+ exports2.STATUSES.UNAUTHORIZED,
+ exports2.STATUSES.PAYMENT_REQUIRED,
+ exports2.STATUSES.FORBIDDEN,
+ exports2.STATUSES.NOT_FOUND,
+ exports2.STATUSES.METHOD_NOT_ALLOWED,
+ exports2.STATUSES.NOT_ACCEPTABLE,
+ exports2.STATUSES.PROXY_AUTHENTICATION_REQUIRED,
+ exports2.STATUSES.REQUEST_TIMEOUT,
+ exports2.STATUSES.CONFLICT,
+ exports2.STATUSES.GONE,
+ exports2.STATUSES.LENGTH_REQUIRED,
+ exports2.STATUSES.PRECONDITION_FAILED,
+ exports2.STATUSES.PAYLOAD_TOO_LARGE,
+ exports2.STATUSES.URI_TOO_LONG,
+ exports2.STATUSES.UNSUPPORTED_MEDIA_TYPE,
+ exports2.STATUSES.RANGE_NOT_SATISFIABLE,
+ exports2.STATUSES.EXPECTATION_FAILED,
+ exports2.STATUSES.IM_A_TEAPOT,
+ exports2.STATUSES.PAGE_EXPIRED,
+ exports2.STATUSES.ENHANCE_YOUR_CALM,
+ exports2.STATUSES.MISDIRECTED_REQUEST,
+ exports2.STATUSES.UNPROCESSABLE_ENTITY,
+ exports2.STATUSES.LOCKED,
+ exports2.STATUSES.FAILED_DEPENDENCY,
+ exports2.STATUSES.TOO_EARLY,
+ exports2.STATUSES.UPGRADE_REQUIRED,
+ exports2.STATUSES.PRECONDITION_REQUIRED,
+ exports2.STATUSES.TOO_MANY_REQUESTS,
+ exports2.STATUSES.REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL,
+ exports2.STATUSES.REQUEST_HEADER_FIELDS_TOO_LARGE,
+ exports2.STATUSES.LOGIN_TIMEOUT,
+ exports2.STATUSES.NO_RESPONSE,
+ exports2.STATUSES.RETRY_WITH,
+ exports2.STATUSES.BLOCKED_BY_PARENTAL_CONTROL,
+ exports2.STATUSES.UNAVAILABLE_FOR_LEGAL_REASONS,
+ exports2.STATUSES.CLIENT_CLOSED_LOAD_BALANCED_REQUEST,
+ exports2.STATUSES.INVALID_X_FORWARDED_FOR,
+ exports2.STATUSES.REQUEST_HEADER_TOO_LARGE,
+ exports2.STATUSES.SSL_CERTIFICATE_ERROR,
+ exports2.STATUSES.SSL_CERTIFICATE_REQUIRED,
+ exports2.STATUSES.HTTP_REQUEST_SENT_TO_HTTPS_PORT,
+ exports2.STATUSES.INVALID_TOKEN,
+ exports2.STATUSES.CLIENT_CLOSED_REQUEST,
+ exports2.STATUSES.INTERNAL_SERVER_ERROR,
+ exports2.STATUSES.NOT_IMPLEMENTED,
+ exports2.STATUSES.BAD_GATEWAY,
+ exports2.STATUSES.SERVICE_UNAVAILABLE,
+ exports2.STATUSES.GATEWAY_TIMEOUT,
+ exports2.STATUSES.HTTP_VERSION_NOT_SUPPORTED,
+ exports2.STATUSES.VARIANT_ALSO_NEGOTIATES,
+ exports2.STATUSES.INSUFFICIENT_STORAGE,
+ exports2.STATUSES.LOOP_DETECTED,
+ exports2.STATUSES.BANDWIDTH_LIMIT_EXCEEDED,
+ exports2.STATUSES.NOT_EXTENDED,
+ exports2.STATUSES.NETWORK_AUTHENTICATION_REQUIRED,
+ exports2.STATUSES.WEB_SERVER_UNKNOWN_ERROR,
+ exports2.STATUSES.WEB_SERVER_IS_DOWN,
+ exports2.STATUSES.CONNECTION_TIMEOUT,
+ exports2.STATUSES.ORIGIN_IS_UNREACHABLE,
+ exports2.STATUSES.TIMEOUT_OCCURED,
+ exports2.STATUSES.SSL_HANDSHAKE_FAILED,
+ exports2.STATUSES.INVALID_SSL_CERTIFICATE,
+ exports2.STATUSES.RAILGUN_ERROR,
+ exports2.STATUSES.SITE_IS_OVERLOADED,
+ exports2.STATUSES.SITE_IS_FROZEN,
+ exports2.STATUSES.IDENTITY_PROVIDER_AUTHENTICATION_ERROR,
+ exports2.STATUSES.NETWORK_READ_TIMEOUT,
+ exports2.STATUSES.NETWORK_CONNECT_TIMEOUT
+ ];
+ exports2.ALPHA = [];
+ for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) {
+ exports2.ALPHA.push(String.fromCharCode(i));
+ exports2.ALPHA.push(String.fromCharCode(i + 32));
+ }
+ exports2.NUM_MAP = {
+ 0: 0,
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ 9: 9
};
- function createInflate(zlibOptions) {
- return new InflateStream(zlibOptions);
- }
- __name(createInflate, "createInflate");
- function extractMimeType(headers) {
- let charset = null;
- let essence = null;
- let mimeType = null;
- const values = getDecodeSplit("content-type", headers);
- if (values === null) {
- return "failure";
- }
- for (const value of values) {
- const temporaryMimeType = parseMIMEType(value);
- if (temporaryMimeType === "failure" || temporaryMimeType.essence === "*/*") {
- continue;
- }
- mimeType = temporaryMimeType;
- if (mimeType.essence !== essence) {
- charset = null;
- if (mimeType.parameters.has("charset")) {
- charset = mimeType.parameters.get("charset");
- }
- essence = mimeType.essence;
- } else if (!mimeType.parameters.has("charset") && charset !== null) {
- mimeType.parameters.set("charset", charset);
- }
- }
- if (mimeType == null) {
- return "failure";
- }
- return mimeType;
- }
- __name(extractMimeType, "extractMimeType");
- function gettingDecodingSplitting(value) {
- const input = value;
- const position = { position: 0 };
- const values = [];
- let temporaryValue = "";
- while (position.position < input.length) {
- temporaryValue += collectASequenceOfCodePoints(
- (char) => char !== '"' && char !== ",",
- input,
- position
- );
- if (position.position < input.length) {
- if (input.charCodeAt(position.position) === 34) {
- temporaryValue += collectAnHTTPQuotedString(
- input,
- position
- );
- if (position.position < input.length) {
- continue;
- }
- } else {
- assert(input.charCodeAt(position.position) === 44);
- position.position++;
- }
- }
- temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 9 || char === 32);
- values.push(temporaryValue);
- temporaryValue = "";
+ exports2.HEX_MAP = {
+ 0: 0,
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ 9: 9,
+ A: 10,
+ B: 11,
+ C: 12,
+ D: 13,
+ E: 14,
+ F: 15,
+ a: 10,
+ b: 11,
+ c: 12,
+ d: 13,
+ e: 14,
+ f: 15
+ };
+ exports2.NUM = [
+ "0",
+ "1",
+ "2",
+ "3",
+ "4",
+ "5",
+ "6",
+ "7",
+ "8",
+ "9"
+ ];
+ exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM);
+ exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
+ exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
+ exports2.URL_CHAR = [
+ "!",
+ '"',
+ "$",
+ "%",
+ "&",
+ "'",
+ "(",
+ ")",
+ "*",
+ "+",
+ ",",
+ "-",
+ ".",
+ "/",
+ ":",
+ ";",
+ "<",
+ "=",
+ ">",
+ "@",
+ "[",
+ "\\",
+ "]",
+ "^",
+ "_",
+ "`",
+ "{",
+ "|",
+ "}",
+ "~"
+ ].concat(exports2.ALPHANUM);
+ exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
+ exports2.TOKEN = [
+ "!",
+ "#",
+ "$",
+ "%",
+ "&",
+ "'",
+ "*",
+ "+",
+ "-",
+ ".",
+ "^",
+ "_",
+ "`",
+ "|",
+ "~"
+ ].concat(exports2.ALPHANUM);
+ exports2.HEADER_CHARS = [" "];
+ for (let i = 32; i <= 255; i++) {
+ if (i !== 127) {
+ exports2.HEADER_CHARS.push(i);
}
- return values;
}
- __name(gettingDecodingSplitting, "gettingDecodingSplitting");
- function getDecodeSplit(name, list) {
- const value = list.get(name, true);
- if (value === null) {
- return null;
+ exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44);
+ exports2.QUOTED_STRING = [" ", " "];
+ for (let i = 33; i <= 255; i++) {
+ if (i !== 34 && i !== 92) {
+ exports2.QUOTED_STRING.push(i);
}
- return gettingDecodingSplitting(value);
- }
- __name(getDecodeSplit, "getDecodeSplit");
- function hasAuthenticationEntry(request) {
- return false;
}
- __name(hasAuthenticationEntry, "hasAuthenticationEntry");
- function includesCredentials(url) {
- return !!(url.username || url.password);
+ exports2.HTAB_SP_VCHAR_OBS_TEXT = [" ", " "];
+ for (let i = 33; i <= 126; i++) {
+ exports2.HTAB_SP_VCHAR_OBS_TEXT.push(i);
}
- __name(includesCredentials, "includesCredentials");
- function isTraversableNavigable(navigable) {
- return navigable != null && navigable !== "client" && navigable !== "no-traversable";
+ for (let i = 128; i <= 255; i++) {
+ exports2.HTAB_SP_VCHAR_OBS_TEXT.push(i);
}
- __name(isTraversableNavigable, "isTraversableNavigable");
- var EnvironmentSettingsObjectBase = class {
- static {
- __name(this, "EnvironmentSettingsObjectBase");
- }
- get baseUrl() {
- return getGlobalOrigin();
- }
- get origin() {
- return this.baseUrl?.origin;
- }
- policyContainer = makePolicyContainer();
- };
- var EnvironmentSettingsObject = class {
- static {
- __name(this, "EnvironmentSettingsObject");
- }
- settingsObject = new EnvironmentSettingsObjectBase();
+ exports2.MAJOR = exports2.NUM_MAP;
+ exports2.MINOR = exports2.MAJOR;
+ exports2.SPECIAL_HEADERS = {
+ "connection": exports2.HEADER_STATE.CONNECTION,
+ "content-length": exports2.HEADER_STATE.CONTENT_LENGTH,
+ "proxy-connection": exports2.HEADER_STATE.CONNECTION,
+ "transfer-encoding": exports2.HEADER_STATE.TRANSFER_ENCODING,
+ "upgrade": exports2.HEADER_STATE.UPGRADE
};
- var environmentSettingsObject = new EnvironmentSettingsObject();
- module2.exports = {
- isAborted,
- isCancelled,
- isValidEncodedURL,
- tryUpgradeRequestToAPotentiallyTrustworthyURL,
- clampAndCoarsenConnectionTimingInfo,
- coarsenedSharedCurrentTime,
- determineRequestsReferrer,
- makePolicyContainer,
- clonePolicyContainer,
- appendFetchMetadata,
- appendRequestOriginHeader,
- TAOCheck,
- corsCheck,
- crossOriginResourcePolicyCheck,
- createOpaqueTimingInfo,
- setRequestReferrerPolicyOnRedirect,
- isValidHTTPToken,
- requestBadPort,
- requestCurrentURL,
- responseURL,
- responseLocationURL,
- isURLPotentiallyTrustworthy,
- isValidReasonPhrase,
- sameOrigin,
- normalizeMethod,
- iteratorMixin,
- createIterator,
- isValidHeaderName,
- isValidHeaderValue,
- isErrorLike,
- fullyReadBody,
- readableStreamClose,
- urlIsLocal,
- urlHasHttpsScheme,
- urlIsHttpHttpsScheme,
- readAllBytes,
- simpleRangeHeaderValue,
- buildContentRange,
- createInflate,
- extractMimeType,
- getDecodeSplit,
- environmentSettingsObject,
- isOriginIPPotentiallyTrustworthy,
- hasAuthenticationEntry,
- includesCredentials,
- isTraversableNavigable
+ exports2.default = {
+ ERROR: exports2.ERROR,
+ TYPE: exports2.TYPE,
+ FLAGS: exports2.FLAGS,
+ LENIENT_FLAGS: exports2.LENIENT_FLAGS,
+ METHODS: exports2.METHODS,
+ STATUSES: exports2.STATUSES,
+ FINISH: exports2.FINISH,
+ HEADER_STATE: exports2.HEADER_STATE,
+ ALPHA: exports2.ALPHA,
+ NUM_MAP: exports2.NUM_MAP,
+ HEX_MAP: exports2.HEX_MAP,
+ NUM: exports2.NUM,
+ ALPHANUM: exports2.ALPHANUM,
+ MARK: exports2.MARK,
+ USERINFO_CHARS: exports2.USERINFO_CHARS,
+ URL_CHAR: exports2.URL_CHAR,
+ HEX: exports2.HEX,
+ TOKEN: exports2.TOKEN,
+ HEADER_CHARS: exports2.HEADER_CHARS,
+ CONNECTION_TOKEN_CHARS: exports2.CONNECTION_TOKEN_CHARS,
+ QUOTED_STRING: exports2.QUOTED_STRING,
+ HTAB_SP_VCHAR_OBS_TEXT: exports2.HTAB_SP_VCHAR_OBS_TEXT,
+ MAJOR: exports2.MAJOR,
+ MINOR: exports2.MINOR,
+ SPECIAL_HEADERS: exports2.SPECIAL_HEADERS,
+ METHODS_HTTP: exports2.METHODS_HTTP,
+ METHODS_ICE: exports2.METHODS_ICE,
+ METHODS_RTSP: exports2.METHODS_RTSP,
+ METHOD_MAP: exports2.METHOD_MAP,
+ H_METHOD_MAP: exports2.H_METHOD_MAP,
+ STATUSES_HTTP: exports2.STATUSES_HTTP
};
}
});
-// lib/util/runtime-features.js
-var require_runtime_features = __commonJS({
- "lib/util/runtime-features.js"(exports2, module2) {
+// lib/llhttp/llhttp-wasm.js
+var require_llhttp_wasm = __commonJS({
+ "lib/llhttp/llhttp-wasm.js"(exports2, module2) {
"use strict";
- var lazyLoaders = {
- __proto__: null,
- "node:crypto": /* @__PURE__ */ __name(() => require("node:crypto"), "node:crypto"),
- "node:sqlite": /* @__PURE__ */ __name(() => require("node:sqlite"), "node:sqlite")
- };
- function detectRuntimeFeatureByNodeModule(moduleName) {
- try {
- lazyLoaders[moduleName]();
- return true;
- } catch (err) {
- if (err.code !== "ERR_UNKNOWN_BUILTIN_MODULE" && err.code !== "ERR_NO_CRYPTO") {
- throw err;
- }
- return false;
- }
- }
- __name(detectRuntimeFeatureByNodeModule, "detectRuntimeFeatureByNodeModule");
- var runtimeFeaturesAsNodeModule = (
- /** @type {const} */
- ["crypto", "sqlite"]
- );
- function detectRuntimeFeature(feature) {
- if (runtimeFeaturesAsNodeModule.includes(
- /** @type {RuntimeFeatureByNodeModule} */
- feature
- )) {
- return detectRuntimeFeatureByNodeModule(`node:${feature}`);
- }
- throw new TypeError(`unknown feature: ${feature}`);
- }
- __name(detectRuntimeFeature, "detectRuntimeFeature");
- var RuntimeFeatures = class {
- static {
- __name(this, "RuntimeFeatures");
- }
- /** @type {Map<Feature, boolean>} */
- #map = /* @__PURE__ */ new Map();
- /**
- * Clears all cached feature detections.
- */
- clear() {
- this.#map.clear();
- }
- /**
- * @param {Feature} feature
- * @returns {boolean}
- */
- has(feature) {
- return this.#map.get(feature) ?? this.#detectRuntimeFeature(feature);
- }
- /**
- * @param {Feature} feature
- * @param {boolean} value
- */
- set(feature, value) {
- if (runtimeFeaturesAsNodeModule.includes(feature) === false) {
- throw new TypeError(`unknown feature: ${feature}`);
- }
- this.#map.set(feature, value);
- }
- /**
- * @param {Feature} feature
- * @returns {boolean}
- */
- #detectRuntimeFeature(feature) {
- const result = detectRuntimeFeature(feature);
- this.#map.set(feature, result);
- return result;
- }
- };
- var instance = new RuntimeFeatures();
- module2.exports.runtimeFeatures = instance;
- module2.exports.default = instance;
+ var { Buffer: Buffer2 } = require("node:buffer");
+ var wasmBase64 = "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";
+ var wasmBuffer;
+ Object.defineProperty(module2, "exports", {
+ get: /* @__PURE__ */ __name(() => {
+ return wasmBuffer ? wasmBuffer : wasmBuffer = Buffer2.from(wasmBase64, "base64");
+ }, "get")
+ });
}
});
-// lib/web/fetch/formdata.js
-var require_formdata = __commonJS({
- "lib/web/fetch/formdata.js"(exports2, module2) {
+// lib/llhttp/llhttp_simd-wasm.js
+var require_llhttp_simd_wasm = __commonJS({
+ "lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) {
"use strict";
- var { iteratorMixin } = require_util2();
- var { kEnumerableProperty } = require_util();
- var { webidl } = require_webidl();
- var nodeUtil = require("node:util");
- var { runtimeFeatures } = require_runtime_features();
- var random = runtimeFeatures.has("crypto") ? require("node:crypto").randomInt : (max) => Math.floor(Math.random() * max);
- var getFormDataState;
- var setFormDataState;
- var getFormDataBoundary;
- var FormData = class {
- static {
- __name(this, "FormData");
- }
- #state = [];
- #boundary = null;
- constructor(form = void 0) {
- webidl.util.markAsUncloneable(this);
- if (form !== void 0) {
- throw webidl.errors.conversionFailed({
- prefix: "FormData constructor",
- argument: "Argument 1",
- types: ["undefined"]
- });
- }
- }
- append(name, value, filename = void 0) {
- webidl.brandCheck(this, webidl.is.FormData);
- const prefix = "FormData.append";
- webidl.argumentLengthCheck(arguments, 2, prefix);
- name = webidl.converters.USVString(name);
- if (arguments.length === 3 || webidl.is.Blob(value)) {
- value = webidl.converters.Blob(value, prefix, "value");
- if (filename !== void 0) {
- filename = webidl.converters.USVString(filename);
- }
- } else {
- value = webidl.converters.USVString(value);
- }
- const entry = makeEntry(name, value, filename);
- this.#state.push(entry);
- }
- delete(name) {
- webidl.brandCheck(this, webidl.is.FormData);
- const prefix = "FormData.delete";
- webidl.argumentLengthCheck(arguments, 1, prefix);
- name = webidl.converters.USVString(name);
- this.#state = this.#state.filter((entry) => entry.name !== name);
- }
- get(name) {
- webidl.brandCheck(this, webidl.is.FormData);
- const prefix = "FormData.get";
- webidl.argumentLengthCheck(arguments, 1, prefix);
- name = webidl.converters.USVString(name);
- const idx = this.#state.findIndex((entry) => entry.name === name);
- if (idx === -1) {
- return null;
- }
- return this.#state[idx].value;
- }
- getAll(name) {
- webidl.brandCheck(this, webidl.is.FormData);
- const prefix = "FormData.getAll";
- webidl.argumentLengthCheck(arguments, 1, prefix);
- name = webidl.converters.USVString(name);
- return this.#state.filter((entry) => entry.name === name).map((entry) => entry.value);
- }
- has(name) {
- webidl.brandCheck(this, webidl.is.FormData);
- const prefix = "FormData.has";
- webidl.argumentLengthCheck(arguments, 1, prefix);
- name = webidl.converters.USVString(name);
- return this.#state.findIndex((entry) => entry.name === name) !== -1;
- }
- set(name, value, filename = void 0) {
- webidl.brandCheck(this, webidl.is.FormData);
- const prefix = "FormData.set";
- webidl.argumentLengthCheck(arguments, 2, prefix);
- name = webidl.converters.USVString(name);
- if (arguments.length === 3 || webidl.is.Blob(value)) {
- value = webidl.converters.Blob(value, prefix, "value");
- if (filename !== void 0) {
- filename = webidl.converters.USVString(filename);
- }
- } else {
- value = webidl.converters.USVString(value);
- }
- const entry = makeEntry(name, value, filename);
- const idx = this.#state.findIndex((entry2) => entry2.name === name);
- if (idx !== -1) {
- this.#state = [
- ...this.#state.slice(0, idx),
- entry,
- ...this.#state.slice(idx + 1).filter((entry2) => entry2.name !== name)
- ];
- } else {
- this.#state.push(entry);
- }
- }
- [nodeUtil.inspect.custom](depth, options) {
- const state = this.#state.reduce((a, b) => {
- if (a[b.name]) {
- if (Array.isArray(a[b.name])) {
- a[b.name].push(b.value);
- } else {
- a[b.name] = [a[b.name], b.value];
- }
- } else {
- a[b.name] = b.value;
- }
- return a;
- }, { __proto__: null });
- options.depth ??= depth;
- options.colors ??= true;
- const output = nodeUtil.formatWithOptions(options, state);
- return `FormData ${output.slice(output.indexOf("]") + 2)}`;
- }
- static {
- getFormDataState = /* @__PURE__ */ __name((formData) => formData.#state, "getFormDataState");
- setFormDataState = /* @__PURE__ */ __name((formData, newState) => {
- formData.#state = newState;
- }, "setFormDataState");
- getFormDataBoundary = /* @__PURE__ */ __name((formData) => {
- return formData.#boundary ??= `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
- }, "getFormDataBoundary");
- webidl.is.FormData = (arg) => {
- return arg != null && typeof arg === "object" && #state in arg;
- };
- }
- };
- iteratorMixin("FormData", FormData, getFormDataState, "name", "value", webidl.is.FormData);
- Object.defineProperties(FormData.prototype, {
- append: kEnumerableProperty,
- delete: kEnumerableProperty,
- get: kEnumerableProperty,
- getAll: kEnumerableProperty,
- has: kEnumerableProperty,
- set: kEnumerableProperty,
- [Symbol.toStringTag]: {
- value: "FormData",
- configurable: true
- }
+ var { Buffer: Buffer2 } = require("node:buffer");
+ var wasmBase64 = "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";
+ var wasmBuffer;
+ Object.defineProperty(module2, "exports", {
+ get: /* @__PURE__ */ __name(() => {
+ return wasmBuffer ? wasmBuffer : wasmBuffer = Buffer2.from(wasmBase64, "base64");
+ }, "get")
});
- function makeEntry(name, value, filename) {
- if (typeof value === "string") {
- } else {
- if (!webidl.is.File(value)) {
- value = new File([value], "blob", { type: value.type });
- }
- if (filename !== void 0) {
- const options = {
- type: value.type,
- lastModified: value.lastModified
- };
- value = new File([value], filename, options);
- }
- }
- return { name, value };
- }
- __name(makeEntry, "makeEntry");
- module2.exports = { FormData, makeEntry, setFormDataState, getFormDataBoundary };
}
});
@@ -6576,14 +6677,19 @@ var require_formdata_parser = __commonJS({
input,
position
);
- if (headerValue[0] !== 117 && headerValue[0] !== 85 || // u or U
+ const charsetSeparator = headerValue.indexOf(39);
+ const languageSeparator = charsetSeparator === -1 ? -1 : headerValue.indexOf(39, charsetSeparator + 1);
+ if (charsetSeparator === -1 || languageSeparator === -1) {
+ throw parsingError("expected charset and language separators in extended value");
+ }
+ if (charsetSeparator !== 5 || headerValue[0] !== 117 && headerValue[0] !== 85 || // u or U
headerValue[1] !== 116 && headerValue[1] !== 84 || // t or T
headerValue[2] !== 102 && headerValue[2] !== 70 || // f or F
headerValue[3] !== 45 || // -
headerValue[4] !== 56) {
- throw parsingError("unknown encoding, expected utf-8''");
+ throw parsingError("unknown charset, expected utf-8");
}
- value = decodeURIComponent(decoder.decode(headerValue.subarray(7)));
+ value = decodeURIComponent(decoder.decode(headerValue.subarray(languageSeparator + 1)));
} else if (input[position.position] === 34) {
position.position++;
const quotedValue = collectASequenceOfBytes(
@@ -6811,19 +6917,38 @@ var require_body = __commonJS({
});
function extractBody(object, keepalive = false) {
let stream = null;
- let controller = null;
if (webidl.is.ReadableStream(object)) {
stream = object;
} else if (webidl.is.Blob(object)) {
stream = object.stream();
} else {
stream = new ReadableStream({
- pull() {
+ start() {
},
- start(c) {
- controller = c;
+ async pull(controller) {
+ const result = action();
+ const iterator = result?.[Symbol.asyncIterator]?.();
+ if (iterator == null) {
+ if (result?.length && !isErrored(stream)) {
+ controller.enqueue(typeof result === "string" ? textEncoder.encode(result) : new Uint8Array(result));
+ }
+ queueMicrotask(() => readableStreamClose(controller));
+ return;
+ }
+ while (true) {
+ const { value, done } = await iterator.next();
+ if (done) {
+ queueMicrotask(() => readableStreamClose(controller));
+ return;
+ }
+ if (value.length && !isErrored(stream)) {
+ controller.enqueue(new Uint8Array(value));
+ return;
+ }
+ }
},
- cancel() {
+ cancel(reason) {
+ return action()[Symbol.asyncIterator]?.().return(reason);
},
type: "bytes"
});
@@ -6880,7 +7005,7 @@ Content-Type: ${value.type || "application/octet-stream"}\r
length = null;
}
source = object;
- action = /* @__PURE__ */ __name(async function* () {
+ const parts = (async function* () {
for (const part of blobParts) {
if (part.stream) {
yield* part.stream();
@@ -6888,7 +7013,8 @@ Content-Type: ${value.type || "application/octet-stream"}\r
yield part;
}
}
- }, "action");
+ })();
+ action = /* @__PURE__ */ __name(() => parts, "action");
type = `multipart/form-data; boundary=${boundary}`;
} else if (webidl.is.Blob(object)) {
source = object;
@@ -6906,37 +7032,17 @@ Content-Type: ${value.type || "application/octet-stream"}\r
);
}
stream = webidl.is.ReadableStream(object) ? object : ReadableStream.from(object).pipeThrough(new TransformStream({
- transform(chunk, controller2) {
+ transform(chunk, controller) {
const bytes = isUint8Array(chunk) ? chunk : Buffer.from(chunk);
if (bytes.byteLength) {
- controller2.enqueue(bytes);
+ controller.enqueue(bytes);
}
}
}));
}
if (typeof source === "string" || isUint8Array(source)) {
- action = /* @__PURE__ */ __name(() => {
- length = typeof source === "string" ? Buffer.byteLength(source) : source.length;
- return source;
- }, "action");
- }
- if (action != null) {
- ;
- (async () => {
- const result = action();
- const iterator = result?.[Symbol.asyncIterator]?.();
- if (iterator) {
- for await (const bytes of iterator) {
- if (isErrored(stream)) break;
- if (bytes.length) {
- controller.enqueue(new Uint8Array(bytes));
- }
- }
- } else if (result?.length && !isErrored(stream)) {
- controller.enqueue(typeof result === "string" ? textEncoder.encode(result) : new Uint8Array(result));
- }
- queueMicrotask(() => readableStreamClose(controller));
- })();
+ action = /* @__PURE__ */ __name(() => source, "action");
+ length = typeof source === "string" ? Buffer.byteLength(source) : source.length;
}
const body = { stream, source, length };
return [body, type];
@@ -7117,6 +7223,7 @@ var require_client_h1 = __commonJS({
InformationalError,
BodyTimeoutError,
HTTPParserError,
+ WebAssemblyNotSupportedError,
ResponseExceededMaxSizeError
} = require_errors();
var {
@@ -7151,9 +7258,11 @@ var require_client_h1 = __commonJS({
kOnError,
kResume,
kHTTPContext,
- kClosed
+ kClosed,
+ kUseMilo
} = require_symbols();
- var constants = require_constants2();
+ var constants = require_constants3();
+ var { H1Parser, getMiloEnabled } = false ? null : {};
var EMPTY_BUF = Buffer.alloc(0);
var FastBuffer = Buffer[Symbol.species];
var removeAllListeners = util.removeAllListeners;
@@ -7163,6 +7272,9 @@ var require_client_h1 = __commonJS({
var kTypeOfService = /* @__PURE__ */ Symbol("kTypeOfService");
var extractBody;
function lazyllhttp() {
+ if (typeof WebAssembly === "undefined") {
+ throw new WebAssemblyNotSupportedError();
+ }
const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
let mod;
let useWasmSIMD = true;
@@ -7288,10 +7400,10 @@ var require_client_h1 = __commonJS({
__name(this, "Parser");
}
/**
- * @param {import('./client.js')} client
- * @param {import('net').Socket} socket
- * @param {*} llhttp
- */
+ * @param {import('./client.js')} client
+ * @param {import('net').Socket} socket
+ * @param {*} llhttp
+ */
constructor(client, socket, { exports: exports3 }) {
this.llhttp = exports3;
this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE);
@@ -7313,7 +7425,8 @@ var require_client_h1 = __commonJS({
this.bytesRead = 0;
this.keepAlive = "";
this.contentLength = -1;
- this.connectionKeepAlive = false;
+ this.hasTransferEncoding = false;
+ this.connection = "";
this.maxResponseSize = client[kMaxResponseSize];
}
setTimeout(delay, type) {
@@ -7512,6 +7625,7 @@ var require_client_h1 = __commonJS({
*/
onHeaderValue(buf) {
let len = this.headers.length;
+ const isContinuation = (len & 1) === 0;
if ((len & 1) === 1) {
this.headers.push(buf);
len += 1;
@@ -7522,9 +7636,9 @@ var require_client_h1 = __commonJS({
if (key.length === 10) {
const headerName = util.bufferToLowerCasedHeaderName(key);
if (headerName === "keep-alive") {
- this.keepAlive += buf.toString();
+ this.keepAlive += (isContinuation || this.keepAlive.length === 0 ? "" : ",") + buf.toString();
} else if (headerName === "connection") {
- this.connectionKeepAlive = this.headers[len - 1].length === 10 && util.bufferToLowerCasedHeaderName(this.headers[len - 1]) === "keep-alive";
+ this.connection += (isContinuation || this.connection.length === 0 ? "" : ",") + buf.toString();
}
} else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === "content-length") {
if (this.contentLength === -1) {
@@ -7533,6 +7647,8 @@ var require_client_h1 = __commonJS({
for (let i = 0; i < buf.length; i++) {
this.contentLength = this.contentLength * 10 + (buf[i] - 48);
}
+ } else if (key.length === 17 && util.bufferToLowerCasedHeaderName(key) === "transfer-encoding") {
+ this.hasTransferEncoding = true;
}
this.trackHeader(buf.length);
return 0;
@@ -7614,7 +7730,13 @@ var require_client_h1 = __commonJS({
assert(this.timeoutType === TIMEOUT_HEADERS);
this.statusCode = statusCode;
this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
- request.method === "HEAD" && !socket[kReset] && this.connectionKeepAlive;
+ request.method === "HEAD" && !socket[kReset] && /(?:^|,)[\t ]*keep-alive[\t ]*(?:,|$)/i.test(this.connection) && !/(?:^|,)[\t ]*close[\t ]*(?:,|$)/i.test(this.connection);
+ if (request.method === "HEAD" || statusCode === 204 || statusCode === 304) {
+ if (request.method !== "HEAD" && (this.contentLength > 0 || this.hasTransferEncoding)) {
+ this.shouldKeepAlive = false;
+ }
+ this.contentLength = -1;
+ }
if (this.statusCode >= 200) {
const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout];
this.setTimeout(bodyTimeout, TIMEOUT_BODY);
@@ -7639,10 +7761,7 @@ var require_client_h1 = __commonJS({
if (this.shouldKeepAlive && client[kPipelining]) {
const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null;
if (keepAliveTimeout != null) {
- const timeout = Math.min(
- keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
- client[kKeepAliveMaxTimeout]
- );
+ const timeout = Math.min(keepAliveTimeout - client[kKeepAliveTimeoutThreshold], client[kKeepAliveMaxTimeout]);
if (timeout <= 0) {
socket[kReset] = true;
} else {
@@ -7717,14 +7836,15 @@ var require_client_h1 = __commonJS({
this.statusText = "";
this.bytesRead = 0;
this.contentLength = -1;
+ this.hasTransferEncoding = false;
this.keepAlive = "";
- this.connectionKeepAlive = false;
+ this.connection = "";
this.headers = [];
this.headersSize = 0;
if (statusCode < 200) {
return 0;
}
- if (request.method !== "HEAD" && contentLength !== -1 && bytesRead !== contentLength) {
+ if (contentLength !== -1 && bytesRead !== contentLength) {
util.destroy(socket, new ResponseContentLengthMismatchError());
return -1;
}
@@ -7788,7 +7908,7 @@ var require_client_h1 = __commonJS({
socket[kIdleSocketValidation] = 0;
socket[kIdleSocketValidationTimeout] = null;
socket[kSocketUsed] = false;
- socket[kParser] = new Parser(client, socket, llhttpInstance);
+ socket[kParser] = false ? new H1Parser(client, socket) : new Parser(client, socket, llhttpInstance);
util.addListener(socket, "error", onHttpSocketError);
util.addListener(socket, "readable", onHttpSocketReadable);
util.addListener(socket, "end", onHttpSocketEnd);
@@ -7847,7 +7967,6 @@ var require_client_h1 = __commonJS({
}
__name(connectH1, "connectH1");
function onHttpSocketError(err) {
- assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
const parser = this[kParser];
if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
const parserErr = parser.finish();
@@ -8323,8 +8442,23 @@ upgrade: ${upgrade}\r
this.expectsPayload = expectsPayload;
this.header = header;
this.abort = abort;
+ this.lengthMismatch = false;
socket[kWriting] = true;
}
+ /**
+ * The body doesn't match the declared content-length and strictContentLength
+ * is off. Warn once, and mark the socket so it isn't reused: on the wire this
+ * request's body no longer ends where the server expects, so anything sent
+ * after it on the same connection would be misread.
+ * @returns {void}
+ */
+ onLengthMismatch() {
+ this.socket[kReset] = true;
+ if (!this.lengthMismatch) {
+ this.lengthMismatch = true;
+ process.emitWarning(new RequestContentLengthMismatchError());
+ }
+ }
/**
* @param {string|Uint8Array} chunk
* @returns
@@ -8337,7 +8471,7 @@ upgrade: ${upgrade}\r
if (socket.destroyed) {
return false;
}
- const len = chunk instanceof Uint8Array ? chunk.byteLength : Buffer.byteLength(chunk);
+ let len = chunk instanceof Uint8Array ? chunk.byteLength : Buffer.byteLength(chunk);
if (!len) {
return true;
}
@@ -8345,7 +8479,13 @@ upgrade: ${upgrade}\r
if (client[kStrictContentLength]) {
throw new RequestContentLengthMismatchError();
}
- process.emitWarning(new RequestContentLengthMismatchError());
+ this.onLengthMismatch();
+ const remaining = contentLength - bytesWritten;
+ if (remaining === 0) {
+ return true;
+ }
+ chunk = (typeof chunk === "string" ? Buffer.from(chunk) : chunk).subarray(0, remaining);
+ len = remaining;
}
socket.cork();
if (bytesWritten === 0) {
@@ -8407,9 +8547,8 @@ ${len.toString(16)}\r
if (contentLength !== null && bytesWritten !== contentLength) {
if (client[kStrictContentLength]) {
throw new RequestContentLengthMismatchError();
- } else {
- process.emitWarning(new RequestContentLengthMismatchError());
}
+ this.onLengthMismatch();
}
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
if (socket[kParser].timeout.refresh) {
@@ -8873,7 +9012,10 @@ var require_client_h2 = __commonJS({
}
__name(applyConnectionWindowSize, "applyConnectionWindowSize");
function onHttp2RemoteSettings(settings) {
- this[kClient][kMaxConcurrentStreams] = settings.maxConcurrentStreams ?? this[kClient][kMaxConcurrentStreams];
+ const client = this[kClient];
+ const localMaxConcurrentStreams = client[kHTTP2Options].maxConcurrentStreams;
+ const remoteMaxConcurrentStreams = settings.maxConcurrentStreams ?? client[kMaxConcurrentStreams] ?? localMaxConcurrentStreams;
+ client[kMaxConcurrentStreams] = Math.min(remoteMaxConcurrentStreams, localMaxConcurrentStreams);
if (this[kRemoteSettings] === true && this[kEnableConnectProtocol] === true && settings.enableConnectProtocol === false) {
const err = new InformationalError("HTTP/2: Server disabled extended CONNECT protocol against RFC-8441");
this[kSocket][kError] = err;
@@ -8908,7 +9050,6 @@ var require_client_h2 = __commonJS({
}
__name(onHttp2SendPing, "onHttp2SendPing");
function onHttp2SessionError(err) {
- assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
this[kSocket][kError] = err;
if (this[kReceivedGoAway]) {
return;
@@ -8963,6 +9104,9 @@ var require_client_h2 = __commonJS({
client[kHTTPContext] = null;
client[kHTTP2Session] = null;
}
+ if (this[kOpenStreams] === 0) {
+ unrefH2Session(this);
+ }
clearHttp2IdleTimeout(this);
clearNoStreamsTimeout(this);
if (!this.closed && !this.destroyed) {
@@ -9021,7 +9165,6 @@ var require_client_h2 = __commonJS({
}
__name(onHttp2SocketClose, "onHttp2SocketClose");
function onHttp2SocketError(err) {
- assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
this[kError] = err;
if (this[kHTTP2Session]?.[kReceivedGoAway]) {
return;
@@ -9088,21 +9231,21 @@ var require_client_h2 = __commonJS({
for (let n = 0; n < reqHeaders.length; n += 2) {
const key = reqHeaders[n + 0];
const val = reqHeaders[n + 1];
- const current = headers[key];
+ const current = Object.hasOwn(headers, key) ? headers[key] : void 0;
if (key === "cookie") {
if (current != null) {
- headers[key] = Array.isArray(current) ? (current.push(val), current) : [current, val];
+ util.setHeader(headers, key, Array.isArray(current) ? (current.push(val), current) : [current, val]);
} else {
- headers[key] = val;
+ util.setHeader(headers, key, val);
}
continue;
}
if (typeof val === "string") {
- headers[key] = current ? `${current}, ${val}` : val;
+ util.setHeader(headers, key, current ? `${current}, ${val}` : val);
continue;
}
for (let i = 0; i < val.length; i++) {
- headers[key] = headers[key] ? `${headers[key]}, ${val[i]}` : val[i];
+ util.setHeader(headers, key, Object.hasOwn(headers, key) ? `${headers[key]}, ${val[i]}` : val[i]);
}
}
return headers;
@@ -9459,10 +9602,26 @@ var require_client_h2 = __commonJS({
}
state.bytesRead += chunk.length;
if (request.onResponseData(chunk) === false) {
- stream.pause();
+ pauseResponseStream(stream, state);
}
}
__name(onData, "onData");
+ function pauseResponseStream(stream, state) {
+ stream.pause();
+ if (state.bodyTimeout) {
+ stream.setTimeout(0);
+ }
+ }
+ __name(pauseResponseStream, "pauseResponseStream");
+ function resumeResponseStream() {
+ const stream = this;
+ const state = stream[kRequestStreamState];
+ if (state != null && state.bodyTimeout && stream.isPaused()) {
+ stream.setTimeout(state.bodyTimeout);
+ }
+ stream.resume();
+ }
+ __name(resumeResponseStream, "resumeResponseStream");
function onInterimResponse(headers) {
const stream = this;
const state = stream[kRequestStreamState];
@@ -9505,8 +9664,8 @@ var require_client_h2 = __commonJS({
releaseRequestStream(stream);
return;
}
- if (request.onResponseStart(statusCode, headers, stream.resume.bind(stream), "") === false) {
- stream.pause();
+ if (request.onResponseStart(statusCode, headers, resumeResponseStream.bind(stream), "") === false) {
+ pauseResponseStream(stream, state);
}
stream.on("data", onData);
}
@@ -9858,7 +10017,8 @@ var require_client = __commonJS({
kMaxConcurrentStreams,
kHostAuthority,
kResume,
- kHTTP2Options
+ kHTTP2Options,
+ kUseMilo
} = require_symbols();
var connectH1 = require_client_h1();
var connectH2 = require_client_h2();
@@ -9928,6 +10088,7 @@ var require_client = __commonJS({
initialWindowSize,
connectionWindowSize,
pingInterval,
+ useMilo,
webSocket,
h2Options,
eventSource
@@ -10090,6 +10251,7 @@ var require_client = __commonJS({
initialWindowSize: h2Options?.initialWindowSize ?? initialWindowSize ?? 262144
}
};
+ this[kUseMilo] = useMilo;
this[kQueue] = [];
this[kRunningIdx] = 0;
this[kPendingIdx] = 0;
@@ -10419,14 +10581,15 @@ var require_pool = __commonJS({
kOnClientDrain,
kGetDispatcher,
kHasDispatcher,
- kRemoveClient
+ kRemoveClient,
+ kRetireClient
} = require_pool_base();
var Client = require_client();
var {
InvalidArgumentError
} = require_errors();
var util = require_util();
- var { kConnecting, kHTTPContext, kUrl } = require_symbols();
+ var { kConnecting, kHTTPContext, kUrl, kQueued } = require_symbols();
var buildConnector = require_connect();
var kOptions = /* @__PURE__ */ Symbol("options");
var kConnections = /* @__PURE__ */ Symbol("connections");
@@ -10527,12 +10690,11 @@ var require_pool = __commonJS({
this[kProtocolProbe] = null;
resumeQueued = true;
}
- const idx = this[kClients].indexOf(target);
- if (idx !== -1) {
- this[kClients].splice(idx, 1);
+ if (this[kClients].includes(target)) {
+ this[kRetireClient](target);
}
}
- if (resumeQueued) {
+ if (resumeQueued || this[kQueued] > 0) {
this[kDrainQueue](origin2, targets.slice(1));
}
});
@@ -10615,7 +10777,7 @@ var require_agent = __commonJS({
static {
__name(this, "Agent");
}
- constructor({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
+ constructor({ factory = defaultFactory, maxOrigins = Infinity, connect, tls, ...options } = {}) {
if (typeof factory !== "function") {
throw new InvalidArgumentError("factory must be a function.");
}
@@ -10629,7 +10791,10 @@ var require_agent = __commonJS({
if (connect && typeof connect !== "function") {
connect = { ...connect };
}
- this[kOptions] = { ...util.deepClone(options), maxOrigins, connect };
+ if (tls && typeof tls !== "function") {
+ tls = { ...tls };
+ }
+ this[kOptions] = { ...util.deepClone(options), maxOrigins, connect, tls };
this[kFactory] = factory;
this[kClients] = /* @__PURE__ */ new Map();
this[kOrigins] = /* @__PURE__ */ new Set();
@@ -10752,11 +10917,11 @@ var require_dispatcher1_wrapper = __commonJS({
this.#handler.onConnect?.((reason) => controller.abort(reason), context);
}
onRequestUpgrade(controller, statusCode, headers, socket) {
- const rawHeaders = controller?.rawHeaders ?? toRawHeaders(headers ?? {});
+ const rawHeaders = Array.isArray(controller?.rawHeaders) ? controller.rawHeaders : toRawHeaders(controller?.rawHeaders ?? headers ?? {});
this.#handler.onUpgrade?.(statusCode, rawHeaders, socket);
}
onResponseStart(controller, statusCode, headers, statusMessage) {
- const rawHeaders = controller?.rawHeaders ?? toRawHeaders(headers ?? {});
+ const rawHeaders = Array.isArray(controller?.rawHeaders) ? controller.rawHeaders : toRawHeaders(controller?.rawHeaders ?? headers ?? {});
if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === false) {
controller.pause();
}
@@ -10767,7 +10932,7 @@ var require_dispatcher1_wrapper = __commonJS({
}
}
onResponseEnd(controller, trailers) {
- const rawTrailers = controller?.rawTrailers ?? toRawHeaders(trailers ?? {});
+ const rawTrailers = Array.isArray(controller?.rawTrailers) ? controller.rawTrailers : toRawHeaders(controller?.rawTrailers ?? trailers ?? {});
this.#handler.onComplete?.(rawTrailers);
}
onResponseError(_controller, err) {
@@ -10815,6 +10980,15 @@ var require_dispatcher1_wrapper = __commonJS({
}
return this.#dispatcher.dispatch(opts, _Dispatcher1Wrapper.wrapHandler(handler));
}
+ // Older undici versions read WebSocket and EventSource receive limits from
+ // the (legacy) global dispatcher, which is this wrapper, so report the
+ // wrapped dispatcher's settings.
+ get webSocketOptions() {
+ return this.#dispatcher.webSocketOptions;
+ }
+ get eventSourceOptions() {
+ return this.#dispatcher.eventSourceOptions;
+ }
close(...args) {
return this.#dispatcher.close(...args);
}
@@ -11756,11 +11930,10 @@ var require_proxy_agent = __commonJS({
headers = {}
} = opts;
opts.path = origin + path;
- if (!("host" in headers) && !("Host" in headers)) {
- const { host } = new URL(origin);
- headers.host = host;
- }
opts.headers = { ...this[kProxyHeaders], ...headers };
+ if (!hasHostHeader(headers)) {
+ opts.headers.host = new URL(origin).host;
+ }
if (this.#proxyServername != null) {
opts.servername = this.#proxyServername;
}
@@ -11908,11 +12081,13 @@ var require_proxy_agent = __commonJS({
});
}
dispatch(opts, handler) {
- const headers = buildHeaders(opts.headers);
+ let headers = buildHeaders(opts.headers);
throwIfProxyAuthIsSent(headers);
- if (headers && !("host" in headers) && !("Host" in headers)) {
- const { host } = new URL(opts.origin);
- headers.host = host;
+ if (headers && !hasHostHeader(headers)) {
+ if (headers === opts.headers) {
+ headers = { ...headers };
+ }
+ headers.host = new URL(opts.origin).host;
}
return this[kAgent].dispatch(
{
@@ -11995,6 +12170,15 @@ var require_proxy_agent = __commonJS({
return key.length === proxyAuthorization.length && key.toLowerCase() === proxyAuthorization;
}
__name(isProxyAuthorizationHeader, "isProxyAuthorizationHeader");
+ function hasHostHeader(headers) {
+ for (const key in headers) {
+ if (key.length === 4 && key.toLowerCase() === "host") {
+ return true;
+ }
+ }
+ return false;
+ }
+ __name(hasHostHeader, "hasHostHeader");
function throwProxyAuthError() {
throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
}
@@ -12153,7 +12337,7 @@ var require_headers = __commonJS({
"lib/web/fetch/headers.js"(exports2, module2) {
"use strict";
var { kConstruct } = require_symbols();
- var { kEnumerableProperty } = require_util();
+ var { kEnumerableProperty, setHeader } = require_util();
var {
iteratorMixin,
isValidHeaderName,
@@ -12351,7 +12535,7 @@ var require_headers = __commonJS({
const headers = {};
if (this.headersMap.size !== 0) {
for (const { name, value } of this.headersMap.values()) {
- headers[name] = value;
+ setHeader(headers, name, value);
}
}
return headers;
@@ -12633,7 +12817,7 @@ var require_response = __commonJS({
var {
redirectStatusSet,
nullBodyStatus
- } = require_constants3();
+ } = require_constants2();
var { webidl } = require_webidl();
var { URLSerializer } = require_data_url();
var { kConstruct } = require_symbols();
@@ -13057,7 +13241,7 @@ var require_request2 = __commonJS({
requestCredentials,
requestCache,
requestDuplex
- } = require_constants3();
+ } = require_constants2();
var { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util;
var { webidl } = require_webidl();
var { URLSerializer } = require_data_url();
@@ -13801,6 +13985,7 @@ var require_subresource_integrity = __commonJS({
"use strict";
var assert = require("node:assert");
var { runtimeFeatures } = require_runtime_features();
+ var { asciiLowercase } = require_infra();
var validSRIHashAlgorithmTokenSet = /* @__PURE__ */ new Map([["sha256", 0], ["sha384", 1], ["sha512", 2]]);
var crypto;
if (runtimeFeatures.has("crypto")) {
@@ -13823,10 +14008,7 @@ var require_subresource_integrity = __commonJS({
validSRIHashAlgorithmTokenSet
)
);
- var isValidSRIHashAlgorithm = (
- /** @type {IsValidSRIHashAlgorithm} */
- Map.prototype.has.bind(validSRIHashAlgorithmTokenSet)
- );
+ var isValidSRIHashAlgorithm = /* @__PURE__ */ __name((algorithm) => validSRIHashAlgorithmTokenSet.has(asciiLowercase(algorithm)), "isValidSRIHashAlgorithm");
var bytesMatch = runtimeFeatures.has("crypto") === false || validSRIHashAlgorithmTokenSet.size === 0 ? () => true : (bytes, metadataList) => {
const parsedMetadata = parseMetadata(metadataList);
if (parsedMetadata.length === 0) {
@@ -13888,7 +14070,8 @@ var require_subresource_integrity = __commonJS({
base64Value = algorithmAndValue[1];
}
const metadata2 = {
- alg: algorithm,
+ // Possible spec bug?
+ alg: asciiLowercase(algorithm),
val: base64Value
};
result.push(metadata2);
@@ -13994,7 +14177,7 @@ var require_fetch = __commonJS({
safeMethodsSet,
requestBodyHeader,
subresourceSet
- } = require_constants3();
+ } = require_constants2();
var EE = require("node:events");
var { Readable, pipeline, finished, isErrored, isReadable } = require("node:stream");
var { addAbortListener, bufferToLowerCasedHeaderName } = require_util();
@@ -14997,7 +15180,6 @@ var require_fetch = __commonJS({
const headersList = new HeadersList();
appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders);
const location = headersList.get("location", true);
- this.body = new Readable({ read: /* @__PURE__ */ __name(() => controller.resume(), "read") });
const willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status);
const decoders = [];
if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
@@ -15005,7 +15187,7 @@ var require_fetch = __commonJS({
const codings = contentEncoding ? contentEncoding.toLowerCase().split(",") : [];
const maxContentEncodings = 5;
if (codings.length > maxContentEncodings) {
- reject(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`));
+ controller.abort(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`));
return;
}
for (let i = codings.length - 1; i >= 0; --i) {
@@ -15032,7 +15214,11 @@ var require_fetch = __commonJS({
} else if (coding === "zstd") {
decoders.push(zlib.createZstdDecompress({
flush: zlib.constants.ZSTD_e_continue,
- finishFlush: zlib.constants.ZSTD_e_end
+ finishFlush: zlib.constants.ZSTD_e_end,
+ params: {
+ // https://www.rfc-editor.org/rfc/rfc9659.html#section-3
+ [zlib.constants.ZSTD_d_windowLogMax]: 23
+ }
}));
} else {
decoders.length = 0;
@@ -15040,6 +15226,7 @@ var require_fetch = __commonJS({
}
}
}
+ this.body = new Readable({ read: /* @__PURE__ */ __name(() => controller.resume(), "read") });
const onError = /* @__PURE__ */ __name((err) => this.onResponseError(controller, err), "onError");
resolve({
status,
@@ -16039,6 +16226,7 @@ var require_receiver = __commonJS({
var { WebsocketFrameSend } = require_frame();
var { PerMessageDeflate } = require_permessage_deflate();
var { MessageSizeExceededError } = require_errors();
+ var { defaultWebSocketMaxFragments, defaultWebSocketMaxPayloadSize } = require_constants();
var ByteParser = class extends Writable {
static {
__name(this, "ByteParser");
@@ -16061,16 +16249,19 @@ var require_receiver = __commonJS({
/**
* @param {import('./websocket').Handler} handler
* @param {Map<string, string>|null} extensions
- * @param {{ maxPayloadSize?: number }} [options]
+ * @param {{ maxFragments?: number, maxPayloadSize?: number }} [options]
+ * A missing value uses the default limit; `0` disables the limit.
*/
constructor(handler, extensions, options = {}) {
super();
this.#handler = handler;
this.#extensions = extensions == null ? /* @__PURE__ */ new Map() : extensions;
- this.#maxFragments = options.maxFragments ?? 0;
- this.#maxPayloadSize = options.maxPayloadSize ?? 0;
+ this.#maxFragments = options.maxFragments ?? defaultWebSocketMaxFragments;
+ this.#maxPayloadSize = options.maxPayloadSize ?? defaultWebSocketMaxPayloadSize;
if (this.#extensions.has("permessage-deflate")) {
- this.#extensions.set("permessage-deflate", new PerMessageDeflate(extensions, options));
+ this.#extensions.set("permessage-deflate", new PerMessageDeflate(extensions, {
+ maxPayloadSize: this.#maxPayloadSize
+ }));
}
}
/**
@@ -16199,6 +16390,15 @@ var require_receiver = __commonJS({
if (isControlFrame(this.#info.opcode)) {
this.#loop = this.parseControlFrame(body);
this.#state = parserStates.INFO;
+ if (this.#loop && this.#handler.socket.writableNeedDrain) {
+ this.#loop = false;
+ this.#handler.socket.once("drain", () => {
+ if (this.destroyed) return;
+ this.#loop = true;
+ this.run(callback);
+ });
+ return;
+ }
} else {
if (!this.#info.compressed) {
if (!this.writeFragments(body)) {
@@ -17043,6 +17243,9 @@ var require_eventsource_stream = __commonJS({
var EVENT = Buffer.from("event");
var ID = Buffer.from("id");
var RETRY = Buffer.from("retry");
+ var minParserItems = 1024;
+ var maxParserItems = 131072;
+ var bytesPerParserItem = 128;
function isASCIINumberBytes(buffer2, start) {
if (start >= buffer2.length) {
return false;
@@ -17111,8 +17314,13 @@ var require_eventsource_stream = __commonJS({
pos = 0;
lineChunkIndex = 0;
linePos = 0;
- eventDataSize = 0;
+ lineLength = 0;
+ eventSize = 0;
+ eventFieldSizes = { data: 0, event: 0, id: 0, retry: 0 };
+ dataLineCount = 0;
maxEventSize;
+ maxDataLines;
+ maxBufferedChunks;
event = {
data: void 0,
event: void 0,
@@ -17131,6 +17339,9 @@ var require_eventsource_stream = __commonJS({
super(options);
this.state = options.eventSourceSettings || {};
this.maxEventSize = options.maxEventSize ?? defaultMaxEventSize;
+ const parserItemLimit = this.maxEventSize > 0 ? Math.min(maxParserItems, Math.max(minParserItems, Math.floor(this.maxEventSize / bytesPerParserItem))) : 0;
+ this.maxDataLines = parserItemLimit;
+ this.maxBufferedChunks = parserItemLimit;
if (options.push) {
this.push = options.push;
}
@@ -17146,6 +17357,10 @@ var require_eventsource_stream = __commonJS({
callback();
return;
}
+ if (this.maxEventSize > 0 && this.chunks.length >= this.maxBufferedChunks && chunk[0] !== LF && chunk[0] !== CR) {
+ callback(createMaxEventSizeExceededError());
+ return;
+ }
this.chunks.push(chunk);
if (this.checkBOM) {
if (this.handleBOM()) {
@@ -17192,10 +17407,19 @@ var require_eventsource_stream = __commonJS({
this.eventEndCheck = true;
continue;
}
+ if (this.maxEventSize > 0 && ++this.lineLength > this.maxEventSize + 7) {
+ callback(createMaxEventSizeExceededError());
+ return;
+ }
this.advanceCursor();
}
callback();
}
+ _destroy(error, callback) {
+ this.chunks.length = 0;
+ this.clearEvent();
+ super._destroy(error, callback);
+ }
/**
* @param {Buffer} line
* @param {EventSourceStreamEvent} event
@@ -17218,11 +17442,12 @@ var require_eventsource_stream = __commonJS({
}
}
if (isFieldName(line, fieldLength, DATA)) {
- const valueBytes = line.length - valueStart;
- const eventDataSize = this.eventDataSize + (event.data === void 0 ? 0 : 1) + valueBytes;
- if (this.maxEventSize > 0 && eventDataSize > this.maxEventSize) {
+ if (this.maxEventSize > 0 && this.dataLineCount >= this.maxDataLines) {
throw createMaxEventSizeExceededError();
}
+ const valueBytes = line.length - valueStart;
+ const dataSize = this.eventFieldSizes.data + (event.data === void 0 ? 0 : 1) + valueBytes;
+ this.setEventFieldSize("data", dataSize);
const value = line.toString("utf8", valueStart);
if (event.data === void 0) {
event.data = value;
@@ -17230,28 +17455,38 @@ var require_eventsource_stream = __commonJS({
event.data += `
${value}`;
}
- this.eventDataSize = eventDataSize;
+ this.dataLineCount++;
return;
}
if (isFieldName(line, fieldLength, RETRY)) {
if (isASCIINumberBytes(line, valueStart)) {
+ this.setEventFieldSize("retry", line.length - valueStart);
event.retry = line.toString("utf8", valueStart);
}
return;
}
if (isFieldName(line, fieldLength, ID)) {
if (isValidLastEventIdBytes(line, valueStart)) {
+ this.setEventFieldSize("id", line.length - valueStart);
event.id = line.toString("utf8", valueStart);
}
return;
}
if (isFieldName(line, fieldLength, EVENT)) {
- const value = line.toString("utf8", valueStart);
- if (value.length > 0) {
- event.event = value;
+ if (valueStart < line.length) {
+ this.setEventFieldSize("event", line.length - valueStart);
+ event.event = line.toString("utf8", valueStart);
}
}
}
+ setEventFieldSize(field, size) {
+ const eventSize = this.eventSize - this.eventFieldSizes[field] + size;
+ if (this.maxEventSize > 0 && eventSize > this.maxEventSize) {
+ throw createMaxEventSizeExceededError();
+ }
+ this.eventSize = eventSize;
+ this.eventFieldSizes[field] = size;
+ }
/**
* @param {EventSourceStreamEvent} event
*/
@@ -17278,7 +17513,12 @@ ${value}`;
this.event.event = void 0;
this.event.id = void 0;
this.event.retry = void 0;
- this.eventDataSize = 0;
+ this.eventSize = 0;
+ this.dataLineCount = 0;
+ this.eventFieldSizes.data = 0;
+ this.eventFieldSizes.event = 0;
+ this.eventFieldSizes.id = 0;
+ this.eventFieldSizes.retry = 0;
}
hasPendingEvent() {
return this.event.data !== void 0 || this.event.event !== void 0 || this.event.id !== void 0 || this.event.retry !== void 0;
@@ -17303,13 +17543,15 @@ ${value}`;
syncLineStartToCursor() {
this.lineChunkIndex = this.chunkIndex;
this.linePos = this.pos;
+ this.lineLength = 0;
this.dropConsumedChunks();
}
dropConsumedChunks() {
- while (this.lineChunkIndex > 0) {
- this.chunks.shift();
- this.lineChunkIndex--;
- this.chunkIndex--;
+ if (this.lineChunkIndex > 0) {
+ const consumed = this.lineChunkIndex;
+ this.chunks.splice(0, consumed);
+ this.lineChunkIndex = 0;
+ this.chunkIndex -= consumed;
}
if (this.chunkIndex === this.chunks.length) {
this.chunks.length = 0;
@@ -17408,6 +17650,7 @@ var require_eventsource = __commonJS({
var { parseMIMEType } = require_data_url();
var { createFastMessageEvent: createFastMessageEvent2 } = require_events();
var { isNetworkError } = require_response();
+ var { cloneRequest } = require_request2();
var { isValidHeaderValue, kEnumerableProperty } = require_util();
var { environmentSettingsObject } = require_util2();
var { createPotentialCORSRequest } = require_util4();
@@ -17416,6 +17659,7 @@ var require_eventsource = __commonJS({
var textEncoder = new TextEncoder();
var experimentalWarned = false;
var defaultReconnectionTime = 3e3;
+ var maxReconnectionTime = 2 ** 31 - 1;
var CONNECTING = 0;
var OPEN = 1;
var CLOSED = 2;
@@ -17519,8 +17763,10 @@ var require_eventsource = __commonJS({
#connect() {
if (this.#readyState === CLOSED) return;
this.#readyState = CONNECTING;
+ const request = cloneRequest(this.#request);
+ request.urlList = [...this.#request.urlList];
const fetchParams = {
- request: this.#request,
+ request,
dispatcher: this.#dispatcher
};
const processEventSourceEndOfBody = /* @__PURE__ */ __name((response) => {
@@ -17592,7 +17838,7 @@ var require_eventsource = __commonJS({
}
}
this.#connect();
- }, this.#state.reconnectionTime)?.unref();
+ }, Math.min(this.#state.reconnectionTime, maxReconnectionTime))?.unref();
}
/**
* Closes the connection, if any, and sets the readyState attribute to
diff --git a/src/undici_version.h b/src/undici_version.h
index 22dc13300b7..ba81332319c 100644
--- a/src/undici_version.h
+++ b/src/undici_version.h
@@ -2,5 +2,5 @@
// Refer to tools/dep_updaters/update-undici.sh
#ifndef SRC_UNDICI_VERSION_H_
#define SRC_UNDICI_VERSION_H_
-#define UNDICI_VERSION "8.11.2"
+#define UNDICI_VERSION "8.12.2"
#endif // SRC_UNDICI_VERSION_H_