Repository: deployphp/action
Branch: master
Commit: a1b46c204dbd
Files: 15
Total size: 1.4 MB

Directory structure:
gitextract_oxn71in9/

├── .github/
│   └── workflows/
│       ├── build.yaml
│       ├── prettier.yaml
│       ├── test.yaml
│       ├── typecheck.yaml
│       └── zizmor.yaml
├── .gitignore
├── .prettierignore
├── LICENSE
├── README.md
├── action.yaml
├── dist/
│   └── index.js
├── package.json
├── src/
│   └── index.ts
├── tsconfig.json
└── vite.config.ts

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/workflows/build.yaml
================================================
name: Build
on:
  pull_request:
  push:
    branches:
      - master
      - 'releases/*'

permissions:
  contents: read

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
      - uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
        with:
          node-version: '22'
          package-manager-cache: false
      - run: npm ci
      - run: npm run build
      - name: Check dist/ is up to date
        run: |
          if [ "$(git diff --name-only dist/)" != "" ]; then
            echo "dist/ is out of date. Run 'npm run build' and commit the result."
            git diff dist/
            exit 1
          fi


================================================
FILE: .github/workflows/prettier.yaml
================================================
name: Prettier
on:
  pull_request:
  push:
    branches:
      - master
      - 'releases/*'

permissions:
  contents: read

jobs:
  prettier:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
      - uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
        with:
          node-version: '22'
          package-manager-cache: false
      - run: npm ci
      - run: npm run format:check


================================================
FILE: .github/workflows/test.yaml
================================================
name: Test
on:
  pull_request:
  push:
    branches:
      - master
      - 'releases/*'

permissions:
  contents: read

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
      - uses: ./
        with:
          dep: list
          deployer-version: '7.3.0'


================================================
FILE: .github/workflows/typecheck.yaml
================================================
name: Typecheck
on:
  pull_request:
  push:
    branches:
      - master
      - 'releases/*'

permissions:
  contents: read

jobs:
  typecheck:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
      - uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
        with:
          node-version: '22'
          package-manager-cache: false
      - run: npm ci
      - run: npm run typecheck


================================================
FILE: .github/workflows/zizmor.yaml
================================================
name: Zizmor
on:
  pull_request:
  push:
    branches:
      - master
      - 'releases/*'

jobs:
  zizmor:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
      - uses: zizmorcore/zizmor-action@71321a20a9ded102f6e9ce5718a2fcec2c4f70d8 # v0.5.2


================================================
FILE: .gitignore
================================================
node_modules/
.idea/
*.log


================================================
FILE: .prettierignore
================================================
dist/
node_modules/
package-lock.json


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2021 Anton Medvedev

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
# GitHub Action for Deployer

```yaml
- name: Deploy
  uses: deployphp/action@v1
  with:
    dep: deploy
    private-key: ${{ secrets.PRIVATE_KEY }}
```

## Inputs

```yaml
- name: Deploy
  uses: deployphp/action@v1
  with:
    # The deployer task to run. For example:
    # `deploy all`.
    # Required.
    dep: deploy

    # The path to the PHP binary to use.
    # Optional.
    php-binary: 'php'

    # Specifies a sub directory within the repository to deploy
    # Optional
    sub-directory: '...'

    # Config options for the Deployer. Same as the `-o` flag in the CLI.
    # Optional.
    options:
      keep_releases: 7

    # Private key for connecting to remote hosts. To generate private key:
    # `ssh-keygen -o -t rsa -C 'action@deployer.org'`.
    # Optional.
    private-key: ${{ secrets.PRIVATE_KEY }}

    # Content of `~/.ssh/known_hosts` file. The public SSH keys for a
    # host may be obtained using the utility `ssh-keyscan`.
    # For example: `ssh-keyscan deployer.org`.
    # If known-hosts omitted, `StrictHostKeyChecking no` will be added to
    # `ssh_config`.
    # Optional.
    known-hosts: |
      ...

    # The SSH configuration. Content of `~/.ssh/config` file.
    # Optional.
    ssh-config: |
      ...

    # Option to skip over the SSH setup/configuration.
    # Self-hosted runners don't need the SSH configuration or the SSH agent
    # to be started.
    # Optional.
    skip-ssh-setup: false

    # Deployer version to download from deployer.org.
    # First, the action will check for Deployer binary at those paths:
    # - `vendor/bin/deployer.phar`
    # - `vendor/bin/dep`
    # - `deployer.phar`
    # If the binary not found, phar version will be downloaded from
    # deployer.org.
    # Optional.
    deployer-version: '7.0.0'

    # You can specify path to your local Deployer binary in the repo.
    # Optional.
    deployer-binary: 'bin/dep'

    # You can choose to disable ANSI output.
    # Optional. Defaults to true.
    ansi: false

    # You can specify the output verbosity level.
    # Optional. Defaults to -v.
    verbosity: -vvv
```

## Example

```yaml
name: deploy

on: push

# It is important to specify "concurrency" for the workflow,
# to prevent concurrency between different deploys.
concurrency: production_environment

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.1'

      - name: Install dependencies
        run: composer install

      - name: Deploy
        uses: deployphp/action@v1
        with:
          dep: deploy
          private-key: ${{ secrets.PRIVATE_KEY }}
```


================================================
FILE: action.yaml
================================================
name: 'deployphp/action'

description: 'Deploy with Deployer'

inputs:
  dep:
    required: true
    description: The command.

  php-binary:
    required: false
    default: ''
    description: Path to PHP binary.

  sub-directory:
    required: false
    default: ''
    description: Specifies a sub directory within the repository to deploy.

  options:
    required: false
    default: ''
    description: List of options for the Deployer.

  private-key:
    required: false
    default: ''
    description: The private key for connecting to remote hosts.

  known-hosts:
    required: false
    default: ''
    description: Content of `~/.ssh/known_hosts` file.

  ssh-config:
    required: false
    default: ''
    description: The SSH configuration

  skip-ssh-setup:
    required: false
    default: 'false'
    description: Whether the SSH setup should be skipped.

  deployer-version:
    required: false
    default: ''
    description: Deployer version to download from deployer.org.

  deployer-binary:
    required: false
    default: ''
    description: Path to local Deployer binary.

  recipe:
    required: false
    default: ''
    description: Recipe file path.

  ansi:
    required: false
    default: 'true'
    description: Whether to enable ANSI output.

  verbosity:
    required: false
    default: '-v'
    description: Verbosity level Can be -v, -vv or -vvv.

runs:
  using: 'node24'
  main: 'dist/index.js'

branding:
  color: blue
  icon: send


================================================
FILE: dist/index.js
================================================
import { createRequire } from "node:module";
import * as os$3 from "os";
import os, { EOL } from "os";
import * as crypto from "crypto";
import * as fs$1 from "fs";
import { constants, promises } from "fs";
import * as path$1 from "path";
import * as events from "events";
import "child_process";
import "timers";
import * as process$1 from "node:process";
//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
		key = keys[i];
		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: ((k) => from[k]).bind(null, key),
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));
var __require = /* @__PURE__ */ createRequire(import.meta.url);
//#endregion
//#region node_modules/@actions/core/lib/utils.js
/**
* Sanitizes an input into a string so it can be passed into issueCommand safely
* @param input input to sanitize into a string
*/
function toCommandValue(input) {
	if (input === null || input === void 0) return "";
	else if (typeof input === "string" || input instanceof String) return input;
	return JSON.stringify(input);
}
/**
*
* @param annotationProperties
* @returns The command properties to send with the actual annotation command
* See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646
*/
function toCommandProperties(annotationProperties) {
	if (!Object.keys(annotationProperties).length) return {};
	return {
		title: annotationProperties.title,
		file: annotationProperties.file,
		line: annotationProperties.startLine,
		endLine: annotationProperties.endLine,
		col: annotationProperties.startColumn,
		endColumn: annotationProperties.endColumn
	};
}
//#endregion
//#region node_modules/@actions/core/lib/command.js
/**
* Issues a command to the GitHub Actions runner
*
* @param command - The command name to issue
* @param properties - Additional properties for the command (key-value pairs)
* @param message - The message to include with the command
* @remarks
* This function outputs a specially formatted string to stdout that the Actions
* runner interprets as a command. These commands can control workflow behavior,
* set outputs, create annotations, mask values, and more.
*
* Command Format:
*   ::name key=value,key=value::message
*
* @example
* ```typescript
* // Issue a warning annotation
* issueCommand('warning', {}, 'This is a warning message');
* // Output: ::warning::This is a warning message
*
* // Set an environment variable
* issueCommand('set-env', { name: 'MY_VAR' }, 'some value');
* // Output: ::set-env name=MY_VAR::some value
*
* // Add a secret mask
* issueCommand('add-mask', {}, 'secretValue123');
* // Output: ::add-mask::secretValue123
* ```
*
* @internal
* This is an internal utility function that powers the public API functions
* such as setSecret, warning, error, and exportVariable.
*/
function issueCommand(command, properties, message) {
	const cmd = new Command(command, properties, message);
	process.stdout.write(cmd.toString() + os$3.EOL);
}
var CMD_STRING = "::";
var Command = class {
	constructor(command, properties, message) {
		if (!command) command = "missing.command";
		this.command = command;
		this.properties = properties;
		this.message = message;
	}
	toString() {
		let cmdStr = CMD_STRING + this.command;
		if (this.properties && Object.keys(this.properties).length > 0) {
			cmdStr += " ";
			let first = true;
			for (const key in this.properties) if (this.properties.hasOwnProperty(key)) {
				const val = this.properties[key];
				if (val) {
					if (first) first = false;
					else cmdStr += ",";
					cmdStr += `${key}=${escapeProperty(val)}`;
				}
			}
		}
		cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
		return cmdStr;
	}
};
function escapeData(s) {
	return toCommandValue(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
}
function escapeProperty(s) {
	return toCommandValue(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C");
}
//#endregion
//#region node_modules/@actions/core/lib/file-command.js
function issueFileCommand(command, message) {
	const filePath = process.env[`GITHUB_${command}`];
	if (!filePath) throw new Error(`Unable to find environment variable for file command ${command}`);
	if (!fs$1.existsSync(filePath)) throw new Error(`Missing file at path: ${filePath}`);
	fs$1.appendFileSync(filePath, `${toCommandValue(message)}${os$3.EOL}`, { encoding: "utf8" });
}
function prepareKeyValueMessage(key, value) {
	const delimiter = `ghadelimiter_${crypto.randomUUID()}`;
	const convertedValue = toCommandValue(value);
	if (key.includes(delimiter)) throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`);
	if (convertedValue.includes(delimiter)) throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`);
	return `${key}<<${delimiter}${os$3.EOL}${convertedValue}${os$3.EOL}${delimiter}`;
}
//#endregion
//#region node_modules/tunnel/lib/tunnel.js
var require_tunnel$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	__require("net");
	__require("tls");
	var http$1 = __require("http");
	__require("https");
	var events$1 = __require("events");
	__require("assert");
	var util$2 = __require("util");
	function TunnelingAgent(options) {
		var self = this;
		self.options = options || {};
		self.proxyOptions = self.options.proxy || {};
		self.maxSockets = self.options.maxSockets || http$1.Agent.defaultMaxSockets;
		self.requests = [];
		self.sockets = [];
		self.on("free", function onFree(socket, host, port, localAddress) {
			var options = toOptions(host, port, localAddress);
			for (var i = 0, len = self.requests.length; i < len; ++i) {
				var pending = self.requests[i];
				if (pending.host === options.host && pending.port === options.port) {
					self.requests.splice(i, 1);
					pending.request.onSocket(socket);
					return;
				}
			}
			socket.destroy();
			self.removeSocket(socket);
		});
	}
	util$2.inherits(TunnelingAgent, events$1.EventEmitter);
	TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
		var self = this;
		var options = mergeOptions({ request: req }, self.options, toOptions(host, port, localAddress));
		if (self.sockets.length >= this.maxSockets) {
			self.requests.push(options);
			return;
		}
		self.createSocket(options, function(socket) {
			socket.on("free", onFree);
			socket.on("close", onCloseOrRemove);
			socket.on("agentRemove", onCloseOrRemove);
			req.onSocket(socket);
			function onFree() {
				self.emit("free", socket, options);
			}
			function onCloseOrRemove(err) {
				self.removeSocket(socket);
				socket.removeListener("free", onFree);
				socket.removeListener("close", onCloseOrRemove);
				socket.removeListener("agentRemove", onCloseOrRemove);
			}
		});
	};
	TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
		var self = this;
		var placeholder = {};
		self.sockets.push(placeholder);
		var connectOptions = mergeOptions({}, self.proxyOptions, {
			method: "CONNECT",
			path: options.host + ":" + options.port,
			agent: false,
			headers: { host: options.host + ":" + options.port }
		});
		if (options.localAddress) connectOptions.localAddress = options.localAddress;
		if (connectOptions.proxyAuth) {
			connectOptions.headers = connectOptions.headers || {};
			connectOptions.headers["Proxy-Authorization"] = "Basic " + new Buffer(connectOptions.proxyAuth).toString("base64");
		}
		debug("making CONNECT request");
		var connectReq = self.request(connectOptions);
		connectReq.useChunkedEncodingByDefault = false;
		connectReq.once("response", onResponse);
		connectReq.once("upgrade", onUpgrade);
		connectReq.once("connect", onConnect);
		connectReq.once("error", onError);
		connectReq.end();
		function onResponse(res) {
			res.upgrade = true;
		}
		function onUpgrade(res, socket, head) {
			process.nextTick(function() {
				onConnect(res, socket, head);
			});
		}
		function onConnect(res, socket, head) {
			connectReq.removeAllListeners();
			socket.removeAllListeners();
			if (res.statusCode !== 200) {
				debug("tunneling socket could not be established, statusCode=%d", res.statusCode);
				socket.destroy();
				var error = /* @__PURE__ */ new Error("tunneling socket could not be established, statusCode=" + res.statusCode);
				error.code = "ECONNRESET";
				options.request.emit("error", error);
				self.removeSocket(placeholder);
				return;
			}
			if (head.length > 0) {
				debug("got illegal response body from proxy");
				socket.destroy();
				var error = /* @__PURE__ */ new Error("got illegal response body from proxy");
				error.code = "ECONNRESET";
				options.request.emit("error", error);
				self.removeSocket(placeholder);
				return;
			}
			debug("tunneling connection has established");
			self.sockets[self.sockets.indexOf(placeholder)] = socket;
			return cb(socket);
		}
		function onError(cause) {
			connectReq.removeAllListeners();
			debug("tunneling socket could not be established, cause=%s\n", cause.message, cause.stack);
			var error = /* @__PURE__ */ new Error("tunneling socket could not be established, cause=" + cause.message);
			error.code = "ECONNRESET";
			options.request.emit("error", error);
			self.removeSocket(placeholder);
		}
	};
	TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
		var pos = this.sockets.indexOf(socket);
		if (pos === -1) return;
		this.sockets.splice(pos, 1);
		var pending = this.requests.shift();
		if (pending) this.createSocket(pending, function(socket) {
			pending.request.onSocket(socket);
		});
	};
	function toOptions(host, port, localAddress) {
		if (typeof host === "string") return {
			host,
			port,
			localAddress
		};
		return host;
	}
	function mergeOptions(target) {
		for (var i = 1, len = arguments.length; i < len; ++i) {
			var overrides = arguments[i];
			if (typeof overrides === "object") {
				var keys = Object.keys(overrides);
				for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
					var k = keys[j];
					if (overrides[k] !== void 0) target[k] = overrides[k];
				}
			}
		}
		return target;
	}
	var debug;
	if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) debug = function() {
		var args = Array.prototype.slice.call(arguments);
		if (typeof args[0] === "string") args[0] = "TUNNEL: " + args[0];
		else args.unshift("TUNNEL:");
		console.error.apply(console, args);
	};
	else debug = function() {};
}));
//#endregion
//#region node_modules/tunnel/index.js
var require_tunnel = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = require_tunnel$1();
}));
//#endregion
//#region node_modules/undici/lib/core/symbols.js
var require_symbols$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = {
		kClose: Symbol("close"),
		kDestroy: Symbol("destroy"),
		kDispatch: Symbol("dispatch"),
		kUrl: Symbol("url"),
		kWriting: Symbol("writing"),
		kResuming: Symbol("resuming"),
		kQueue: Symbol("queue"),
		kConnect: Symbol("connect"),
		kConnecting: Symbol("connecting"),
		kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"),
		kKeepAliveMaxTimeout: Symbol("max keep alive timeout"),
		kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"),
		kKeepAliveTimeoutValue: Symbol("keep alive timeout"),
		kKeepAlive: Symbol("keep alive"),
		kHeadersTimeout: Symbol("headers timeout"),
		kBodyTimeout: Symbol("body timeout"),
		kServerName: Symbol("server name"),
		kLocalAddress: Symbol("local address"),
		kHost: Symbol("host"),
		kNoRef: Symbol("no ref"),
		kBodyUsed: Symbol("used"),
		kBody: Symbol("abstracted request body"),
		kRunning: Symbol("running"),
		kBlocking: Symbol("blocking"),
		kPending: Symbol("pending"),
		kSize: Symbol("size"),
		kBusy: Symbol("busy"),
		kQueued: Symbol("queued"),
		kFree: Symbol("free"),
		kConnected: Symbol("connected"),
		kClosed: Symbol("closed"),
		kNeedDrain: Symbol("need drain"),
		kReset: Symbol("reset"),
		kDestroyed: Symbol.for("nodejs.stream.destroyed"),
		kResume: Symbol("resume"),
		kOnError: Symbol("on error"),
		kMaxHeadersSize: Symbol("max headers size"),
		kRunningIdx: Symbol("running index"),
		kPendingIdx: Symbol("pending index"),
		kError: Symbol("error"),
		kClients: Symbol("clients"),
		kClient: Symbol("client"),
		kParser: Symbol("parser"),
		kOnDestroyed: Symbol("destroy callbacks"),
		kPipelining: Symbol("pipelining"),
		kSocket: Symbol("socket"),
		kHostHeader: Symbol("host header"),
		kConnector: Symbol("connector"),
		kStrictContentLength: Symbol("strict content length"),
		kMaxRedirections: Symbol("maxRedirections"),
		kMaxRequests: Symbol("maxRequestsPerClient"),
		kProxy: Symbol("proxy agent options"),
		kCounter: Symbol("socket request counter"),
		kInterceptors: Symbol("dispatch interceptors"),
		kMaxResponseSize: Symbol("max response size"),
		kHTTP2Session: Symbol("http2Session"),
		kHTTP2SessionState: Symbol("http2Session state"),
		kRetryHandlerDefaultRetry: Symbol("retry agent default retry"),
		kConstruct: Symbol("constructable"),
		kListeners: Symbol("listeners"),
		kHTTPContext: Symbol("http context"),
		kMaxConcurrentStreams: Symbol("max concurrent streams"),
		kNoProxyAgent: Symbol("no proxy agent"),
		kHttpProxyAgent: Symbol("http proxy agent"),
		kHttpsProxyAgent: Symbol("https proxy agent")
	};
}));
//#endregion
//#region node_modules/undici/lib/core/errors.js
var require_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var kUndiciError = Symbol.for("undici.error.UND_ERR");
	var UndiciError = class extends Error {
		constructor(message) {
			super(message);
			this.name = "UndiciError";
			this.code = "UND_ERR";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kUndiciError] === true;
		}
		[kUndiciError] = true;
	};
	var kConnectTimeoutError = Symbol.for("undici.error.UND_ERR_CONNECT_TIMEOUT");
	var ConnectTimeoutError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "ConnectTimeoutError";
			this.message = message || "Connect Timeout Error";
			this.code = "UND_ERR_CONNECT_TIMEOUT";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kConnectTimeoutError] === true;
		}
		[kConnectTimeoutError] = true;
	};
	var kHeadersTimeoutError = Symbol.for("undici.error.UND_ERR_HEADERS_TIMEOUT");
	var HeadersTimeoutError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "HeadersTimeoutError";
			this.message = message || "Headers Timeout Error";
			this.code = "UND_ERR_HEADERS_TIMEOUT";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kHeadersTimeoutError] === true;
		}
		[kHeadersTimeoutError] = true;
	};
	var kHeadersOverflowError = Symbol.for("undici.error.UND_ERR_HEADERS_OVERFLOW");
	var HeadersOverflowError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "HeadersOverflowError";
			this.message = message || "Headers Overflow Error";
			this.code = "UND_ERR_HEADERS_OVERFLOW";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kHeadersOverflowError] === true;
		}
		[kHeadersOverflowError] = true;
	};
	var kBodyTimeoutError = Symbol.for("undici.error.UND_ERR_BODY_TIMEOUT");
	var BodyTimeoutError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "BodyTimeoutError";
			this.message = message || "Body Timeout Error";
			this.code = "UND_ERR_BODY_TIMEOUT";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kBodyTimeoutError] === true;
		}
		[kBodyTimeoutError] = true;
	};
	var kResponseStatusCodeError = Symbol.for("undici.error.UND_ERR_RESPONSE_STATUS_CODE");
	var ResponseStatusCodeError = class extends UndiciError {
		constructor(message, statusCode, headers, body) {
			super(message);
			this.name = "ResponseStatusCodeError";
			this.message = message || "Response Status Code Error";
			this.code = "UND_ERR_RESPONSE_STATUS_CODE";
			this.body = body;
			this.status = statusCode;
			this.statusCode = statusCode;
			this.headers = headers;
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kResponseStatusCodeError] === true;
		}
		[kResponseStatusCodeError] = true;
	};
	var kInvalidArgumentError = Symbol.for("undici.error.UND_ERR_INVALID_ARG");
	var InvalidArgumentError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "InvalidArgumentError";
			this.message = message || "Invalid Argument Error";
			this.code = "UND_ERR_INVALID_ARG";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kInvalidArgumentError] === true;
		}
		[kInvalidArgumentError] = true;
	};
	var kInvalidReturnValueError = Symbol.for("undici.error.UND_ERR_INVALID_RETURN_VALUE");
	var InvalidReturnValueError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "InvalidReturnValueError";
			this.message = message || "Invalid Return Value Error";
			this.code = "UND_ERR_INVALID_RETURN_VALUE";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kInvalidReturnValueError] === true;
		}
		[kInvalidReturnValueError] = true;
	};
	var kAbortError = Symbol.for("undici.error.UND_ERR_ABORT");
	var AbortError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "AbortError";
			this.message = message || "The operation was aborted";
			this.code = "UND_ERR_ABORT";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kAbortError] === true;
		}
		[kAbortError] = true;
	};
	var kRequestAbortedError = Symbol.for("undici.error.UND_ERR_ABORTED");
	var RequestAbortedError = class extends AbortError {
		constructor(message) {
			super(message);
			this.name = "AbortError";
			this.message = message || "Request aborted";
			this.code = "UND_ERR_ABORTED";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kRequestAbortedError] === true;
		}
		[kRequestAbortedError] = true;
	};
	var kInformationalError = Symbol.for("undici.error.UND_ERR_INFO");
	var InformationalError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "InformationalError";
			this.message = message || "Request information";
			this.code = "UND_ERR_INFO";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kInformationalError] === true;
		}
		[kInformationalError] = true;
	};
	var kRequestContentLengthMismatchError = Symbol.for("undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH");
	var RequestContentLengthMismatchError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "RequestContentLengthMismatchError";
			this.message = message || "Request body length does not match content-length header";
			this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kRequestContentLengthMismatchError] === true;
		}
		[kRequestContentLengthMismatchError] = true;
	};
	var kResponseContentLengthMismatchError = Symbol.for("undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH");
	var ResponseContentLengthMismatchError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "ResponseContentLengthMismatchError";
			this.message = message || "Response body length does not match content-length header";
			this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kResponseContentLengthMismatchError] === true;
		}
		[kResponseContentLengthMismatchError] = true;
	};
	var kClientDestroyedError = Symbol.for("undici.error.UND_ERR_DESTROYED");
	var ClientDestroyedError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "ClientDestroyedError";
			this.message = message || "The client is destroyed";
			this.code = "UND_ERR_DESTROYED";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kClientDestroyedError] === true;
		}
		[kClientDestroyedError] = true;
	};
	var kClientClosedError = Symbol.for("undici.error.UND_ERR_CLOSED");
	var ClientClosedError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "ClientClosedError";
			this.message = message || "The client is closed";
			this.code = "UND_ERR_CLOSED";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kClientClosedError] === true;
		}
		[kClientClosedError] = true;
	};
	var kSocketError = Symbol.for("undici.error.UND_ERR_SOCKET");
	var SocketError = class extends UndiciError {
		constructor(message, socket) {
			super(message);
			this.name = "SocketError";
			this.message = message || "Socket error";
			this.code = "UND_ERR_SOCKET";
			this.socket = socket;
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kSocketError] === true;
		}
		[kSocketError] = true;
	};
	var kNotSupportedError = Symbol.for("undici.error.UND_ERR_NOT_SUPPORTED");
	var NotSupportedError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "NotSupportedError";
			this.message = message || "Not supported error";
			this.code = "UND_ERR_NOT_SUPPORTED";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kNotSupportedError] === true;
		}
		[kNotSupportedError] = true;
	};
	var kBalancedPoolMissingUpstreamError = Symbol.for("undici.error.UND_ERR_BPL_MISSING_UPSTREAM");
	var BalancedPoolMissingUpstreamError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "MissingUpstreamError";
			this.message = message || "No upstream has been added to the BalancedPool";
			this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kBalancedPoolMissingUpstreamError] === true;
		}
		[kBalancedPoolMissingUpstreamError] = true;
	};
	var kHTTPParserError = Symbol.for("undici.error.UND_ERR_HTTP_PARSER");
	var HTTPParserError = class extends Error {
		constructor(message, code, data) {
			super(message);
			this.name = "HTTPParserError";
			this.code = code ? `HPE_${code}` : void 0;
			this.data = data ? data.toString() : void 0;
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kHTTPParserError] === true;
		}
		[kHTTPParserError] = true;
	};
	var kResponseExceededMaxSizeError = Symbol.for("undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE");
	var ResponseExceededMaxSizeError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "ResponseExceededMaxSizeError";
			this.message = message || "Response content exceeded max size";
			this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kResponseExceededMaxSizeError] === true;
		}
		[kResponseExceededMaxSizeError] = true;
	};
	var kRequestRetryError = Symbol.for("undici.error.UND_ERR_REQ_RETRY");
	var RequestRetryError = class extends UndiciError {
		constructor(message, code, { headers, data }) {
			super(message);
			this.name = "RequestRetryError";
			this.message = message || "Request retry error";
			this.code = "UND_ERR_REQ_RETRY";
			this.statusCode = code;
			this.data = data;
			this.headers = headers;
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kRequestRetryError] === true;
		}
		[kRequestRetryError] = true;
	};
	var kResponseError = Symbol.for("undici.error.UND_ERR_RESPONSE");
	var ResponseError = class extends UndiciError {
		constructor(message, code, { headers, data }) {
			super(message);
			this.name = "ResponseError";
			this.message = message || "Response error";
			this.code = "UND_ERR_RESPONSE";
			this.statusCode = code;
			this.data = data;
			this.headers = headers;
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kResponseError] === true;
		}
		[kResponseError] = true;
	};
	var kSecureProxyConnectionError = Symbol.for("undici.error.UND_ERR_PRX_TLS");
	var SecureProxyConnectionError = class extends UndiciError {
		constructor(cause, message, options) {
			super(message, {
				cause,
				...options ?? {}
			});
			this.name = "SecureProxyConnectionError";
			this.message = message || "Secure Proxy Connection failed";
			this.code = "UND_ERR_PRX_TLS";
			this.cause = cause;
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kSecureProxyConnectionError] === true;
		}
		[kSecureProxyConnectionError] = true;
	};
	var kMessageSizeExceededError = Symbol.for("undici.error.UND_ERR_WS_MESSAGE_SIZE_EXCEEDED");
	var MessageSizeExceededError = class extends UndiciError {
		constructor(message) {
			super(message);
			this.name = "MessageSizeExceededError";
			this.message = message || "Max decompressed message size exceeded";
			this.code = "UND_ERR_WS_MESSAGE_SIZE_EXCEEDED";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kMessageSizeExceededError] === true;
		}
		get [kMessageSizeExceededError]() {
			return true;
		}
	};
	module.exports = {
		AbortError,
		HTTPParserError,
		UndiciError,
		HeadersTimeoutError,
		HeadersOverflowError,
		BodyTimeoutError,
		RequestContentLengthMismatchError,
		ConnectTimeoutError,
		ResponseStatusCodeError,
		InvalidArgumentError,
		InvalidReturnValueError,
		RequestAbortedError,
		ClientDestroyedError,
		ClientClosedError,
		InformationalError,
		SocketError,
		NotSupportedError,
		ResponseContentLengthMismatchError,
		BalancedPoolMissingUpstreamError,
		ResponseExceededMaxSizeError,
		RequestRetryError,
		ResponseError,
		SecureProxyConnectionError,
		MessageSizeExceededError
	};
}));
//#endregion
//#region node_modules/undici/lib/core/constants.js
var require_constants$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/** @type {Record<string, string | undefined>} */
	var headerNameLowerCasedRecord = {};
	var wellknownHeaderNames = [
		"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"
	];
	for (let i = 0; i < wellknownHeaderNames.length; ++i) {
		const key = wellknownHeaderNames[i];
		const lowerCasedKey = key.toLowerCase();
		headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
	}
	Object.setPrototypeOf(headerNameLowerCasedRecord, null);
	module.exports = {
		wellknownHeaderNames,
		headerNameLowerCasedRecord
	};
}));
//#endregion
//#region node_modules/undici/lib/core/tree.js
var require_tree = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { wellknownHeaderNames, headerNameLowerCasedRecord } = require_constants$4();
	var TstNode = class TstNode {
		/** @type {any} */
		value = null;
		/** @type {null | TstNode} */
		left = null;
		/** @type {null | TstNode} */
		middle = null;
		/** @type {null | TstNode} */
		right = null;
		/** @type {number} */
		code;
		/**
		* @param {string} key
		* @param {any} value
		* @param {number} index
		*/
		constructor(key, value, index) {
			if (index === void 0 || index >= key.length) throw new TypeError("Unreachable");
			if ((this.code = key.charCodeAt(index)) > 127) throw new TypeError("key must be ascii string");
			if (key.length !== ++index) this.middle = new TstNode(key, value, index);
			else this.value = value;
		}
		/**
		* @param {string} key
		* @param {any} value
		*/
		add(key, value) {
			const length = key.length;
			if (length === 0) throw new TypeError("Unreachable");
			let index = 0;
			let node = this;
			while (true) {
				const code = key.charCodeAt(index);
				if (code > 127) throw new TypeError("key must be ascii string");
				if (node.code === code) if (length === ++index) {
					node.value = value;
					break;
				} else if (node.middle !== null) node = node.middle;
				else {
					node.middle = new TstNode(key, value, index);
					break;
				}
				else if (node.code < code) if (node.left !== null) node = node.left;
				else {
					node.left = new TstNode(key, value, index);
					break;
				}
				else if (node.right !== null) node = node.right;
				else {
					node.right = new TstNode(key, value, index);
					break;
				}
			}
		}
		/**
		* @param {Uint8Array} key
		* @return {TstNode | null}
		*/
		search(key) {
			const keylength = key.length;
			let index = 0;
			let node = this;
			while (node !== null && index < keylength) {
				let code = key[index];
				if (code <= 90 && code >= 65) code |= 32;
				while (node !== null) {
					if (code === node.code) {
						if (keylength === ++index) return node;
						node = node.middle;
						break;
					}
					node = node.code < code ? node.left : node.right;
				}
			}
			return null;
		}
	};
	var TernarySearchTree = class {
		/** @type {TstNode | null} */
		node = null;
		/**
		* @param {string} key
		* @param {any} value
		* */
		insert(key, value) {
			if (this.node === null) this.node = new TstNode(key, value, 0);
			else this.node.add(key, value);
		}
		/**
		* @param {Uint8Array} key
		* @return {any}
		*/
		lookup(key) {
			return this.node?.search(key)?.value ?? null;
		}
	};
	var tree = new TernarySearchTree();
	for (let i = 0; i < wellknownHeaderNames.length; ++i) {
		const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]];
		tree.insert(key, key);
	}
	module.exports = {
		TernarySearchTree,
		tree
	};
}));
//#endregion
//#region node_modules/undici/lib/core/util.js
var require_util$8 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$26 = __require("node:assert");
	var { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols$4();
	var { IncomingMessage } = __require("node:http");
	var stream = __require("node:stream");
	var net$2 = __require("node:net");
	var { Blob: Blob$3 } = __require("node:buffer");
	var nodeUtil$3 = __require("node:util");
	var { stringify } = __require("node:querystring");
	var { EventEmitter: EE$2 } = __require("node:events");
	var { InvalidArgumentError } = require_errors();
	var { headerNameLowerCasedRecord } = require_constants$4();
	var { tree } = require_tree();
	var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v));
	var BodyAsyncIterable = class {
		constructor(body) {
			this[kBody] = body;
			this[kBodyUsed] = false;
		}
		async *[Symbol.asyncIterator]() {
			assert$26(!this[kBodyUsed], "disturbed");
			this[kBodyUsed] = true;
			yield* this[kBody];
		}
	};
	function wrapRequestBody(body) {
		if (isStream(body)) {
			if (bodyLength(body) === 0) body.on("data", function() {
				assert$26(false);
			});
			if (typeof body.readableDidRead !== "boolean") {
				body[kBodyUsed] = false;
				EE$2.prototype.on.call(body, "data", function() {
					this[kBodyUsed] = true;
				});
			}
			return body;
		} else if (body && typeof body.pipeTo === "function") return new BodyAsyncIterable(body);
		else if (body && typeof body !== "string" && !ArrayBuffer.isView(body) && isIterable(body)) return new BodyAsyncIterable(body);
		else return body;
	}
	function nop() {}
	function isStream(obj) {
		return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
	}
	function isBlobLike(object) {
		if (object === null) return false;
		else if (object instanceof Blob$3) return true;
		else if (typeof object !== "object") return false;
		else {
			const sTag = object[Symbol.toStringTag];
			return (sTag === "Blob" || sTag === "File") && ("stream" in object && typeof object.stream === "function" || "arrayBuffer" in object && typeof object.arrayBuffer === "function");
		}
	}
	function buildURL(url, queryParams) {
		if (url.includes("?") || url.includes("#")) throw new Error("Query params cannot be passed when url already contains \"?\" or \"#\".");
		const stringified = stringify(queryParams);
		if (stringified) url += "?" + stringified;
		return url;
	}
	function isValidPort(port) {
		const value = parseInt(port, 10);
		return value === Number(port) && value >= 0 && value <= 65535;
	}
	function isHttpOrHttpsPrefixed(value) {
		return value != null && value[0] === "h" && value[1] === "t" && value[2] === "t" && value[3] === "p" && (value[4] === ":" || value[4] === "s" && value[5] === ":");
	}
	function parseURL(url) {
		if (typeof url === "string") {
			url = new URL(url);
			if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
			return url;
		}
		if (!url || typeof url !== "object") throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object.");
		if (!(url instanceof URL)) {
			if (url.port != null && url.port !== "" && isValidPort(url.port) === false) throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer.");
			if (url.path != null && typeof url.path !== "string") throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined.");
			if (url.pathname != null && typeof url.pathname !== "string") throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined.");
			if (url.hostname != null && typeof url.hostname !== "string") throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined.");
			if (url.origin != null && typeof url.origin !== "string") throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined.");
			if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
			const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
			let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`;
			let path = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
			if (origin[origin.length - 1] === "/") origin = origin.slice(0, origin.length - 1);
			if (path && path[0] !== "/") path = `/${path}`;
			return new URL(`${origin}${path}`);
		}
		if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
		return url;
	}
	function parseOrigin(url) {
		url = parseURL(url);
		if (url.pathname !== "/" || url.search || url.hash) throw new InvalidArgumentError("invalid url");
		return url;
	}
	function getHostname(host) {
		if (host[0] === "[") {
			const idx = host.indexOf("]");
			assert$26(idx !== -1);
			return host.substring(1, idx);
		}
		const idx = host.indexOf(":");
		if (idx === -1) return host;
		return host.substring(0, idx);
	}
	function getServerName(host) {
		if (!host) return null;
		assert$26(typeof host === "string");
		const servername = getHostname(host);
		if (net$2.isIP(servername)) return "";
		return servername;
	}
	function deepClone(obj) {
		return JSON.parse(JSON.stringify(obj));
	}
	function isAsyncIterable(obj) {
		return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
	}
	function isIterable(obj) {
		return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
	}
	function bodyLength(body) {
		if (body == null) return 0;
		else if (isStream(body)) {
			const state = body._readableState;
			return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null;
		} else if (isBlobLike(body)) return body.size != null ? body.size : null;
		else if (isBuffer(body)) return body.byteLength;
		return null;
	}
	function isDestroyed(body) {
		return body && !!(body.destroyed || body[kDestroyed] || stream.isDestroyed?.(body));
	}
	function destroy(stream, err) {
		if (stream == null || !isStream(stream) || isDestroyed(stream)) return;
		if (typeof stream.destroy === "function") {
			if (Object.getPrototypeOf(stream).constructor === IncomingMessage) stream.socket = null;
			stream.destroy(err);
		} else if (err) queueMicrotask(() => {
			stream.emit("error", err);
		});
		if (stream.destroyed !== true) stream[kDestroyed] = true;
	}
	var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
	function parseKeepAliveTimeout(val) {
		const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR);
		return m ? parseInt(m[1], 10) * 1e3 : null;
	}
	/**
	* Retrieves a header name and returns its lowercase value.
	* @param {string | Buffer} value Header name
	* @returns {string}
	*/
	function headerNameToString(value) {
		return typeof value === "string" ? headerNameLowerCasedRecord[value] ?? value.toLowerCase() : tree.lookup(value) ?? value.toString("latin1").toLowerCase();
	}
	/**
	* Receive the buffer as a string and return its lowercase value.
	* @param {Buffer} value Header name
	* @returns {string}
	*/
	function bufferToLowerCasedHeaderName(value) {
		return tree.lookup(value) ?? value.toString("latin1").toLowerCase();
	}
	/**
	* @param {Record<string, string | string[]> | (Buffer | string | (Buffer | string)[])[]} headers
	* @param {Record<string, string | string[]>} [obj]
	* @returns {Record<string, string | string[]>}
	*/
	function parseHeaders(headers, obj) {
		if (obj === void 0) obj = {};
		for (let i = 0; i < headers.length; i += 2) {
			const key = headerNameToString(headers[i]);
			let val = obj[key];
			if (val) {
				if (typeof val === "string") {
					val = [val];
					obj[key] = val;
				}
				val.push(headers[i + 1].toString("utf8"));
			} else {
				const headersValue = headers[i + 1];
				if (typeof headersValue === "string") obj[key] = headersValue;
				else obj[key] = Array.isArray(headersValue) ? headersValue.map((x) => x.toString("utf8")) : headersValue.toString("utf8");
			}
		}
		if ("content-length" in obj && "content-disposition" in obj) obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1");
		return obj;
	}
	function parseRawHeaders(headers) {
		const len = headers.length;
		const ret = new Array(len);
		let hasContentLength = false;
		let contentDispositionIdx = -1;
		let key;
		let val;
		let kLen = 0;
		for (let n = 0; n < headers.length; n += 2) {
			key = headers[n];
			val = headers[n + 1];
			typeof key !== "string" && (key = key.toString());
			typeof val !== "string" && (val = val.toString("utf8"));
			kLen = key.length;
			if (kLen === 14 && key[7] === "-" && (key === "content-length" || key.toLowerCase() === "content-length")) hasContentLength = true;
			else if (kLen === 19 && key[7] === "-" && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) contentDispositionIdx = n + 1;
			ret[n] = key;
			ret[n + 1] = val;
		}
		if (hasContentLength && contentDispositionIdx !== -1) ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
		return ret;
	}
	function isBuffer(buffer) {
		return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
	}
	function validateHandler(handler, method, upgrade) {
		if (!handler || typeof handler !== "object") throw new InvalidArgumentError("handler must be an object");
		if (typeof handler.onConnect !== "function") throw new InvalidArgumentError("invalid onConnect method");
		if (typeof handler.onError !== "function") throw new InvalidArgumentError("invalid onError method");
		if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) throw new InvalidArgumentError("invalid onBodySent method");
		if (upgrade || method === "CONNECT") {
			if (typeof handler.onUpgrade !== "function") throw new InvalidArgumentError("invalid onUpgrade method");
		} else {
			if (typeof handler.onHeaders !== "function") throw new InvalidArgumentError("invalid onHeaders method");
			if (typeof handler.onData !== "function") throw new InvalidArgumentError("invalid onData method");
			if (typeof handler.onComplete !== "function") throw new InvalidArgumentError("invalid onComplete method");
		}
	}
	function isDisturbed(body) {
		return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]));
	}
	function isErrored(body) {
		return !!(body && stream.isErrored(body));
	}
	function isReadable(body) {
		return !!(body && stream.isReadable(body));
	}
	function getSocketInfo(socket) {
		return {
			localAddress: socket.localAddress,
			localPort: socket.localPort,
			remoteAddress: socket.remoteAddress,
			remotePort: socket.remotePort,
			remoteFamily: socket.remoteFamily,
			timeout: socket.timeout,
			bytesWritten: socket.bytesWritten,
			bytesRead: socket.bytesRead
		};
	}
	/** @type {globalThis['ReadableStream']} */
	function ReadableStreamFrom(iterable) {
		let iterator;
		return new ReadableStream({
			async start() {
				iterator = iterable[Symbol.asyncIterator]();
			},
			async pull(controller) {
				const { done, value } = await iterator.next();
				if (done) queueMicrotask(() => {
					controller.close();
					controller.byobRequest?.respond(0);
				});
				else {
					const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
					if (buf.byteLength) controller.enqueue(new Uint8Array(buf));
				}
				return controller.desiredSize > 0;
			},
			async cancel(reason) {
				await iterator.return();
			},
			type: "bytes"
		});
	}
	function isFormDataLike(object) {
		return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData";
	}
	function addAbortListener(signal, listener) {
		if ("addEventListener" in signal) {
			signal.addEventListener("abort", listener, { once: true });
			return () => signal.removeEventListener("abort", listener);
		}
		signal.addListener("abort", listener);
		return () => signal.removeListener("abort", listener);
	}
	var hasToWellFormed = typeof String.prototype.toWellFormed === "function";
	var hasIsWellFormed = typeof String.prototype.isWellFormed === "function";
	/**
	* @param {string} val
	*/
	function toUSVString(val) {
		return hasToWellFormed ? `${val}`.toWellFormed() : nodeUtil$3.toUSVString(val);
	}
	/**
	* @param {string} val
	*/
	function isUSVString(val) {
		return hasIsWellFormed ? `${val}`.isWellFormed() : toUSVString(val) === `${val}`;
	}
	/**
	* @see https://tools.ietf.org/html/rfc7230#section-3.2.6
	* @param {number} c
	*/
	function isTokenCharCode(c) {
		switch (c) {
			case 34:
			case 40:
			case 41:
			case 44:
			case 47:
			case 58:
			case 59:
			case 60:
			case 61:
			case 62:
			case 63:
			case 64:
			case 91:
			case 92:
			case 93:
			case 123:
			case 125: return false;
			default: return c >= 33 && c <= 126;
		}
	}
	/**
	* @param {string} characters
	*/
	function isValidHTTPToken(characters) {
		if (characters.length === 0) return false;
		for (let i = 0; i < characters.length; ++i) if (!isTokenCharCode(characters.charCodeAt(i))) return false;
		return true;
	}
	/**
	* Matches if val contains an invalid field-vchar
	*  field-value    = *( field-content / obs-fold )
	*  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
	*  field-vchar    = VCHAR / obs-text
	*/
	var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
	/**
	* @param {string} characters
	*/
	function isValidHeaderValue(characters) {
		return !headerCharRegex.test(characters);
	}
	function parseRangeHeader(range) {
		if (range == null || range === "") return {
			start: 0,
			end: null,
			size: null
		};
		const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
		return m ? {
			start: parseInt(m[1]),
			end: m[2] ? parseInt(m[2]) : null,
			size: m[3] ? parseInt(m[3]) : null
		} : null;
	}
	function addListener(obj, name, listener) {
		(obj[kListeners] ??= []).push([name, listener]);
		obj.on(name, listener);
		return obj;
	}
	function removeAllListeners(obj) {
		for (const [name, listener] of obj[kListeners] ?? []) obj.removeListener(name, listener);
		obj[kListeners] = null;
	}
	function errorRequest(client, request, err) {
		try {
			request.onError(err);
			assert$26(request.aborted);
		} catch (err) {
			client.emit("error", err);
		}
	}
	var kEnumerableProperty = Object.create(null);
	kEnumerableProperty.enumerable = true;
	var normalizedMethodRecordsBase = {
		delete: "DELETE",
		DELETE: "DELETE",
		get: "GET",
		GET: "GET",
		head: "HEAD",
		HEAD: "HEAD",
		options: "OPTIONS",
		OPTIONS: "OPTIONS",
		post: "POST",
		POST: "POST",
		put: "PUT",
		PUT: "PUT"
	};
	var normalizedMethodRecords = {
		...normalizedMethodRecordsBase,
		patch: "patch",
		PATCH: "PATCH"
	};
	Object.setPrototypeOf(normalizedMethodRecordsBase, null);
	Object.setPrototypeOf(normalizedMethodRecords, null);
	module.exports = {
		kEnumerableProperty,
		nop,
		isDisturbed,
		isErrored,
		isReadable,
		toUSVString,
		isUSVString,
		isBlobLike,
		parseOrigin,
		parseURL,
		getServerName,
		isStream,
		isIterable,
		isAsyncIterable,
		isDestroyed,
		headerNameToString,
		bufferToLowerCasedHeaderName,
		addListener,
		removeAllListeners,
		errorRequest,
		parseRawHeaders,
		parseHeaders,
		parseKeepAliveTimeout,
		destroy,
		bodyLength,
		deepClone,
		ReadableStreamFrom,
		isBuffer,
		validateHandler,
		getSocketInfo,
		isFormDataLike,
		buildURL,
		addAbortListener,
		isValidHTTPToken,
		isValidHeaderValue,
		isTokenCharCode,
		parseRangeHeader,
		normalizedMethodRecordsBase,
		normalizedMethodRecords,
		isValidPort,
		isHttpOrHttpsPrefixed,
		nodeMajor,
		nodeMinor,
		safeHTTPMethods: [
			"GET",
			"HEAD",
			"OPTIONS",
			"TRACE"
		],
		wrapRequestBody
	};
}));
//#endregion
//#region node_modules/undici/lib/core/diagnostics.js
var require_diagnostics = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var diagnosticsChannel = __require("node:diagnostics_channel");
	var util$1 = __require("node:util");
	var undiciDebugLog = util$1.debuglog("undici");
	var fetchDebuglog = util$1.debuglog("fetch");
	var websocketDebuglog = util$1.debuglog("websocket");
	var isClientSet = false;
	var channels = {
		beforeConnect: diagnosticsChannel.channel("undici:client:beforeConnect"),
		connected: diagnosticsChannel.channel("undici:client:connected"),
		connectError: diagnosticsChannel.channel("undici:client:connectError"),
		sendHeaders: diagnosticsChannel.channel("undici:client:sendHeaders"),
		create: diagnosticsChannel.channel("undici:request:create"),
		bodySent: diagnosticsChannel.channel("undici:request:bodySent"),
		headers: diagnosticsChannel.channel("undici:request:headers"),
		trailers: diagnosticsChannel.channel("undici:request:trailers"),
		error: diagnosticsChannel.channel("undici:request:error"),
		open: diagnosticsChannel.channel("undici:websocket:open"),
		close: diagnosticsChannel.channel("undici:websocket:close"),
		socketError: diagnosticsChannel.channel("undici:websocket:socket_error"),
		ping: diagnosticsChannel.channel("undici:websocket:ping"),
		pong: diagnosticsChannel.channel("undici:websocket:pong")
	};
	if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
		const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog;
		diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => {
			const { connectParams: { version, protocol, port, host } } = evt;
			debuglog("connecting to %s using %s%s", `${host}${port ? `:${port}` : ""}`, protocol, version);
		});
		diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => {
			const { connectParams: { version, protocol, port, host } } = evt;
			debuglog("connected to %s using %s%s", `${host}${port ? `:${port}` : ""}`, protocol, version);
		});
		diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => {
			const { connectParams: { version, protocol, port, host }, error } = evt;
			debuglog("connection to %s using %s%s errored - %s", `${host}${port ? `:${port}` : ""}`, protocol, version, error.message);
		});
		diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => {
			const { request: { method, path, origin } } = evt;
			debuglog("sending request to %s %s/%s", method, origin, path);
		});
		diagnosticsChannel.channel("undici:request:headers").subscribe((evt) => {
			const { request: { method, path, origin }, response: { statusCode } } = evt;
			debuglog("received response to %s %s/%s - HTTP %d", method, origin, path, statusCode);
		});
		diagnosticsChannel.channel("undici:request:trailers").subscribe((evt) => {
			const { request: { method, path, origin } } = evt;
			debuglog("trailers received from %s %s/%s", method, origin, path);
		});
		diagnosticsChannel.channel("undici:request:error").subscribe((evt) => {
			const { request: { method, path, origin }, error } = evt;
			debuglog("request to %s %s/%s errored - %s", method, origin, path, error.message);
		});
		isClientSet = true;
	}
	if (websocketDebuglog.enabled) {
		if (!isClientSet) {
			const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog;
			diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => {
				const { connectParams: { version, protocol, port, host } } = evt;
				debuglog("connecting to %s%s using %s%s", host, port ? `:${port}` : "", protocol, version);
			});
			diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => {
				const { connectParams: { version, protocol, port, host } } = evt;
				debuglog("connected to %s%s using %s%s", host, port ? `:${port}` : "", protocol, version);
			});
			diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => {
				const { connectParams: { version, protocol, port, host }, error } = evt;
				debuglog("connection to %s%s using %s%s errored - %s", host, port ? `:${port}` : "", protocol, version, error.message);
			});
			diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => {
				const { request: { method, path, origin } } = evt;
				debuglog("sending request to %s %s/%s", method, origin, path);
			});
		}
		diagnosticsChannel.channel("undici:websocket:open").subscribe((evt) => {
			const { address: { address, port } } = evt;
			websocketDebuglog("connection opened %s%s", address, port ? `:${port}` : "");
		});
		diagnosticsChannel.channel("undici:websocket:close").subscribe((evt) => {
			const { websocket, code, reason } = evt;
			websocketDebuglog("closed connection to %s - %s %s", websocket.url, code, reason);
		});
		diagnosticsChannel.channel("undici:websocket:socket_error").subscribe((err) => {
			websocketDebuglog("connection errored - %s", err.message);
		});
		diagnosticsChannel.channel("undici:websocket:ping").subscribe((evt) => {
			websocketDebuglog("ping received");
		});
		diagnosticsChannel.channel("undici:websocket:pong").subscribe((evt) => {
			websocketDebuglog("pong received");
		});
	}
	module.exports = { channels };
}));
//#endregion
//#region node_modules/undici/lib/core/request.js
var require_request$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { InvalidArgumentError, NotSupportedError } = require_errors();
	var assert$25 = __require("node:assert");
	var { isValidHTTPToken, isValidHeaderValue, isStream, destroy, isBuffer, isFormDataLike, isIterable, isBlobLike, buildURL, validateHandler, getServerName, normalizedMethodRecords } = require_util$8();
	var { channels } = require_diagnostics();
	var { headerNameLowerCasedRecord } = require_constants$4();
	var invalidPathRegex = /[^\u0021-\u00ff]/;
	var kHandler = Symbol("handler");
	var Request = class {
		constructor(origin, { path, method, body, headers, query, idempotent, blocking, upgrade, headersTimeout, bodyTimeout, reset, throwOnError, expectContinue, servername }, 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");
			this.headersTimeout = headersTimeout;
			this.bodyTimeout = bodyTimeout;
			this.throwOnError = throwOnError === true;
			this.method = method;
			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 = function autoDestroy() {
						destroy(this);
					};
					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 ? buildURL(path, query) : path;
			this.origin = origin;
			this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
			this.blocking = blocking == null ? false : blocking;
			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 (headers[Symbol.iterator]) 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");
			validateHandler(handler, method, upgrade);
			this.servername = servername || getServerName(this.host);
			this[kHandler] = handler;
			if (channels.create.hasSubscribers) channels.create.publish({ request: this });
		}
		onBodySent(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);
			}
		}
		onConnect(abort) {
			assert$25(!this.aborted);
			assert$25(!this.completed);
			if (this.error) abort(this.error);
			else {
				this.abort = abort;
				return this[kHandler].onConnect(abort);
			}
		}
		onResponseStarted() {
			return this[kHandler].onResponseStarted?.();
		}
		onHeaders(statusCode, headers, resume, statusText) {
			assert$25(!this.aborted);
			assert$25(!this.completed);
			if (channels.headers.hasSubscribers) channels.headers.publish({
				request: this,
				response: {
					statusCode,
					headers,
					statusText
				}
			});
			try {
				return this[kHandler].onHeaders(statusCode, headers, resume, statusText);
			} catch (err) {
				this.abort(err);
			}
		}
		onData(chunk) {
			assert$25(!this.aborted);
			assert$25(!this.completed);
			try {
				return this[kHandler].onData(chunk);
			} catch (err) {
				this.abort(err);
				return false;
			}
		}
		onUpgrade(statusCode, headers, socket) {
			assert$25(!this.aborted);
			assert$25(!this.completed);
			return this[kHandler].onUpgrade(statusCode, headers, socket);
		}
		onComplete(trailers) {
			this.onFinally();
			assert$25(!this.aborted);
			this.completed = true;
			if (channels.trailers.hasSubscribers) channels.trailers.publish({
				request: this,
				trailers
			});
			try {
				return this[kHandler].onComplete(trailers);
			} catch (err) {
				this.onError(err);
			}
		}
		onError(error) {
			this.onFinally();
			if (channels.error.hasSubscribers) channels.error.publish({
				request: this,
				error
			});
			if (this.aborted) return;
			this.aborted = true;
			return this[kHandler].onError(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 arr.push(`${val[i]}`);
			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 (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");
			request.contentLength = parseInt(val, 10);
			if (!Number.isFinite(request.contentLength)) throw new InvalidArgumentError("invalid content-length header");
		} 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.toLowerCase() : null;
			if (value !== "close" && value !== "keep-alive") throw new InvalidArgumentError("invalid connection header");
			if (value === "close") request.reset = true;
		} else if (headerName === "expect") throw new NotSupportedError("expect header not supported");
		else request.headers.push(key, val);
	}
	module.exports = Request;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/dispatcher.js
var require_dispatcher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var EventEmitter = __require("node:events");
	var Dispatcher = class extends EventEmitter {
		dispatch() {
			throw new Error("not implemented");
		}
		close() {
			throw new Error("not implemented");
		}
		destroy() {
			throw new Error("not implemented");
		}
		compose(...args) {
			const interceptors = Array.isArray(args[0]) ? args[0] : args;
			let dispatch = this.dispatch.bind(this);
			for (const interceptor of interceptors) {
				if (interceptor == null) continue;
				if (typeof interceptor !== "function") throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`);
				dispatch = interceptor(dispatch);
				if (dispatch == null || typeof dispatch !== "function" || dispatch.length !== 2) throw new TypeError("invalid interceptor");
			}
			return new ComposedDispatcher(this, dispatch);
		}
	};
	var ComposedDispatcher = class extends Dispatcher {
		#dispatcher = null;
		#dispatch = null;
		constructor(dispatcher, dispatch) {
			super();
			this.#dispatcher = dispatcher;
			this.#dispatch = dispatch;
		}
		dispatch(...args) {
			this.#dispatch(...args);
		}
		close(...args) {
			return this.#dispatcher.close(...args);
		}
		destroy(...args) {
			return this.#dispatcher.destroy(...args);
		}
	};
	module.exports = Dispatcher;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/dispatcher-base.js
var require_dispatcher_base = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var Dispatcher = require_dispatcher();
	var { ClientDestroyedError, ClientClosedError, InvalidArgumentError } = require_errors();
	var { kDestroy, kClose, kClosed, kDestroyed, kDispatch, kInterceptors } = require_symbols$4();
	var kOnDestroyed = Symbol("onDestroyed");
	var kOnClosed = Symbol("onClosed");
	var kInterceptedDispatch = Symbol("Intercepted Dispatch");
	var DispatcherBase = class extends Dispatcher {
		constructor() {
			super();
			this[kDestroyed] = false;
			this[kOnDestroyed] = null;
			this[kClosed] = false;
			this[kOnClosed] = [];
		}
		get destroyed() {
			return this[kDestroyed];
		}
		get closed() {
			return this[kClosed];
		}
		get interceptors() {
			return this[kInterceptors];
		}
		set interceptors(newInterceptors) {
			if (newInterceptors) {
				for (let i = newInterceptors.length - 1; i >= 0; i--) if (typeof this[kInterceptors][i] !== "function") throw new InvalidArgumentError("interceptor must be an function");
			}
			this[kInterceptors] = newInterceptors;
		}
		close(callback) {
			if (callback === void 0) return new Promise((resolve, reject) => {
				this.close((err, data) => {
					return err ? reject(err) : resolve(data);
				});
			});
			if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback");
			if (this[kDestroyed]) {
				queueMicrotask(() => callback(new ClientDestroyedError(), null));
				return;
			}
			if (this[kClosed]) {
				if (this[kOnClosed]) this[kOnClosed].push(callback);
				else queueMicrotask(() => callback(null, null));
				return;
			}
			this[kClosed] = true;
			this[kOnClosed].push(callback);
			const onClosed = () => {
				const callbacks = this[kOnClosed];
				this[kOnClosed] = null;
				for (let i = 0; i < callbacks.length; i++) callbacks[i](null, null);
			};
			this[kClose]().then(() => this.destroy()).then(() => {
				queueMicrotask(onClosed);
			});
		}
		destroy(err, callback) {
			if (typeof err === "function") {
				callback = err;
				err = null;
			}
			if (callback === void 0) return new Promise((resolve, reject) => {
				this.destroy(err, (err, data) => {
					return err ? reject(err) : resolve(data);
				});
			});
			if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback");
			if (this[kDestroyed]) {
				if (this[kOnDestroyed]) this[kOnDestroyed].push(callback);
				else queueMicrotask(() => callback(null, null));
				return;
			}
			if (!err) err = new ClientDestroyedError();
			this[kDestroyed] = true;
			this[kOnDestroyed] = this[kOnDestroyed] || [];
			this[kOnDestroyed].push(callback);
			const onDestroyed = () => {
				const callbacks = this[kOnDestroyed];
				this[kOnDestroyed] = null;
				for (let i = 0; i < callbacks.length; i++) callbacks[i](null, null);
			};
			this[kDestroy](err).then(() => {
				queueMicrotask(onDestroyed);
			});
		}
		[kInterceptedDispatch](opts, handler) {
			if (!this[kInterceptors] || this[kInterceptors].length === 0) {
				this[kInterceptedDispatch] = this[kDispatch];
				return this[kDispatch](opts, handler);
			}
			let dispatch = this[kDispatch].bind(this);
			for (let i = this[kInterceptors].length - 1; i >= 0; i--) dispatch = this[kInterceptors][i](dispatch);
			this[kInterceptedDispatch] = dispatch;
			return dispatch(opts, handler);
		}
		dispatch(opts, handler) {
			if (!handler || typeof handler !== "object") throw new InvalidArgumentError("handler must be an object");
			try {
				if (!opts || typeof opts !== "object") throw new InvalidArgumentError("opts must be an object.");
				if (this[kDestroyed] || this[kOnDestroyed]) throw new ClientDestroyedError();
				if (this[kClosed]) throw new ClientClosedError();
				return this[kInterceptedDispatch](opts, handler);
			} catch (err) {
				if (typeof handler.onError !== "function") throw new InvalidArgumentError("invalid onError method");
				handler.onError(err);
				return false;
			}
		}
	};
	module.exports = DispatcherBase;
}));
//#endregion
//#region node_modules/undici/lib/util/timers.js
var require_timers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/**
	* This module offers an optimized timer implementation designed for scenarios
	* where high precision is not critical.
	*
	* The timer achieves faster performance by using a low-resolution approach,
	* with an accuracy target of within 500ms. This makes it particularly useful
	* for timers with delays of 1 second or more, where exact timing is less
	* crucial.
	*
	* It's important to note that Node.js timers are inherently imprecise, as
	* delays can occur due to the event loop being blocked by other operations.
	* Consequently, timers may trigger later than their scheduled time.
	*/
	/**
	* The fastNow variable contains the internal fast timer clock value.
	*
	* @type {number}
	*/
	var fastNow = 0;
	/**
	* RESOLUTION_MS represents the target resolution time in milliseconds.
	*
	* @type {number}
	* @default 1000
	*/
	var RESOLUTION_MS = 1e3;
	/**
	* TICK_MS defines the desired interval in milliseconds between each tick.
	* The target value is set to half the resolution time, minus 1 ms, to account
	* for potential event loop overhead.
	*
	* @type {number}
	* @default 499
	*/
	var TICK_MS = (RESOLUTION_MS >> 1) - 1;
	/**
	* fastNowTimeout is a Node.js timer used to manage and process
	* the FastTimers stored in the `fastTimers` array.
	*
	* @type {NodeJS.Timeout}
	*/
	var fastNowTimeout;
	/**
	* The kFastTimer symbol is used to identify FastTimer instances.
	*
	* @type {Symbol}
	*/
	var kFastTimer = Symbol("kFastTimer");
	/**
	* The fastTimers array contains all active FastTimers.
	*
	* @type {FastTimer[]}
	*/
	var fastTimers = [];
	/**
	* These constants represent the various states of a FastTimer.
	*/
	/**
	* The `NOT_IN_LIST` constant indicates that the FastTimer is not included
	* in the `fastTimers` array. Timers with this status will not be processed
	* during the next tick by the `onTick` function.
	*
	* A FastTimer can be re-added to the `fastTimers` array by invoking the
	* `refresh` method on the FastTimer instance.
	*
	* @type {-2}
	*/
	var NOT_IN_LIST = -2;
	/**
	* The `TO_BE_CLEARED` constant indicates that the FastTimer is scheduled
	* for removal from the `fastTimers` array. A FastTimer in this state will
	* be removed in the next tick by the `onTick` function and will no longer
	* be processed.
	*
	* This status is also set when the `clear` method is called on the FastTimer instance.
	*
	* @type {-1}
	*/
	var TO_BE_CLEARED = -1;
	/**
	* The `PENDING` constant signifies that the FastTimer is awaiting processing
	* in the next tick by the `onTick` function. Timers with this status will have
	* their `_idleStart` value set and their status updated to `ACTIVE` in the next tick.
	*
	* @type {0}
	*/
	var PENDING = 0;
	/**
	* The `ACTIVE` constant indicates that the FastTimer is active and waiting
	* for its timer to expire. During the next tick, the `onTick` function will
	* check if the timer has expired, and if so, it will execute the associated callback.
	*
	* @type {1}
	*/
	var ACTIVE = 1;
	/**
	* The onTick function processes the fastTimers array.
	*
	* @returns {void}
	*/
	function onTick() {
		/**
		* Increment the fastNow value by the TICK_MS value, despite the actual time
		* that has passed since the last tick. This approach ensures independence
		* from the system clock and delays caused by a blocked event loop.
		*
		* @type {number}
		*/
		fastNow += TICK_MS;
		/**
		* The `idx` variable is used to iterate over the `fastTimers` array.
		* Expired timers are removed by replacing them with the last element in the array.
		* Consequently, `idx` is only incremented when the current element is not removed.
		*
		* @type {number}
		*/
		let idx = 0;
		/**
		* The len variable will contain the length of the fastTimers array
		* and will be decremented when a FastTimer should be removed from the
		* fastTimers array.
		*
		* @type {number}
		*/
		let len = fastTimers.length;
		while (idx < len) {
			/**
			* @type {FastTimer}
			*/
			const timer = fastTimers[idx];
			if (timer._state === PENDING) {
				timer._idleStart = fastNow - TICK_MS;
				timer._state = ACTIVE;
			} else if (timer._state === ACTIVE && fastNow >= timer._idleStart + timer._idleTimeout) {
				timer._state = TO_BE_CLEARED;
				timer._idleStart = -1;
				timer._onTimeout(timer._timerArg);
			}
			if (timer._state === TO_BE_CLEARED) {
				timer._state = NOT_IN_LIST;
				if (--len !== 0) fastTimers[idx] = fastTimers[len];
			} else ++idx;
		}
		fastTimers.length = len;
		if (fastTimers.length !== 0) refreshTimeout();
	}
	function refreshTimeout() {
		if (fastNowTimeout) fastNowTimeout.refresh();
		else {
			clearTimeout(fastNowTimeout);
			fastNowTimeout = setTimeout(onTick, TICK_MS);
			if (fastNowTimeout.unref) fastNowTimeout.unref();
		}
	}
	/**
	* The `FastTimer` class is a data structure designed to store and manage
	* timer information.
	*/
	var FastTimer = class {
		[kFastTimer] = true;
		/**
		* The state of the timer, which can be one of the following:
		* - NOT_IN_LIST (-2)
		* - TO_BE_CLEARED (-1)
		* - PENDING (0)
		* - ACTIVE (1)
		*
		* @type {-2|-1|0|1}
		* @private
		*/
		_state = NOT_IN_LIST;
		/**
		* The number of milliseconds to wait before calling the callback.
		*
		* @type {number}
		* @private
		*/
		_idleTimeout = -1;
		/**
		* The time in milliseconds when the timer was started. This value is used to
		* calculate when the timer should expire.
		*
		* @type {number}
		* @default -1
		* @private
		*/
		_idleStart = -1;
		/**
		* The function to be executed when the timer expires.
		* @type {Function}
		* @private
		*/
		_onTimeout;
		/**
		* The argument to be passed to the callback when the timer expires.
		*
		* @type {*}
		* @private
		*/
		_timerArg;
		/**
		* @constructor
		* @param {Function} callback A function to be executed after the timer
		* expires.
		* @param {number} delay The time, in milliseconds that the timer should wait
		* before the specified function or code is executed.
		* @param {*} arg
		*/
		constructor(callback, delay, arg) {
			this._onTimeout = callback;
			this._idleTimeout = delay;
			this._timerArg = arg;
			this.refresh();
		}
		/**
		* Sets the timer's start time to the current time, and reschedules the timer
		* to call its callback at the previously specified duration adjusted to the
		* current time.
		* Using this on a timer that has already called its callback will reactivate
		* the timer.
		*
		* @returns {void}
		*/
		refresh() {
			if (this._state === NOT_IN_LIST) fastTimers.push(this);
			if (!fastNowTimeout || fastTimers.length === 1) refreshTimeout();
			this._state = PENDING;
		}
		/**
		* The `clear` method cancels the timer, preventing it from executing.
		*
		* @returns {void}
		* @private
		*/
		clear() {
			this._state = TO_BE_CLEARED;
			this._idleStart = -1;
		}
	};
	/**
	* This module exports a setTimeout and clearTimeout function that can be
	* used as a drop-in replacement for the native functions.
	*/
	module.exports = {
		setTimeout(callback, delay, arg) {
			return delay <= RESOLUTION_MS ? setTimeout(callback, delay, arg) : new FastTimer(callback, delay, arg);
		},
		clearTimeout(timeout) {
			if (timeout[kFastTimer])
 /**
			* @type {FastTimer}
			*/
			timeout.clear();
			else clearTimeout(timeout);
		},
		setFastTimeout(callback, delay, arg) {
			return new FastTimer(callback, delay, arg);
		},
		clearFastTimeout(timeout) {
			timeout.clear();
		},
		now() {
			return fastNow;
		},
		tick(delay = 0) {
			fastNow += delay - RESOLUTION_MS + 1;
			onTick();
			onTick();
		},
		reset() {
			fastNow = 0;
			fastTimers.length = 0;
			clearTimeout(fastNowTimeout);
			fastNowTimeout = null;
		},
		kFastTimer
	};
}));
//#endregion
//#region node_modules/undici/lib/core/connect.js
var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var net$1 = __require("node:net");
	var assert$24 = __require("node:assert");
	var util = require_util$8();
	var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
	var timers = require_timers();
	function noop() {}
	var tls;
	var SessionCache;
	if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) SessionCache = class WeakSessionCache {
		constructor(maxCachedSessions) {
			this._maxCachedSessions = maxCachedSessions;
			this._sessionCache = /* @__PURE__ */ new Map();
			this._sessionRegistry = new global.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;
			this._sessionCache.set(sessionKey, new WeakRef(session));
			this._sessionRegistry.register(session, sessionKey);
		}
	};
	else SessionCache = class SimpleSessionCache {
		constructor(maxCachedSessions) {
			this._maxCachedSessions = maxCachedSessions;
			this._sessionCache = /* @__PURE__ */ new Map();
		}
		get(sessionKey) {
			return this._sessionCache.get(sessionKey);
		}
		set(sessionKey, session) {
			if (this._maxCachedSessions === 0) return;
			if (this._sessionCache.size >= this._maxCachedSessions) {
				const { value: oldestKey } = this._sessionCache.keys().next();
				this._sessionCache.delete(oldestKey);
			}
			this._sessionCache.set(sessionKey, session);
		}
	};
	function buildConnector({ allowH2, 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 : false;
		return 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$24(sessionKey);
				const session = customSession || sessionCache.get(sessionKey) || null;
				port = port || 443;
				socket = tls.connect({
					highWaterMark: 16384,
					...options,
					servername,
					session,
					localAddress,
					ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"],
					socket: httpSocket,
					port,
					host: hostname
				});
				socket.on("session", function(session) {
					sessionCache.set(sessionKey, session);
				});
			} else {
				assert$24(!httpSocket, "httpSocket can only be sent on TLS update");
				port = port || 80;
				socket = net$1.connect({
					highWaterMark: 64 * 1024,
					...options,
					localAddress,
					port,
					host: hostname
				});
			}
			if (options.keepAlive == null || options.keepAlive) {
				const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay;
				socket.setKeepAlive(true, keepAliveInitialDelay);
			}
			const clearConnectTimeout = 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(err);
				}
			});
			return socket;
		};
	}
	/**
	* @param {WeakRef<net.Socket>} socketWeakRef
	* @param {object} opts
	* @param {number} opts.timeout
	* @param {string} opts.hostname
	* @param {number} opts.port
	* @returns {() => void}
	*/
	var setupConnectTimeout = process.platform === "win32" ? (socketWeakRef, opts) => {
		if (!opts.timeout) return noop;
		let s1 = null;
		let s2 = null;
		const fastTimer = timers.setFastTimeout(() => {
			s1 = setImmediate(() => {
				s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts));
			});
		}, opts.timeout);
		return () => {
			timers.clearFastTimeout(fastTimer);
			clearImmediate(s1);
			clearImmediate(s2);
		};
	} : (socketWeakRef, opts) => {
		if (!opts.timeout) return noop;
		let s1 = null;
		const fastTimer = timers.setFastTimeout(() => {
			s1 = setImmediate(() => {
				onConnectTimeout(socketWeakRef.deref(), opts);
			});
		}, opts.timeout);
		return () => {
			timers.clearFastTimeout(fastTimer);
			clearImmediate(s1);
		};
	};
	/**
	* @param {net.Socket} socket
	* @param {object} opts
	* @param {number} opts.timeout
	* @param {string} opts.hostname
	* @param {number} opts.port
	*/
	function onConnectTimeout(socket, opts) {
		if (socket == null) return;
		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)`;
		util.destroy(socket, new ConnectTimeoutError(message));
	}
	module.exports = buildConnector;
}));
//#endregion
//#region node_modules/undici/lib/llhttp/utils.js
var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.enumToMap = void 0;
	function enumToMap(obj) {
		const res = {};
		Object.keys(obj).forEach((key) => {
			const value = obj[key];
			if (typeof value === "number") res[key] = value;
		});
		return res;
	}
	exports.enumToMap = enumToMap;
}));
//#endregion
//#region node_modules/undici/lib/llhttp/constants.js
var require_constants$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.FINISH = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0;
	var utils_1 = require_utils();
	(function(ERROR) {
		ERROR[ERROR["OK"] = 0] = "OK";
		ERROR[ERROR["INTERNAL"] = 1] = "INTERNAL";
		ERROR[ERROR["STRICT"] = 2] = "STRICT";
		ERROR[ERROR["LF_EXPECTED"] = 3] = "LF_EXPECTED";
		ERROR[ERROR["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
		ERROR[ERROR["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
		ERROR[ERROR["INVALID_METHOD"] = 6] = "INVALID_METHOD";
		ERROR[ERROR["INVALID_URL"] = 7] = "INVALID_URL";
		ERROR[ERROR["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
		ERROR[ERROR["INVALID_VERSION"] = 9] = "INVALID_VERSION";
		ERROR[ERROR["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
		ERROR[ERROR["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
		ERROR[ERROR["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
		ERROR[ERROR["INVALID_STATUS"] = 13] = "INVALID_STATUS";
		ERROR[ERROR["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
		ERROR[ERROR["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
		ERROR[ERROR["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
		ERROR[ERROR["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
		ERROR[ERROR["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
		ERROR[ERROR["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
		ERROR[ERROR["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
		ERROR[ERROR["PAUSED"] = 21] = "PAUSED";
		ERROR[ERROR["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
		ERROR[ERROR["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
		ERROR[ERROR["USER"] = 24] = "USER";
	})(exports.ERROR || (exports.ERROR = {}));
	(function(TYPE) {
		TYPE[TYPE["BOTH"] = 0] = "BOTH";
		TYPE[TYPE["REQUEST"] = 1] = "REQUEST";
		TYPE[TYPE["RESPONSE"] = 2] = "RESPONSE";
	})(exports.TYPE || (exports.TYPE = {}));
	(function(FLAGS) {
		FLAGS[FLAGS["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
		FLAGS[FLAGS["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
		FLAGS[FLAGS["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
		FLAGS[FLAGS["CHUNKED"] = 8] = "CHUNKED";
		FLAGS[FLAGS["UPGRADE"] = 16] = "UPGRADE";
		FLAGS[FLAGS["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
		FLAGS[FLAGS["SKIPBODY"] = 64] = "SKIPBODY";
		FLAGS[FLAGS["TRAILING"] = 128] = "TRAILING";
		FLAGS[FLAGS["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
	})(exports.FLAGS || (exports.FLAGS = {}));
	(function(LENIENT_FLAGS) {
		LENIENT_FLAGS[LENIENT_FLAGS["HEADERS"] = 1] = "HEADERS";
		LENIENT_FLAGS[LENIENT_FLAGS["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
		LENIENT_FLAGS[LENIENT_FLAGS["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
	})(exports.LENIENT_FLAGS || (exports.LENIENT_FLAGS = {}));
	var METHODS;
	(function(METHODS) {
		METHODS[METHODS["DELETE"] = 0] = "DELETE";
		METHODS[METHODS["GET"] = 1] = "GET";
		METHODS[METHODS["HEAD"] = 2] = "HEAD";
		METHODS[METHODS["POST"] = 3] = "POST";
		METHODS[METHODS["PUT"] = 4] = "PUT";
		METHODS[METHODS["CONNECT"] = 5] = "CONNECT";
		METHODS[METHODS["OPTIONS"] = 6] = "OPTIONS";
		METHODS[METHODS["TRACE"] = 7] = "TRACE";
		METHODS[METHODS["COPY"] = 8] = "COPY";
		METHODS[METHODS["LOCK"] = 9] = "LOCK";
		METHODS[METHODS["MKCOL"] = 10] = "MKCOL";
		METHODS[METHODS["MOVE"] = 11] = "MOVE";
		METHODS[METHODS["PROPFIND"] = 12] = "PROPFIND";
		METHODS[METHODS["PROPPATCH"] = 13] = "PROPPATCH";
		METHODS[METHODS["SEARCH"] = 14] = "SEARCH";
		METHODS[METHODS["UNLOCK"] = 15] = "UNLOCK";
		METHODS[METHODS["BIND"] = 16] = "BIND";
		METHODS[METHODS["REBIND"] = 17] = "REBIND";
		METHODS[METHODS["UNBIND"] = 18] = "UNBIND";
		METHODS[METHODS["ACL"] = 19] = "ACL";
		METHODS[METHODS["REPORT"] = 20] = "REPORT";
		METHODS[METHODS["MKACTIVITY"] = 21] = "MKACTIVITY";
		METHODS[METHODS["CHECKOUT"] = 22] = "CHECKOUT";
		METHODS[METHODS["MERGE"] = 23] = "MERGE";
		METHODS[METHODS["M-SEARCH"] = 24] = "M-SEARCH";
		METHODS[METHODS["NOTIFY"] = 25] = "NOTIFY";
		METHODS[METHODS["SUBSCRIBE"] = 26] = "SUBSCRIBE";
		METHODS[METHODS["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
		METHODS[METHODS["PATCH"] = 28] = "PATCH";
		METHODS[METHODS["PURGE"] = 29] = "PURGE";
		METHODS[METHODS["MKCALENDAR"] = 30] = "MKCALENDAR";
		METHODS[METHODS["LINK"] = 31] = "LINK";
		METHODS[METHODS["UNLINK"] = 32] = "UNLINK";
		METHODS[METHODS["SOURCE"] = 33] = "SOURCE";
		METHODS[METHODS["PRI"] = 34] = "PRI";
		METHODS[METHODS["DESCRIBE"] = 35] = "DESCRIBE";
		METHODS[METHODS["ANNOUNCE"] = 36] = "ANNOUNCE";
		METHODS[METHODS["SETUP"] = 37] = "SETUP";
		METHODS[METHODS["PLAY"] = 38] = "PLAY";
		METHODS[METHODS["PAUSE"] = 39] = "PAUSE";
		METHODS[METHODS["TEARDOWN"] = 40] = "TEARDOWN";
		METHODS[METHODS["GET_PARAMETER"] = 41] = "GET_PARAMETER";
		METHODS[METHODS["SET_PARAMETER"] = 42] = "SET_PARAMETER";
		METHODS[METHODS["REDIRECT"] = 43] = "REDIRECT";
		METHODS[METHODS["RECORD"] = 44] = "RECORD";
		METHODS[METHODS["FLUSH"] = 45] = "FLUSH";
	})(METHODS = exports.METHODS || (exports.METHODS = {}));
	exports.METHODS_HTTP = [
		METHODS.DELETE,
		METHODS.GET,
		METHODS.HEAD,
		METHODS.POST,
		METHODS.PUT,
		METHODS.CONNECT,
		METHODS.OPTIONS,
		METHODS.TRACE,
		METHODS.COPY,
		METHODS.LOCK,
		METHODS.MKCOL,
		METHODS.MOVE,
		METHODS.PROPFIND,
		METHODS.PROPPATCH,
		METHODS.SEARCH,
		METHODS.UNLOCK,
		METHODS.BIND,
		METHODS.REBIND,
		METHODS.UNBIND,
		METHODS.ACL,
		METHODS.REPORT,
		METHODS.MKACTIVITY,
		METHODS.CHECKOUT,
		METHODS.MERGE,
		METHODS["M-SEARCH"],
		METHODS.NOTIFY,
		METHODS.SUBSCRIBE,
		METHODS.UNSUBSCRIBE,
		METHODS.PATCH,
		METHODS.PURGE,
		METHODS.MKCALENDAR,
		METHODS.LINK,
		METHODS.UNLINK,
		METHODS.PRI,
		METHODS.SOURCE
	];
	exports.METHODS_ICE = [METHODS.SOURCE];
	exports.METHODS_RTSP = [
		METHODS.OPTIONS,
		METHODS.DESCRIBE,
		METHODS.ANNOUNCE,
		METHODS.SETUP,
		METHODS.PLAY,
		METHODS.PAUSE,
		METHODS.TEARDOWN,
		METHODS.GET_PARAMETER,
		METHODS.SET_PARAMETER,
		METHODS.REDIRECT,
		METHODS.RECORD,
		METHODS.FLUSH,
		METHODS.GET,
		METHODS.POST
	];
	exports.METHOD_MAP = utils_1.enumToMap(METHODS);
	exports.H_METHOD_MAP = {};
	Object.keys(exports.METHOD_MAP).forEach((key) => {
		if (/^H/.test(key)) exports.H_METHOD_MAP[key] = exports.METHOD_MAP[key];
	});
	(function(FINISH) {
		FINISH[FINISH["SAFE"] = 0] = "SAFE";
		FINISH[FINISH["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
		FINISH[FINISH["UNSAFE"] = 2] = "UNSAFE";
	})(exports.FINISH || (exports.FINISH = {}));
	exports.ALPHA = [];
	for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) {
		exports.ALPHA.push(String.fromCharCode(i));
		exports.ALPHA.push(String.fromCharCode(i + 32));
	}
	exports.NUM_MAP = {
		0: 0,
		1: 1,
		2: 2,
		3: 3,
		4: 4,
		5: 5,
		6: 6,
		7: 7,
		8: 8,
		9: 9
	};
	exports.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
	};
	exports.NUM = [
		"0",
		"1",
		"2",
		"3",
		"4",
		"5",
		"6",
		"7",
		"8",
		"9"
	];
	exports.ALPHANUM = exports.ALPHA.concat(exports.NUM);
	exports.MARK = [
		"-",
		"_",
		".",
		"!",
		"~",
		"*",
		"'",
		"(",
		")"
	];
	exports.USERINFO_CHARS = exports.ALPHANUM.concat(exports.MARK).concat([
		"%",
		";",
		":",
		"&",
		"=",
		"+",
		"$",
		","
	]);
	exports.STRICT_URL_CHAR = [
		"!",
		"\"",
		"$",
		"%",
		"&",
		"'",
		"(",
		")",
		"*",
		"+",
		",",
		"-",
		".",
		"/",
		":",
		";",
		"<",
		"=",
		">",
		"@",
		"[",
		"\\",
		"]",
		"^",
		"_",
		"`",
		"{",
		"|",
		"}",
		"~"
	].concat(exports.ALPHANUM);
	exports.URL_CHAR = exports.STRICT_URL_CHAR.concat(["	", "\f"]);
	for (let i = 128; i <= 255; i++) exports.URL_CHAR.push(i);
	exports.HEX = exports.NUM.concat([
		"a",
		"b",
		"c",
		"d",
		"e",
		"f",
		"A",
		"B",
		"C",
		"D",
		"E",
		"F"
	]);
	exports.STRICT_TOKEN = [
		"!",
		"#",
		"$",
		"%",
		"&",
		"'",
		"*",
		"+",
		"-",
		".",
		"^",
		"_",
		"`",
		"|",
		"~"
	].concat(exports.ALPHANUM);
	exports.TOKEN = exports.STRICT_TOKEN.concat([" "]);
	exports.HEADER_CHARS = ["	"];
	for (let i = 32; i <= 255; i++) if (i !== 127) exports.HEADER_CHARS.push(i);
	exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS.filter((c) => c !== 44);
	exports.MAJOR = exports.NUM_MAP;
	exports.MINOR = exports.MAJOR;
	var HEADER_STATE;
	(function(HEADER_STATE) {
		HEADER_STATE[HEADER_STATE["GENERAL"] = 0] = "GENERAL";
		HEADER_STATE[HEADER_STATE["CONNECTION"] = 1] = "CONNECTION";
		HEADER_STATE[HEADER_STATE["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
		HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
		HEADER_STATE[HEADER_STATE["UPGRADE"] = 4] = "UPGRADE";
		HEADER_STATE[HEADER_STATE["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
		HEADER_STATE[HEADER_STATE["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
		HEADER_STATE[HEADER_STATE["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
		HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
	})(HEADER_STATE = exports.HEADER_STATE || (exports.HEADER_STATE = {}));
	exports.SPECIAL_HEADERS = {
		"connection": HEADER_STATE.CONNECTION,
		"content-length": HEADER_STATE.CONTENT_LENGTH,
		"proxy-connection": HEADER_STATE.CONNECTION,
		"transfer-encoding": HEADER_STATE.TRANSFER_ENCODING,
		"upgrade": HEADER_STATE.UPGRADE
	};
}));
//#endregion
//#region node_modules/undici/lib/llhttp/llhttp-wasm.js
var require_llhttp_wasm = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Buffer: Buffer$2 } = __require("node:buffer");
	module.exports = Buffer$2.from("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", "base64");
}));
//#endregion
//#region node_modules/undici/lib/llhttp/llhttp_simd-wasm.js
var require_llhttp_simd_wasm = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Buffer: Buffer$1 } = __require("node:buffer");
	module.exports = Buffer$1.from("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", "base64");
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/constants.js
var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var corsSafeListedMethods = [
		"GET",
		"HEAD",
		"POST"
	];
	var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
	var nullBodyStatus = [
		101,
		204,
		205,
		304
	];
	var redirectStatus = [
		301,
		302,
		303,
		307,
		308
	];
	var redirectStatusSet = new Set(redirectStatus);
	/**
	* @see https://fetch.spec.whatwg.org/#block-bad-port
	*/
	var badPorts = [
		"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);
	/**
	* @see https://w3c.github.io/webappsec-referrer-policy/#referrer-policies
	*/
	var referrerPolicy = [
		"",
		"no-referrer",
		"no-referrer-when-downgrade",
		"same-origin",
		"origin",
		"strict-origin",
		"origin-when-cross-origin",
		"strict-origin-when-cross-origin",
		"unsafe-url"
	];
	var referrerPolicySet = new Set(referrerPolicy);
	var requestRedirect = [
		"follow",
		"manual",
		"error"
	];
	var safeMethods = [
		"GET",
		"HEAD",
		"OPTIONS",
		"TRACE"
	];
	var safeMethodsSet = new Set(safeMethods);
	var requestMode = [
		"navigate",
		"same-origin",
		"no-cors",
		"cors"
	];
	var requestCredentials = [
		"omit",
		"same-origin",
		"include"
	];
	var requestCache = [
		"default",
		"no-store",
		"reload",
		"no-cache",
		"force-cache",
		"only-if-cached"
	];
	/**
	* @see https://fetch.spec.whatwg.org/#request-body-header-name
	*/
	var requestBodyHeader = [
		"content-encoding",
		"content-language",
		"content-location",
		"content-type",
		"content-length"
	];
	/**
	* @see https://fetch.spec.whatwg.org/#enumdef-requestduplex
	*/
	var requestDuplex = ["half"];
	/**
	* @see http://fetch.spec.whatwg.org/#forbidden-method
	*/
	var forbiddenMethods = [
		"CONNECT",
		"TRACE",
		"TRACK"
	];
	var forbiddenMethodsSet = new Set(forbiddenMethods);
	var subresource = [
		"audio",
		"audioworklet",
		"font",
		"image",
		"manifest",
		"paintworklet",
		"script",
		"style",
		"track",
		"video",
		"xslt",
		""
	];
	module.exports = {
		subresource,
		forbiddenMethods,
		requestBodyHeader,
		referrerPolicy,
		requestRedirect,
		requestMode,
		requestCredentials,
		requestCache,
		redirectStatus,
		corsSafeListedMethods,
		nullBodyStatus,
		safeMethods,
		badPorts,
		requestDuplex,
		subresourceSet: new Set(subresource),
		badPortsSet,
		redirectStatusSet,
		corsSafeListedMethodsSet,
		safeMethodsSet,
		forbiddenMethodsSet,
		referrerPolicySet
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/global.js
var require_global$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var globalOrigin = Symbol.for("undici.globalOrigin.1");
	function getGlobalOrigin() {
		return globalThis[globalOrigin];
	}
	function setGlobalOrigin(newOrigin) {
		if (newOrigin === void 0) {
			Object.defineProperty(globalThis, globalOrigin, {
				value: void 0,
				writable: true,
				enumerable: false,
				configurable: false
			});
			return;
		}
		const parsedURL = new URL(newOrigin);
		if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
		Object.defineProperty(globalThis, globalOrigin, {
			value: parsedURL,
			writable: true,
			enumerable: false,
			configurable: false
		});
	}
	module.exports = {
		getGlobalOrigin,
		setGlobalOrigin
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/data-url.js
var require_data_url = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$23 = __require("node:assert");
	var encoder = new TextEncoder();
	/**
	* @see https://mimesniff.spec.whatwg.org/#http-token-code-point
	*/
	var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/;
	var HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/;
	var ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g;
	/**
	* @see https://mimesniff.spec.whatwg.org/#http-quoted-string-token-code-point
	*/
	var HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
	/** @param {URL} dataURL */
	function dataURLProcessor(dataURL) {
		assert$23(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++;
		let body = stringPercentDecode(input.slice(mimeTypeLength + 1));
		if (/;(\u0020){0,}base64$/i.test(mimeType)) {
			body = forgivingBase64(isomorphicDecode(body));
			if (body === "failure") return "failure";
			mimeType = mimeType.slice(0, -6);
			mimeType = mimeType.replace(/(\u0020)+$/, "");
			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
		};
	}
	/**
	* @param {URL} url
	* @param {boolean} excludeFragment
	*/
	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;
	}
	/**
	* @param {(char: string) => boolean} condition
	* @param {string} input
	* @param {{ position: number }} position
	*/
	function collectASequenceOfCodePoints(condition, input, position) {
		let result = "";
		while (position.position < input.length && condition(input[position.position])) {
			result += input[position.position];
			position.position++;
		}
		return result;
	}
	/**
	* A faster collectASequenceOfCodePoints that only works when comparing a single character.
	* @param {string} char
	* @param {string} input
	* @param {{ position: number }} position
	*/
	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);
	}
	/** @param {string} input */
	function stringPercentDecode(input) {
		return percentDecode(encoder.encode(input));
	}
	/**
	* @param {number} byte
	*/
	function isHexCharByte(byte) {
		return byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102;
	}
	/**
	* @param {number} byte
	*/
	function hexByteToNumber(byte) {
		return byte >= 48 && byte <= 57 ? byte - 48 : (byte & 223) - 55;
	}
	/** @param {Uint8Array} input */
	function percentDecode(input) {
		const length = input.length;
		/** @type {Uint8Array} */
		const output = new Uint8Array(length);
		let j = 0;
		for (let i = 0; i < length; ++i) {
			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;
			}
		}
		return length === j ? output : output.subarray(0, j);
	}
	/** @param {string} input */
	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 = type.toLowerCase();
		const subtypeLowercase = subtype.toLowerCase();
		const mimeType = {
			type: typeLowercase,
			subtype: subtypeLowercase,
			parameters: /* @__PURE__ */ new Map(),
			essence: `${typeLowercase}/${subtypeLowercase}`
		};
		while (position.position < input.length) {
			position.position++;
			collectASequenceOfCodePoints((char) => HTTP_WHITESPACE_REGEX.test(char), input, position);
			let parameterName = collectASequenceOfCodePoints((char) => char !== ";" && char !== "=", input, position);
			parameterName = parameterName.toLowerCase();
			if (position.position < input.length) {
				if (input[position.position] === ";") continue;
				position.position++;
			}
			if (position.position > input.length) break;
			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;
			}
			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;
	}
	/** @param {string} data */
	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;
			}
		}
		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);
	}
	/**
	* @param {string} input
	* @param {{ position: number }} position
	* @param {boolean?} extractValue
	*/
	function collectAnHTTPQuotedString(input, position, extractValue) {
		const positionStart = position.position;
		let value = "";
		assert$23(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 {
				assert$23(quoteOrBackslash === "\"");
				break;
			}
		}
		if (extractValue) return value;
		return input.slice(positionStart, position.position);
	}
	/**
	* @see https://mimesniff.spec.whatwg.org/#serialize-a-mime-type
	*/
	function serializeAMimeType(mimeType) {
		assert$23(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(/(\\|")/g, "\\$1");
				value = "\"" + value;
				value += "\"";
			}
			serialization += value;
		}
		return serialization;
	}
	/**
	* @see https://fetch.spec.whatwg.org/#http-whitespace
	* @param {number} char
	*/
	function isHTTPWhiteSpace(char) {
		return char === 13 || char === 10 || char === 9 || char === 32;
	}
	/**
	* @see https://fetch.spec.whatwg.org/#http-whitespace
	* @param {string} str
	* @param {boolean} [leading=true]
	* @param {boolean} [trailing=true]
	*/
	function removeHTTPWhitespace(str, leading = true, trailing = true) {
		return removeChars(str, leading, trailing, isHTTPWhiteSpace);
	}
	/**
	* @see https://infra.spec.whatwg.org/#ascii-whitespace
	* @param {number} char
	*/
	function isASCIIWhitespace(char) {
		return char === 13 || char === 10 || char === 9 || char === 12 || char === 32;
	}
	/**
	* @see https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace
	* @param {string} str
	* @param {boolean} [leading=true]
	* @param {boolean} [trailing=true]
	*/
	function removeASCIIWhitespace(str, leading = true, trailing = true) {
		return removeChars(str, leading, trailing, isASCIIWhitespace);
	}
	/**
	* @param {string} str
	* @param {boolean} leading
	* @param {boolean} trailing
	* @param {(charCode: number) => boolean} predicate
	* @returns
	*/
	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 > 0 && predicate(str.charCodeAt(trail))) trail--;
		return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1);
	}
	/**
	* @see https://infra.spec.whatwg.org/#isomorphic-decode
	* @param {Uint8Array} input
	* @returns {string}
	*/
	function isomorphicDecode(input) {
		const length = input.length;
		if (65535 > length) return String.fromCharCode.apply(null, input);
		let result = "";
		let i = 0;
		let addition = 65535;
		while (i < length) {
			if (i + addition > length) addition = length - i;
			result += String.fromCharCode.apply(null, input.subarray(i, i += addition));
		}
		return result;
	}
	/**
	* @see https://mimesniff.spec.whatwg.org/#minimize-a-supported-mime-type
	* @param {Exclude<ReturnType<typeof parseMIMEType>, 'failure'>} mimeType
	*/
	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 "";
	}
	module.exports = {
		dataURLProcessor,
		URLSerializer,
		collectASequenceOfCodePoints,
		collectASequenceOfCodePointsFast,
		stringPercentDecode,
		parseMIMEType,
		collectAnHTTPQuotedString,
		serializeAMimeType,
		removeChars,
		removeHTTPWhitespace,
		minimizeSupportedMimeType,
		HTTP_TOKEN_CODEPOINTS,
		isomorphicDecode
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/webidl.js
var require_webidl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { types: types$3, inspect } = __require("node:util");
	var { markAsUncloneable } = __require("node:worker_threads");
	var { toUSVString } = require_util$8();
	/** @type {import('../../../types/webidl').Webidl} */
	var webidl = {};
	webidl.converters = {};
	webidl.util = {};
	webidl.errors = {};
	webidl.errors.exception = function(message) {
		return /* @__PURE__ */ new TypeError(`${message.header}: ${message.message}`);
	};
	webidl.errors.conversionFailed = function(context) {
		const plural = context.types.length === 1 ? "" : " one of";
		const message = `${context.argument} could not be converted to${plural}: ${context.types.join(", ")}.`;
		return webidl.errors.exception({
			header: context.prefix,
			message
		});
	};
	webidl.errors.invalidArgument = function(context) {
		return webidl.errors.exception({
			header: context.prefix,
			message: `"${context.value}" is an invalid ${context.type}.`
		});
	};
	webidl.brandCheck = function(V, I, opts) {
		if (opts?.strict !== false) {
			if (!(V instanceof I)) {
				const err = /* @__PURE__ */ new TypeError("Illegal invocation");
				err.code = "ERR_INVALID_THIS";
				throw err;
			}
		} else if (V?.[Symbol.toStringTag] !== I.prototype[Symbol.toStringTag]) {
			const err = /* @__PURE__ */ new TypeError("Illegal invocation");
			err.code = "ERR_INVALID_THIS";
			throw err;
		}
	};
	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.illegalConstructor = function() {
		throw webidl.errors.exception({
			header: "TypeError",
			message: "Illegal constructor"
		});
	};
	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.util.markAsUncloneable = markAsUncloneable || (() => {});
	webidl.util.ConvertToInt = function(V, bitLength, signedness, opts) {
		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;
		}
		let x = Number(V);
		if (x === 0) x = 0;
		if (opts?.enforceRange === true) {
			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) && opts?.clamp === true) {
			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;
	};
	webidl.util.IntegerPart = function(n) {
		const r = Math.floor(Math.abs(n));
		if (n < 0) return -1 * r;
		return r;
	};
	webidl.util.Stringify = function(V) {
		switch (webidl.util.Type(V)) {
			case "Symbol": return `Symbol(${V.description})`;
			case "Object": return inspect(V);
			case "String": return `"${V}"`;
			default: return `${V}`;
		}
	};
	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.`
			});
			/** @type {Generator} */
			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.recordConverter = function(keyConverter, valueConverter) {
		return (O, prefix, argument) => {
			if (webidl.util.Type(O) !== "Object") throw webidl.errors.exception({
				header: prefix,
				message: `${argument} ("${webidl.util.Type(O)}") is not an Object.`
			});
			const result = {};
			if (!types$3.isProxy(O)) {
				const keys = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)];
				for (const key of keys) {
					const typedKey = keyConverter(key, prefix, argument);
					result[typedKey] = valueConverter(O[key], prefix, argument);
				}
				return result;
			}
			const keys = Reflect.ownKeys(O);
			for (const key of keys) if (Reflect.getOwnPropertyDescriptor(O, key)?.enumerable) {
				const typedKey = keyConverter(key, prefix, argument);
				result[typedKey] = valueConverter(O[key], prefix, argument);
			}
			return result;
		};
	};
	webidl.interfaceConverter = function(i) {
		return (V, prefix, argument, opts) => {
			if (opts?.strict !== false && !(V instanceof i)) throw webidl.errors.exception({
				header: prefix,
				message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${i.name}.`
			});
			return V;
		};
	};
	webidl.dictionaryConverter = function(converters) {
		return (dictionary, prefix, argument) => {
			const type = webidl.util.Type(dictionary);
			const dict = {};
			if (type === "Null" || type === "Undefined") return dict;
			else if (type !== "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 (!Object.hasOwn(dictionary, key)) throw webidl.errors.exception({
						header: prefix,
						message: `Missing required key "${key}".`
					});
				}
				let value = dictionary[key];
				const hasDefault = Object.hasOwn(options, "defaultValue");
				if (hasDefault && value !== null) 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;
		};
	};
	webidl.nullableConverter = function(converter) {
		return (V, prefix, argument) => {
			if (V === null) return V;
			return converter(V, prefix, argument);
		};
	};
	webidl.converters.DOMString = function(V, prefix, argument, opts) {
		if (V === null && opts?.legacyNullToEmptyString) return "";
		if (typeof V === "symbol") throw webidl.errors.exception({
			header: prefix,
			message: `${argument} is a symbol, which cannot be converted to a DOMString.`
		});
		return String(V);
	};
	webidl.converters.ByteString = function(V, prefix, argument) {
		const x = webidl.converters.DOMString(V, prefix, argument);
		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.converters.USVString = toUSVString;
	webidl.converters.boolean = function(V) {
		return Boolean(V);
	};
	webidl.converters.any = function(V) {
		return V;
	};
	webidl.converters["long long"] = function(V, prefix, argument) {
		return webidl.util.ConvertToInt(V, 64, "signed", void 0, prefix, argument);
	};
	webidl.converters["unsigned long long"] = function(V, prefix, argument) {
		return webidl.util.ConvertToInt(V, 64, "unsigned", void 0, prefix, argument);
	};
	webidl.converters["unsigned long"] = function(V, prefix, argument) {
		return webidl.util.ConvertToInt(V, 32, "unsigned", void 0, prefix, argument);
	};
	webidl.converters["unsigned short"] = function(V, prefix, argument, opts) {
		return webidl.util.ConvertToInt(V, 16, "unsigned", opts, prefix, argument);
	};
	webidl.converters.ArrayBuffer = function(V, prefix, argument, opts) {
		if (webidl.util.Type(V) !== "Object" || !types$3.isAnyArrayBuffer(V)) throw webidl.errors.conversionFailed({
			prefix,
			argument: `${argument} ("${webidl.util.Stringify(V)}")`,
			types: ["ArrayBuffer"]
		});
		if (opts?.allowShared === false && types$3.isSharedArrayBuffer(V)) throw webidl.errors.exception({
			header: "ArrayBuffer",
			message: "SharedArrayBuffer is not allowed."
		});
		if (V.resizable || V.growable) throw webidl.errors.exception({
			header: "ArrayBuffer",
			message: "Received a resizable ArrayBuffer."
		});
		return V;
	};
	webidl.converters.TypedArray = function(V, T, prefix, name, opts) {
		if (webidl.util.Type(V) !== "Object" || !types$3.isTypedArray(V) || V.constructor.name !== T.name) throw webidl.errors.conversionFailed({
			prefix,
			argument: `${name} ("${webidl.util.Stringify(V)}")`,
			types: [T.name]
		});
		if (opts?.allowShared === false && types$3.isSharedArrayBuffer(V.buffer)) throw webidl.errors.exception({
			header: "ArrayBuffer",
			message: "SharedArrayBuffer is not allowed."
		});
		if (V.buffer.resizable || V.buffer.growable) throw webidl.errors.exception({
			header: "ArrayBuffer",
			message: "Received a resizable ArrayBuffer."
		});
		return V;
	};
	webidl.converters.DataView = function(V, prefix, name, opts) {
		if (webidl.util.Type(V) !== "Object" || !types$3.isDataView(V)) throw webidl.errors.exception({
			header: prefix,
			message: `${name} is not a DataView.`
		});
		if (opts?.allowShared === false && types$3.isSharedArrayBuffer(V.buffer)) throw webidl.errors.exception({
			header: "ArrayBuffer",
			message: "SharedArrayBuffer is not allowed."
		});
		if (V.buffer.resizable || V.buffer.growable) throw webidl.errors.exception({
			header: "ArrayBuffer",
			message: "Received a resizable ArrayBuffer."
		});
		return V;
	};
	webidl.converters.BufferSource = function(V, prefix, name, opts) {
		if (types$3.isAnyArrayBuffer(V)) return webidl.converters.ArrayBuffer(V, prefix, name, {
			...opts,
			allowShared: false
		});
		if (types$3.isTypedArray(V)) return webidl.converters.TypedArray(V, V.constructor, prefix, name, {
			...opts,
			allowShared: false
		});
		if (types$3.isDataView(V)) return webidl.converters.DataView(V, prefix, name, {
			...opts,
			allowShared: false
		});
		throw webidl.errors.conversionFailed({
			prefix,
			argument: `${name} ("${webidl.util.Stringify(V)}")`,
			types: ["BufferSource"]
		});
	};
	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);
	module.exports = { webidl };
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/util.js
var require_util$7 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Transform: Transform$2 } = __require("node:stream");
	var zlib$1 = __require("node:zlib");
	var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants$2();
	var { getGlobalOrigin } = require_global$1();
	var { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = require_data_url();
	var { performance: performance$1 } = __require("node:perf_hooks");
	var { isBlobLike, ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = require_util$8();
	var assert$22 = __require("node:assert");
	var { isUint8Array } = __require("node:util/types");
	var { webidl } = require_webidl();
	var supportedHashes = [];
	/** @type {import('crypto')} */
	var crypto;
	try {
		crypto = __require("node:crypto");
		const possibleRelevantHashes = [
			"sha256",
			"sha384",
			"sha512"
		];
		supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
	} catch {}
	function responseURL(response) {
		const urlList = response.urlList;
		const length = urlList.length;
		return length === 0 ? null : urlList[length - 1].toString();
	}
	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);
			location = new URL(location, responseURL(response));
		}
		if (location && !location.hash) location.hash = requestFragment;
		return location;
	}
	/**
	* @see https://www.rfc-editor.org/rfc/rfc1738#section-2.2
	* @param {string} url
	* @returns {boolean}
	*/
	function isValidEncodedURL(url) {
		for (let i = 0; i < url.length; ++i) {
			const code = url.charCodeAt(i);
			if (code > 126 || code < 32) return false;
		}
		return true;
	}
	/**
	* If string contains non-ASCII characters, assumes it's UTF-8 encoded and decodes it.
	* Since UTF-8 is a superset of ASCII, this will work for ASCII strings as well.
	* @param {string} value
	* @returns {string}
	*/
	function normalizeBinaryStringToUtf8(value) {
		return Buffer.from(value, "binary").toString("utf8");
	}
	/** @returns {URL} */
	function requestCurrentURL(request) {
		return request.urlList[request.urlList.length - 1];
	}
	function requestBadPort(request) {
		const url = requestCurrentURL(request);
		if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) return "blocked";
		return "allowed";
	}
	function isErrorLike(object) {
		return object instanceof Error || object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException";
	}
	function isValidReasonPhrase(statusText) {
		for (let i = 0; i < statusText.length; ++i) {
			const c = statusText.charCodeAt(i);
			if (!(c === 9 || c >= 32 && c <= 126 || c >= 128 && c <= 255)) return false;
		}
		return true;
	}
	/**
	* @see https://fetch.spec.whatwg.org/#header-name
	* @param {string} potentialValue
	*/
	var isValidHeaderName = isValidHTTPToken;
	/**
	* @see https://fetch.spec.whatwg.org/#header-value
	* @param {string} potentialValue
	*/
	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;
	}
	function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
		const { headersList } = actualResponse;
		const policyHeader = (headersList.get("referrer-policy", true) ?? "").split(",");
		let policy = "";
		if (policyHeader.length > 0) for (let i = policyHeader.length; i !== 0; i--) {
			const token = policyHeader[i - 1].trim();
			if (referrerPolicyTokens.has(token)) {
				policy = token;
				break;
			}
		}
		if (policy !== "") request.referrerPolicy = policy;
	}
	function crossOriginResourcePolicyCheck() {
		return "allowed";
	}
	function corsCheck() {
		return "success";
	}
	function TAOCheck() {
		return "success";
	}
	function appendFetchMetadata(httpRequest) {
		let header = null;
		header = httpRequest.mode;
		httpRequest.headersList.set("sec-fetch-mode", header, true);
	}
	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);
		}
	}
	function coarsenTime(timestamp, crossOriginIsolatedCapability) {
		return timestamp;
	}
	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
		};
	}
	function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
		return coarsenTime(performance$1.now(), crossOriginIsolatedCapability);
	}
	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
		};
	}
	function makePolicyContainer() {
		return { referrerPolicy: "strict-origin-when-cross-origin" };
	}
	function clonePolicyContainer(policyContainer) {
		return { referrerPolicy: policyContainer.referrerPolicy };
	}
	function determineRequestsReferrer(request) {
		const policy = request.referrerPolicy;
		assert$22(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 (request.referrer instanceof URL) referrerSource = request.referrer;
		let referrerURL = stripURLForReferrer(referrerSource);
		const referrerOrigin = stripURLForReferrer(referrerSource, true);
		if (referrerURL.toString().length > 4096) referrerURL = referrerOrigin;
		const areSameOrigin = sameOrigin(request, referrerURL);
		const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url);
		switch (policy) {
			case "origin": return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true);
			case "unsafe-url": return referrerURL;
			case "same-origin": return areSameOrigin ? referrerOrigin : "no-referrer";
			case "origin-when-cross-origin": return areSameOrigin ? referrerURL : 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;
			}
			default: return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin;
		}
	}
	/**
	* @see https://w3c.github.io/webappsec-referrer-policy/#strip-url
	* @param {URL} url
	* @param {boolean|undefined} originOnly
	*/
	function stripURLForReferrer(url, originOnly) {
		assert$22(url instanceof URL);
		url = new URL(url);
		if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") return "no-referrer";
		url.username = "";
		url.password = "";
		url.hash = "";
		if (originOnly) {
			url.pathname = "";
			url.search = "";
		}
		return url;
	}
	function isURLPotentiallyTrustworthy(url) {
		if (!(url instanceof URL)) return false;
		if (url.href === "about:blank" || url.href === "about:srcdoc") return true;
		if (url.protocol === "data:") return true;
		if (url.protocol === "file:") return true;
		return isOriginPotentiallyTrustworthy(url.origin);
		function isOriginPotentiallyTrustworthy(origin) {
			if (origin == null || origin === "null") return false;
			const originAsURL = new URL(origin);
			if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") return true;
			if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.") || originAsURL.hostname.endsWith(".localhost")) return true;
			return false;
		}
	}
	/**
	* @see https://w3c.github.io/webappsec-subresource-integrity/#does-response-match-metadatalist
	* @param {Uint8Array} bytes
	* @param {string} metadataList
	*/
	function bytesMatch(bytes, metadataList) {
		/* istanbul ignore if: only if node is built with --without-ssl */
		if (crypto === void 0) return true;
		const parsedMetadata = parseMetadata(metadataList);
		if (parsedMetadata === "no metadata") return true;
		if (parsedMetadata.length === 0) return true;
		const metadata = filterMetadataListByAlgorithm(parsedMetadata, getStrongestMetadata(parsedMetadata));
		for (const item of metadata) {
			const algorithm = item.algo;
			const expectedValue = item.hash;
			let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64");
			if (actualValue[actualValue.length - 1] === "=") if (actualValue[actualValue.length - 2] === "=") actualValue = actualValue.slice(0, -2);
			else actualValue = actualValue.slice(0, -1);
			if (compareBase64Mixed(actualValue, expectedValue)) return true;
		}
		return false;
	}
	var parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i;
	/**
	* @see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata
	* @param {string} metadata
	*/
	function parseMetadata(metadata) {
		/** @type {{ algo: string, hash: string }[]} */
		const result = [];
		let empty = true;
		for (const token of metadata.split(" ")) {
			empty = false;
			const parsedToken = parseHashWithOptions.exec(token);
			if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) continue;
			const algorithm = parsedToken.groups.algo.toLowerCase();
			if (supportedHashes.includes(algorithm)) result.push(parsedToken.groups);
		}
		if (empty === true) return "no metadata";
		return result;
	}
	/**
	* @param {{ algo: 'sha256' | 'sha384' | 'sha512' }[]} metadataList
	*/
	function getStrongestMetadata(metadataList) {
		let algorithm = metadataList[0].algo;
		if (algorithm[3] === "5") return algorithm;
		for (let i = 1; i < metadataList.length; ++i) {
			const metadata = metadataList[i];
			if (metadata.algo[3] === "5") {
				algorithm = "sha512";
				break;
			} else if (algorithm[3] === "3") continue;
			else if (metadata.algo[3] === "3") algorithm = "sha384";
		}
		return algorithm;
	}
	function filterMetadataListByAlgorithm(metadataList, algorithm) {
		if (metadataList.length === 1) return metadataList;
		let pos = 0;
		for (let i = 0; i < metadataList.length; ++i) if (metadataList[i].algo === algorithm) metadataList[pos++] = metadataList[i];
		metadataList.length = pos;
		return metadataList;
	}
	/**
	* Compares two base64 strings, allowing for base64url
	* in the second string.
	*
	* @param {string} actualValue always base64
	* @param {string} expectedValue base64 or base64url
	* @returns {boolean}
	*/
	function compareBase64Mixed(actualValue, expectedValue) {
		if (actualValue.length !== expectedValue.length) return false;
		for (let i = 0; i < actualValue.length; ++i) if (actualValue[i] !== expectedValue[i]) {
			if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") continue;
			return false;
		}
		return true;
	}
	function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {}
	/**
	* @link {https://html.spec.whatwg.org/multipage/origin.html#same-origin}
	* @param {URL} A
	* @param {URL} B
	*/
	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;
	}
	function createDeferredPromise() {
		let res;
		let rej;
		return {
			promise: new Promise((resolve, reject) => {
				res = resolve;
				rej = reject;
			}),
			resolve: res,
			reject: rej
		};
	}
	function isAborted(fetchParams) {
		return fetchParams.controller.state === "aborted";
	}
	function isCancelled(fetchParams) {
		return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
	}
	/**
	* @see https://fetch.spec.whatwg.org/#concept-method-normalize
	* @param {string} method
	*/
	function normalizeMethod(method) {
		return normalizedMethodRecordsBase[method.toLowerCase()] ?? method;
	}
	function serializeJavascriptValueToJSONString(value) {
		const result = JSON.stringify(value);
		if (result === void 0) throw new TypeError("Value is not JSON serializable");
		assert$22(typeof result === "string");
		return result;
	}
	var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
	/**
	* @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
	* @param {string} name name of the instance
	* @param {symbol} kInternalIterator
	* @param {string | number} [keyIndex]
	* @param {string | number} [valueIndex]
	*/
	function createIterator(name, kInternalIterator, keyIndex = 0, valueIndex = 1) {
		class FastIterableIterator {
			/** @type {any} */
			#target;
			/** @type {'key' | 'value' | 'key+value'} */
			#kind;
			/** @type {number} */
			#index;
			/**
			* @see https://webidl.spec.whatwg.org/#dfn-default-iterator-object
			* @param {unknown} target
			* @param {'key' | 'value' | 'key+value'} kind
			*/
			constructor(target, kind) {
				this.#target = target;
				this.#kind = kind;
				this.#index = 0;
			}
			next() {
				if (typeof this !== "object" || this === null || !(#target in this)) throw new TypeError(`'next' called on an object that does not implement interface ${name} Iterator.`);
				const index = this.#index;
				const values = this.#target[kInternalIterator];
				if (index >= values.length) return {
					value: void 0,
					done: true
				};
				const { [keyIndex]: key, [valueIndex]: value } = values[index];
				this.#index = index + 1;
				let result;
				switch (this.#kind) {
					case "key":
						result = key;
						break;
					case "value":
						result = value;
						break;
					case "key+value":
						result = [key, value];
						break;
				}
				return {
					value: result,
					done: false
				};
			}
		}
		delete FastIterableIterator.prototype.constructor;
		Object.setPrototypeOf(FastIterableIterator.prototype, esIteratorPrototype);
		Object.defineProperties(FastIterableIterator.prototype, {
			[Symbol.toStringTag]: {
				writable: false,
				enumerable: false,
				configurable: true,
				value: `${name} Iterator`
			},
			next: {
				writable: true,
				enumerable: true,
				configurable: true
			}
		});
		/**
		* @param {unknown} target
		* @param {'key' | 'value' | 'key+value'} kind
		* @returns {IterableIterator<any>}
		*/
		return function(target, kind) {
			return new FastIterableIterator(target, kind);
		};
	}
	/**
	* @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
	* @param {string} name name of the instance
	* @param {any} object class
	* @param {symbol} kInternalIterator
	* @param {string | number} [keyIndex]
	* @param {string | number} [valueIndex]
	*/
	function iteratorMixin(name, object, kInternalIterator, keyIndex = 0, valueIndex = 1) {
		const makeIterator = createIterator(name, kInternalIterator, keyIndex, valueIndex);
		const properties = {
			keys: {
				writable: true,
				enumerable: true,
				configurable: true,
				value: function keys() {
					webidl.brandCheck(this, object);
					return makeIterator(this, "key");
				}
			},
			values: {
				writable: true,
				enumerable: true,
				configurable: true,
				value: function values() {
					webidl.brandCheck(this, object);
					return makeIterator(this, "value");
				}
			},
			entries: {
				writable: true,
				enumerable: true,
				configurable: true,
				value: function entries() {
					webidl.brandCheck(this, object);
					return makeIterator(this, "key+value");
				}
			},
			forEach: {
				writable: true,
				enumerable: true,
				configurable: true,
				value: function forEach(callbackfn, thisArg = globalThis) {
					webidl.brandCheck(this, object);
					webidl.argumentLengthCheck(arguments, 1, `${name}.forEach`);
					if (typeof callbackfn !== "function") throw new TypeError(`Failed to execute 'forEach' on '${name}': parameter 1 is not of type 'Function'.`);
					for (const { 0: key, 1: value } of makeIterator(this, "key+value")) callbackfn.call(thisArg, value, key, this);
				}
			}
		};
		return Object.defineProperties(object.prototype, {
			...properties,
			[Symbol.iterator]: {
				writable: true,
				enumerable: false,
				configurable: true,
				value: properties.entries.value
			}
		});
	}
	/**
	* @see https://fetch.spec.whatwg.org/#body-fully-read
	*/
	async function fullyReadBody(body, processBody, processBodyError) {
		const successSteps = processBody;
		const errorSteps = processBodyError;
		let reader;
		try {
			reader = body.stream.getReader();
		} catch (e) {
			errorSteps(e);
			return;
		}
		try {
			successSteps(await readAllBytes(reader));
		} catch (e) {
			errorSteps(e);
		}
	}
	function isReadableStreamLike(stream) {
		return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function";
	}
	/**
	* @param {ReadableStreamController<Uint8Array>} controller
	*/
	function readableStreamClose(controller) {
		try {
			controller.close();
			controller.byobRequest?.respond(0);
		} catch (err) {
			if (!err.message.includes("Controller is already closed") && !err.message.includes("ReadableStream is already closed")) throw err;
		}
	}
	var invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/;
	/**
	* @see https://infra.spec.whatwg.org/#isomorphic-encode
	* @param {string} input
	*/
	function isomorphicEncode(input) {
		assert$22(!invalidIsomorphicEncodeValueRegex.test(input));
		return input;
	}
	/**
	* @see https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-all-bytes
	* @see https://streams.spec.whatwg.org/#read-loop
	* @param {ReadableStreamDefaultReader} reader
	*/
	async function readAllBytes(reader) {
		const bytes = [];
		let byteLength = 0;
		while (true) {
			const { done, value: chunk } = await reader.read();
			if (done) return Buffer.concat(bytes, byteLength);
			if (!isUint8Array(chunk)) throw new TypeError("Received non-Uint8Array chunk");
			bytes.push(chunk);
			byteLength += chunk.length;
		}
	}
	/**
	* @see https://fetch.spec.whatwg.org/#is-local
	* @param {URL} url
	*/
	function urlIsLocal(url) {
		assert$22("protocol" in url);
		const protocol = url.protocol;
		return protocol === "about:" || protocol === "blob:" || protocol === "data:";
	}
	/**
	* @param {string|URL} url
	* @returns {boolean}
	*/
	function urlHasHttpsScheme(url) {
		return typeof url === "string" && url[5] === ":" && url[0] === "h" && url[1] === "t" && url[2] === "t" && url[3] === "p" && url[4] === "s" || url.protocol === "https:";
	}
	/**
	* @see https://fetch.spec.whatwg.org/#http-scheme
	* @param {URL} url
	*/
	function urlIsHttpHttpsScheme(url) {
		assert$22("protocol" in url);
		const protocol = url.protocol;
		return protocol === "http:" || protocol === "https:";
	}
	/**
	* @see https://fetch.spec.whatwg.org/#simple-range-header-value
	* @param {string} value
	* @param {boolean} allowWhitespace
	*/
	function simpleRangeHeaderValue(value, allowWhitespace) {
		const data = value;
		if (!data.startsWith("bytes")) return "failure";
		const position = { position: 5 };
		if (allowWhitespace) collectASequenceOfCodePoints((char) => char === "	" || char === " ", data, position);
		if (data.charCodeAt(position.position) !== 61) return "failure";
		position.position++;
		if (allowWhitespace) collectASequenceOfCodePoints((char) => char === "	" || char === " ", data, position);
		const rangeStart = collectASequenceOfCodePoints((char) => {
			const code = char.charCodeAt(0);
			return code >= 48 && code <= 57;
		}, data, position);
		const rangeStartValue = rangeStart.length ? Number(rangeStart) : null;
		if (allowWhitespace) collectASequenceOfCodePoints((char) => char === "	" || char === " ", data, position);
		if (data.charCodeAt(position.position) !== 45) return "failure";
		position.position++;
		if (allowWhitespace) collectASequenceOfCodePoints((char) => char === "	" || char === " ", data, position);
		const rangeEnd = collectASequenceOfCodePoints((char) => {
			const code = char.charCodeAt(0);
			return code >= 48 && code <= 57;
		}, data, position);
		const rangeEndValue = rangeEnd.length ? Number(rangeEnd) : null;
		if (position.position < data.length) return "failure";
		if (rangeEndValue === null && rangeStartValue === null) return "failure";
		if (rangeStartValue > rangeEndValue) return "failure";
		return {
			rangeStartValue,
			rangeEndValue
		};
	}
	/**
	* @see https://fetch.spec.whatwg.org/#build-a-content-range
	* @param {number} rangeStart
	* @param {number} rangeEnd
	* @param {number} fullLength
	*/
	function buildContentRange(rangeStart, rangeEnd, fullLength) {
		let contentRange = "bytes ";
		contentRange += isomorphicEncode(`${rangeStart}`);
		contentRange += "-";
		contentRange += isomorphicEncode(`${rangeEnd}`);
		contentRange += "/";
		contentRange += isomorphicEncode(`${fullLength}`);
		return contentRange;
	}
	var InflateStream = class extends Transform$2 {
		#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$1.createInflate(this.#zlibOptions) : zlib$1.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();
		}
	};
	/**
	* @param {zlib.ZlibOptions} [zlibOptions]
	* @returns {InflateStream}
	*/
	function createInflate(zlibOptions) {
		return new InflateStream(zlibOptions);
	}
	/**
	* @see https://fetch.spec.whatwg.org/#concept-header-extract-mime-type
	* @param {import('./headers').HeadersList} headers
	*/
	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;
	}
	/**
	* @see https://fetch.spec.whatwg.org/#header-value-get-decode-and-split
	* @param {string|null} value
	*/
	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$22(input.charCodeAt(position.position) === 44);
				position.position++;
			}
			temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 9 || char === 32);
			values.push(temporaryValue);
			temporaryValue = "";
		}
		return values;
	}
	/**
	* @see https://fetch.spec.whatwg.org/#concept-header-list-get-decode-split
	* @param {string} name lowercase header name
	* @param {import('./headers').HeadersList} list
	*/
	function getDecodeSplit(name, list) {
		const value = list.get(name, true);
		if (value === null) return null;
		return gettingDecodingSplitting(value);
	}
	var textDecoder = new TextDecoder();
	/**
	* @see https://encoding.spec.whatwg.org/#utf-8-decode
	* @param {Buffer} buffer
	*/
	function utf8DecodeBytes(buffer) {
		if (buffer.length === 0) return "";
		if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) buffer = buffer.subarray(3);
		return textDecoder.decode(buffer);
	}
	var EnvironmentSettingsObjectBase = class {
		get baseUrl() {
			return getGlobalOrigin();
		}
		get origin() {
			return this.baseUrl?.origin;
		}
		policyContainer = makePolicyContainer();
	};
	var EnvironmentSettingsObject = class {
		settingsObject = new EnvironmentSettingsObjectBase();
	};
	module.exports = {
		isAborted,
		isCancelled,
		isValidEncodedURL,
		createDeferredPromise,
		ReadableStreamFrom,
		tryUpgradeRequestToAPotentiallyTrustworthyURL,
		clampAndCoarsenConnectionTimingInfo,
		coarsenedSharedCurrentTime,
		determineRequestsReferrer,
		makePolicyContainer,
		clonePolicyContainer,
		appendFetchMetadata,
		appendRequestOriginHeader,
		TAOCheck,
		corsCheck,
		crossOriginResourcePolicyCheck,
		createOpaqueTimingInfo,
		setRequestReferrerPolicyOnRedirect,
		isValidHTTPToken,
		requestBadPort,
		requestCurrentURL,
		responseURL,
		responseLocationURL,
		isBlobLike,
		isURLPotentiallyTrustworthy,
		isValidReasonPhrase,
		sameOrigin,
		normalizeMethod,
		serializeJavascriptValueToJSONString,
		iteratorMixin,
		createIterator,
		isValidHeaderName,
		isValidHeaderValue,
		isErrorLike,
		fullyReadBody,
		bytesMatch,
		isReadableStreamLike,
		readableStreamClose,
		isomorphicEncode,
		urlIsLocal,
		urlHasHttpsScheme,
		urlIsHttpHttpsScheme,
		readAllBytes,
		simpleRangeHeaderValue,
		buildContentRange,
		parseMetadata,
		createInflate,
		extractMimeType,
		getDecodeSplit,
		utf8DecodeBytes,
		environmentSettingsObject: new EnvironmentSettingsObject()
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/symbols.js
var require_symbols$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = {
		kUrl: Symbol("url"),
		kHeaders: Symbol("headers"),
		kSignal: Symbol("signal"),
		kState: Symbol("state"),
		kDispatcher: Symbol("dispatcher")
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/file.js
var require_file$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Blob: Blob$2, File } = __require("node:buffer");
	var { kState } = require_symbols$3();
	var { webidl } = require_webidl();
	var FileLike = class FileLike {
		constructor(blobLike, fileName, options = {}) {
			this[kState] = {
				blobLike,
				name: fileName,
				type: options.type,
				lastModified: options.lastModified ?? Date.now()
			};
		}
		stream(...args) {
			webidl.brandCheck(this, FileLike);
			return this[kState].blobLike.stream(...args);
		}
		arrayBuffer(...args) {
			webidl.brandCheck(this, FileLike);
			return this[kState].blobLike.arrayBuffer(...args);
		}
		slice(...args) {
			webidl.brandCheck(this, FileLike);
			return this[kState].blobLike.slice(...args);
		}
		text(...args) {
			webidl.brandCheck(this, FileLike);
			return this[kState].blobLike.text(...args);
		}
		get size() {
			webidl.brandCheck(this, FileLike);
			return this[kState].blobLike.size;
		}
		get type() {
			webidl.brandCheck(this, FileLike);
			return this[kState].blobLike.type;
		}
		get name() {
			webidl.brandCheck(this, FileLike);
			return this[kState].name;
		}
		get lastModified() {
			webidl.brandCheck(this, FileLike);
			return this[kState].lastModified;
		}
		get [Symbol.toStringTag]() {
			return "File";
		}
	};
	webidl.converters.Blob = webidl.interfaceConverter(Blob$2);
	function isFileLike(object) {
		return object instanceof File || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File";
	}
	module.exports = {
		FileLike,
		isFileLike
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/formdata.js
var require_formdata = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { isBlobLike, iteratorMixin } = require_util$7();
	var { kState } = require_symbols$3();
	var { kEnumerableProperty } = require_util$8();
	var { FileLike, isFileLike } = require_file$1();
	var { webidl } = require_webidl();
	var { File: NativeFile } = __require("node:buffer");
	var nodeUtil$2 = __require("node:util");
	/** @type {globalThis['File']} */
	var File = globalThis.File ?? NativeFile;
	var FormData = class FormData {
		constructor(form) {
			webidl.util.markAsUncloneable(this);
			if (form !== void 0) throw webidl.errors.conversionFailed({
				prefix: "FormData constructor",
				argument: "Argument 1",
				types: ["undefined"]
			});
			this[kState] = [];
		}
		append(name, value, filename = void 0) {
			webidl.brandCheck(this, FormData);
			const prefix = "FormData.append";
			webidl.argumentLengthCheck(arguments, 2, prefix);
			if (arguments.length === 3 && !isBlobLike(value)) throw new TypeError("Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'");
			name = webidl.converters.USVString(name, prefix, "name");
			value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "value", { strict: false }) : webidl.converters.USVString(value, prefix, "value");
			filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "filename") : void 0;
			const entry = makeEntry(name, value, filename);
			this[kState].push(entry);
		}
		delete(name) {
			webidl.brandCheck(this, FormData);
			const prefix = "FormData.delete";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			name = webidl.converters.USVString(name, prefix, "name");
			this[kState] = this[kState].filter((entry) => entry.name !== name);
		}
		get(name) {
			webidl.brandCheck(this, FormData);
			const prefix = "FormData.get";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			name = webidl.converters.USVString(name, prefix, "name");
			const idx = this[kState].findIndex((entry) => entry.name === name);
			if (idx === -1) return null;
			return this[kState][idx].value;
		}
		getAll(name) {
			webidl.brandCheck(this, FormData);
			const prefix = "FormData.getAll";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			name = webidl.converters.USVString(name, prefix, "name");
			return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value);
		}
		has(name) {
			webidl.brandCheck(this, FormData);
			const prefix = "FormData.has";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			name = webidl.converters.USVString(name, prefix, "name");
			return this[kState].findIndex((entry) => entry.name === name) !== -1;
		}
		set(name, value, filename = void 0) {
			webidl.brandCheck(this, FormData);
			const prefix = "FormData.set";
			webidl.argumentLengthCheck(arguments, 2, prefix);
			if (arguments.length === 3 && !isBlobLike(value)) throw new TypeError("Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'");
			name = webidl.converters.USVString(name, prefix, "name");
			value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "name", { strict: false }) : webidl.converters.USVString(value, prefix, "name");
			filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "name") : void 0;
			const entry = makeEntry(name, value, filename);
			const idx = this[kState].findIndex((entry) => entry.name === name);
			if (idx !== -1) this[kState] = [
				...this[kState].slice(0, idx),
				entry,
				...this[kState].slice(idx + 1).filter((entry) => entry.name !== name)
			];
			else this[kState].push(entry);
		}
		[nodeUtil$2.inspect.custom](depth, options) {
			const state = this[kState].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$2.formatWithOptions(options, state);
			return `FormData ${output.slice(output.indexOf("]") + 2)}`;
		}
	};
	iteratorMixin("FormData", FormData, kState, "name", "value");
	Object.defineProperties(FormData.prototype, {
		append: kEnumerableProperty,
		delete: kEnumerableProperty,
		get: kEnumerableProperty,
		getAll: kEnumerableProperty,
		has: kEnumerableProperty,
		set: kEnumerableProperty,
		[Symbol.toStringTag]: {
			value: "FormData",
			configurable: true
		}
	});
	/**
	* @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#create-an-entry
	* @param {string} name
	* @param {string|Blob} value
	* @param {?string} filename
	* @returns
	*/
	function makeEntry(name, value, filename) {
		if (typeof value === "string") {} else {
			if (!isFileLike(value)) value = value instanceof Blob ? new File([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type });
			if (filename !== void 0) {
				/** @type {FilePropertyBag} */
				const options = {
					type: value.type,
					lastModified: value.lastModified
				};
				value = value instanceof NativeFile ? new File([value], filename, options) : new FileLike(value, filename, options);
			}
		}
		return {
			name,
			value
		};
	}
	module.exports = {
		FormData,
		makeEntry
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/formdata-parser.js
var require_formdata_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { isUSVString, bufferToLowerCasedHeaderName } = require_util$8();
	var { utf8DecodeBytes } = require_util$7();
	var { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = require_data_url();
	var { isFileLike } = require_file$1();
	var { makeEntry } = require_formdata();
	var assert$21 = __require("node:assert");
	var { File: NodeFile } = __require("node:buffer");
	var File = globalThis.File ?? NodeFile;
	var formDataNameBuffer = Buffer.from("form-data; name=\"");
	var filenameBuffer = Buffer.from("; filename");
	var dd = Buffer.from("--");
	var ddcrlf = Buffer.from("--\r\n");
	/**
	* @param {string} chars
	*/
	function isAsciiString(chars) {
		for (let i = 0; i < chars.length; ++i) if ((chars.charCodeAt(i) & -128) !== 0) return false;
		return true;
	}
	/**
	* @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-boundary
	* @param {string} boundary
	*/
	function validateBoundary(boundary) {
		const length = boundary.length;
		if (length < 27 || length > 70) return false;
		for (let i = 0; i < length; ++i) {
			const cp = boundary.charCodeAt(i);
			if (!(cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 39 || cp === 45 || cp === 95)) return false;
		}
		return true;
	}
	/**
	* @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-parser
	* @param {Buffer} input
	* @param {ReturnType<import('./data-url')['parseMIMEType']>} mimeType
	*/
	function multipartFormDataParser(input, mimeType) {
		assert$21(mimeType !== "failure" && mimeType.essence === "multipart/form-data");
		const boundaryString = mimeType.parameters.get("boundary");
		if (boundaryString === void 0) return "failure";
		const boundary = Buffer.from(`--${boundaryString}`, "utf8");
		const entryList = [];
		const position = { position: 0 };
		while (input[position.position] === 13 && input[position.position + 1] === 10) position.position += 2;
		let trailing = input.length;
		while (input[trailing - 1] === 10 && input[trailing - 2] === 13) trailing -= 2;
		if (trailing !== input.length) input = input.subarray(0, trailing);
		while (true) {
			if (input.subarray(position.position, position.position + boundary.length).equals(boundary)) position.position += boundary.length;
			else return "failure";
			if (position.position === input.length - 2 && bufferStartsWith(input, dd, position) || position.position === input.length - 4 && bufferStartsWith(input, ddcrlf, position)) return entryList;
			if (input[position.position] !== 13 || input[position.position + 1] !== 10) return "failure";
			position.position += 2;
			const result = parseMultipartFormDataHeaders(input, position);
			if (result === "failure") return "failure";
			let { name, filename, contentType, encoding } = result;
			position.position += 2;
			let body;
			{
				const boundaryIndex = input.indexOf(boundary.subarray(2), position.position);
				if (boundaryIndex === -1) return "failure";
				body = input.subarray(position.position, boundaryIndex - 4);
				position.position += body.length;
				if (encoding === "base64") body = Buffer.from(body.toString(), "base64");
			}
			if (input[position.position] !== 13 || input[position.position + 1] !== 10) return "failure";
			else position.position += 2;
			let value;
			if (filename !== null) {
				contentType ??= "text/plain";
				if (!isAsciiString(contentType)) contentType = "";
				value = new File([body], filename, { type: contentType });
			} else value = utf8DecodeBytes(Buffer.from(body));
			assert$21(isUSVString(name));
			assert$21(typeof value === "string" && isUSVString(value) || isFileLike(value));
			entryList.push(makeEntry(name, value, filename));
		}
	}
	/**
	* @see https://andreubotella.github.io/multipart-form-data/#parse-multipart-form-data-headers
	* @param {Buffer} input
	* @param {{ position: number }} position
	*/
	function parseMultipartFormDataHeaders(input, position) {
		let name = null;
		let filename = null;
		let contentType = null;
		let encoding = null;
		while (true) {
			if (input[position.position] === 13 && input[position.position + 1] === 10) {
				if (name === null) return "failure";
				return {
					name,
					filename,
					contentType,
					encoding
				};
			}
			let headerName = collectASequenceOfBytes((char) => char !== 10 && char !== 13 && char !== 58, input, position);
			headerName = removeChars(headerName, true, true, (char) => char === 9 || char === 32);
			if (!HTTP_TOKEN_CODEPOINTS.test(headerName.toString())) return "failure";
			if (input[position.position] !== 58) return "failure";
			position.position++;
			collectASequenceOfBytes((char) => char === 32 || char === 9, input, position);
			switch (bufferToLowerCasedHeaderName(headerName)) {
				case "content-disposition":
					name = filename = null;
					if (!bufferStartsWith(input, formDataNameBuffer, position)) return "failure";
					position.position += 17;
					name = parseMultipartFormDataName(input, position);
					if (name === null) return "failure";
					if (bufferStartsWith(input, filenameBuffer, position)) {
						let check = position.position + filenameBuffer.length;
						if (input[check] === 42) {
							position.position += 1;
							check += 1;
						}
						if (input[check] !== 61 || input[check + 1] !== 34) return "failure";
						position.position += 12;
						filename = parseMultipartFormDataName(input, position);
						if (filename === null) return "failure";
					}
					break;
				case "content-type": {
					let headerValue = collectASequenceOfBytes((char) => char !== 10 && char !== 13, input, position);
					headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32);
					contentType = isomorphicDecode(headerValue);
					break;
				}
				case "content-transfer-encoding": {
					let headerValue = collectASequenceOfBytes((char) => char !== 10 && char !== 13, input, position);
					headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32);
					encoding = isomorphicDecode(headerValue);
					break;
				}
				default: collectASequenceOfBytes((char) => char !== 10 && char !== 13, input, position);
			}
			if (input[position.position] !== 13 && input[position.position + 1] !== 10) return "failure";
			else position.position += 2;
		}
	}
	/**
	* @see https://andreubotella.github.io/multipart-form-data/#parse-a-multipart-form-data-name
	* @param {Buffer} input
	* @param {{ position: number }} position
	*/
	function parseMultipartFormDataName(input, position) {
		assert$21(input[position.position - 1] === 34);
		/** @type {string | Buffer} */
		let name = collectASequenceOfBytes((char) => char !== 10 && char !== 13 && char !== 34, input, position);
		if (input[position.position] !== 34) return null;
		else position.position++;
		name = new TextDecoder().decode(name).replace(/%0A/gi, "\n").replace(/%0D/gi, "\r").replace(/%22/g, "\"");
		return name;
	}
	/**
	* @param {(char: number) => boolean} condition
	* @param {Buffer} input
	* @param {{ position: number }} position
	*/
	function collectASequenceOfBytes(condition, input, position) {
		let start = position.position;
		while (start < input.length && condition(input[start])) ++start;
		return input.subarray(position.position, position.position = start);
	}
	/**
	* @param {Buffer} buf
	* @param {boolean} leading
	* @param {boolean} trailing
	* @param {(charCode: number) => boolean} predicate
	* @returns {Buffer}
	*/
	function removeChars(buf, leading, trailing, predicate) {
		let lead = 0;
		let trail = buf.length - 1;
		if (leading) while (lead < buf.length && predicate(buf[lead])) lead++;
		if (trailing) while (trail > 0 && predicate(buf[trail])) trail--;
		return lead === 0 && trail === buf.length - 1 ? buf : buf.subarray(lead, trail + 1);
	}
	/**
	* Checks if {@param buffer} starts with {@param start}
	* @param {Buffer} buffer
	* @param {Buffer} start
	* @param {{ position: number }} position
	*/
	function bufferStartsWith(buffer, start, position) {
		if (buffer.length < start.length) return false;
		for (let i = 0; i < start.length; i++) if (start[i] !== buffer[position.position + i]) return false;
		return true;
	}
	module.exports = {
		multipartFormDataParser,
		validateBoundary
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/body.js
var require_body = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var util = require_util$8();
	var { ReadableStreamFrom, isBlobLike, isReadableStreamLike, readableStreamClose, createDeferredPromise, fullyReadBody, extractMimeType, utf8DecodeBytes } = require_util$7();
	var { FormData } = require_formdata();
	var { kState } = require_symbols$3();
	var { webidl } = require_webidl();
	var { Blob: Blob$1 } = __require("node:buffer");
	var assert$20 = __require("node:assert");
	var { isErrored, isDisturbed } = __require("node:stream");
	var { isArrayBuffer } = __require("node:util/types");
	var { serializeAMimeType } = require_data_url();
	var { multipartFormDataParser } = require_formdata_parser();
	var random;
	try {
		const crypto = __require("node:crypto");
		random = (max) => crypto.randomInt(0, max);
	} catch {
		random = (max) => Math.floor(Math.random(max));
	}
	var textEncoder = new TextEncoder();
	function noop() {}
	var hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf("v18") !== 0;
	var streamRegistry;
	if (hasFinalizationRegistry) streamRegistry = new FinalizationRegistry((weakRef) => {
		const stream = weakRef.deref();
		if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) stream.cancel("Response object has been garbage collected").catch(noop);
	});
	function extractBody(object, keepalive = false) {
		let stream = null;
		if (object instanceof ReadableStream) stream = object;
		else if (isBlobLike(object)) stream = object.stream();
		else stream = new ReadableStream({
			async pull(controller) {
				const buffer = typeof source === "string" ? textEncoder.encode(source) : source;
				if (buffer.byteLength) controller.enqueue(buffer);
				queueMicrotask(() => readableStreamClose(controller));
			},
			start() {},
			type: "bytes"
		});
		assert$20(isReadableStreamLike(stream));
		let action = null;
		let source = null;
		let length = null;
		let type = null;
		if (typeof object === "string") {
			source = object;
			type = "text/plain;charset=UTF-8";
		} else if (object instanceof URLSearchParams) {
			source = object.toString();
			type = "application/x-www-form-urlencoded;charset=UTF-8";
		} else if (isArrayBuffer(object)) source = new Uint8Array(object.slice());
		else if (ArrayBuffer.isView(object)) source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
		else if (util.isFormDataLike(object)) {
			const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
			const prefix = `--${boundary}\r\nContent-Disposition: form-data`;
			/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
			const escape = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
			const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n");
			const blobParts = [];
			const rn = new Uint8Array([13, 10]);
			length = 0;
			let hasUnknownSizeValue = false;
			for (const [name, value] of object) if (typeof value === "string") {
				const chunk = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
				blobParts.push(chunk);
				length += chunk.byteLength;
			} else {
				const chunk = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r
Content-Type: ${value.type || "application/octet-stream"}\r\n\r\n`);
				blobParts.push(chunk, value, rn);
				if (typeof value.size === "number") length += chunk.byteLength + value.size + rn.byteLength;
				else hasUnknownSizeValue = true;
			}
			const chunk = textEncoder.encode(`--${boundary}--\r\n`);
			blobParts.push(chunk);
			length += chunk.byteLength;
			if (hasUnknownSizeValue) length = null;
			source = object;
			action = async function* () {
				for (const part of blobParts) if (part.stream) yield* part.stream();
				else yield part;
			};
			type = `multipart/form-data; boundary=${boundary}`;
		} else if (isBlobLike(object)) {
			source = object;
			length = object.size;
			if (object.type) type = object.type;
		} else if (typeof object[Symbol.asyncIterator] === "function") {
			if (keepalive) throw new TypeError("keepalive");
			if (util.isDisturbed(object) || object.locked) throw new TypeError("Response body object should not be disturbed or locked");
			stream = object instanceof ReadableStream ? object : ReadableStreamFrom(object);
		}
		if (typeof source === "string" || util.isBuffer(source)) length = Buffer.byteLength(source);
		if (action != null) {
			let iterator;
			stream = new ReadableStream({
				async start() {
					iterator = action(object)[Symbol.asyncIterator]();
				},
				async pull(controller) {
					const { value, done } = await iterator.next();
					if (done) queueMicrotask(() => {
						controller.close();
						controller.byobRequest?.respond(0);
					});
					else if (!isErrored(stream)) {
						const buffer = new Uint8Array(value);
						if (buffer.byteLength) controller.enqueue(buffer);
					}
					return controller.desiredSize > 0;
				},
				async cancel(reason) {
					await iterator.return();
				},
				type: "bytes"
			});
		}
		return [{
			stream,
			source,
			length
		}, type];
	}
	function safelyExtractBody(object, keepalive = false) {
		if (object instanceof ReadableStream) {
			// istanbul ignore next
			assert$20(!util.isDisturbed(object), "The body has already been consumed.");
			// istanbul ignore next
			assert$20(!object.locked, "The stream is locked.");
		}
		return extractBody(object, keepalive);
	}
	function cloneBody(instance, body) {
		const [out1, out2] = body.stream.tee();
		body.stream = out1;
		return {
			stream: out2,
			length: body.length,
			source: body.source
		};
	}
	function throwIfAborted(state) {
		if (state.aborted) throw new DOMException("The operation was aborted.", "AbortError");
	}
	function bodyMixinMethods(instance) {
		return {
			blob() {
				return consumeBody(this, (bytes) => {
					let mimeType = bodyMimeType(this);
					if (mimeType === null) mimeType = "";
					else if (mimeType) mimeType = serializeAMimeType(mimeType);
					return new Blob$1([bytes], { type: mimeType });
				}, instance);
			},
			arrayBuffer() {
				return consumeBody(this, (bytes) => {
					return new Uint8Array(bytes).buffer;
				}, instance);
			},
			text() {
				return consumeBody(this, utf8DecodeBytes, instance);
			},
			json() {
				return consumeBody(this, parseJSONFromBytes, instance);
			},
			formData() {
				return consumeBody(this, (value) => {
					const mimeType = bodyMimeType(this);
					if (mimeType !== null) switch (mimeType.essence) {
						case "multipart/form-data": {
							const parsed = multipartFormDataParser(value, mimeType);
							if (parsed === "failure") throw new TypeError("Failed to parse body as FormData.");
							const fd = new FormData();
							fd[kState] = parsed;
							return fd;
						}
						case "application/x-www-form-urlencoded": {
							const entries = new URLSearchParams(value.toString());
							const fd = new FormData();
							for (const [name, value] of entries) fd.append(name, value);
							return fd;
						}
					}
					throw new TypeError("Content-Type was not one of \"multipart/form-data\" or \"application/x-www-form-urlencoded\".");
				}, instance);
			},
			bytes() {
				return consumeBody(this, (bytes) => {
					return new Uint8Array(bytes);
				}, instance);
			}
		};
	}
	function mixinBody(prototype) {
		Object.assign(prototype.prototype, bodyMixinMethods(prototype));
	}
	/**
	* @see https://fetch.spec.whatwg.org/#concept-body-consume-body
	* @param {Response|Request} object
	* @param {(value: unknown) => unknown} convertBytesToJSValue
	* @param {Response|Request} instance
	*/
	async function consumeBody(object, convertBytesToJSValue, instance) {
		webidl.brandCheck(object, instance);
		if (bodyUnusable(object)) throw new TypeError("Body is unusable: Body has already been read");
		throwIfAborted(object[kState]);
		const promise = createDeferredPromise();
		const errorSteps = (error) => promise.reject(error);
		const successSteps = (data) => {
			try {
				promise.resolve(convertBytesToJSValue(data));
			} catch (e) {
				errorSteps(e);
			}
		};
		if (object[kState].body == null) {
			successSteps(Buffer.allocUnsafe(0));
			return promise.promise;
		}
		await fullyReadBody(object[kState].body, successSteps, errorSteps);
		return promise.promise;
	}
	function bodyUnusable(object) {
		const body = object[kState].body;
		return body != null && (body.stream.locked || util.isDisturbed(body.stream));
	}
	/**
	* @see https://infra.spec.whatwg.org/#parse-json-bytes-to-a-javascript-value
	* @param {Uint8Array} bytes
	*/
	function parseJSONFromBytes(bytes) {
		return JSON.parse(utf8DecodeBytes(bytes));
	}
	/**
	* @see https://fetch.spec.whatwg.org/#concept-body-mime-type
	* @param {import('./response').Response|import('./request').Request} requestOrResponse
	*/
	function bodyMimeType(requestOrResponse) {
		/** @type {import('./headers').HeadersList} */
		const headers = requestOrResponse[kState].headersList;
		const mimeType = extractMimeType(headers);
		if (mimeType === "failure") return null;
		return mimeType;
	}
	module.exports = {
		extractBody,
		safelyExtractBody,
		cloneBody,
		mixinBody,
		streamRegistry,
		hasFinalizationRegistry,
		bodyUnusable
	};
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/client-h1.js
var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$19 = __require("node:assert");
	var util = require_util$8();
	var { channels } = require_diagnostics();
	var timers = require_timers();
	var { RequestContentLengthMismatchError, ResponseContentLengthMismatchError, RequestAbortedError, HeadersTimeoutError, HeadersOverflowError, SocketError, InformationalError, BodyTimeoutError, HTTPParserError, ResponseExceededMaxSizeError } = require_errors();
	var { kUrl, kReset, kClient, kParser, kBlocking, kRunning, kPending, kSize, kWriting, kQueue, kNoRef, kKeepAliveDefaultTimeout, kHostHeader, kPendingIdx, kRunningIdx, kError, kPipelining, kSocket, kKeepAliveTimeoutValue, kMaxHeadersSize, kKeepAliveMaxTimeout, kKeepAliveTimeoutThreshold, kHeadersTimeout, kBodyTimeout, kStrictContentLength, kMaxRequests, kCounter, kMaxResponseSize, kOnError, kResume, kHTTPContext } = require_symbols$4();
	var constants = require_constants$3();
	var EMPTY_BUF = Buffer.alloc(0);
	var FastBuffer = Buffer[Symbol.species];
	var addListener = util.addListener;
	var removeAllListeners = util.removeAllListeners;
	var extractBody;
	async function lazyllhttp() {
		const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
		let mod;
		try {
			mod = await WebAssembly.compile(require_llhttp_simd_wasm());
		} catch (e) {
			/* istanbul ignore next */
			mod = await WebAssembly.compile(llhttpWasmData || require_llhttp_wasm());
		}
		return await WebAssembly.instantiate(mod, { env: {
			wasm_on_url: (p, at, len) => {
				/* istanbul ignore next */
				return 0;
			},
			wasm_on_status: (p, at, len) => {
				assert$19(currentParser.ptr === p);
				const start = at - currentBufferPtr + currentBufferRef.byteOffset;
				return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
			},
			wasm_on_message_begin: (p) => {
				assert$19(currentParser.ptr === p);
				return currentParser.onMessageBegin() || 0;
			},
			wasm_on_header_field: (p, at, len) => {
				assert$19(currentParser.ptr === p);
				const start = at - currentBufferPtr + currentBufferRef.byteOffset;
				return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
			},
			wasm_on_header_value: (p, at, len) => {
				assert$19(currentParser.ptr === p);
				const start = at - currentBufferPtr + currentBufferRef.byteOffset;
				return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
			},
			wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
				assert$19(currentParser.ptr === p);
				return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
			},
			wasm_on_body: (p, at, len) => {
				assert$19(currentParser.ptr === p);
				const start = at - currentBufferPtr + currentBufferRef.byteOffset;
				return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
			},
			wasm_on_message_complete: (p) => {
				assert$19(currentParser.ptr === p);
				return currentParser.onMessageComplete() || 0;
			}
		} });
	}
	var llhttpInstance = null;
	var llhttpPromise = lazyllhttp();
	llhttpPromise.catch();
	var currentParser = null;
	var currentBufferRef = null;
	var currentBufferSize = 0;
	var currentBufferPtr = null;
	var USE_NATIVE_TIMER = 0;
	var USE_FAST_TIMER = 1;
	var TIMEOUT_HEADERS = 2 | USE_FAST_TIMER;
	var TIMEOUT_BODY = 4 | USE_FAST_TIMER;
	var TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER;
	var Parser = class {
		constructor(client, socket, { exports: exports$1 }) {
			assert$19(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
			this.llhttp = exports$1;
			this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE);
			this.client = client;
			this.socket = socket;
			this.timeout = null;
			this.timeoutValue = null;
			this.timeoutType = null;
			this.statusCode = null;
			this.statusText = "";
			this.upgrade = false;
			this.headers = [];
			this.headersSize = 0;
			this.headersMaxSize = client[kMaxHeadersSize];
			this.shouldKeepAlive = false;
			this.paused = false;
			this.resume = this.resume.bind(this);
			this.bytesRead = 0;
			this.keepAlive = "";
			this.contentLength = "";
			this.connection = "";
			this.maxResponseSize = client[kMaxResponseSize];
		}
		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, new WeakRef(this));
				else {
					this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this));
					this.timeout.unref();
				}
				this.timeoutValue = delay;
			} else if (this.timeout) {
				// istanbul ignore else: only for jest
				if (this.timeout.refresh) this.timeout.refresh();
			}
			this.timeoutType = type;
		}
		resume() {
			if (this.socket.destroyed || !this.paused) return;
			assert$19(this.ptr != null);
			assert$19(currentParser == null);
			this.llhttp.llhttp_resume(this.ptr);
			assert$19(this.timeoutType === TIMEOUT_BODY);
			if (this.timeout) {
				// istanbul ignore else: only for jest
				if (this.timeout.refresh) this.timeout.refresh();
			}
			this.paused = false;
			this.execute(this.socket.read() || EMPTY_BUF);
			this.readMore();
		}
		readMore() {
			while (!this.paused && this.ptr) {
				const chunk = this.socket.read();
				if (chunk === null) break;
				this.execute(chunk);
			}
		}
		execute(data) {
			assert$19(this.ptr != null);
			assert$19(currentParser == null);
			assert$19(!this.paused);
			const { socket, llhttp } = this;
			if (data.length > currentBufferSize) {
				if (currentBufferPtr) llhttp.free(currentBufferPtr);
				currentBufferSize = Math.ceil(data.length / 4096) * 4096;
				currentBufferPtr = llhttp.malloc(currentBufferSize);
			}
			new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data);
			try {
				let ret;
				try {
					currentBufferRef = data;
					currentParser = this;
					ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length);
				} catch (err) {
					/* istanbul ignore next: difficult to make a test case for */
					throw err;
				} finally {
					currentParser = null;
					currentBufferRef = null;
				}
				const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr;
				if (ret === constants.ERROR.PAUSED_UPGRADE) this.onUpgrade(data.slice(offset));
				else if (ret === constants.ERROR.PAUSED) {
					this.paused = true;
					socket.unshift(data.slice(offset));
				} else if (ret !== constants.ERROR.OK) {
					const ptr = llhttp.llhttp_get_error_reason(this.ptr);
					let message = "";
					/* istanbul ignore else: difficult to make a test case for */
					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() + ")";
					}
					throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset));
				}
			} catch (err) {
				util.destroy(socket, err);
			}
		}
		destroy() {
			assert$19(this.ptr != null);
			assert$19(currentParser == null);
			this.llhttp.llhttp_free(this.ptr);
			this.ptr = null;
			this.timeout && timers.clearTimeout(this.timeout);
			this.timeout = null;
			this.timeoutValue = null;
			this.timeoutType = null;
			this.paused = false;
		}
		onStatus(buf) {
			this.statusText = buf.toString();
		}
		onMessageBegin() {
			const { socket, client } = this;
			/* istanbul ignore next: difficult to make a test case for */
			if (socket.destroyed) return -1;
			const request = client[kQueue][client[kRunningIdx]];
			if (!request) return -1;
			request.onResponseStarted();
		}
		onHeaderField(buf) {
			const len = this.headers.length;
			if ((len & 1) === 0) this.headers.push(buf);
			else this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
			this.trackHeader(buf.length);
		}
		onHeaderValue(buf) {
			let len = this.headers.length;
			if ((len & 1) === 1) {
				this.headers.push(buf);
				len += 1;
			} else this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
			const key = this.headers[len - 2];
			if (key.length === 10) {
				const headerName = util.bufferToLowerCasedHeaderName(key);
				if (headerName === "keep-alive") this.keepAlive += buf.toString();
				else if (headerName === "connection") this.connection += buf.toString();
			} else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === "content-length") this.contentLength += buf.toString();
			this.trackHeader(buf.length);
		}
		trackHeader(len) {
			this.headersSize += len;
			if (this.headersSize >= this.headersMaxSize) util.destroy(this.socket, new HeadersOverflowError());
		}
		onUpgrade(head) {
			const { upgrade, client, socket, headers, statusCode } = this;
			assert$19(upgrade);
			assert$19(client[kSocket] === socket);
			assert$19(!socket.destroyed);
			assert$19(!this.paused);
			assert$19((headers.length & 1) === 0);
			const request = client[kQueue][client[kRunningIdx]];
			assert$19(request);
			assert$19(request.upgrade || request.method === "CONNECT");
			this.statusCode = null;
			this.statusText = "";
			this.shouldKeepAlive = null;
			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.onUpgrade(statusCode, headers, socket);
			} catch (err) {
				util.destroy(socket, err);
			}
			client[kResume]();
		}
		onHeadersComplete(statusCode, upgrade, shouldKeepAlive) {
			const { client, socket, headers, statusText } = this;
			/* istanbul ignore next: difficult to make a test case for */
			if (socket.destroyed) return -1;
			const request = client[kQueue][client[kRunningIdx]];
			/* istanbul ignore next: difficult to make a test case for */
			if (!request) return -1;
			assert$19(!this.upgrade);
			assert$19(this.statusCode < 200);
			if (statusCode === 100) {
				util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
				return -1;
			}
			if (upgrade && !request.upgrade) {
				util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket)));
				return -1;
			}
			assert$19(this.timeoutType === TIMEOUT_HEADERS);
			this.statusCode = statusCode;
			this.shouldKeepAlive = shouldKeepAlive || request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
			if (this.statusCode >= 200) {
				const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout];
				this.setTimeout(bodyTimeout, TIMEOUT_BODY);
			} else if (this.timeout) {
				// istanbul ignore else: only for jest
				if (this.timeout.refresh) this.timeout.refresh();
			}
			if (request.method === "CONNECT") {
				assert$19(client[kRunning] === 1);
				this.upgrade = true;
				return 2;
			}
			if (upgrade) {
				assert$19(client[kRunning] === 1);
				this.upgrade = true;
				return 2;
			}
			assert$19((this.headers.length & 1) === 0);
			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.onHeaders(statusCode, headers, this.resume, statusText) === false;
			if (request.aborted) return -1;
			if (request.method === "HEAD") return 1;
			if (statusCode < 200) return 1;
			if (socket[kBlocking]) {
				socket[kBlocking] = false;
				client[kResume]();
			}
			return pause ? constants.ERROR.PAUSED : 0;
		}
		onBody(buf) {
			const { client, socket, statusCode, maxResponseSize } = this;
			if (socket.destroyed) return -1;
			const request = client[kQueue][client[kRunningIdx]];
			assert$19(request);
			assert$19(this.timeoutType === TIMEOUT_BODY);
			if (this.timeout) {
				// istanbul ignore else: only for jest
				if (this.timeout.refresh) this.timeout.refresh();
			}
			assert$19(statusCode >= 200);
			if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
				util.destroy(socket, new ResponseExceededMaxSizeError());
				return -1;
			}
			this.bytesRead += buf.length;
			if (request.onData(buf) === false) return constants.ERROR.PAUSED;
		}
		onMessageComplete() {
			const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this;
			if (socket.destroyed && (!statusCode || shouldKeepAlive)) return -1;
			if (upgrade) return;
			assert$19(statusCode >= 100);
			assert$19((this.headers.length & 1) === 0);
			const request = client[kQueue][client[kRunningIdx]];
			assert$19(request);
			this.statusCode = null;
			this.statusText = "";
			this.bytesRead = 0;
			this.contentLength = "";
			this.keepAlive = "";
			this.connection = "";
			this.headers = [];
			this.headersSize = 0;
			if (statusCode < 200) return;
			/* istanbul ignore next: should be handled by llhttp? */
			if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
				util.destroy(socket, new ResponseContentLengthMismatchError());
				return -1;
			}
			request.onComplete(headers);
			client[kQueue][client[kRunningIdx]++] = null;
			if (socket[kWriting]) {
				assert$19(client[kRunning] === 0);
				util.destroy(socket, new InformationalError("reset"));
				return constants.ERROR.PAUSED;
			} else if (!shouldKeepAlive) {
				util.destroy(socket, new InformationalError("reset"));
				return constants.ERROR.PAUSED;
			} else if (socket[kReset] && client[kRunning] === 0) {
				util.destroy(socket, new InformationalError("reset"));
				return constants.ERROR.PAUSED;
			} else if (client[kPipelining] == null || client[kPipelining] === 1) setImmediate(() => client[kResume]());
			else client[kResume]();
		}
	};
	function onParserTimeout(parser) {
		const { socket, timeoutType, client, paused } = parser.deref();
		/* istanbul ignore else */
		if (timeoutType === TIMEOUT_HEADERS) {
			if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
				assert$19(!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$19(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
			util.destroy(socket, new InformationalError("socket idle timeout"));
		}
	}
	async function connectH1(client, socket) {
		client[kSocket] = socket;
		if (!llhttpInstance) {
			llhttpInstance = await llhttpPromise;
			llhttpPromise = null;
		}
		socket[kNoRef] = false;
		socket[kWriting] = false;
		socket[kReset] = false;
		socket[kBlocking] = false;
		socket[kParser] = new Parser(client, socket, llhttpInstance);
		addListener(socket, "error", function(err) {
			assert$19(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
			const parser = this[kParser];
			if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
				parser.onMessageComplete();
				return;
			}
			this[kError] = err;
			this[kClient][kOnError](err);
		});
		addListener(socket, "readable", function() {
			const parser = this[kParser];
			if (parser) parser.readMore();
		});
		addListener(socket, "end", function() {
			const parser = this[kParser];
			if (parser.statusCode && !parser.shouldKeepAlive) {
				parser.onMessageComplete();
				return;
			}
			util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
		});
		addListener(socket, "close", function() {
			const client = this[kClient];
			const parser = this[kParser];
			if (parser) {
				if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) parser.onMessageComplete();
				this[kParser].destroy();
				this[kParser] = null;
			}
			const err = this[kError] || new SocketError("closed", util.getSocketInfo(this));
			client[kSocket] = null;
			client[kHTTPContext] = null;
			if (client.destroyed) {
				assert$19(client[kPending] === 0);
				const requests = client[kQueue].splice(client[kRunningIdx]);
				for (let i = 0; i < requests.length; i++) {
					const request = requests[i];
					util.errorRequest(client, request, err);
				}
			} else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
				const request = client[kQueue][client[kRunningIdx]];
				client[kQueue][client[kRunningIdx]++] = null;
				util.errorRequest(client, request, err);
			}
			client[kPendingIdx] = client[kRunningIdx];
			assert$19(client[kRunning] === 0);
			client.emit("disconnect", client[kUrl], [client], err);
			client[kResume]();
		});
		let closed = false;
		socket.on("close", () => {
			closed = true;
		});
		return {
			version: "h1",
			defaultPipelining: 1,
			write(...args) {
				return writeH1(client, ...args);
			},
			resume() {
				resumeH1(client);
			},
			destroy(err, callback) {
				if (closed) queueMicrotask(callback);
				else socket.destroy(err).on("close", callback);
			},
			get destroyed() {
				return socket.destroyed;
			},
			busy(request) {
				if (socket[kWriting] || socket[kReset] || socket[kBlocking]) return true;
				if (request) {
					if (client[kRunning] > 0 && !request.idempotent) return true;
					if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) return true;
					if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body))) return true;
				}
				return false;
			}
		};
	}
	function resumeH1(client) {
		const socket = client[kSocket];
		if (socket && !socket.destroyed) {
			if (client[kSize] === 0) {
				if (!socket[kNoRef] && socket.unref) {
					socket.unref();
					socket[kNoRef] = true;
				}
			} else if (socket[kNoRef] && socket.ref) {
				socket.ref();
				socket[kNoRef] = false;
			}
			if (client[kSize] === 0) {
				if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE) socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE);
			} 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];
					socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
				}
			}
		}
	}
	function shouldSendContentLength(method) {
		return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
	}
	function writeH1(client, request) {
		const { method, path, host, upgrade, blocking, reset } = request;
		let { body, headers, contentLength } = request;
		const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
		if (util.isFormDataLike(body)) {
			if (!extractBody) extractBody = require_body().extractBody;
			const [bodyStream, contentType] = extractBody(body);
			if (request.contentType == null) headers.push("content-type", contentType);
			body = bodyStream.stream;
			contentLength = bodyStream.length;
		} else if (util.isBlobLike(body) && request.contentType == null && body.type) headers.push("content-type", body.type);
		if (body && typeof body.read === "function") body.read(0);
		const bodyLength = util.bodyLength(body);
		contentLength = bodyLength ?? contentLength;
		if (contentLength === null) contentLength = request.contentLength;
		if (contentLength === 0 && !expectsPayload) contentLength = null;
		if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
			if (client[kStrictContentLength]) {
				util.errorRequest(client, request, new RequestContentLengthMismatchError());
				return false;
			}
			process.emitWarning(new RequestContentLengthMismatchError());
		}
		const socket = client[kSocket];
		const abort = (err) => {
			if (request.aborted || request.completed) return;
			util.errorRequest(client, request, err || new RequestAbortedError());
			util.destroy(body);
			util.destroy(socket, new InformationalError("aborted"));
		};
		try {
			request.onConnect(abort);
		} catch (err) {
			util.errorRequest(client, request, err);
		}
		if (request.aborted) return false;
		if (method === "HEAD") socket[kReset] = true;
		if (upgrade || method === "CONNECT") socket[kReset] = true;
		if (reset != null) socket[kReset] = reset;
		if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) socket[kReset] = true;
		if (blocking) socket[kBlocking] = true;
		let header = `${method} ${path} HTTP/1.1\r\n`;
		if (typeof host === "string") header += `host: ${host}\r\n`;
		else header += client[kHostHeader];
		if (upgrade) header += `connection: upgrade\r\nupgrade: ${upgrade}\r\n`;
		else if (client[kPipelining] && !socket[kReset]) header += "connection: keep-alive\r\n";
		else header += "connection: close\r\n";
		if (Array.isArray(headers)) for (let n = 0; n < headers.length; n += 2) {
			const key = headers[n + 0];
			const val = headers[n + 1];
			if (Array.isArray(val)) for (let i = 0; i < val.length; i++) header += `${key}: ${val[i]}\r\n`;
			else header += `${key}: ${val}\r\n`;
		}
		if (channels.sendHeaders.hasSubscribers) channels.sendHeaders.publish({
			request,
			headers: header,
			socket
		});
		/* istanbul ignore else: assertion */
		if (!body || bodyLength === 0) writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload);
		else if (util.isBuffer(body)) writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload);
		else if (util.isBlobLike(body)) if (typeof body.stream === "function") writeIterable(abort, body.stream(), client, request, socket, contentLength, header, expectsPayload);
		else writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload);
		else if (util.isStream(body)) writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload);
		else if (util.isIterable(body)) writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload);
		else assert$19(false);
		return true;
	}
	function writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload) {
		assert$19(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
		let finished = false;
		const writer = new AsyncWriter({
			abort,
			socket,
			request,
			contentLength,
			client,
			expectsPayload,
			header
		});
		const onData = function(chunk) {
			if (finished) return;
			try {
				if (!writer.write(chunk) && this.pause) this.pause();
			} catch (err) {
				util.destroy(this, err);
			}
		};
		const onDrain = function() {
			if (finished) return;
			if (body.resume) body.resume();
		};
		const onClose = function() {
			queueMicrotask(() => {
				body.removeListener("error", onFinished);
			});
			if (!finished) {
				const err = new RequestAbortedError();
				queueMicrotask(() => onFinished(err));
			}
		};
		const onFinished = function(err) {
			if (finished) return;
			finished = true;
			assert$19(socket.destroyed || socket[kWriting] && client[kRunning] <= 1);
			socket.off("drain", onDrain).off("error", onFinished);
			body.removeListener("data", onData).removeListener("end", onFinished).removeListener("close", onClose);
			if (!err) try {
				writer.end();
			} catch (er) {
				err = er;
			}
			writer.destroy(err);
			if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) util.destroy(body, err);
			else util.destroy(body);
		};
		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);
		if (body.errorEmitted ?? body.errored) setImmediate(() => onFinished(body.errored));
		else if (body.endEmitted ?? body.readableEnded) setImmediate(() => onFinished(null));
		if (body.closeEmitted ?? body.closed) setImmediate(onClose);
	}
	function writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload) {
		try {
			if (!body) if (contentLength === 0) socket.write(`${header}content-length: 0\r\n\r\n`, "latin1");
			else {
				assert$19(contentLength === null, "no body must not have content length");
				socket.write(`${header}\r\n`, "latin1");
			}
			else if (util.isBuffer(body)) {
				assert$19(contentLength === body.byteLength, "buffer body must have content length");
				socket.cork();
				socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, "latin1");
				socket.write(body);
				socket.uncork();
				request.onBodySent(body);
				if (!expectsPayload && request.reset !== false) socket[kReset] = true;
			}
			request.onRequestSent();
			client[kResume]();
		} catch (err) {
			abort(err);
		}
	}
	async function writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload) {
		assert$19(contentLength === body.size, "blob body must have content length");
		try {
			if (contentLength != null && contentLength !== body.size) throw new RequestContentLengthMismatchError();
			const buffer = Buffer.from(await body.arrayBuffer());
			socket.cork();
			socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, "latin1");
			socket.write(buffer);
			socket.uncork();
			request.onBodySent(buffer);
			request.onRequestSent();
			if (!expectsPayload && request.reset !== false) socket[kReset] = true;
			client[kResume]();
		} catch (err) {
			abort(err);
		}
	}
	async function writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload) {
		assert$19(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
		let callback = null;
		function onDrain() {
			if (callback) {
				const cb = callback;
				callback = null;
				cb();
			}
		}
		const waitForDrain = () => new Promise((resolve, reject) => {
			assert$19(callback === null);
			if (socket[kError]) reject(socket[kError]);
			else callback = resolve;
		});
		socket.on("close", onDrain).on("drain", onDrain);
		const writer = new AsyncWriter({
			abort,
			socket,
			request,
			contentLength,
			client,
			expectsPayload,
			header
		});
		try {
			for await (const chunk of body) {
				if (socket[kError]) throw socket[kError];
				if (!writer.write(chunk)) await waitForDrain();
			}
			writer.end();
		} catch (err) {
			writer.destroy(err);
		} finally {
			socket.off("close", onDrain).off("drain", onDrain);
		}
	}
	var AsyncWriter = class {
		constructor({ abort, socket, request, contentLength, client, expectsPayload, header }) {
			this.socket = socket;
			this.request = request;
			this.contentLength = contentLength;
			this.client = client;
			this.bytesWritten = 0;
			this.expectsPayload = expectsPayload;
			this.header = header;
			this.abort = abort;
			socket[kWriting] = true;
		}
		write(chunk) {
			const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this;
			if (socket[kError]) throw socket[kError];
			if (socket.destroyed) return false;
			const len = Buffer.byteLength(chunk);
			if (!len) return true;
			if (contentLength !== null && bytesWritten + len > contentLength) {
				if (client[kStrictContentLength]) throw new RequestContentLengthMismatchError();
				process.emitWarning(new RequestContentLengthMismatchError());
			}
			socket.cork();
			if (bytesWritten === 0) {
				if (!expectsPayload && request.reset !== false) socket[kReset] = true;
				if (contentLength === null) socket.write(`${header}transfer-encoding: chunked\r\n`, "latin1");
				else socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, "latin1");
			}
			if (contentLength === null) socket.write(`\r\n${len.toString(16)}\r\n`, "latin1");
			this.bytesWritten += len;
			const ret = socket.write(chunk);
			socket.uncork();
			request.onBodySent(chunk);
			if (!ret) {
				if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
					// istanbul ignore else: only for jest
					if (socket[kParser].timeout.refresh) socket[kParser].timeout.refresh();
				}
			}
			return ret;
		}
		end() {
			const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this;
			request.onRequestSent();
			socket[kWriting] = false;
			if (socket[kError]) throw socket[kError];
			if (socket.destroyed) return;
			if (bytesWritten === 0) if (expectsPayload) socket.write(`${header}content-length: 0\r\n\r\n`, "latin1");
			else socket.write(`${header}\r\n`, "latin1");
			else if (contentLength === null) socket.write("\r\n0\r\n\r\n", "latin1");
			if (contentLength !== null && bytesWritten !== contentLength) if (client[kStrictContentLength]) throw new RequestContentLengthMismatchError();
			else process.emitWarning(new RequestContentLengthMismatchError());
			if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
				// istanbul ignore else: only for jest
				if (socket[kParser].timeout.refresh) socket[kParser].timeout.refresh();
			}
			client[kResume]();
		}
		destroy(err) {
			const { socket, client, abort } = this;
			socket[kWriting] = false;
			if (err) {
				assert$19(client[kRunning] <= 1, "pipeline should only contain this request");
				abort(err);
			}
		}
	};
	module.exports = connectH1;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/client-h2.js
var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$18 = __require("node:assert");
	var { pipeline: pipeline$2 } = __require("node:stream");
	var util = require_util$8();
	var { RequestContentLengthMismatchError, RequestAbortedError, SocketError, InformationalError } = require_errors();
	var { kUrl, kReset, kClient, kRunning, kPending, kQueue, kPendingIdx, kRunningIdx, kError, kSocket, kStrictContentLength, kOnError, kMaxConcurrentStreams, kHTTP2Session, kResume, kSize, kHTTPContext } = require_symbols$4();
	var kOpenStreams = Symbol("open streams");
	var extractBody;
	var h2ExperimentalWarned = false;
	/** @type {import('http2')} */
	var http2;
	try {
		http2 = __require("node:http2");
	} catch {
		http2 = { constants: {} };
	}
	var { constants: { HTTP2_HEADER_AUTHORITY, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_SCHEME, HTTP2_HEADER_CONTENT_LENGTH, HTTP2_HEADER_EXPECT, HTTP2_HEADER_STATUS } } = http2;
	function parseH2Headers(headers) {
		const result = [];
		for (const [name, value] of Object.entries(headers)) if (Array.isArray(value)) for (const subvalue of value) result.push(Buffer.from(name), Buffer.from(subvalue));
		else result.push(Buffer.from(name), Buffer.from(value));
		return result;
	}
	async function connectH2(client, socket) {
		client[kSocket] = socket;
		if (!h2ExperimentalWarned) {
			h2ExperimentalWarned = true;
			process.emitWarning("H2 support is experimental, expect them to change at any time.", { code: "UNDICI-H2" });
		}
		const session = http2.connect(client[kUrl], {
			createConnection: () => socket,
			peerMaxConcurrentStreams: client[kMaxConcurrentStreams]
		});
		session[kOpenStreams] = 0;
		session[kClient] = client;
		session[kSocket] = socket;
		util.addListener(session, "error", onHttp2SessionError);
		util.addListener(session, "frameError", onHttp2FrameError);
		util.addListener(session, "end", onHttp2SessionEnd);
		util.addListener(session, "goaway", onHTTP2GoAway);
		util.addListener(session, "close", function() {
			const { [kClient]: client } = this;
			const { [kSocket]: socket } = client;
			const err = this[kSocket][kError] || this[kError] || new SocketError("closed", util.getSocketInfo(socket));
			client[kHTTP2Session] = null;
			if (client.destroyed) {
				assert$18(client[kPending] === 0);
				const requests = client[kQueue].splice(client[kRunningIdx]);
				for (let i = 0; i < requests.length; i++) {
					const request = requests[i];
					util.errorRequest(client, request, err);
				}
			}
		});
		session.unref();
		client[kHTTP2Session] = session;
		socket[kHTTP2Session] = session;
		util.addListener(socket, "error", function(err) {
			assert$18(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
			this[kError] = err;
			this[kClient][kOnError](err);
		});
		util.addListener(socket, "end", function() {
			util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
		});
		util.addListener(socket, "close", function() {
			const err = this[kError] || new SocketError("closed", util.getSocketInfo(this));
			client[kSocket] = null;
			if (this[kHTTP2Session] != null) this[kHTTP2Session].destroy(err);
			client[kPendingIdx] = client[kRunningIdx];
			assert$18(client[kRunning] === 0);
			client.emit("disconnect", client[kUrl], [client], err);
			client[kResume]();
		});
		let closed = false;
		socket.on("close", () => {
			closed = true;
		});
		return {
			version: "h2",
			defaultPipelining: Infinity,
			write(...args) {
				return writeH2(client, ...args);
			},
			resume() {
				resumeH2(client);
			},
			destroy(err, callback) {
				if (closed) queueMicrotask(callback);
				else socket.destroy(err).on("close", callback);
			},
			get destroyed() {
				return socket.destroyed;
			},
			busy() {
				return false;
			}
		};
	}
	function resumeH2(client) {
		const socket = client[kSocket];
		if (socket?.destroyed === false) if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) {
			socket.unref();
			client[kHTTP2Session].unref();
		} else {
			socket.ref();
			client[kHTTP2Session].ref();
		}
	}
	function onHttp2SessionError(err) {
		assert$18(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
		this[kSocket][kError] = err;
		this[kClient][kOnError](err);
	}
	function onHttp2FrameError(type, code, id) {
		if (id === 0) {
			const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
			this[kSocket][kError] = err;
			this[kClient][kOnError](err);
		}
	}
	function onHttp2SessionEnd() {
		const err = new SocketError("other side closed", util.getSocketInfo(this[kSocket]));
		this.destroy(err);
		util.destroy(this[kSocket], err);
	}
	/**
	* This is the root cause of #3011
	* We need to handle GOAWAY frames properly, and trigger the session close
	* along with the socket right away
	*/
	function onHTTP2GoAway(code) {
		const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${code}`, util.getSocketInfo(this));
		const client = this[kClient];
		client[kSocket] = null;
		client[kHTTPContext] = null;
		if (this[kHTTP2Session] != null) {
			this[kHTTP2Session].destroy(err);
			this[kHTTP2Session] = null;
		}
		util.destroy(this[kSocket], err);
		if (client[kRunningIdx] < client[kQueue].length) {
			const request = client[kQueue][client[kRunningIdx]];
			client[kQueue][client[kRunningIdx]++] = null;
			util.errorRequest(client, request, err);
			client[kPendingIdx] = client[kRunningIdx];
		}
		assert$18(client[kRunning] === 0);
		client.emit("disconnect", client[kUrl], [client], err);
		client[kResume]();
	}
	function shouldSendContentLength(method) {
		return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
	}
	function writeH2(client, request) {
		const session = client[kHTTP2Session];
		const { method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
		let { body } = request;
		if (upgrade) {
			util.errorRequest(client, request, /* @__PURE__ */ new Error("Upgrade not supported for H2"));
			return false;
		}
		const headers = {};
		for (let n = 0; n < reqHeaders.length; n += 2) {
			const key = reqHeaders[n + 0];
			const val = reqHeaders[n + 1];
			if (Array.isArray(val)) for (let i = 0; i < val.length; i++) if (headers[key]) headers[key] += `,${val[i]}`;
			else headers[key] = val[i];
			else headers[key] = val;
		}
		/** @type {import('node:http2').ClientHttp2Stream} */
		let stream;
		const { hostname, port } = client[kUrl];
		headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ""}`;
		headers[HTTP2_HEADER_METHOD] = method;
		const abort = (err) => {
			if (request.aborted || request.completed) return;
			err = err || new RequestAbortedError();
			util.errorRequest(client, request, err);
			if (stream != null) util.destroy(stream, err);
			util.destroy(body, err);
			client[kQueue][client[kRunningIdx]++] = null;
			client[kResume]();
		};
		try {
			request.onConnect(abort);
		} catch (err) {
			util.errorRequest(client, request, err);
		}
		if (request.aborted) return false;
		if (method === "CONNECT") {
			session.ref();
			stream = session.request(headers, {
				endStream: false,
				signal
			});
			if (stream.id && !stream.pending) {
				request.onUpgrade(null, null, stream);
				++session[kOpenStreams];
				client[kQueue][client[kRunningIdx]++] = null;
			} else stream.once("ready", () => {
				request.onUpgrade(null, null, stream);
				++session[kOpenStreams];
				client[kQueue][client[kRunningIdx]++] = null;
			});
			stream.once("close", () => {
				session[kOpenStreams] -= 1;
				if (session[kOpenStreams] === 0) session.unref();
			});
			return true;
		}
		headers[HTTP2_HEADER_PATH] = path;
		headers[HTTP2_HEADER_SCHEME] = "https";
		const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
		if (body && typeof body.read === "function") body.read(0);
		let contentLength = util.bodyLength(body);
		if (util.isFormDataLike(body)) {
			extractBody ??= require_body().extractBody;
			const [bodyStream, contentType] = extractBody(body);
			headers["content-type"] = contentType;
			body = bodyStream.stream;
			contentLength = bodyStream.length;
		}
		if (contentLength == null) contentLength = request.contentLength;
		if (contentLength === 0 || !expectsPayload) contentLength = null;
		if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) {
			if (client[kStrictContentLength]) {
				util.errorRequest(client, request, new RequestContentLengthMismatchError());
				return false;
			}
			process.emitWarning(new RequestContentLengthMismatchError());
		}
		if (contentLength != null) {
			assert$18(body, "no body must not have content length");
			headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
		}
		session.ref();
		const shouldEndStream = method === "GET" || method === "HEAD" || body === null;
		if (expectContinue) {
			headers[HTTP2_HEADER_EXPECT] = "100-continue";
			stream = session.request(headers, {
				endStream: shouldEndStream,
				signal
			});
			stream.once("continue", writeBodyH2);
		} else {
			stream = session.request(headers, {
				endStream: shouldEndStream,
				signal
			});
			writeBodyH2();
		}
		++session[kOpenStreams];
		stream.once("response", (headers) => {
			const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers;
			request.onResponseStarted();
			if (request.aborted) {
				const err = new RequestAbortedError();
				util.errorRequest(client, request, err);
				util.destroy(stream, err);
				return;
			}
			if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) stream.pause();
			stream.on("data", (chunk) => {
				if (request.onData(chunk) === false) stream.pause();
			});
		});
		stream.once("end", () => {
			if (stream.state?.state == null || stream.state.state < 6) request.onComplete([]);
			if (session[kOpenStreams] === 0) session.unref();
			abort(new InformationalError("HTTP/2: stream half-closed (remote)"));
			client[kQueue][client[kRunningIdx]++] = null;
			client[kPendingIdx] = client[kRunningIdx];
			client[kResume]();
		});
		stream.once("close", () => {
			session[kOpenStreams] -= 1;
			if (session[kOpenStreams] === 0) session.unref();
		});
		stream.once("error", function(err) {
			abort(err);
		});
		stream.once("frameError", (type, code) => {
			abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`));
		});
		return true;
		function writeBodyH2() {
			/* istanbul ignore else: assertion */
			if (!body || contentLength === 0) writeBuffer(abort, stream, null, client, request, client[kSocket], contentLength, expectsPayload);
			else if (util.isBuffer(body)) writeBuffer(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload);
			else if (util.isBlobLike(body)) if (typeof body.stream === "function") writeIterable(abort, stream, body.stream(), client, request, client[kSocket], contentLength, expectsPayload);
			else writeBlob(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload);
			else if (util.isStream(body)) writeStream(abort, client[kSocket], expectsPayload, stream, body, client, request, contentLength);
			else if (util.isIterable(body)) writeIterable(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload);
			else assert$18(false);
		}
	}
	function writeBuffer(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
		try {
			if (body != null && util.isBuffer(body)) {
				assert$18(contentLength === body.byteLength, "buffer body must have content length");
				h2stream.cork();
				h2stream.write(body);
				h2stream.uncork();
				h2stream.end();
				request.onBodySent(body);
			}
			if (!expectsPayload) socket[kReset] = true;
			request.onRequestSent();
			client[kResume]();
		} catch (error) {
			abort(error);
		}
	}
	function writeStream(abort, socket, expectsPayload, h2stream, body, client, request, contentLength) {
		assert$18(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
		const pipe = pipeline$2(body, h2stream, (err) => {
			if (err) {
				util.destroy(pipe, err);
				abort(err);
			} else {
				util.removeAllListeners(pipe);
				request.onRequestSent();
				if (!expectsPayload) socket[kReset] = true;
				client[kResume]();
			}
		});
		util.addListener(pipe, "data", onPipeData);
		function onPipeData(chunk) {
			request.onBodySent(chunk);
		}
	}
	async function writeBlob(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
		assert$18(contentLength === body.size, "blob body must have content length");
		try {
			if (contentLength != null && contentLength !== body.size) throw new RequestContentLengthMismatchError();
			const buffer = Buffer.from(await body.arrayBuffer());
			h2stream.cork();
			h2stream.write(buffer);
			h2stream.uncork();
			h2stream.end();
			request.onBodySent(buffer);
			request.onRequestSent();
			if (!expectsPayload) socket[kReset] = true;
			client[kResume]();
		} catch (err) {
			abort(err);
		}
	}
	async function writeIterable(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
		assert$18(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
		let callback = null;
		function onDrain() {
			if (callback) {
				const cb = callback;
				callback = null;
				cb();
			}
		}
		const waitForDrain = () => new Promise((resolve, reject) => {
			assert$18(callback === null);
			if (socket[kError]) reject(socket[kError]);
			else callback = resolve;
		});
		h2stream.on("close", onDrain).on("drain", onDrain);
		try {
			for await (const chunk of body) {
				if (socket[kError]) throw socket[kError];
				const res = h2stream.write(chunk);
				request.onBodySent(chunk);
				if (!res) await waitForDrain();
			}
			h2stream.end();
			request.onRequestSent();
			if (!expectsPayload) socket[kReset] = true;
			client[kResume]();
		} catch (err) {
			abort(err);
		} finally {
			h2stream.off("close", onDrain).off("drain", onDrain);
		}
	}
	module.exports = connectH2;
}));
//#endregion
//#region node_modules/undici/lib/handler/redirect-handler.js
var require_redirect_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var util = require_util$8();
	var { kBodyUsed } = require_symbols$4();
	var assert$17 = __require("node:assert");
	var { InvalidArgumentError } = require_errors();
	var EE$1 = __require("node:events");
	var redirectableStatusCodes = [
		300,
		301,
		302,
		303,
		307,
		308
	];
	var kBody = Symbol("body");
	var BodyAsyncIterable = class {
		constructor(body) {
			this[kBody] = body;
			this[kBodyUsed] = false;
		}
		async *[Symbol.asyncIterator]() {
			assert$17(!this[kBodyUsed], "disturbed");
			this[kBodyUsed] = true;
			yield* this[kBody];
		}
	};
	var RedirectHandler = class {
		constructor(dispatch, maxRedirections, opts, handler) {
			if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) throw new InvalidArgumentError("maxRedirections must be a positive number");
			util.validateHandler(handler, opts.method, opts.upgrade);
			this.dispatch = dispatch;
			this.location = null;
			this.abort = null;
			this.opts = {
				...opts,
				maxRedirections: 0
			};
			this.maxRedirections = maxRedirections;
			this.handler = handler;
			this.history = [];
			this.redirectionLimitReached = false;
			if (util.isStream(this.opts.body)) {
				if (util.bodyLength(this.opts.body) === 0) this.opts.body.on("data", function() {
					assert$17(false);
				});
				if (typeof this.opts.body.readableDidRead !== "boolean") {
					this.opts.body[kBodyUsed] = false;
					EE$1.prototype.on.call(this.opts.body, "data", function() {
						this[kBodyUsed] = true;
					});
				}
			} else if (this.opts.body && typeof this.opts.body.pipeTo === "function") this.opts.body = new BodyAsyncIterable(this.opts.body);
			else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) this.opts.body = new BodyAsyncIterable(this.opts.body);
		}
		onConnect(abort) {
			this.abort = abort;
			this.handler.onConnect(abort, { history: this.history });
		}
		onUpgrade(statusCode, headers, socket) {
			this.handler.onUpgrade(statusCode, headers, socket);
		}
		onError(error) {
			this.handler.onError(error);
		}
		onHeaders(statusCode, headers, resume, statusText) {
			this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
			if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) {
				if (this.request) this.request.abort(/* @__PURE__ */ new Error("max redirects"));
				this.redirectionLimitReached = true;
				this.abort(/* @__PURE__ */ new Error("max redirects"));
				return;
			}
			if (this.opts.origin) this.history.push(new URL(this.opts.path, this.opts.origin));
			if (!this.location) return this.handler.onHeaders(statusCode, headers, resume, statusText);
			const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
			const path = search ? `${pathname}${search}` : pathname;
			this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
			this.opts.path = path;
			this.opts.origin = origin;
			this.opts.maxRedirections = 0;
			this.opts.query = null;
			if (statusCode === 303 && this.opts.method !== "HEAD") {
				this.opts.method = "GET";
				this.opts.body = null;
			}
		}
		onData(chunk) {
			if (this.location) {} else return this.handler.onData(chunk);
		}
		onComplete(trailers) {
			if (this.location) {
				this.location = null;
				this.abort = null;
				this.dispatch(this.opts, this);
			} else this.handler.onComplete(trailers);
		}
		onBodySent(chunk) {
			if (this.handler.onBodySent) this.handler.onBodySent(chunk);
		}
	};
	function parseLocation(statusCode, headers) {
		if (redirectableStatusCodes.indexOf(statusCode) === -1) return null;
		for (let i = 0; i < headers.length; i += 2) if (headers[i].length === 8 && util.headerNameToString(headers[i]) === "location") return headers[i + 1];
	}
	function shouldRemoveHeader(header, removeContent, unknownOrigin) {
		if (header.length === 4) return util.headerNameToString(header) === "host";
		if (removeContent && util.headerNameToString(header).startsWith("content-")) return true;
		if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
			const name = util.headerNameToString(header);
			return name === "authorization" || name === "cookie" || name === "proxy-authorization";
		}
		return false;
	}
	function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
		const ret = [];
		if (Array.isArray(headers)) {
			for (let i = 0; i < headers.length; i += 2) if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) ret.push(headers[i], headers[i + 1]);
		} else if (headers && typeof headers === "object") {
			for (const key of Object.keys(headers)) if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) ret.push(key, headers[key]);
		} else assert$17(headers == null, "headers must be an object or an array");
		return ret;
	}
	module.exports = RedirectHandler;
}));
//#endregion
//#region node_modules/undici/lib/interceptor/redirect-interceptor.js
var require_redirect_interceptor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var RedirectHandler = require_redirect_handler();
	function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) {
		return (dispatch) => {
			return function Intercept(opts, handler) {
				const { maxRedirections = defaultMaxRedirections } = opts;
				if (!maxRedirections) return dispatch(opts, handler);
				const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler);
				opts = {
					...opts,
					maxRedirections: 0
				};
				return dispatch(opts, redirectHandler);
			};
		};
	}
	module.exports = createRedirectInterceptor;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/client.js
var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$16 = __require("node:assert");
	var net = __require("node:net");
	var http = __require("node:http");
	var util = require_util$8();
	var { channels } = require_diagnostics();
	var Request = require_request$1();
	var DispatcherBase = require_dispatcher_base();
	var { InvalidArgumentError, InformationalError, ClientDestroyedError } = require_errors();
	var buildConnector = require_connect();
	var { kUrl, kServerName, kClient, kBusy, kConnect, kResuming, kRunning, kPending, kSize, kQueue, kConnected, kConnecting, kNeedDrain, kKeepAliveDefaultTimeout, kHostHeader, kPendingIdx, kRunningIdx, kError, kPipelining, kKeepAliveTimeoutValue, kMaxHeadersSize, kKeepAliveMaxTimeout, kKeepAliveTimeoutThreshold, kHeadersTimeout, kBodyTimeout, kStrictContentLength, kConnector, kMaxRedirections, kMaxRequests, kCounter, kClose, kDestroy, kDispatch, kInterceptors, kLocalAddress, kMaxResponseSize, kOnError, kHTTPContext, kMaxConcurrentStreams, kResume } = require_symbols$4();
	var connectH1 = require_client_h1();
	var connectH2 = require_client_h2();
	var deprecatedInterceptorWarned = false;
	var kClosedResolve = Symbol("kClosedResolve");
	var noop = () => {};
	function getPipelining(client) {
		return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1;
	}
	/**
	* @type {import('../../types/client.js').default}
	*/
	var Client = class extends DispatcherBase {
		/**
		*
		* @param {string|URL} url
		* @param {import('../../types/client.js').Client.Options} options
		*/
		constructor(url, { interceptors, maxHeaderSize, headersTimeout, socketTimeout, requestTimeout, connectTimeout, bodyTimeout, idleTimeout, keepAlive, keepAliveTimeout, maxKeepAliveTimeout, keepAliveMaxTimeout, keepAliveTimeoutThreshold, socketPath, pipelining, tls, strictContentLength, maxCachedSessions, maxRedirections, connect, maxRequestsPerClient, localAddress, maxResponseSize, autoSelectFamily, autoSelectFamilyAttemptTimeout, maxConcurrentStreams, allowH2 } = {}) {
			super();
			if (keepAlive !== void 0) throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
			if (socketTimeout !== void 0) throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");
			if (requestTimeout !== void 0) throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");
			if (idleTimeout !== void 0) throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead");
			if (maxKeepAliveTimeout !== void 0) throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");
			if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) throw new InvalidArgumentError("invalid maxHeaderSize");
			if (socketPath != null && typeof socketPath !== "string") throw new InvalidArgumentError("invalid socketPath");
			if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) throw new InvalidArgumentError("invalid connectTimeout");
			if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) throw new InvalidArgumentError("invalid keepAliveTimeout");
			if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) throw new InvalidArgumentError("invalid keepAliveMaxTimeout");
			if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold");
			if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) throw new InvalidArgumentError("headersTimeout must be a positive integer or zero");
			if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero");
			if (connect != null && typeof connect !== "function" && typeof connect !== "object") throw new InvalidArgumentError("connect must be a function or an object");
			if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) throw new InvalidArgumentError("maxRedirections must be a positive number");
			if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) throw new InvalidArgumentError("maxRequestsPerClient must be a positive number");
			if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) throw new InvalidArgumentError("localAddress must be valid string IP address");
			if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) throw new InvalidArgumentError("maxResponseSize must be a positive number");
			if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number");
			if (allowH2 != null && typeof allowH2 !== "boolean") throw new InvalidArgumentError("allowH2 must be a valid boolean value");
			if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) throw new InvalidArgumentError("maxConcurrentStreams must be a positive integer, greater than 0");
			if (typeof connect !== "function") connect = buildConnector({
				...tls,
				maxCachedSessions,
				allowH2,
				socketPath,
				timeout: connectTimeout,
				...autoSelectFamily ? {
					autoSelectFamily,
					autoSelectFamilyAttemptTimeout
				} : void 0,
				...connect
			});
			if (interceptors?.Client && Array.isArray(interceptors.Client)) {
				this[kInterceptors] = interceptors.Client;
				if (!deprecatedInterceptorWarned) {
					deprecatedInterceptorWarned = true;
					process.emitWarning("Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.", { code: "UNDICI-CLIENT-INTERCEPTOR-DEPRECATED" });
				}
			} else this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })];
			this[kUrl] = util.parseOrigin(url);
			this[kConnector] = connect;
			this[kPipelining] = pipelining != null ? pipelining : 1;
			this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize;
			this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
			this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout;
			this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2e3 : keepAliveTimeoutThreshold;
			this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout];
			this[kServerName] = null;
			this[kLocalAddress] = localAddress != null ? localAddress : null;
			this[kResuming] = 0;
			this[kNeedDrain] = 0;
			this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r\n`;
			this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5;
			this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5;
			this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
			this[kMaxRedirections] = maxRedirections;
			this[kMaxRequests] = maxRequestsPerClient;
			this[kClosedResolve] = null;
			this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
			this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100;
			this[kHTTPContext] = null;
			this[kQueue] = [];
			this[kRunningIdx] = 0;
			this[kPendingIdx] = 0;
			this[kResume] = (sync) => resume(this, sync);
			this[kOnError] = (err) => onError(this, err);
		}
		get pipelining() {
			return this[kPipelining];
		}
		set pipelining(value) {
			this[kPipelining] = value;
			this[kResume](true);
		}
		get [kPending]() {
			return this[kQueue].length - this[kPendingIdx];
		}
		get [kRunning]() {
			return this[kPendingIdx] - this[kRunningIdx];
		}
		get [kSize]() {
			return this[kQueue].length - this[kRunningIdx];
		}
		get [kConnected]() {
			return !!this[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed;
		}
		get [kBusy]() {
			return Boolean(this[kHTTPContext]?.busy(null) || this[kSize] >= (getPipelining(this) || 1) || this[kPending] > 0);
		}
		/* istanbul ignore: only used for test */
		[kConnect](cb) {
			connect(this);
			this.once("connect", cb);
		}
		[kDispatch](opts, handler) {
			const request = new Request(opts.origin || this[kUrl].origin, opts, handler);
			this[kQueue].push(request);
			if (this[kResuming]) {} else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) {
				this[kResuming] = 1;
				queueMicrotask(() => resume(this));
			} else this[kResume](true);
			if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) this[kNeedDrain] = 2;
			return this[kNeedDrain] < 2;
		}
		async [kClose]() {
			return new Promise((resolve) => {
				if (this[kSize]) this[kClosedResolve] = resolve;
				else resolve(null);
			});
		}
		async [kDestroy](err) {
			return new Promise((resolve) => {
				const requests = this[kQueue].splice(this[kPendingIdx]);
				for (let i = 0; i < requests.length; i++) {
					const request = requests[i];
					util.errorRequest(this, request, err);
				}
				const callback = () => {
					if (this[kClosedResolve]) {
						this[kClosedResolve]();
						this[kClosedResolve] = null;
					}
					resolve(null);
				};
				if (this[kHTTPContext]) {
					this[kHTTPContext].destroy(err, callback);
					this[kHTTPContext] = null;
				} else queueMicrotask(callback);
				this[kResume]();
			});
		}
	};
	var createRedirectInterceptor = require_redirect_interceptor();
	function onError(client, err) {
		if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
			assert$16(client[kPendingIdx] === client[kRunningIdx]);
			const requests = client[kQueue].splice(client[kRunningIdx]);
			for (let i = 0; i < requests.length; i++) {
				const request = requests[i];
				util.errorRequest(client, request, err);
			}
			assert$16(client[kSize] === 0);
		}
	}
	/**
	* @param {Client} client
	* @returns
	*/
	async function connect(client) {
		assert$16(!client[kConnecting]);
		assert$16(!client[kHTTPContext]);
		let { host, hostname, protocol, port } = client[kUrl];
		if (hostname[0] === "[") {
			const idx = hostname.indexOf("]");
			assert$16(idx !== -1);
			const ip = hostname.substring(1, idx);
			assert$16(net.isIP(ip));
			hostname = ip;
		}
		client[kConnecting] = true;
		if (channels.beforeConnect.hasSubscribers) channels.beforeConnect.publish({
			connectParams: {
				host,
				hostname,
				protocol,
				port,
				version: client[kHTTPContext]?.version,
				servername: client[kServerName],
				localAddress: client[kLocalAddress]
			},
			connector: client[kConnector]
		});
		try {
			const socket = await new Promise((resolve, reject) => {
				client[kConnector]({
					host,
					hostname,
					protocol,
					port,
					servername: client[kServerName],
					localAddress: client[kLocalAddress]
				}, (err, socket) => {
					if (err) reject(err);
					else resolve(socket);
				});
			});
			if (client.destroyed) {
				util.destroy(socket.on("error", noop), new ClientDestroyedError());
				return;
			}
			assert$16(socket);
			try {
				client[kHTTPContext] = socket.alpnProtocol === "h2" ? await connectH2(client, socket) : await connectH1(client, socket);
			} catch (err) {
				socket.destroy().on("error", noop);
				throw err;
			}
			client[kConnecting] = false;
			socket[kCounter] = 0;
			socket[kMaxRequests] = client[kMaxRequests];
			socket[kClient] = client;
			socket[kError] = null;
			if (channels.connected.hasSubscribers) channels.connected.publish({
				connectParams: {
					host,
					hostname,
					protocol,
					port,
					version: client[kHTTPContext]?.version,
					servername: client[kServerName],
					localAddress: client[kLocalAddress]
				},
				connector: client[kConnector],
				socket
			});
			client.emit("connect", client[kUrl], [client]);
		} catch (err) {
			if (client.destroyed) return;
			client[kConnecting] = false;
			if (channels.connectError.hasSubscribers) channels.connectError.publish({
				connectParams: {
					host,
					hostname,
					protocol,
					port,
					version: client[kHTTPContext]?.version,
					servername: client[kServerName],
					localAddress: client[kLocalAddress]
				},
				connector: client[kConnector],
				error: err
			});
			if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
				assert$16(client[kRunning] === 0);
				while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
					const request = client[kQueue][client[kPendingIdx]++];
					util.errorRequest(client, request, err);
				}
			} else onError(client, err);
			client.emit("connectionError", client[kUrl], [client], err);
		}
		client[kResume]();
	}
	function emitDrain(client) {
		client[kNeedDrain] = 0;
		client.emit("drain", client[kUrl], [client]);
	}
	function resume(client, sync) {
		if (client[kResuming] === 2) return;
		client[kResuming] = 2;
		_resume(client, sync);
		client[kResuming] = 0;
		if (client[kRunningIdx] > 256) {
			client[kQueue].splice(0, client[kRunningIdx]);
			client[kPendingIdx] -= client[kRunningIdx];
			client[kRunningIdx] = 0;
		}
	}
	function _resume(client, sync) {
		while (true) {
			if (client.destroyed) {
				assert$16(client[kPending] === 0);
				return;
			}
			if (client[kClosedResolve] && !client[kSize]) {
				client[kClosedResolve]();
				client[kClosedResolve] = null;
				return;
			}
			if (client[kHTTPContext]) client[kHTTPContext].resume();
			if (client[kBusy]) client[kNeedDrain] = 2;
			else if (client[kNeedDrain] === 2) {
				if (sync) {
					client[kNeedDrain] = 1;
					queueMicrotask(() => emitDrain(client));
				} else emitDrain(client);
				continue;
			}
			if (client[kPending] === 0) return;
			if (client[kRunning] >= (getPipelining(client) || 1)) return;
			const request = client[kQueue][client[kPendingIdx]];
			if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) {
				if (client[kRunning] > 0) return;
				client[kServerName] = request.servername;
				client[kHTTPContext]?.destroy(new InformationalError("servername changed"), () => {
					client[kHTTPContext] = null;
					resume(client);
				});
			}
			if (client[kConnecting]) return;
			if (!client[kHTTPContext]) {
				connect(client);
				return;
			}
			if (client[kHTTPContext].destroyed) return;
			if (client[kHTTPContext].busy(request)) return;
			if (!request.aborted && client[kHTTPContext].write(request)) client[kPendingIdx]++;
			else client[kQueue].splice(client[kPendingIdx], 1);
		}
	}
	module.exports = Client;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/fixed-queue.js
var require_fixed_queue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var kSize = 2048;
	var kMask = kSize - 1;
	var FixedCircularBuffer = class {
		constructor() {
			this.bottom = 0;
			this.top = 0;
			this.list = new Array(kSize);
			this.next = null;
		}
		isEmpty() {
			return this.top === this.bottom;
		}
		isFull() {
			return (this.top + 1 & kMask) === this.bottom;
		}
		push(data) {
			this.list[this.top] = data;
			this.top = this.top + 1 & kMask;
		}
		shift() {
			const nextItem = this.list[this.bottom];
			if (nextItem === void 0) return null;
			this.list[this.bottom] = void 0;
			this.bottom = this.bottom + 1 & kMask;
			return nextItem;
		}
	};
	module.exports = class FixedQueue {
		constructor() {
			this.head = this.tail = new FixedCircularBuffer();
		}
		isEmpty() {
			return this.head.isEmpty();
		}
		push(data) {
			if (this.head.isFull()) this.head = this.head.next = new FixedCircularBuffer();
			this.head.push(data);
		}
		shift() {
			const tail = this.tail;
			const next = tail.shift();
			if (tail.isEmpty() && tail.next !== null) this.tail = tail.next;
			return next;
		}
	};
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/pool-stats.js
var require_pool_stats = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols$4();
	var kPool = Symbol("pool");
	var PoolStats = class {
		constructor(pool) {
			this[kPool] = pool;
		}
		get connected() {
			return this[kPool][kConnected];
		}
		get free() {
			return this[kPool][kFree];
		}
		get pending() {
			return this[kPool][kPending];
		}
		get queued() {
			return this[kPool][kQueued];
		}
		get running() {
			return this[kPool][kRunning];
		}
		get size() {
			return this[kPool][kSize];
		}
	};
	module.exports = PoolStats;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/pool-base.js
var require_pool_base = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var DispatcherBase = require_dispatcher_base();
	var FixedQueue = require_fixed_queue();
	var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols$4();
	var PoolStats = require_pool_stats();
	var kClients = Symbol("clients");
	var kNeedDrain = Symbol("needDrain");
	var kQueue = Symbol("queue");
	var kClosedResolve = Symbol("closed resolve");
	var kOnDrain = Symbol("onDrain");
	var kOnConnect = Symbol("onConnect");
	var kOnDisconnect = Symbol("onDisconnect");
	var kOnConnectionError = Symbol("onConnectionError");
	var kGetDispatcher = Symbol("get dispatcher");
	var kAddClient = Symbol("add client");
	var kRemoveClient = Symbol("remove client");
	var kStats = Symbol("stats");
	var PoolBase = class extends DispatcherBase {
		constructor() {
			super();
			this[kQueue] = new FixedQueue();
			this[kClients] = [];
			this[kQueued] = 0;
			const pool = this;
			this[kOnDrain] = function onDrain(origin, targets) {
				const queue = pool[kQueue];
				let needDrain = false;
				while (!needDrain) {
					const item = queue.shift();
					if (!item) break;
					pool[kQueued]--;
					needDrain = !this.dispatch(item.opts, item.handler);
				}
				this[kNeedDrain] = needDrain;
				if (!this[kNeedDrain] && pool[kNeedDrain]) {
					pool[kNeedDrain] = false;
					pool.emit("drain", origin, [pool, ...targets]);
				}
				if (pool[kClosedResolve] && queue.isEmpty()) Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]);
			};
			this[kOnConnect] = (origin, targets) => {
				pool.emit("connect", origin, [pool, ...targets]);
			};
			this[kOnDisconnect] = (origin, targets, err) => {
				pool.emit("disconnect", origin, [pool, ...targets], err);
			};
			this[kOnConnectionError] = (origin, targets, err) => {
				pool.emit("connectionError", origin, [pool, ...targets], err);
			};
			this[kStats] = new PoolStats(this);
		}
		get [kBusy]() {
			return this[kNeedDrain];
		}
		get [kConnected]() {
			return this[kClients].filter((client) => client[kConnected]).length;
		}
		get [kFree]() {
			return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length;
		}
		get [kPending]() {
			let ret = this[kQueued];
			for (const { [kPending]: pending } of this[kClients]) ret += pending;
			return ret;
		}
		get [kRunning]() {
			let ret = 0;
			for (const { [kRunning]: running } of this[kClients]) ret += running;
			return ret;
		}
		get [kSize]() {
			let ret = this[kQueued];
			for (const { [kSize]: size } of this[kClients]) ret += size;
			return ret;
		}
		get stats() {
			return this[kStats];
		}
		async [kClose]() {
			if (this[kQueue].isEmpty()) await Promise.all(this[kClients].map((c) => c.close()));
			else await new Promise((resolve) => {
				this[kClosedResolve] = resolve;
			});
		}
		async [kDestroy](err) {
			while (true) {
				const item = this[kQueue].shift();
				if (!item) break;
				item.handler.onError(err);
			}
			await Promise.all(this[kClients].map((c) => c.destroy(err)));
		}
		[kDispatch](opts, handler) {
			const dispatcher = this[kGetDispatcher]();
			if (!dispatcher) {
				this[kNeedDrain] = true;
				this[kQueue].push({
					opts,
					handler
				});
				this[kQueued]++;
			} else if (!dispatcher.dispatch(opts, handler)) {
				dispatcher[kNeedDrain] = true;
				this[kNeedDrain] = !this[kGetDispatcher]();
			}
			return !this[kNeedDrain];
		}
		[kAddClient](client) {
			client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
			this[kClients].push(client);
			if (this[kNeedDrain]) queueMicrotask(() => {
				if (this[kNeedDrain]) this[kOnDrain](client[kUrl], [this, client]);
			});
			return this;
		}
		[kRemoveClient](client) {
			client.close(() => {
				const idx = this[kClients].indexOf(client);
				if (idx !== -1) this[kClients].splice(idx, 1);
			});
			this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
		}
	};
	module.exports = {
		PoolBase,
		kClients,
		kNeedDrain,
		kAddClient,
		kRemoveClient,
		kGetDispatcher
	};
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/pool.js
var require_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { PoolBase, kClients, kNeedDrain, kAddClient, kGetDispatcher } = require_pool_base();
	var Client = require_client();
	var { InvalidArgumentError } = require_errors();
	var util = require_util$8();
	var { kUrl, kInterceptors } = require_symbols$4();
	var buildConnector = require_connect();
	var kOptions = Symbol("options");
	var kConnections = Symbol("connections");
	var kFactory = Symbol("factory");
	function defaultFactory(origin, opts) {
		return new Client(origin, opts);
	}
	var Pool = class extends PoolBase {
		constructor(origin, { connections, factory = defaultFactory, connect, connectTimeout, tls, maxCachedSessions, socketPath, autoSelectFamily, autoSelectFamilyAttemptTimeout, allowH2, ...options } = {}) {
			super();
			if (connections != null && (!Number.isFinite(connections) || connections < 0)) throw new InvalidArgumentError("invalid connections");
			if (typeof factory !== "function") throw new InvalidArgumentError("factory must be a function.");
			if (connect != null && typeof connect !== "function" && typeof connect !== "object") throw new InvalidArgumentError("connect must be a function or an object");
			if (typeof connect !== "function") connect = buildConnector({
				...tls,
				maxCachedSessions,
				allowH2,
				socketPath,
				timeout: connectTimeout,
				...autoSelectFamily ? {
					autoSelectFamily,
					autoSelectFamilyAttemptTimeout
				} : void 0,
				...connect
			});
			this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : [];
			this[kConnections] = connections || null;
			this[kUrl] = util.parseOrigin(origin);
			this[kOptions] = {
				...util.deepClone(options),
				connect,
				allowH2
			};
			this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
			this[kFactory] = factory;
			this.on("connectionError", (origin, targets, error) => {
				for (const target of targets) {
					const idx = this[kClients].indexOf(target);
					if (idx !== -1) this[kClients].splice(idx, 1);
				}
			});
		}
		[kGetDispatcher]() {
			for (const client of this[kClients]) if (!client[kNeedDrain]) return client;
			if (!this[kConnections] || this[kClients].length < this[kConnections]) {
				const dispatcher = this[kFactory](this[kUrl], this[kOptions]);
				this[kAddClient](dispatcher);
				return dispatcher;
			}
		}
	};
	module.exports = Pool;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/balanced-pool.js
var require_balanced_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { BalancedPoolMissingUpstreamError, InvalidArgumentError } = require_errors();
	var { PoolBase, kClients, kNeedDrain, kAddClient, kRemoveClient, kGetDispatcher } = require_pool_base();
	var Pool = require_pool();
	var { kUrl, kInterceptors } = require_symbols$4();
	var { parseOrigin } = require_util$8();
	var kFactory = Symbol("factory");
	var kOptions = Symbol("options");
	var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor");
	var kCurrentWeight = Symbol("kCurrentWeight");
	var kIndex = Symbol("kIndex");
	var kWeight = Symbol("kWeight");
	var kMaxWeightPerServer = Symbol("kMaxWeightPerServer");
	var kErrorPenalty = Symbol("kErrorPenalty");
	/**
	* Calculate the greatest common divisor of two numbers by
	* using the Euclidean algorithm.
	*
	* @param {number} a
	* @param {number} b
	* @returns {number}
	*/
	function getGreatestCommonDivisor(a, b) {
		if (a === 0) return b;
		while (b !== 0) {
			const t = b;
			b = a % b;
			a = t;
		}
		return a;
	}
	function defaultFactory(origin, opts) {
		return new Pool(origin, opts);
	}
	var BalancedPool = class extends PoolBase {
		constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) {
			super();
			this[kOptions] = opts;
			this[kIndex] = -1;
			this[kCurrentWeight] = 0;
			this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100;
			this[kErrorPenalty] = this[kOptions].errorPenalty || 15;
			if (!Array.isArray(upstreams)) upstreams = [upstreams];
			if (typeof factory !== "function") throw new InvalidArgumentError("factory must be a function.");
			this[kInterceptors] = opts.interceptors?.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : [];
			this[kFactory] = factory;
			for (const upstream of upstreams) this.addUpstream(upstream);
			this._updateBalancedPoolStats();
		}
		addUpstream(upstream) {
			const upstreamOrigin = parseOrigin(upstream).origin;
			if (this[kClients].find((pool) => pool[kUrl].origin === upstreamOrigin && pool.closed !== true && pool.destroyed !== true)) return this;
			const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]));
			this[kAddClient](pool);
			pool.on("connect", () => {
				pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]);
			});
			pool.on("connectionError", () => {
				pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]);
				this._updateBalancedPoolStats();
			});
			pool.on("disconnect", (...args) => {
				const err = args[2];
				if (err && err.code === "UND_ERR_SOCKET") {
					pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]);
					this._updateBalancedPoolStats();
				}
			});
			for (const client of this[kClients]) client[kWeight] = this[kMaxWeightPerServer];
			this._updateBalancedPoolStats();
			return this;
		}
		_updateBalancedPoolStats() {
			let result = 0;
			for (let i = 0; i < this[kClients].length; i++) result = getGreatestCommonDivisor(this[kClients][i][kWeight], result);
			this[kGreatestCommonDivisor] = result;
		}
		removeUpstream(upstream) {
			const upstreamOrigin = parseOrigin(upstream).origin;
			const pool = this[kClients].find((pool) => pool[kUrl].origin === upstreamOrigin && pool.closed !== true && pool.destroyed !== true);
			if (pool) this[kRemoveClient](pool);
			return this;
		}
		get upstreams() {
			return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin);
		}
		[kGetDispatcher]() {
			if (this[kClients].length === 0) throw new BalancedPoolMissingUpstreamError();
			if (!this[kClients].find((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true)) return;
			if (this[kClients].map((pool) => pool[kNeedDrain]).reduce((a, b) => a && b, true)) return;
			let counter = 0;
			let maxWeightIndex = this[kClients].findIndex((pool) => !pool[kNeedDrain]);
			while (counter++ < this[kClients].length) {
				this[kIndex] = (this[kIndex] + 1) % this[kClients].length;
				const pool = this[kClients][this[kIndex]];
				if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) maxWeightIndex = this[kIndex];
				if (this[kIndex] === 0) {
					this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor];
					if (this[kCurrentWeight] <= 0) this[kCurrentWeight] = this[kMaxWeightPerServer];
				}
				if (pool[kWeight] >= this[kCurrentWeight] && !pool[kNeedDrain]) return pool;
			}
			this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight];
			this[kIndex] = maxWeightIndex;
			return this[kClients][maxWeightIndex];
		}
	};
	module.exports = BalancedPool;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/agent.js
var require_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { InvalidArgumentError } = require_errors();
	var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols$4();
	var DispatcherBase = require_dispatcher_base();
	var Pool = require_pool();
	var Client = require_client();
	var util = require_util$8();
	var createRedirectInterceptor = require_redirect_interceptor();
	var kOnConnect = Symbol("onConnect");
	var kOnDisconnect = Symbol("onDisconnect");
	var kOnConnectionError = Symbol("onConnectionError");
	var kMaxRedirections = Symbol("maxRedirections");
	var kOnDrain = Symbol("onDrain");
	var kFactory = Symbol("factory");
	var kOptions = Symbol("options");
	function defaultFactory(origin, opts) {
		return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
	}
	var Agent = class extends DispatcherBase {
		constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
			super();
			if (typeof factory !== "function") throw new InvalidArgumentError("factory must be a function.");
			if (connect != null && typeof connect !== "function" && typeof connect !== "object") throw new InvalidArgumentError("connect must be a function or an object");
			if (!Number.isInteger(maxRedirections) || maxRedirections < 0) throw new InvalidArgumentError("maxRedirections must be a positive number");
			if (connect && typeof connect !== "function") connect = { ...connect };
			this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })];
			this[kOptions] = {
				...util.deepClone(options),
				connect
			};
			this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
			this[kMaxRedirections] = maxRedirections;
			this[kFactory] = factory;
			this[kClients] = /* @__PURE__ */ new Map();
			this[kOnDrain] = (origin, targets) => {
				this.emit("drain", origin, [this, ...targets]);
			};
			this[kOnConnect] = (origin, targets) => {
				this.emit("connect", origin, [this, ...targets]);
			};
			this[kOnDisconnect] = (origin, targets, err) => {
				this.emit("disconnect", origin, [this, ...targets], err);
			};
			this[kOnConnectionError] = (origin, targets, err) => {
				this.emit("connectionError", origin, [this, ...targets], err);
			};
		}
		get [kRunning]() {
			let ret = 0;
			for (const client of this[kClients].values()) ret += client[kRunning];
			return ret;
		}
		[kDispatch](opts, handler) {
			let key;
			if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) key = String(opts.origin);
			else throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
			let dispatcher = this[kClients].get(key);
			if (!dispatcher) {
				dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
				this[kClients].set(key, dispatcher);
			}
			return dispatcher.dispatch(opts, handler);
		}
		async [kClose]() {
			const closePromises = [];
			for (const client of this[kClients].values()) closePromises.push(client.close());
			this[kClients].clear();
			await Promise.all(closePromises);
		}
		async [kDestroy](err) {
			const destroyPromises = [];
			for (const client of this[kClients].values()) destroyPromises.push(client.destroy(err));
			this[kClients].clear();
			await Promise.all(destroyPromises);
		}
	};
	module.exports = Agent;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/proxy-agent.js
var require_proxy_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kProxy, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols$4();
	var { URL: URL$1 } = __require("node:url");
	var Agent = require_agent();
	var Pool = require_pool();
	var DispatcherBase = require_dispatcher_base();
	var { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require_errors();
	var buildConnector = require_connect();
	var Client = require_client();
	var kAgent = Symbol("proxy agent");
	var kClient = Symbol("proxy client");
	var kProxyHeaders = Symbol("proxy headers");
	var kRequestTls = Symbol("request tls settings");
	var kProxyTls = Symbol("proxy tls settings");
	var kConnectEndpoint = Symbol("connect endpoint function");
	var kTunnelProxy = Symbol("tunnel proxy");
	function defaultProtocolPort(protocol) {
		return protocol === "https:" ? 443 : 80;
	}
	function defaultFactory(origin, opts) {
		return new Pool(origin, opts);
	}
	var noop = () => {};
	function defaultAgentFactory(origin, opts) {
		if (opts.connections === 1) return new Client(origin, opts);
		return new Pool(origin, opts);
	}
	var Http1ProxyWrapper = class extends DispatcherBase {
		#client;
		constructor(proxyUrl, { headers = {}, connect, factory }) {
			super();
			if (!proxyUrl) throw new InvalidArgumentError("Proxy URL is mandatory");
			this[kProxyHeaders] = headers;
			if (factory) this.#client = factory(proxyUrl, { connect });
			else this.#client = new Client(proxyUrl, { connect });
		}
		[kDispatch](opts, handler) {
			const onHeaders = handler.onHeaders;
			handler.onHeaders = function(statusCode, data, resume) {
				if (statusCode === 407) {
					if (typeof handler.onError === "function") handler.onError(new InvalidArgumentError("Proxy Authentication Required (407)"));
					return;
				}
				if (onHeaders) onHeaders.call(this, statusCode, data, resume);
			};
			const { origin, path = "/", headers = {} } = opts;
			opts.path = origin + path;
			if (!("host" in headers) && !("Host" in headers)) {
				const { host } = new URL$1(origin);
				headers.host = host;
			}
			opts.headers = {
				...this[kProxyHeaders],
				...headers
			};
			return this.#client[kDispatch](opts, handler);
		}
		async [kClose]() {
			return this.#client.close();
		}
		async [kDestroy](err) {
			return this.#client.destroy(err);
		}
	};
	var ProxyAgent = class extends DispatcherBase {
		constructor(opts) {
			super();
			if (!opts || typeof opts === "object" && !(opts instanceof URL$1) && !opts.uri) throw new InvalidArgumentError("Proxy uri is mandatory");
			const { clientFactory = defaultFactory } = opts;
			if (typeof clientFactory !== "function") throw new InvalidArgumentError("Proxy opts.clientFactory must be a function.");
			const { proxyTunnel = true } = opts;
			const url = this.#getUrl(opts);
			const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url;
			this[kProxy] = {
				uri: href,
				protocol
			};
			this[kInterceptors] = opts.interceptors?.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : [];
			this[kRequestTls] = opts.requestTls;
			this[kProxyTls] = opts.proxyTls;
			this[kProxyHeaders] = opts.headers || {};
			this[kTunnelProxy] = proxyTunnel;
			if (opts.auth && opts.token) throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token");
			else if (opts.auth) this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`;
			else if (opts.token) this[kProxyHeaders]["proxy-authorization"] = opts.token;
			else if (username && password) this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`;
			const connect = buildConnector({ ...opts.proxyTls });
			this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
			const agentFactory = opts.factory || defaultAgentFactory;
			const factory = (origin, options) => {
				const { protocol } = new URL$1(origin);
				if (!this[kTunnelProxy] && protocol === "http:" && this[kProxy].protocol === "http:") return new Http1ProxyWrapper(this[kProxy].uri, {
					headers: this[kProxyHeaders],
					connect,
					factory: agentFactory
				});
				return agentFactory(origin, options);
			};
			this[kClient] = clientFactory(url, { connect });
			this[kAgent] = new Agent({
				...opts,
				factory,
				connect: async (opts, callback) => {
					let requestedPath = opts.host;
					if (!opts.port) requestedPath += `:${defaultProtocolPort(opts.protocol)}`;
					try {
						const { socket, statusCode } = await this[kClient].connect({
							origin,
							port,
							path: requestedPath,
							signal: opts.signal,
							headers: {
								...this[kProxyHeaders],
								host: opts.host
							},
							servername: this[kProxyTls]?.servername || proxyHostname
						});
						if (statusCode !== 200) {
							socket.on("error", noop).destroy();
							callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`));
						}
						if (opts.protocol !== "https:") {
							callback(null, socket);
							return;
						}
						let servername;
						if (this[kRequestTls]) servername = this[kRequestTls].servername;
						else servername = opts.servername;
						this[kConnectEndpoint]({
							...opts,
							servername,
							httpSocket: socket
						}, callback);
					} catch (err) {
						if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") callback(new SecureProxyConnectionError(err));
						else callback(err);
					}
				}
			});
		}
		dispatch(opts, handler) {
			const headers = buildHeaders(opts.headers);
			throwIfProxyAuthIsSent(headers);
			if (headers && !("host" in headers) && !("Host" in headers)) {
				const { host } = new URL$1(opts.origin);
				headers.host = host;
			}
			return this[kAgent].dispatch({
				...opts,
				headers
			}, handler);
		}
		/**
		* @param {import('../types/proxy-agent').ProxyAgent.Options | string | URL} opts
		* @returns {URL}
		*/
		#getUrl(opts) {
			if (typeof opts === "string") return new URL$1(opts);
			else if (opts instanceof URL$1) return opts;
			else return new URL$1(opts.uri);
		}
		async [kClose]() {
			await this[kAgent].close();
			await this[kClient].close();
		}
		async [kDestroy]() {
			await this[kAgent].destroy();
			await this[kClient].destroy();
		}
	};
	/**
	* @param {string[] | Record<string, string>} headers
	* @returns {Record<string, string>}
	*/
	function buildHeaders(headers) {
		if (Array.isArray(headers)) {
			/** @type {Record<string, string>} */
			const headersPair = {};
			for (let i = 0; i < headers.length; i += 2) headersPair[headers[i]] = headers[i + 1];
			return headersPair;
		}
		return headers;
	}
	/**
	* @param {Record<string, string>} headers
	*
	* Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers
	* Nevertheless, it was changed and to avoid a security vulnerability by end users
	* this check was created.
	* It should be removed in the next major version for performance reasons
	*/
	function throwIfProxyAuthIsSent(headers) {
		if (headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization")) throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
	}
	module.exports = ProxyAgent;
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/env-http-proxy-agent.js
var require_env_http_proxy_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var DispatcherBase = require_dispatcher_base();
	var { kClose, kDestroy, kClosed, kDestroyed, kDispatch, kNoProxyAgent, kHttpProxyAgent, kHttpsProxyAgent } = require_symbols$4();
	var ProxyAgent = require_proxy_agent();
	var Agent = require_agent();
	var DEFAULT_PORTS = {
		"http:": 80,
		"https:": 443
	};
	var experimentalWarned = false;
	var EnvHttpProxyAgent = class extends DispatcherBase {
		#noProxyValue = null;
		#noProxyEntries = null;
		#opts = null;
		constructor(opts = {}) {
			super();
			this.#opts = opts;
			if (!experimentalWarned) {
				experimentalWarned = true;
				process.emitWarning("EnvHttpProxyAgent is experimental, expect them to change at any time.", { code: "UNDICI-EHPA" });
			}
			const { httpProxy, httpsProxy, noProxy, ...agentOpts } = opts;
			this[kNoProxyAgent] = new Agent(agentOpts);
			const HTTP_PROXY = httpProxy ?? process.env.http_proxy ?? process.env.HTTP_PROXY;
			if (HTTP_PROXY) this[kHttpProxyAgent] = new ProxyAgent({
				...agentOpts,
				uri: HTTP_PROXY
			});
			else this[kHttpProxyAgent] = this[kNoProxyAgent];
			const HTTPS_PROXY = httpsProxy ?? process.env.https_proxy ?? process.env.HTTPS_PROXY;
			if (HTTPS_PROXY) this[kHttpsProxyAgent] = new ProxyAgent({
				...agentOpts,
				uri: HTTPS_PROXY
			});
			else this[kHttpsProxyAgent] = this[kHttpProxyAgent];
			this.#parseNoProxy();
		}
		[kDispatch](opts, handler) {
			const url = new URL(opts.origin);
			return this.#getProxyAgentForUrl(url).dispatch(opts, handler);
		}
		async [kClose]() {
			await this[kNoProxyAgent].close();
			if (!this[kHttpProxyAgent][kClosed]) await this[kHttpProxyAgent].close();
			if (!this[kHttpsProxyAgent][kClosed]) await this[kHttpsProxyAgent].close();
		}
		async [kDestroy](err) {
			await this[kNoProxyAgent].destroy(err);
			if (!this[kHttpProxyAgent][kDestroyed]) await this[kHttpProxyAgent].destroy(err);
			if (!this[kHttpsProxyAgent][kDestroyed]) await this[kHttpsProxyAgent].destroy(err);
		}
		#getProxyAgentForUrl(url) {
			let { protocol, host: hostname, port } = url;
			hostname = hostname.replace(/:\d*$/, "").toLowerCase();
			port = Number.parseInt(port, 10) || DEFAULT_PORTS[protocol] || 0;
			if (!this.#shouldProxy(hostname, port)) return this[kNoProxyAgent];
			if (protocol === "https:") return this[kHttpsProxyAgent];
			return this[kHttpProxyAgent];
		}
		#shouldProxy(hostname, port) {
			if (this.#noProxyChanged) this.#parseNoProxy();
			if (this.#noProxyEntries.length === 0) return true;
			if (this.#noProxyValue === "*") return false;
			for (let i = 0; i < this.#noProxyEntries.length; i++) {
				const entry = this.#noProxyEntries[i];
				if (entry.port && entry.port !== port) continue;
				if (!/^[.*]/.test(entry.hostname)) {
					if (hostname === entry.hostname) return false;
				} else if (hostname.endsWith(entry.hostname.replace(/^\*/, ""))) return false;
			}
			return true;
		}
		#parseNoProxy() {
			const noProxyValue = this.#opts.noProxy ?? this.#noProxyEnv;
			const noProxySplit = noProxyValue.split(/[,\s]/);
			const noProxyEntries = [];
			for (let i = 0; i < noProxySplit.length; i++) {
				const entry = noProxySplit[i];
				if (!entry) continue;
				const parsed = entry.match(/^(.+):(\d+)$/);
				noProxyEntries.push({
					hostname: (parsed ? parsed[1] : entry).toLowerCase(),
					port: parsed ? Number.parseInt(parsed[2], 10) : 0
				});
			}
			this.#noProxyValue = noProxyValue;
			this.#noProxyEntries = noProxyEntries;
		}
		get #noProxyChanged() {
			if (this.#opts.noProxy !== void 0) return false;
			return this.#noProxyValue !== this.#noProxyEnv;
		}
		get #noProxyEnv() {
			return process.env.no_proxy ?? process.env.NO_PROXY ?? "";
		}
	};
	module.exports = EnvHttpProxyAgent;
}));
//#endregion
//#region node_modules/undici/lib/handler/retry-handler.js
var require_retry_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$15 = __require("node:assert");
	var { kRetryHandlerDefaultRetry } = require_symbols$4();
	var { RequestRetryError } = require_errors();
	var { isDisturbed, parseHeaders, parseRangeHeader, wrapRequestBody } = require_util$8();
	function calculateRetryAfterHeader(retryAfter) {
		const current = Date.now();
		return new Date(retryAfter).getTime() - current;
	}
	module.exports = class RetryHandler {
		constructor(opts, handlers) {
			const { retryOptions, ...dispatchOpts } = opts;
			const { retry: retryFn, maxRetries, maxTimeout, minTimeout, timeoutFactor, methods, errorCodes, retryAfter, statusCodes } = retryOptions ?? {};
			this.dispatch = handlers.dispatch;
			this.handler = handlers.handler;
			this.opts = {
				...dispatchOpts,
				body: wrapRequestBody(opts.body)
			};
			this.abort = null;
			this.aborted = false;
			this.retryOpts = {
				retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry],
				retryAfter: retryAfter ?? true,
				maxTimeout: maxTimeout ?? 30 * 1e3,
				minTimeout: minTimeout ?? 500,
				timeoutFactor: timeoutFactor ?? 2,
				maxRetries: maxRetries ?? 5,
				methods: methods ?? [
					"GET",
					"HEAD",
					"OPTIONS",
					"PUT",
					"DELETE",
					"TRACE"
				],
				statusCodes: statusCodes ?? [
					500,
					502,
					503,
					504,
					429
				],
				errorCodes: errorCodes ?? [
					"ECONNRESET",
					"ECONNREFUSED",
					"ENOTFOUND",
					"ENETDOWN",
					"ENETUNREACH",
					"EHOSTDOWN",
					"EHOSTUNREACH",
					"EPIPE",
					"UND_ERR_SOCKET"
				]
			};
			this.retryCount = 0;
			this.retryCountCheckpoint = 0;
			this.start = 0;
			this.end = null;
			this.etag = null;
			this.resume = null;
			this.handler.onConnect((reason) => {
				this.aborted = true;
				if (this.abort) this.abort(reason);
				else this.reason = reason;
			});
		}
		onRequestSent() {
			if (this.handler.onRequestSent) this.handler.onRequestSent();
		}
		onUpgrade(statusCode, headers, socket) {
			if (this.handler.onUpgrade) this.handler.onUpgrade(statusCode, headers, socket);
		}
		onConnect(abort) {
			if (this.aborted) abort(this.reason);
			else this.abort = abort;
		}
		onBodySent(chunk) {
			if (this.handler.onBodySent) return this.handler.onBodySent(chunk);
		}
		static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) {
			const { statusCode, code, headers } = err;
			const { method, retryOptions } = opts;
			const { maxRetries, minTimeout, maxTimeout, timeoutFactor, statusCodes, errorCodes, methods } = retryOptions;
			const { counter } = state;
			if (code && code !== "UND_ERR_REQ_RETRY" && !errorCodes.includes(code)) {
				cb(err);
				return;
			}
			if (Array.isArray(methods) && !methods.includes(method)) {
				cb(err);
				return;
			}
			if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) {
				cb(err);
				return;
			}
			if (counter > maxRetries) {
				cb(err);
				return;
			}
			let retryAfterHeader = headers?.["retry-after"];
			if (retryAfterHeader) {
				retryAfterHeader = Number(retryAfterHeader);
				retryAfterHeader = Number.isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3;
			}
			const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(minTimeout * timeoutFactor ** (counter - 1), maxTimeout);
			setTimeout(() => cb(null), retryTimeout);
		}
		onHeaders(statusCode, rawHeaders, resume, statusMessage) {
			const headers = parseHeaders(rawHeaders);
			this.retryCount += 1;
			if (statusCode >= 300) if (this.retryOpts.statusCodes.includes(statusCode) === false) return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage);
			else {
				this.abort(new RequestRetryError("Request failed", statusCode, {
					headers,
					data: { count: this.retryCount }
				}));
				return false;
			}
			if (this.resume != null) {
				this.resume = null;
				if (statusCode !== 206 && (this.start > 0 || statusCode !== 200)) {
					this.abort(new RequestRetryError("server does not support the range header and the payload was partially consumed", statusCode, {
						headers,
						data: { count: this.retryCount }
					}));
					return false;
				}
				const contentRange = parseRangeHeader(headers["content-range"]);
				if (!contentRange) {
					this.abort(new RequestRetryError("Content-Range mismatch", statusCode, {
						headers,
						data: { count: this.retryCount }
					}));
					return false;
				}
				if (this.etag != null && this.etag !== headers.etag) {
					this.abort(new RequestRetryError("ETag mismatch", statusCode, {
						headers,
						data: { count: this.retryCount }
					}));
					return false;
				}
				const { start, size, end = size - 1 } = contentRange;
				assert$15(this.start === start, "content-range mismatch");
				assert$15(this.end == null || this.end === end, "content-range mismatch");
				this.resume = resume;
				return true;
			}
			if (this.end == null) {
				if (statusCode === 206) {
					const range = parseRangeHeader(headers["content-range"]);
					if (range == null) return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage);
					const { start, size, end = size - 1 } = range;
					assert$15(start != null && Number.isFinite(start), "content-range mismatch");
					assert$15(end != null && Number.isFinite(end), "invalid content-length");
					this.start = start;
					this.end = end;
				}
				if (this.end == null) {
					const contentLength = headers["content-length"];
					this.end = contentLength != null ? Number(contentLength) - 1 : null;
				}
				assert$15(Number.isFinite(this.start));
				assert$15(this.end == null || Number.isFinite(this.end), "invalid content-length");
				this.resume = resume;
				this.etag = headers.etag != null ? headers.etag : null;
				if (this.etag != null && this.etag.startsWith("W/")) this.etag = null;
				return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage);
			}
			const err = new RequestRetryError("Request failed", statusCode, {
				headers,
				data: { count: this.retryCount }
			});
			this.abort(err);
			return false;
		}
		onData(chunk) {
			this.start += chunk.length;
			return this.handler.onData(chunk);
		}
		onComplete(rawTrailers) {
			this.retryCount = 0;
			return this.handler.onComplete(rawTrailers);
		}
		onError(err) {
			if (this.aborted || isDisturbed(this.opts.body)) return this.handler.onError(err);
			if (this.retryCount - this.retryCountCheckpoint > 0) this.retryCount = this.retryCountCheckpoint + (this.retryCount - this.retryCountCheckpoint);
			else this.retryCount += 1;
			this.retryOpts.retry(err, {
				state: { counter: this.retryCount },
				opts: {
					retryOptions: this.retryOpts,
					...this.opts
				}
			}, onRetry.bind(this));
			function onRetry(err) {
				if (err != null || this.aborted || isDisturbed(this.opts.body)) return this.handler.onError(err);
				if (this.start !== 0) {
					const headers = { range: `bytes=${this.start}-${this.end ?? ""}` };
					if (this.etag != null) headers["if-match"] = this.etag;
					this.opts = {
						...this.opts,
						headers: {
							...this.opts.headers,
							...headers
						}
					};
				}
				try {
					this.retryCountCheckpoint = this.retryCount;
					this.dispatch(this.opts, this);
				} catch (err) {
					this.handler.onError(err);
				}
			}
		}
	};
}));
//#endregion
//#region node_modules/undici/lib/dispatcher/retry-agent.js
var require_retry_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var Dispatcher = require_dispatcher();
	var RetryHandler = require_retry_handler();
	var RetryAgent = class extends Dispatcher {
		#agent = null;
		#options = null;
		constructor(agent, options = {}) {
			super(options);
			this.#agent = agent;
			this.#options = options;
		}
		dispatch(opts, handler) {
			const retry = new RetryHandler({
				...opts,
				retryOptions: this.#options
			}, {
				dispatch: this.#agent.dispatch.bind(this.#agent),
				handler
			});
			return this.#agent.dispatch(opts, retry);
		}
		close() {
			return this.#agent.close();
		}
		destroy() {
			return this.#agent.destroy();
		}
	};
	module.exports = RetryAgent;
}));
//#endregion
//#region node_modules/undici/lib/api/readable.js
var require_readable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$14 = __require("node:assert");
	var { Readable: Readable$2 } = __require("node:stream");
	var { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require_errors();
	var util = require_util$8();
	var { ReadableStreamFrom } = require_util$8();
	var kConsume = Symbol("kConsume");
	var kReading = Symbol("kReading");
	var kBody = Symbol("kBody");
	var kAbort = Symbol("kAbort");
	var kContentType = Symbol("kContentType");
	var kContentLength = Symbol("kContentLength");
	var noop = () => {};
	var BodyReadable = class extends Readable$2 {
		constructor({ resume, abort, contentType = "", contentLength, highWaterMark = 64 * 1024 }) {
			super({
				autoDestroy: true,
				read: resume,
				highWaterMark
			});
			this._readableState.dataEmitted = false;
			this[kAbort] = abort;
			this[kConsume] = null;
			this[kBody] = null;
			this[kContentType] = contentType;
			this[kContentLength] = contentLength;
			this[kReading] = false;
		}
		destroy(err) {
			if (!err && !this._readableState.endEmitted) err = new RequestAbortedError();
			if (err) this[kAbort]();
			return super.destroy(err);
		}
		_destroy(err, callback) {
			if (!this[kReading]) setImmediate(() => {
				callback(err);
			});
			else callback(err);
		}
		on(ev, ...args) {
			if (ev === "data" || ev === "readable") this[kReading] = true;
			return super.on(ev, ...args);
		}
		addListener(ev, ...args) {
			return this.on(ev, ...args);
		}
		off(ev, ...args) {
			const ret = super.off(ev, ...args);
			if (ev === "data" || ev === "readable") this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0;
			return ret;
		}
		removeListener(ev, ...args) {
			return this.off(ev, ...args);
		}
		push(chunk) {
			if (this[kConsume] && chunk !== null) {
				consumePush(this[kConsume], chunk);
				return this[kReading] ? super.push(chunk) : true;
			}
			return super.push(chunk);
		}
		async text() {
			return consume(this, "text");
		}
		async json() {
			return consume(this, "json");
		}
		async blob() {
			return consume(this, "blob");
		}
		async bytes() {
			return consume(this, "bytes");
		}
		async arrayBuffer() {
			return consume(this, "arrayBuffer");
		}
		async formData() {
			throw new NotSupportedError();
		}
		get bodyUsed() {
			return util.isDisturbed(this);
		}
		get body() {
			if (!this[kBody]) {
				this[kBody] = ReadableStreamFrom(this);
				if (this[kConsume]) {
					this[kBody].getReader();
					assert$14(this[kBody].locked);
				}
			}
			return this[kBody];
		}
		async dump(opts) {
			let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024;
			const signal = opts?.signal;
			if (signal != null && (typeof signal !== "object" || !("aborted" in signal))) throw new InvalidArgumentError("signal must be an AbortSignal");
			signal?.throwIfAborted();
			if (this._readableState.closeEmitted) return null;
			return await new Promise((resolve, reject) => {
				if (this[kContentLength] > limit) this.destroy(new AbortError());
				const onAbort = () => {
					this.destroy(signal.reason ?? new AbortError());
				};
				signal?.addEventListener("abort", onAbort);
				this.on("close", function() {
					signal?.removeEventListener("abort", onAbort);
					if (signal?.aborted) reject(signal.reason ?? new AbortError());
					else resolve(null);
				}).on("error", noop).on("data", function(chunk) {
					limit -= chunk.length;
					if (limit <= 0) this.destroy();
				}).resume();
			});
		}
	};
	function isLocked(self) {
		return self[kBody] && self[kBody].locked === true || self[kConsume];
	}
	function isUnusable(self) {
		return util.isDisturbed(self) || isLocked(self);
	}
	async function consume(stream, type) {
		assert$14(!stream[kConsume]);
		return new Promise((resolve, reject) => {
			if (isUnusable(stream)) {
				const rState = stream._readableState;
				if (rState.destroyed && rState.closeEmitted === false) stream.on("error", (err) => {
					reject(err);
				}).on("close", () => {
					reject(/* @__PURE__ */ new TypeError("unusable"));
				});
				else reject(rState.errored ?? /* @__PURE__ */ new TypeError("unusable"));
			} else queueMicrotask(() => {
				stream[kConsume] = {
					type,
					stream,
					resolve,
					reject,
					length: 0,
					body: []
				};
				stream.on("error", function(err) {
					consumeFinish(this[kConsume], err);
				}).on("close", function() {
					if (this[kConsume].body !== null) consumeFinish(this[kConsume], new RequestAbortedError());
				});
				consumeStart(stream[kConsume]);
			});
		});
	}
	function consumeStart(consume) {
		if (consume.body === null) return;
		const { _readableState: state } = consume.stream;
		if (state.bufferIndex) {
			const start = state.bufferIndex;
			const end = state.buffer.length;
			for (let n = start; n < end; n++) consumePush(consume, state.buffer[n]);
		} else for (const chunk of state.buffer) consumePush(consume, chunk);
		if (state.endEmitted) consumeEnd(this[kConsume]);
		else consume.stream.on("end", function() {
			consumeEnd(this[kConsume]);
		});
		consume.stream.resume();
		while (consume.stream.read() != null);
	}
	/**
	* @param {Buffer[]} chunks
	* @param {number} length
	*/
	function chunksDecode(chunks, length) {
		if (chunks.length === 0 || length === 0) return "";
		const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length);
		const bufferLength = buffer.length;
		const start = bufferLength > 2 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191 ? 3 : 0;
		return buffer.utf8Slice(start, bufferLength);
	}
	/**
	* @param {Buffer[]} chunks
	* @param {number} length
	* @returns {Uint8Array}
	*/
	function chunksConcat(chunks, length) {
		if (chunks.length === 0 || length === 0) return new Uint8Array(0);
		if (chunks.length === 1) return new Uint8Array(chunks[0]);
		const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer);
		let offset = 0;
		for (let i = 0; i < chunks.length; ++i) {
			const chunk = chunks[i];
			buffer.set(chunk, offset);
			offset += chunk.length;
		}
		return buffer;
	}
	function consumeEnd(consume) {
		const { type, body, resolve, stream, length } = consume;
		try {
			if (type === "text") resolve(chunksDecode(body, length));
			else if (type === "json") resolve(JSON.parse(chunksDecode(body, length)));
			else if (type === "arrayBuffer") resolve(chunksConcat(body, length).buffer);
			else if (type === "blob") resolve(new Blob(body, { type: stream[kContentType] }));
			else if (type === "bytes") resolve(chunksConcat(body, length));
			consumeFinish(consume);
		} catch (err) {
			stream.destroy(err);
		}
	}
	function consumePush(consume, chunk) {
		consume.length += chunk.length;
		consume.body.push(chunk);
	}
	function consumeFinish(consume, err) {
		if (consume.body === null) return;
		if (err) consume.reject(err);
		else consume.resolve();
		consume.type = null;
		consume.stream = null;
		consume.resolve = null;
		consume.reject = null;
		consume.length = 0;
		consume.body = null;
	}
	module.exports = {
		Readable: BodyReadable,
		chunksDecode
	};
}));
//#endregion
//#region node_modules/undici/lib/api/util.js
var require_util$6 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$13 = __require("node:assert");
	var { ResponseStatusCodeError } = require_errors();
	var { chunksDecode } = require_readable();
	var CHUNK_LIMIT = 128 * 1024;
	async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) {
		assert$13(body);
		let chunks = [];
		let length = 0;
		try {
			for await (const chunk of body) {
				chunks.push(chunk);
				length += chunk.length;
				if (length > CHUNK_LIMIT) {
					chunks = [];
					length = 0;
					break;
				}
			}
		} catch {
			chunks = [];
			length = 0;
		}
		const message = `Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`;
		if (statusCode === 204 || !contentType || !length) {
			queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers)));
			return;
		}
		const stackTraceLimit = Error.stackTraceLimit;
		Error.stackTraceLimit = 0;
		let payload;
		try {
			if (isContentTypeApplicationJson(contentType)) payload = JSON.parse(chunksDecode(chunks, length));
			else if (isContentTypeText(contentType)) payload = chunksDecode(chunks, length);
		} catch {} finally {
			Error.stackTraceLimit = stackTraceLimit;
		}
		queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers, payload)));
	}
	var isContentTypeApplicationJson = (contentType) => {
		return contentType.length > 15 && contentType[11] === "/" && contentType[0] === "a" && contentType[1] === "p" && contentType[2] === "p" && contentType[3] === "l" && contentType[4] === "i" && contentType[5] === "c" && contentType[6] === "a" && contentType[7] === "t" && contentType[8] === "i" && contentType[9] === "o" && contentType[10] === "n" && contentType[12] === "j" && contentType[13] === "s" && contentType[14] === "o" && contentType[15] === "n";
	};
	var isContentTypeText = (contentType) => {
		return contentType.length > 4 && contentType[4] === "/" && contentType[0] === "t" && contentType[1] === "e" && contentType[2] === "x" && contentType[3] === "t";
	};
	module.exports = {
		getResolveErrorBodyCallback,
		isContentTypeApplicationJson,
		isContentTypeText
	};
}));
//#endregion
//#region node_modules/undici/lib/api/api-request.js
var require_api_request = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$12 = __require("node:assert");
	var { Readable } = require_readable();
	var { InvalidArgumentError, RequestAbortedError } = require_errors();
	var util = require_util$8();
	var { getResolveErrorBodyCallback } = require_util$6();
	var { AsyncResource: AsyncResource$4 } = __require("node:async_hooks");
	var RequestHandler = class extends AsyncResource$4 {
		constructor(opts, callback) {
			if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts");
			const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts;
			try {
				if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback");
				if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) throw new InvalidArgumentError("invalid highWaterMark");
				if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
				if (method === "CONNECT") throw new InvalidArgumentError("invalid method");
				if (onInfo && typeof onInfo !== "function") throw new InvalidArgumentError("invalid onInfo callback");
				super("UNDICI_REQUEST");
			} catch (err) {
				if (util.isStream(body)) util.destroy(body.on("error", util.nop), err);
				throw err;
			}
			this.method = method;
			this.responseHeaders = responseHeaders || null;
			this.opaque = opaque || null;
			this.callback = callback;
			this.res = null;
			this.abort = null;
			this.body = body;
			this.trailers = {};
			this.context = null;
			this.onInfo = onInfo || null;
			this.throwOnError = throwOnError;
			this.highWaterMark = highWaterMark;
			this.signal = signal;
			this.reason = null;
			this.removeAbortListener = null;
			if (util.isStream(body)) body.on("error", (err) => {
				this.onError(err);
			});
			if (this.signal) if (this.signal.aborted) this.reason = this.signal.reason ?? new RequestAbortedError();
			else this.removeAbortListener = util.addAbortListener(this.signal, () => {
				this.reason = this.signal.reason ?? new RequestAbortedError();
				if (this.res) util.destroy(this.res.on("error", util.nop), this.reason);
				else if (this.abort) this.abort(this.reason);
				if (this.removeAbortListener) {
					this.res?.off("close", this.removeAbortListener);
					this.removeAbortListener();
					this.removeAbortListener = null;
				}
			});
		}
		onConnect(abort, context) {
			if (this.reason) {
				abort(this.reason);
				return;
			}
			assert$12(this.callback);
			this.abort = abort;
			this.context = context;
		}
		onHeaders(statusCode, rawHeaders, resume, statusMessage) {
			const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this;
			const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
			if (statusCode < 200) {
				if (this.onInfo) this.onInfo({
					statusCode,
					headers
				});
				return;
			}
			const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers;
			const contentType = parsedHeaders["content-type"];
			const contentLength = parsedHeaders["content-length"];
			const res = new Readable({
				resume,
				abort,
				contentType,
				contentLength: this.method !== "HEAD" && contentLength ? Number(contentLength) : null,
				highWaterMark
			});
			if (this.removeAbortListener) res.on("close", this.removeAbortListener);
			this.callback = null;
			this.res = res;
			if (callback !== null) if (this.throwOnError && statusCode >= 400) this.runInAsyncScope(getResolveErrorBodyCallback, null, {
				callback,
				body: res,
				contentType,
				statusCode,
				statusMessage,
				headers
			});
			else this.runInAsyncScope(callback, null, null, {
				statusCode,
				headers,
				trailers: this.trailers,
				opaque,
				body: res,
				context
			});
		}
		onData(chunk) {
			return this.res.push(chunk);
		}
		onComplete(trailers) {
			util.parseHeaders(trailers, this.trailers);
			this.res.push(null);
		}
		onError(err) {
			const { res, callback, body, opaque } = this;
			if (callback) {
				this.callback = null;
				queueMicrotask(() => {
					this.runInAsyncScope(callback, null, err, { opaque });
				});
			}
			if (res) {
				this.res = null;
				queueMicrotask(() => {
					util.destroy(res, err);
				});
			}
			if (body) {
				this.body = null;
				util.destroy(body, err);
			}
			if (this.removeAbortListener) {
				res?.off("close", this.removeAbortListener);
				this.removeAbortListener();
				this.removeAbortListener = null;
			}
		}
	};
	function request(opts, callback) {
		if (callback === void 0) return new Promise((resolve, reject) => {
			request.call(this, opts, (err, data) => {
				return err ? reject(err) : resolve(data);
			});
		});
		try {
			this.dispatch(opts, new RequestHandler(opts, callback));
		} catch (err) {
			if (typeof callback !== "function") throw err;
			const opaque = opts?.opaque;
			queueMicrotask(() => callback(err, { opaque }));
		}
	}
	module.exports = request;
	module.exports.RequestHandler = RequestHandler;
}));
//#endregion
//#region node_modules/undici/lib/api/abort-signal.js
var require_abort_signal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { addAbortListener } = require_util$8();
	var { RequestAbortedError } = require_errors();
	var kListener = Symbol("kListener");
	var kSignal = Symbol("kSignal");
	function abort(self) {
		if (self.abort) self.abort(self[kSignal]?.reason);
		else self.reason = self[kSignal]?.reason ?? new RequestAbortedError();
		removeSignal(self);
	}
	function addSignal(self, signal) {
		self.reason = null;
		self[kSignal] = null;
		self[kListener] = null;
		if (!signal) return;
		if (signal.aborted) {
			abort(self);
			return;
		}
		self[kSignal] = signal;
		self[kListener] = () => {
			abort(self);
		};
		addAbortListener(self[kSignal], self[kListener]);
	}
	function removeSignal(self) {
		if (!self[kSignal]) return;
		if ("removeEventListener" in self[kSignal]) self[kSignal].removeEventListener("abort", self[kListener]);
		else self[kSignal].removeListener("abort", self[kListener]);
		self[kSignal] = null;
		self[kListener] = null;
	}
	module.exports = {
		addSignal,
		removeSignal
	};
}));
//#endregion
//#region node_modules/undici/lib/api/api-stream.js
var require_api_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$11 = __require("node:assert");
	var { finished: finished$1, PassThrough: PassThrough$1 } = __require("node:stream");
	var { InvalidArgumentError, InvalidReturnValueError } = require_errors();
	var util = require_util$8();
	var { getResolveErrorBodyCallback } = require_util$6();
	var { AsyncResource: AsyncResource$3 } = __require("node:async_hooks");
	var { addSignal, removeSignal } = require_abort_signal();
	var StreamHandler = class extends AsyncResource$3 {
		constructor(opts, factory, callback) {
			if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts");
			const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts;
			try {
				if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback");
				if (typeof factory !== "function") throw new InvalidArgumentError("invalid factory");
				if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
				if (method === "CONNECT") throw new InvalidArgumentError("invalid method");
				if (onInfo && typeof onInfo !== "function") throw new InvalidArgumentError("invalid onInfo callback");
				super("UNDICI_STREAM");
			} catch (err) {
				if (util.isStream(body)) util.destroy(body.on("error", util.nop), err);
				throw err;
			}
			this.responseHeaders = responseHeaders || null;
			this.opaque = opaque || null;
			this.factory = factory;
			this.callback = callback;
			this.res = null;
			this.abort = null;
			this.context = null;
			this.trailers = null;
			this.body = body;
			this.onInfo = onInfo || null;
			this.throwOnError = throwOnError || false;
			if (util.isStream(body)) body.on("error", (err) => {
				this.onError(err);
			});
			addSignal(this, signal);
		}
		onConnect(abort, context) {
			if (this.reason) {
				abort(this.reason);
				return;
			}
			assert$11(this.callback);
			this.abort = abort;
			this.context = context;
		}
		onHeaders(statusCode, rawHeaders, resume, statusMessage) {
			const { factory, opaque, context, callback, responseHeaders } = this;
			const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
			if (statusCode < 200) {
				if (this.onInfo) this.onInfo({
					statusCode,
					headers
				});
				return;
			}
			this.factory = null;
			let res;
			if (this.throwOnError && statusCode >= 400) {
				const contentType = (responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers)["content-type"];
				res = new PassThrough$1();
				this.callback = null;
				this.runInAsyncScope(getResolveErrorBodyCallback, null, {
					callback,
					body: res,
					contentType,
					statusCode,
					statusMessage,
					headers
				});
			} else {
				if (factory === null) return;
				res = this.runInAsyncScope(factory, null, {
					statusCode,
					headers,
					opaque,
					context
				});
				if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") throw new InvalidReturnValueError("expected Writable");
				finished$1(res, { readable: false }, (err) => {
					const { callback, res, opaque, trailers, abort } = this;
					this.res = null;
					if (err || !res.readable) util.destroy(res, err);
					this.callback = null;
					this.runInAsyncScope(callback, null, err || null, {
						opaque,
						trailers
					});
					if (err) abort();
				});
			}
			res.on("drain", resume);
			this.res = res;
			return (res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState?.needDrain) !== true;
		}
		onData(chunk) {
			const { res } = this;
			return res ? res.write(chunk) : true;
		}
		onComplete(trailers) {
			const { res } = this;
			removeSignal(this);
			if (!res) return;
			this.trailers = util.parseHeaders(trailers);
			res.end();
		}
		onError(err) {
			const { res, callback, opaque, body } = this;
			removeSignal(this);
			this.factory = null;
			if (res) {
				this.res = null;
				util.destroy(res, err);
			} else if (callback) {
				this.callback = null;
				queueMicrotask(() => {
					this.runInAsyncScope(callback, null, err, { opaque });
				});
			}
			if (body) {
				this.body = null;
				util.destroy(body, err);
			}
		}
	};
	function stream(opts, factory, callback) {
		if (callback === void 0) return new Promise((resolve, reject) => {
			stream.call(this, opts, factory, (err, data) => {
				return err ? reject(err) : resolve(data);
			});
		});
		try {
			this.dispatch(opts, new StreamHandler(opts, factory, callback));
		} catch (err) {
			if (typeof callback !== "function") throw err;
			const opaque = opts?.opaque;
			queueMicrotask(() => callback(err, { opaque }));
		}
	}
	module.exports = stream;
}));
//#endregion
//#region node_modules/undici/lib/api/api-pipeline.js
var require_api_pipeline = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Readable: Readable$1, Duplex, PassThrough } = __require("node:stream");
	var { InvalidArgumentError, InvalidReturnValueError, RequestAbortedError } = require_errors();
	var util = require_util$8();
	var { AsyncResource: AsyncResource$2 } = __require("node:async_hooks");
	var { addSignal, removeSignal } = require_abort_signal();
	var assert$10 = __require("node:assert");
	var kResume = Symbol("resume");
	var PipelineRequest = class extends Readable$1 {
		constructor() {
			super({ autoDestroy: true });
			this[kResume] = null;
		}
		_read() {
			const { [kResume]: resume } = this;
			if (resume) {
				this[kResume] = null;
				resume();
			}
		}
		_destroy(err, callback) {
			this._read();
			callback(err);
		}
	};
	var PipelineResponse = class extends Readable$1 {
		constructor(resume) {
			super({ autoDestroy: true });
			this[kResume] = resume;
		}
		_read() {
			this[kResume]();
		}
		_destroy(err, callback) {
			if (!err && !this._readableState.endEmitted) err = new RequestAbortedError();
			callback(err);
		}
	};
	var PipelineHandler = class extends AsyncResource$2 {
		constructor(opts, handler) {
			if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts");
			if (typeof handler !== "function") throw new InvalidArgumentError("invalid handler");
			const { signal, method, opaque, onInfo, responseHeaders } = opts;
			if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
			if (method === "CONNECT") throw new InvalidArgumentError("invalid method");
			if (onInfo && typeof onInfo !== "function") throw new InvalidArgumentError("invalid onInfo callback");
			super("UNDICI_PIPELINE");
			this.opaque = opaque || null;
			this.responseHeaders = responseHeaders || null;
			this.handler = handler;
			this.abort = null;
			this.context = null;
			this.onInfo = onInfo || null;
			this.req = new PipelineRequest().on("error", util.nop);
			this.ret = new Duplex({
				readableObjectMode: opts.objectMode,
				autoDestroy: true,
				read: () => {
					const { body } = this;
					if (body?.resume) body.resume();
				},
				write: (chunk, encoding, callback) => {
					const { req } = this;
					if (req.push(chunk, encoding) || req._readableState.destroyed) callback();
					else req[kResume] = callback;
				},
				destroy: (err, callback) => {
					const { body, req, res, ret, abort } = this;
					if (!err && !ret._readableState.endEmitted) err = new RequestAbortedError();
					if (abort && err) abort();
					util.destroy(body, err);
					util.destroy(req, err);
					util.destroy(res, err);
					removeSignal(this);
					callback(err);
				}
			}).on("prefinish", () => {
				const { req } = this;
				req.push(null);
			});
			this.res = null;
			addSignal(this, signal);
		}
		onConnect(abort, context) {
			const { ret, res } = this;
			if (this.reason) {
				abort(this.reason);
				return;
			}
			assert$10(!res, "pipeline cannot be retried");
			assert$10(!ret.destroyed);
			this.abort = abort;
			this.context = context;
		}
		onHeaders(statusCode, rawHeaders, resume) {
			const { opaque, handler, context } = this;
			if (statusCode < 200) {
				if (this.onInfo) {
					const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
					this.onInfo({
						statusCode,
						headers
					});
				}
				return;
			}
			this.res = new PipelineResponse(resume);
			let body;
			try {
				this.handler = null;
				const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
				body = this.runInAsyncScope(handler, null, {
					statusCode,
					headers,
					opaque,
					body: this.res,
					context
				});
			} catch (err) {
				this.res.on("error", util.nop);
				throw err;
			}
			if (!body || typeof body.on !== "function") throw new InvalidReturnValueError("expected Readable");
			body.on("data", (chunk) => {
				const { ret, body } = this;
				if (!ret.push(chunk) && body.pause) body.pause();
			}).on("error", (err) => {
				const { ret } = this;
				util.destroy(ret, err);
			}).on("end", () => {
				const { ret } = this;
				ret.push(null);
			}).on("close", () => {
				const { ret } = this;
				if (!ret._readableState.ended) util.destroy(ret, new RequestAbortedError());
			});
			this.body = body;
		}
		onData(chunk) {
			const { res } = this;
			return res.push(chunk);
		}
		onComplete(trailers) {
			const { res } = this;
			res.push(null);
		}
		onError(err) {
			const { ret } = this;
			this.handler = null;
			util.destroy(ret, err);
		}
	};
	function pipeline(opts, handler) {
		try {
			const pipelineHandler = new PipelineHandler(opts, handler);
			this.dispatch({
				...opts,
				body: pipelineHandler.req
			}, pipelineHandler);
			return pipelineHandler.ret;
		} catch (err) {
			return new PassThrough().destroy(err);
		}
	}
	module.exports = pipeline;
}));
//#endregion
//#region node_modules/undici/lib/api/api-upgrade.js
var require_api_upgrade = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { InvalidArgumentError, SocketError } = require_errors();
	var { AsyncResource: AsyncResource$1 } = __require("node:async_hooks");
	var util = require_util$8();
	var { addSignal, removeSignal } = require_abort_signal();
	var assert$9 = __require("node:assert");
	var UpgradeHandler = class extends AsyncResource$1 {
		constructor(opts, callback) {
			if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts");
			if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback");
			const { signal, opaque, responseHeaders } = opts;
			if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
			super("UNDICI_UPGRADE");
			this.responseHeaders = responseHeaders || null;
			this.opaque = opaque || null;
			this.callback = callback;
			this.abort = null;
			this.context = null;
			addSignal(this, signal);
		}
		onConnect(abort, context) {
			if (this.reason) {
				abort(this.reason);
				return;
			}
			assert$9(this.callback);
			this.abort = abort;
			this.context = null;
		}
		onHeaders() {
			throw new SocketError("bad upgrade", null);
		}
		onUpgrade(statusCode, rawHeaders, socket) {
			assert$9(statusCode === 101);
			const { callback, opaque, context } = this;
			removeSignal(this);
			this.callback = null;
			const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
			this.runInAsyncScope(callback, null, null, {
				headers,
				socket,
				opaque,
				context
			});
		}
		onError(err) {
			const { callback, opaque } = this;
			removeSignal(this);
			if (callback) {
				this.callback = null;
				queueMicrotask(() => {
					this.runInAsyncScope(callback, null, err, { opaque });
				});
			}
		}
	};
	function upgrade(opts, callback) {
		if (callback === void 0) return new Promise((resolve, reject) => {
			upgrade.call(this, opts, (err, data) => {
				return err ? reject(err) : resolve(data);
			});
		});
		try {
			const upgradeHandler = new UpgradeHandler(opts, callback);
			this.dispatch({
				...opts,
				method: opts.method || "GET",
				upgrade: opts.protocol || "Websocket"
			}, upgradeHandler);
		} catch (err) {
			if (typeof callback !== "function") throw err;
			const opaque = opts?.opaque;
			queueMicrotask(() => callback(err, { opaque }));
		}
	}
	module.exports = upgrade;
}));
//#endregion
//#region node_modules/undici/lib/api/api-connect.js
var require_api_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$8 = __require("node:assert");
	var { AsyncResource } = __require("node:async_hooks");
	var { InvalidArgumentError, SocketError } = require_errors();
	var util = require_util$8();
	var { addSignal, removeSignal } = require_abort_signal();
	var ConnectHandler = class extends AsyncResource {
		constructor(opts, callback) {
			if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts");
			if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback");
			const { signal, opaque, responseHeaders } = opts;
			if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
			super("UNDICI_CONNECT");
			this.opaque = opaque || null;
			this.responseHeaders = responseHeaders || null;
			this.callback = callback;
			this.abort = null;
			addSignal(this, signal);
		}
		onConnect(abort, context) {
			if (this.reason) {
				abort(this.reason);
				return;
			}
			assert$8(this.callback);
			this.abort = abort;
			this.context = context;
		}
		onHeaders() {
			throw new SocketError("bad connect", null);
		}
		onUpgrade(statusCode, rawHeaders, socket) {
			const { callback, opaque, context } = this;
			removeSignal(this);
			this.callback = null;
			let headers = rawHeaders;
			if (headers != null) headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
			this.runInAsyncScope(callback, null, null, {
				statusCode,
				headers,
				socket,
				opaque,
				context
			});
		}
		onError(err) {
			const { callback, opaque } = this;
			removeSignal(this);
			if (callback) {
				this.callback = null;
				queueMicrotask(() => {
					this.runInAsyncScope(callback, null, err, { opaque });
				});
			}
		}
	};
	function connect(opts, callback) {
		if (callback === void 0) return new Promise((resolve, reject) => {
			connect.call(this, opts, (err, data) => {
				return err ? reject(err) : resolve(data);
			});
		});
		try {
			const connectHandler = new ConnectHandler(opts, callback);
			this.dispatch({
				...opts,
				method: "CONNECT"
			}, connectHandler);
		} catch (err) {
			if (typeof callback !== "function") throw err;
			const opaque = opts?.opaque;
			queueMicrotask(() => callback(err, { opaque }));
		}
	}
	module.exports = connect;
}));
//#endregion
//#region node_modules/undici/lib/api/index.js
var require_api = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports.request = require_api_request();
	module.exports.stream = require_api_stream();
	module.exports.pipeline = require_api_pipeline();
	module.exports.upgrade = require_api_upgrade();
	module.exports.connect = require_api_connect();
}));
//#endregion
//#region node_modules/undici/lib/mock/mock-errors.js
var require_mock_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { UndiciError } = require_errors();
	var kMockNotMatchedError = Symbol.for("undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED");
	module.exports = { MockNotMatchedError: class MockNotMatchedError extends UndiciError {
		constructor(message) {
			super(message);
			Error.captureStackTrace(this, MockNotMatchedError);
			this.name = "MockNotMatchedError";
			this.message = message || "The request does not match any registered mock dispatches";
			this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED";
		}
		static [Symbol.hasInstance](instance) {
			return instance && instance[kMockNotMatchedError] === true;
		}
		[kMockNotMatchedError] = true;
	} };
}));
//#endregion
//#region node_modules/undici/lib/mock/mock-symbols.js
var require_mock_symbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = {
		kAgent: Symbol("agent"),
		kOptions: Symbol("options"),
		kFactory: Symbol("factory"),
		kDispatches: Symbol("dispatches"),
		kDispatchKey: Symbol("dispatch key"),
		kDefaultHeaders: Symbol("default headers"),
		kDefaultTrailers: Symbol("default trailers"),
		kContentLength: Symbol("content length"),
		kMockAgent: Symbol("mock agent"),
		kMockAgentSet: Symbol("mock agent set"),
		kMockAgentGet: Symbol("mock agent get"),
		kMockDispatch: Symbol("mock dispatch"),
		kClose: Symbol("close"),
		kOriginalClose: Symbol("original agent close"),
		kOrigin: Symbol("origin"),
		kIsMockActive: Symbol("is mock active"),
		kNetConnect: Symbol("net connect"),
		kGetNetConnect: Symbol("get net connect"),
		kConnected: Symbol("connected")
	};
}));
//#endregion
//#region node_modules/undici/lib/mock/mock-utils.js
var require_mock_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { MockNotMatchedError } = require_mock_errors();
	var { kDispatches, kMockAgent, kOriginalDispatch, kOrigin, kGetNetConnect } = require_mock_symbols();
	var { buildURL } = require_util$8();
	var { STATUS_CODES: STATUS_CODES$1 } = __require("node:http");
	var { types: { isPromise } } = __require("node:util");
	function matchValue(match, value) {
		if (typeof match === "string") return match === value;
		if (match instanceof RegExp) return match.test(value);
		if (typeof match === "function") return match(value) === true;
		return false;
	}
	function lowerCaseEntries(headers) {
		return Object.fromEntries(Object.entries(headers).map(([headerName, headerValue]) => {
			return [headerName.toLocaleLowerCase(), headerValue];
		}));
	}
	/**
	* @param {import('../../index').Headers|string[]|Record<string, string>} headers
	* @param {string} key
	*/
	function getHeaderByName(headers, key) {
		if (Array.isArray(headers)) {
			for (let i = 0; i < headers.length; i += 2) if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) return headers[i + 1];
			return;
		} else if (typeof headers.get === "function") return headers.get(key);
		else return lowerCaseEntries(headers)[key.toLocaleLowerCase()];
	}
	/** @param {string[]} headers */
	function buildHeadersFromArray(headers) {
		const clone = headers.slice();
		const entries = [];
		for (let index = 0; index < clone.length; index += 2) entries.push([clone[index], clone[index + 1]]);
		return Object.fromEntries(entries);
	}
	function matchHeaders(mockDispatch, headers) {
		if (typeof mockDispatch.headers === "function") {
			if (Array.isArray(headers)) headers = buildHeadersFromArray(headers);
			return mockDispatch.headers(headers ? lowerCaseEntries(headers) : {});
		}
		if (typeof mockDispatch.headers === "undefined") return true;
		if (typeof headers !== "object" || typeof mockDispatch.headers !== "object") return false;
		for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch.headers)) if (!matchValue(matchHeaderValue, getHeaderByName(headers, matchHeaderName))) return false;
		return true;
	}
	function safeUrl(path) {
		if (typeof path !== "string") return path;
		const pathSegments = path.split("?");
		if (pathSegments.length !== 2) return path;
		const qp = new URLSearchParams(pathSegments.pop());
		qp.sort();
		return [...pathSegments, qp.toString()].join("?");
	}
	function matchKey(mockDispatch, { path, method, body, headers }) {
		const pathMatch = matchValue(mockDispatch.path, path);
		const methodMatch = matchValue(mockDispatch.method, method);
		const bodyMatch = typeof mockDispatch.body !== "undefined" ? matchValue(mockDispatch.body, body) : true;
		const headersMatch = matchHeaders(mockDispatch, headers);
		return pathMatch && methodMatch && bodyMatch && headersMatch;
	}
	function getResponseData(data) {
		if (Buffer.isBuffer(data)) return data;
		else if (data instanceof Uint8Array) return data;
		else if (data instanceof ArrayBuffer) return data;
		else if (typeof data === "object") return JSON.stringify(data);
		else return data.toString();
	}
	function getMockDispatch(mockDispatches, key) {
		const basePath = key.query ? buildURL(key.path, key.query) : key.path;
		const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
		let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path }) => matchValue(safeUrl(path), resolvedPath));
		if (matchedMockDispatches.length === 0) throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
		matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method));
		if (matchedMockDispatches.length === 0) throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}' on path '${resolvedPath}'`);
		matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true);
		if (matchedMockDispatches.length === 0) throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}' on path '${resolvedPath}'`);
		matchedMockDispatches = matchedMockDispatches.filter((mockDispatch) => matchHeaders(mockDispatch, key.headers));
		if (matchedMockDispatches.length === 0) throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}' on path '${resolvedPath}'`);
		return matchedMockDispatches[0];
	}
	function addMockDispatch(mockDispatches, key, data) {
		const baseData = {
			timesInvoked: 0,
			times: 1,
			persist: false,
			consumed: false
		};
		const replyData = typeof data === "function" ? { callback: data } : { ...data };
		const newMockDispatch = {
			...baseData,
			...key,
			pending: true,
			data: {
				error: null,
				...replyData
			}
		};
		mockDispatches.push(newMockDispatch);
		return newMockDispatch;
	}
	function deleteMockDispatch(mockDispatches, key) {
		const index = mockDispatches.findIndex((dispatch) => {
			if (!dispatch.consumed) return false;
			return matchKey(dispatch, key);
		});
		if (index !== -1) mockDispatches.splice(index, 1);
	}
	function buildKey(opts) {
		const { path, method, body, headers, query } = opts;
		return {
			path,
			method,
			body,
			headers,
			query
		};
	}
	function generateKeyValues(data) {
		const keys = Object.keys(data);
		const result = [];
		for (let i = 0; i < keys.length; ++i) {
			const key = keys[i];
			const value = data[key];
			const name = Buffer.from(`${key}`);
			if (Array.isArray(value)) for (let j = 0; j < value.length; ++j) result.push(name, Buffer.from(`${value[j]}`));
			else result.push(name, Buffer.from(`${value}`));
		}
		return result;
	}
	/**
	* @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
	* @param {number} statusCode
	*/
	function getStatusText(statusCode) {
		return STATUS_CODES$1[statusCode] || "unknown";
	}
	async function getResponse(body) {
		const buffers = [];
		for await (const data of body) buffers.push(data);
		return Buffer.concat(buffers).toString("utf8");
	}
	/**
	* Mock dispatch function used to simulate undici dispatches
	*/
	function mockDispatch(opts, handler) {
		const key = buildKey(opts);
		const mockDispatch = getMockDispatch(this[kDispatches], key);
		mockDispatch.timesInvoked++;
		if (mockDispatch.data.callback) mockDispatch.data = {
			...mockDispatch.data,
			...mockDispatch.data.callback(opts)
		};
		const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch;
		const { timesInvoked, times } = mockDispatch;
		mockDispatch.consumed = !persist && timesInvoked >= times;
		mockDispatch.pending = timesInvoked < times;
		if (error !== null) {
			deleteMockDispatch(this[kDispatches], key);
			handler.onError(error);
			return true;
		}
		if (typeof delay === "number" && delay > 0) setTimeout(() => {
			handleReply(this[kDispatches]);
		}, delay);
		else handleReply(this[kDispatches]);
		function handleReply(mockDispatches, _data = data) {
			const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers;
			const body = typeof _data === "function" ? _data({
				...opts,
				headers: optsHeaders
			}) : _data;
			if (isPromise(body)) {
				body.then((newData) => handleReply(mockDispatches, newData));
				return;
			}
			const responseData = getResponseData(body);
			const responseHeaders = generateKeyValues(headers);
			const responseTrailers = generateKeyValues(trailers);
			handler.onConnect?.((err) => handler.onError(err), null);
			handler.onHeaders?.(statusCode, responseHeaders, resume, getStatusText(statusCode));
			handler.onData?.(Buffer.from(responseData));
			handler.onComplete?.(responseTrailers);
			deleteMockDispatch(mockDispatches, key);
		}
		function resume() {}
		return true;
	}
	function buildMockDispatch() {
		const agent = this[kMockAgent];
		const origin = this[kOrigin];
		const originalDispatch = this[kOriginalDispatch];
		return function dispatch(opts, handler) {
			if (agent.isMockActive) try {
				mockDispatch.call(this, opts, handler);
			} catch (error) {
				if (error instanceof MockNotMatchedError) {
					const netConnect = agent[kGetNetConnect]();
					if (netConnect === false) throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
					if (checkNetConnect(netConnect, origin)) originalDispatch.call(this, opts, handler);
					else throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
				} else throw error;
			}
			else originalDispatch.call(this, opts, handler);
		};
	}
	function checkNetConnect(netConnect, origin) {
		const url = new URL(origin);
		if (netConnect === true) return true;
		else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) return true;
		return false;
	}
	function buildMockOptions(opts) {
		if (opts) {
			const { agent, ...mockOptions } = opts;
			return mockOptions;
		}
	}
	module.exports = {
		getResponseData,
		getMockDispatch,
		addMockDispatch,
		deleteMockDispatch,
		buildKey,
		generateKeyValues,
		matchValue,
		getResponse,
		getStatusText,
		mockDispatch,
		buildMockDispatch,
		checkNetConnect,
		buildMockOptions,
		getHeaderByName,
		buildHeadersFromArray
	};
}));
//#endregion
//#region node_modules/undici/lib/mock/mock-interceptor.js
var require_mock_interceptor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { getResponseData, buildKey, addMockDispatch } = require_mock_utils();
	var { kDispatches, kDispatchKey, kDefaultHeaders, kDefaultTrailers, kContentLength, kMockDispatch } = require_mock_symbols();
	var { InvalidArgumentError } = require_errors();
	var { buildURL } = require_util$8();
	/**
	* Defines the scope API for an interceptor reply
	*/
	var MockScope = class {
		constructor(mockDispatch) {
			this[kMockDispatch] = mockDispatch;
		}
		/**
		* Delay a reply by a set amount in ms.
		*/
		delay(waitInMs) {
			if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) throw new InvalidArgumentError("waitInMs must be a valid integer > 0");
			this[kMockDispatch].delay = waitInMs;
			return this;
		}
		/**
		* For a defined reply, never mark as consumed.
		*/
		persist() {
			this[kMockDispatch].persist = true;
			return this;
		}
		/**
		* Allow one to define a reply for a set amount of matching requests.
		*/
		times(repeatTimes) {
			if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) throw new InvalidArgumentError("repeatTimes must be a valid integer > 0");
			this[kMockDispatch].times = repeatTimes;
			return this;
		}
	};
	/**
	* Defines an interceptor for a Mock
	*/
	var MockInterceptor = class {
		constructor(opts, mockDispatches) {
			if (typeof opts !== "object") throw new InvalidArgumentError("opts must be an object");
			if (typeof opts.path === "undefined") throw new InvalidArgumentError("opts.path must be defined");
			if (typeof opts.method === "undefined") opts.method = "GET";
			if (typeof opts.path === "string") if (opts.query) opts.path = buildURL(opts.path, opts.query);
			else {
				const parsedURL = new URL(opts.path, "data://");
				opts.path = parsedURL.pathname + parsedURL.search;
			}
			if (typeof opts.method === "string") opts.method = opts.method.toUpperCase();
			this[kDispatchKey] = buildKey(opts);
			this[kDispatches] = mockDispatches;
			this[kDefaultHeaders] = {};
			this[kDefaultTrailers] = {};
			this[kContentLength] = false;
		}
		createMockScopeDispatchData({ statusCode, data, responseOptions }) {
			const responseData = getResponseData(data);
			const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {};
			return {
				statusCode,
				data,
				headers: {
					...this[kDefaultHeaders],
					...contentLength,
					...responseOptions.headers
				},
				trailers: {
					...this[kDefaultTrailers],
					...responseOptions.trailers
				}
			};
		}
		validateReplyParameters(replyParameters) {
			if (typeof replyParameters.statusCode === "undefined") throw new InvalidArgumentError("statusCode must be defined");
			if (typeof replyParameters.responseOptions !== "object" || replyParameters.responseOptions === null) throw new InvalidArgumentError("responseOptions must be an object");
		}
		/**
		* Mock an undici request with a defined reply.
		*/
		reply(replyOptionsCallbackOrStatusCode) {
			if (typeof replyOptionsCallbackOrStatusCode === "function") {
				const wrappedDefaultsCallback = (opts) => {
					const resolvedData = replyOptionsCallbackOrStatusCode(opts);
					if (typeof resolvedData !== "object" || resolvedData === null) throw new InvalidArgumentError("reply options callback must return an object");
					const replyParameters = {
						data: "",
						responseOptions: {},
						...resolvedData
					};
					this.validateReplyParameters(replyParameters);
					return { ...this.createMockScopeDispatchData(replyParameters) };
				};
				return new MockScope(addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback));
			}
			const replyParameters = {
				statusCode: replyOptionsCallbackOrStatusCode,
				data: arguments[1] === void 0 ? "" : arguments[1],
				responseOptions: arguments[2] === void 0 ? {} : arguments[2]
			};
			this.validateReplyParameters(replyParameters);
			const dispatchData = this.createMockScopeDispatchData(replyParameters);
			return new MockScope(addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData));
		}
		/**
		* Mock an undici request with a defined error.
		*/
		replyWithError(error) {
			if (typeof error === "undefined") throw new InvalidArgumentError("error must be defined");
			return new MockScope(addMockDispatch(this[kDispatches], this[kDispatchKey], { error }));
		}
		/**
		* Set default reply headers on the interceptor for subsequent replies
		*/
		defaultReplyHeaders(headers) {
			if (typeof headers === "undefined") throw new InvalidArgumentError("headers must be defined");
			this[kDefaultHeaders] = headers;
			return this;
		}
		/**
		* Set default reply trailers on the interceptor for subsequent replies
		*/
		defaultReplyTrailers(trailers) {
			if (typeof trailers === "undefined") throw new InvalidArgumentError("trailers must be defined");
			this[kDefaultTrailers] = trailers;
			return this;
		}
		/**
		* Set reply content length header for replies on the interceptor
		*/
		replyContentLength() {
			this[kContentLength] = true;
			return this;
		}
	};
	module.exports.MockInterceptor = MockInterceptor;
	module.exports.MockScope = MockScope;
}));
//#endregion
//#region node_modules/undici/lib/mock/mock-client.js
var require_mock_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { promisify: promisify$1 } = __require("node:util");
	var Client = require_client();
	var { buildMockDispatch } = require_mock_utils();
	var { kDispatches, kMockAgent, kClose, kOriginalClose, kOrigin, kOriginalDispatch, kConnected } = require_mock_symbols();
	var { MockInterceptor } = require_mock_interceptor();
	var Symbols = require_symbols$4();
	var { InvalidArgumentError } = require_errors();
	/**
	* MockClient provides an API that extends the Client to influence the mockDispatches.
	*/
	var MockClient = class extends Client {
		constructor(origin, opts) {
			super(origin, opts);
			if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") throw new InvalidArgumentError("Argument opts.agent must implement Agent");
			this[kMockAgent] = opts.agent;
			this[kOrigin] = origin;
			this[kDispatches] = [];
			this[kConnected] = 1;
			this[kOriginalDispatch] = this.dispatch;
			this[kOriginalClose] = this.close.bind(this);
			this.dispatch = buildMockDispatch.call(this);
			this.close = this[kClose];
		}
		get [Symbols.kConnected]() {
			return this[kConnected];
		}
		/**
		* Sets up the base interceptor for mocking replies from undici.
		*/
		intercept(opts) {
			return new MockInterceptor(opts, this[kDispatches]);
		}
		async [kClose]() {
			await promisify$1(this[kOriginalClose])();
			this[kConnected] = 0;
			this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
		}
	};
	module.exports = MockClient;
}));
//#endregion
//#region node_modules/undici/lib/mock/mock-pool.js
var require_mock_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { promisify } = __require("node:util");
	var Pool = require_pool();
	var { buildMockDispatch } = require_mock_utils();
	var { kDispatches, kMockAgent, kClose, kOriginalClose, kOrigin, kOriginalDispatch, kConnected } = require_mock_symbols();
	var { MockInterceptor } = require_mock_interceptor();
	var Symbols = require_symbols$4();
	var { InvalidArgumentError } = require_errors();
	/**
	* MockPool provides an API that extends the Pool to influence the mockDispatches.
	*/
	var MockPool = class extends Pool {
		constructor(origin, opts) {
			super(origin, opts);
			if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") throw new InvalidArgumentError("Argument opts.agent must implement Agent");
			this[kMockAgent] = opts.agent;
			this[kOrigin] = origin;
			this[kDispatches] = [];
			this[kConnected] = 1;
			this[kOriginalDispatch] = this.dispatch;
			this[kOriginalClose] = this.close.bind(this);
			this.dispatch = buildMockDispatch.call(this);
			this.close = this[kClose];
		}
		get [Symbols.kConnected]() {
			return this[kConnected];
		}
		/**
		* Sets up the base interceptor for mocking replies from undici.
		*/
		intercept(opts) {
			return new MockInterceptor(opts, this[kDispatches]);
		}
		async [kClose]() {
			await promisify(this[kOriginalClose])();
			this[kConnected] = 0;
			this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
		}
	};
	module.exports = MockPool;
}));
//#endregion
//#region node_modules/undici/lib/mock/pluralizer.js
var require_pluralizer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var singulars = {
		pronoun: "it",
		is: "is",
		was: "was",
		this: "this"
	};
	var plurals = {
		pronoun: "they",
		is: "are",
		was: "were",
		this: "these"
	};
	module.exports = class Pluralizer {
		constructor(singular, plural) {
			this.singular = singular;
			this.plural = plural;
		}
		pluralize(count) {
			const one = count === 1;
			const keys = one ? singulars : plurals;
			const noun = one ? this.singular : this.plural;
			return {
				...keys,
				count,
				noun
			};
		}
	};
}));
//#endregion
//#region node_modules/undici/lib/mock/pending-interceptors-formatter.js
var require_pending_interceptors_formatter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Transform: Transform$1 } = __require("node:stream");
	var { Console } = __require("node:console");
	var PERSISTENT = process.versions.icu ? "✅" : "Y ";
	var NOT_PERSISTENT = process.versions.icu ? "❌" : "N ";
	/**
	* Gets the output of `console.table(…)` as a string.
	*/
	module.exports = class PendingInterceptorsFormatter {
		constructor({ disableColors } = {}) {
			this.transform = new Transform$1({ transform(chunk, _enc, cb) {
				cb(null, chunk);
			} });
			this.logger = new Console({
				stdout: this.transform,
				inspectOptions: { colors: !disableColors && !process.env.CI }
			});
		}
		format(pendingInterceptors) {
			const withPrettyHeaders = pendingInterceptors.map(({ method, path, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
				Method: method,
				Origin: origin,
				Path: path,
				"Status code": statusCode,
				Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
				Invocations: timesInvoked,
				Remaining: persist ? Infinity : times - timesInvoked
			}));
			this.logger.table(withPrettyHeaders);
			return this.transform.read().toString();
		}
	};
}));
//#endregion
//#region node_modules/undici/lib/mock/mock-agent.js
var require_mock_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kClients } = require_symbols$4();
	var Agent = require_agent();
	var { kAgent, kMockAgentSet, kMockAgentGet, kDispatches, kIsMockActive, kNetConnect, kGetNetConnect, kOptions, kFactory } = require_mock_symbols();
	var MockClient = require_mock_client();
	var MockPool = require_mock_pool();
	var { matchValue, buildMockOptions } = require_mock_utils();
	var { InvalidArgumentError, UndiciError } = require_errors();
	var Dispatcher = require_dispatcher();
	var Pluralizer = require_pluralizer();
	var PendingInterceptorsFormatter = require_pending_interceptors_formatter();
	var MockAgent = class extends Dispatcher {
		constructor(opts) {
			super(opts);
			this[kNetConnect] = true;
			this[kIsMockActive] = true;
			if (opts?.agent && typeof opts.agent.dispatch !== "function") throw new InvalidArgumentError("Argument opts.agent must implement Agent");
			const agent = opts?.agent ? opts.agent : new Agent(opts);
			this[kAgent] = agent;
			this[kClients] = agent[kClients];
			this[kOptions] = buildMockOptions(opts);
		}
		get(origin) {
			let dispatcher = this[kMockAgentGet](origin);
			if (!dispatcher) {
				dispatcher = this[kFactory](origin);
				this[kMockAgentSet](origin, dispatcher);
			}
			return dispatcher;
		}
		dispatch(opts, handler) {
			this.get(opts.origin);
			return this[kAgent].dispatch(opts, handler);
		}
		async close() {
			await this[kAgent].close();
			this[kClients].clear();
		}
		deactivate() {
			this[kIsMockActive] = false;
		}
		activate() {
			this[kIsMockActive] = true;
		}
		enableNetConnect(matcher) {
			if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) if (Array.isArray(this[kNetConnect])) this[kNetConnect].push(matcher);
			else this[kNetConnect] = [matcher];
			else if (typeof matcher === "undefined") this[kNetConnect] = true;
			else throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp.");
		}
		disableNetConnect() {
			this[kNetConnect] = false;
		}
		get isMockActive() {
			return this[kIsMockActive];
		}
		[kMockAgentSet](origin, dispatcher) {
			this[kClients].set(origin, dispatcher);
		}
		[kFactory](origin) {
			const mockOptions = Object.assign({ agent: this }, this[kOptions]);
			return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions);
		}
		[kMockAgentGet](origin) {
			const client = this[kClients].get(origin);
			if (client) return client;
			if (typeof origin !== "string") {
				const dispatcher = this[kFactory]("http://localhost:9999");
				this[kMockAgentSet](origin, dispatcher);
				return dispatcher;
			}
			for (const [keyMatcher, nonExplicitDispatcher] of Array.from(this[kClients])) if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) {
				const dispatcher = this[kFactory](origin);
				this[kMockAgentSet](origin, dispatcher);
				dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches];
				return dispatcher;
			}
		}
		[kGetNetConnect]() {
			return this[kNetConnect];
		}
		pendingInterceptors() {
			const mockAgentClients = this[kClients];
			return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope[kDispatches].map((dispatch) => ({
				...dispatch,
				origin
			}))).filter(({ pending }) => pending);
		}
		assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
			const pending = this.pendingInterceptors();
			if (pending.length === 0) return;
			const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length);
			throw new UndiciError(`
${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:

${pendingInterceptorsFormatter.format(pending)}
`.trim());
		}
	};
	module.exports = MockAgent;
}));
//#endregion
//#region node_modules/undici/lib/global.js
var require_global = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var globalDispatcher = Symbol.for("undici.globalDispatcher.1");
	var { InvalidArgumentError } = require_errors();
	var Agent = require_agent();
	if (getGlobalDispatcher() === void 0) setGlobalDispatcher(new Agent());
	function setGlobalDispatcher(agent) {
		if (!agent || typeof agent.dispatch !== "function") throw new InvalidArgumentError("Argument agent must implement Agent");
		Object.defineProperty(globalThis, globalDispatcher, {
			value: agent,
			writable: true,
			enumerable: false,
			configurable: false
		});
	}
	function getGlobalDispatcher() {
		return globalThis[globalDispatcher];
	}
	module.exports = {
		setGlobalDispatcher,
		getGlobalDispatcher
	};
}));
//#endregion
//#region node_modules/undici/lib/handler/decorator-handler.js
var require_decorator_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = class DecoratorHandler {
		#handler;
		constructor(handler) {
			if (typeof handler !== "object" || handler === null) throw new TypeError("handler must be an object");
			this.#handler = handler;
		}
		onConnect(...args) {
			return this.#handler.onConnect?.(...args);
		}
		onError(...args) {
			return this.#handler.onError?.(...args);
		}
		onUpgrade(...args) {
			return this.#handler.onUpgrade?.(...args);
		}
		onResponseStarted(...args) {
			return this.#handler.onResponseStarted?.(...args);
		}
		onHeaders(...args) {
			return this.#handler.onHeaders?.(...args);
		}
		onData(...args) {
			return this.#handler.onData?.(...args);
		}
		onComplete(...args) {
			return this.#handler.onComplete?.(...args);
		}
		onBodySent(...args) {
			return this.#handler.onBodySent?.(...args);
		}
	};
}));
//#endregion
//#region node_modules/undici/lib/interceptor/redirect.js
var require_redirect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var RedirectHandler = require_redirect_handler();
	module.exports = (opts) => {
		const globalMaxRedirections = opts?.maxRedirections;
		return (dispatch) => {
			return function redirectInterceptor(opts, handler) {
				const { maxRedirections = globalMaxRedirections, ...baseOpts } = opts;
				if (!maxRedirections) return dispatch(opts, handler);
				return dispatch(baseOpts, new RedirectHandler(dispatch, maxRedirections, opts, handler));
			};
		};
	};
}));
//#endregion
//#region node_modules/undici/lib/interceptor/retry.js
var require_retry = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var RetryHandler = require_retry_handler();
	module.exports = (globalOpts) => {
		return (dispatch) => {
			return function retryInterceptor(opts, handler) {
				return dispatch(opts, new RetryHandler({
					...opts,
					retryOptions: {
						...globalOpts,
						...opts.retryOptions
					}
				}, {
					handler,
					dispatch
				}));
			};
		};
	};
}));
//#endregion
//#region node_modules/undici/lib/interceptor/dump.js
var require_dump = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var util = require_util$8();
	var { InvalidArgumentError, RequestAbortedError } = require_errors();
	var DecoratorHandler = require_decorator_handler();
	var DumpHandler = class extends DecoratorHandler {
		#maxSize = 1024 * 1024;
		#abort = null;
		#dumped = false;
		#aborted = false;
		#size = 0;
		#reason = null;
		#handler = null;
		constructor({ maxSize }, handler) {
			super(handler);
			if (maxSize != null && (!Number.isFinite(maxSize) || maxSize < 1)) throw new InvalidArgumentError("maxSize must be a number greater than 0");
			this.#maxSize = maxSize ?? this.#maxSize;
			this.#handler = handler;
		}
		onConnect(abort) {
			this.#abort = abort;
			this.#handler.onConnect(this.#customAbort.bind(this));
		}
		#customAbort(reason) {
			this.#aborted = true;
			this.#reason = reason;
		}
		onHeaders(statusCode, rawHeaders, resume, statusMessage) {
			const contentLength = util.parseHeaders(rawHeaders)["content-length"];
			if (contentLength != null && contentLength > this.#maxSize) throw new RequestAbortedError(`Response size (${contentLength}) larger than maxSize (${this.#maxSize})`);
			if (this.#aborted) return true;
			return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage);
		}
		onError(err) {
			if (this.#dumped) return;
			err = this.#reason ?? err;
			this.#handler.onError(err);
		}
		onData(chunk) {
			this.#size = this.#size + chunk.length;
			if (this.#size >= this.#maxSize) {
				this.#dumped = true;
				if (this.#aborted) this.#handler.onError(this.#reason);
				else this.#handler.onComplete([]);
			}
			return true;
		}
		onComplete(trailers) {
			if (this.#dumped) return;
			if (this.#aborted) {
				this.#handler.onError(this.reason);
				return;
			}
			this.#handler.onComplete(trailers);
		}
	};
	function createDumpInterceptor({ maxSize: defaultMaxSize } = { maxSize: 1024 * 1024 }) {
		return (dispatch) => {
			return function Intercept(opts, handler) {
				const { dumpMaxSize = defaultMaxSize } = opts;
				return dispatch(opts, new DumpHandler({ maxSize: dumpMaxSize }, handler));
			};
		};
	}
	module.exports = createDumpInterceptor;
}));
//#endregion
//#region node_modules/undici/lib/interceptor/dns.js
var require_dns = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { isIP } = __require("node:net");
	var { lookup } = __require("node:dns");
	var DecoratorHandler = require_decorator_handler();
	var { InvalidArgumentError, InformationalError } = require_errors();
	var maxInt = Math.pow(2, 31) - 1;
	var DNSInstance = class {
		#maxTTL = 0;
		#maxItems = 0;
		#records = /* @__PURE__ */ new Map();
		dualStack = true;
		affinity = null;
		lookup = null;
		pick = null;
		constructor(opts) {
			this.#maxTTL = opts.maxTTL;
			this.#maxItems = opts.maxItems;
			this.dualStack = opts.dualStack;
			this.affinity = opts.affinity;
			this.lookup = opts.lookup ?? this.#defaultLookup;
			this.pick = opts.pick ?? this.#defaultPick;
		}
		get full() {
			return this.#records.size === this.#maxItems;
		}
		runLookup(origin, opts, cb) {
			const ips = this.#records.get(origin.hostname);
			if (ips == null && this.full) {
				cb(null, origin.origin);
				return;
			}
			const newOpts = {
				affinity: this.affinity,
				dualStack: this.dualStack,
				lookup: this.lookup,
				pick: this.pick,
				...opts.dns,
				maxTTL: this.#maxTTL,
				maxItems: this.#maxItems
			};
			if (ips == null) this.lookup(origin, newOpts, (err, addresses) => {
				if (err || addresses == null || addresses.length === 0) {
					cb(err ?? new InformationalError("No DNS entries found"));
					return;
				}
				this.setRecords(origin, addresses);
				const records = this.#records.get(origin.hostname);
				const ip = this.pick(origin, records, newOpts.affinity);
				let port;
				if (typeof ip.port === "number") port = `:${ip.port}`;
				else if (origin.port !== "") port = `:${origin.port}`;
				else port = "";
				cb(null, `${origin.protocol}//${ip.family === 6 ? `[${ip.address}]` : ip.address}${port}`);
			});
			else {
				const ip = this.pick(origin, ips, newOpts.affinity);
				if (ip == null) {
					this.#records.delete(origin.hostname);
					this.runLookup(origin, opts, cb);
					return;
				}
				let port;
				if (typeof ip.port === "number") port = `:${ip.port}`;
				else if (origin.port !== "") port = `:${origin.port}`;
				else port = "";
				cb(null, `${origin.protocol}//${ip.family === 6 ? `[${ip.address}]` : ip.address}${port}`);
			}
		}
		#defaultLookup(origin, opts, cb) {
			lookup(origin.hostname, {
				all: true,
				family: this.dualStack === false ? this.affinity : 0,
				order: "ipv4first"
			}, (err, addresses) => {
				if (err) return cb(err);
				const results = /* @__PURE__ */ new Map();
				for (const addr of addresses) results.set(`${addr.address}:${addr.family}`, addr);
				cb(null, results.values());
			});
		}
		#defaultPick(origin, hostnameRecords, affinity) {
			let ip = null;
			const { records, offset } = hostnameRecords;
			let family;
			if (this.dualStack) {
				if (affinity == null) if (offset == null || offset === maxInt) {
					hostnameRecords.offset = 0;
					affinity = 4;
				} else {
					hostnameRecords.offset++;
					affinity = (hostnameRecords.offset & 1) === 1 ? 6 : 4;
				}
				if (records[affinity] != null && records[affinity].ips.length > 0) family = records[affinity];
				else family = records[affinity === 4 ? 6 : 4];
			} else family = records[affinity];
			if (family == null || family.ips.length === 0) return ip;
			if (family.offset == null || family.offset === maxInt) family.offset = 0;
			else family.offset++;
			const position = family.offset % family.ips.length;
			ip = family.ips[position] ?? null;
			if (ip == null) return ip;
			if (Date.now() - ip.timestamp > ip.ttl) {
				family.ips.splice(position, 1);
				return this.pick(origin, hostnameRecords, affinity);
			}
			return ip;
		}
		setRecords(origin, addresses) {
			const timestamp = Date.now();
			const records = { records: {
				4: null,
				6: null
			} };
			for (const record of addresses) {
				record.timestamp = timestamp;
				if (typeof record.ttl === "number") record.ttl = Math.min(record.ttl, this.#maxTTL);
				else record.ttl = this.#maxTTL;
				const familyRecords = records.records[record.family] ?? { ips: [] };
				familyRecords.ips.push(record);
				records.records[record.family] = familyRecords;
			}
			this.#records.set(origin.hostname, records);
		}
		getHandler(meta, opts) {
			return new DNSDispatchHandler(this, meta, opts);
		}
	};
	var DNSDispatchHandler = class extends DecoratorHandler {
		#state = null;
		#opts = null;
		#dispatch = null;
		#handler = null;
		#origin = null;
		constructor(state, { origin, handler, dispatch }, opts) {
			super(handler);
			this.#origin = origin;
			this.#handler = handler;
			this.#opts = { ...opts };
			this.#state = state;
			this.#dispatch = dispatch;
		}
		onError(err) {
			switch (err.code) {
				case "ETIMEDOUT":
				case "ECONNREFUSED":
					if (this.#state.dualStack) {
						this.#state.runLookup(this.#origin, this.#opts, (err, newOrigin) => {
							if (err) return this.#handler.onError(err);
							const dispatchOpts = {
								...this.#opts,
								origin: newOrigin
							};
							this.#dispatch(dispatchOpts, this);
						});
						return;
					}
					this.#handler.onError(err);
					return;
				case "ENOTFOUND": this.#state.deleteRecord(this.#origin);
				default:
					this.#handler.onError(err);
					break;
			}
		}
	};
	module.exports = (interceptorOpts) => {
		if (interceptorOpts?.maxTTL != null && (typeof interceptorOpts?.maxTTL !== "number" || interceptorOpts?.maxTTL < 0)) throw new InvalidArgumentError("Invalid maxTTL. Must be a positive number");
		if (interceptorOpts?.maxItems != null && (typeof interceptorOpts?.maxItems !== "number" || interceptorOpts?.maxItems < 1)) throw new InvalidArgumentError("Invalid maxItems. Must be a positive number and greater than zero");
		if (interceptorOpts?.affinity != null && interceptorOpts?.affinity !== 4 && interceptorOpts?.affinity !== 6) throw new InvalidArgumentError("Invalid affinity. Must be either 4 or 6");
		if (interceptorOpts?.dualStack != null && typeof interceptorOpts?.dualStack !== "boolean") throw new InvalidArgumentError("Invalid dualStack. Must be a boolean");
		if (interceptorOpts?.lookup != null && typeof interceptorOpts?.lookup !== "function") throw new InvalidArgumentError("Invalid lookup. Must be a function");
		if (interceptorOpts?.pick != null && typeof interceptorOpts?.pick !== "function") throw new InvalidArgumentError("Invalid pick. Must be a function");
		const dualStack = interceptorOpts?.dualStack ?? true;
		let affinity;
		if (dualStack) affinity = interceptorOpts?.affinity ?? null;
		else affinity = interceptorOpts?.affinity ?? 4;
		const instance = new DNSInstance({
			maxTTL: interceptorOpts?.maxTTL ?? 1e4,
			lookup: interceptorOpts?.lookup ?? null,
			pick: interceptorOpts?.pick ?? null,
			dualStack,
			affinity,
			maxItems: interceptorOpts?.maxItems ?? Infinity
		});
		return (dispatch) => {
			return function dnsInterceptor(origDispatchOpts, handler) {
				const origin = origDispatchOpts.origin.constructor === URL ? origDispatchOpts.origin : new URL(origDispatchOpts.origin);
				if (isIP(origin.hostname) !== 0) return dispatch(origDispatchOpts, handler);
				instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => {
					if (err) return handler.onError(err);
					let dispatchOpts = null;
					dispatchOpts = {
						...origDispatchOpts,
						servername: origin.hostname,
						origin: newOrigin,
						headers: {
							host: origin.hostname,
							...origDispatchOpts.headers
						}
					};
					dispatch(dispatchOpts, instance.getHandler({
						origin,
						dispatch,
						handler
					}, origDispatchOpts));
				});
				return true;
			};
		};
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/headers.js
var require_headers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kConstruct } = require_symbols$4();
	var { kEnumerableProperty } = require_util$8();
	var { iteratorMixin, isValidHeaderName, isValidHeaderValue } = require_util$7();
	var { webidl } = require_webidl();
	var assert$7 = __require("node:assert");
	var util = __require("node:util");
	var kHeadersMap = Symbol("headers map");
	var kHeadersSortedMap = Symbol("headers map sorted");
	/**
	* @param {number} code
	*/
	function isHTTPWhiteSpaceCharCode(code) {
		return code === 10 || code === 13 || code === 9 || code === 32;
	}
	/**
	* @see https://fetch.spec.whatwg.org/#concept-header-value-normalize
	* @param {string} potentialValue
	*/
	function headerValueNormalize(potentialValue) {
		let i = 0;
		let j = potentialValue.length;
		while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j;
		while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i;
		return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j);
	}
	function fill(headers, object) {
		if (Array.isArray(object)) for (let i = 0; i < object.length; ++i) {
			const header = object[i];
			if (header.length !== 2) throw webidl.errors.exception({
				header: "Headers constructor",
				message: `expected name/value pair to be length 2, found ${header.length}.`
			});
			appendHeader(headers, header[0], header[1]);
		}
		else if (typeof object === "object" && object !== null) {
			const keys = Object.keys(object);
			for (let i = 0; i < keys.length; ++i) appendHeader(headers, keys[i], object[keys[i]]);
		} else throw webidl.errors.conversionFailed({
			prefix: "Headers constructor",
			argument: "Argument 1",
			types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
		});
	}
	/**
	* @see https://fetch.spec.whatwg.org/#concept-headers-append
	*/
	function appendHeader(headers, name, value) {
		value = headerValueNormalize(value);
		if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({
			prefix: "Headers.append",
			value: name,
			type: "header name"
		});
		else if (!isValidHeaderValue(value)) throw webidl.errors.invalidArgument({
			prefix: "Headers.append",
			value,
			type: "header value"
		});
		if (getHeadersGuard(headers) === "immutable") throw new TypeError("immutable");
		return getHeadersList(headers).append(name, value, false);
	}
	function compareHeaderName(a, b) {
		return a[0] < b[0] ? -1 : 1;
	}
	var HeadersList = class HeadersList {
		/** @type {[string, string][]|null} */
		cookies = null;
		constructor(init) {
			if (init instanceof HeadersList) {
				this[kHeadersMap] = new Map(init[kHeadersMap]);
				this[kHeadersSortedMap] = init[kHeadersSortedMap];
				this.cookies = init.cookies === null ? null : [...init.cookies];
			} else {
				this[kHeadersMap] = new Map(init);
				this[kHeadersSortedMap] = null;
			}
		}
		/**
		* @see https://fetch.spec.whatwg.org/#header-list-contains
		* @param {string} name
		* @param {boolean} isLowerCase
		*/
		contains(name, isLowerCase) {
			return this[kHeadersMap].has(isLowerCase ? name : name.toLowerCase());
		}
		clear() {
			this[kHeadersMap].clear();
			this[kHeadersSortedMap] = null;
			this.cookies = null;
		}
		/**
		* @see https://fetch.spec.whatwg.org/#concept-header-list-append
		* @param {string} name
		* @param {string} value
		* @param {boolean} isLowerCase
		*/
		append(name, value, isLowerCase) {
			this[kHeadersSortedMap] = null;
			const lowercaseName = isLowerCase ? name : name.toLowerCase();
			const exists = this[kHeadersMap].get(lowercaseName);
			if (exists) {
				const delimiter = lowercaseName === "cookie" ? "; " : ", ";
				this[kHeadersMap].set(lowercaseName, {
					name: exists.name,
					value: `${exists.value}${delimiter}${value}`
				});
			} else this[kHeadersMap].set(lowercaseName, {
				name,
				value
			});
			if (lowercaseName === "set-cookie") (this.cookies ??= []).push(value);
		}
		/**
		* @see https://fetch.spec.whatwg.org/#concept-header-list-set
		* @param {string} name
		* @param {string} value
		* @param {boolean} isLowerCase
		*/
		set(name, value, isLowerCase) {
			this[kHeadersSortedMap] = null;
			const lowercaseName = isLowerCase ? name : name.toLowerCase();
			if (lowercaseName === "set-cookie") this.cookies = [value];
			this[kHeadersMap].set(lowercaseName, {
				name,
				value
			});
		}
		/**
		* @see https://fetch.spec.whatwg.org/#concept-header-list-delete
		* @param {string} name
		* @param {boolean} isLowerCase
		*/
		delete(name, isLowerCase) {
			this[kHeadersSortedMap] = null;
			if (!isLowerCase) name = name.toLowerCase();
			if (name === "set-cookie") this.cookies = null;
			this[kHeadersMap].delete(name);
		}
		/**
		* @see https://fetch.spec.whatwg.org/#concept-header-list-get
		* @param {string} name
		* @param {boolean} isLowerCase
		* @returns {string | null}
		*/
		get(name, isLowerCase) {
			return this[kHeadersMap].get(isLowerCase ? name : name.toLowerCase())?.value ?? null;
		}
		*[Symbol.iterator]() {
			for (const { 0: name, 1: { value } } of this[kHeadersMap]) yield [name, value];
		}
		get entries() {
			const headers = {};
			if (this[kHeadersMap].size !== 0) for (const { name, value } of this[kHeadersMap].values()) headers[name] = value;
			return headers;
		}
		rawValues() {
			return this[kHeadersMap].values();
		}
		get entriesList() {
			const headers = [];
			if (this[kHeadersMap].size !== 0) for (const { 0: lowerName, 1: { name, value } } of this[kHeadersMap]) if (lowerName === "set-cookie") for (const cookie of this.cookies) headers.push([name, cookie]);
			else headers.push([name, value]);
			return headers;
		}
		toSortedArray() {
			const size = this[kHeadersMap].size;
			const array = new Array(size);
			if (size <= 32) {
				if (size === 0) return array;
				const iterator = this[kHeadersMap][Symbol.iterator]();
				const firstValue = iterator.next().value;
				array[0] = [firstValue[0], firstValue[1].value];
				assert$7(firstValue[1].value !== null);
				for (let i = 1, j = 0, right = 0, left = 0, pivot = 0, x, value; i < size; ++i) {
					value = iterator.next().value;
					x = array[i] = [value[0], value[1].value];
					assert$7(x[1] !== null);
					left = 0;
					right = i;
					while (left < right) {
						pivot = left + (right - left >> 1);
						if (array[pivot][0] <= x[0]) left = pivot + 1;
						else right = pivot;
					}
					if (i !== pivot) {
						j = i;
						while (j > left) array[j] = array[--j];
						array[left] = x;
					}
				}
				/* c8 ignore next 4 */
				if (!iterator.next().done) throw new TypeError("Unreachable");
				return array;
			} else {
				let i = 0;
				for (const { 0: name, 1: { value } } of this[kHeadersMap]) {
					array[i++] = [name, value];
					assert$7(value !== null);
				}
				return array.sort(compareHeaderName);
			}
		}
	};
	var Headers = class Headers {
		#guard;
		#headersList;
		constructor(init = void 0) {
			webidl.util.markAsUncloneable(this);
			if (init === kConstruct) return;
			this.#headersList = new HeadersList();
			this.#guard = "none";
			if (init !== void 0) {
				init = webidl.converters.HeadersInit(init, "Headers contructor", "init");
				fill(this, init);
			}
		}
		append(name, value) {
			webidl.brandCheck(this, Headers);
			webidl.argumentLengthCheck(arguments, 2, "Headers.append");
			const prefix = "Headers.append";
			name = webidl.converters.ByteString(name, prefix, "name");
			value = webidl.converters.ByteString(value, prefix, "value");
			return appendHeader(this, name, value);
		}
		delete(name) {
			webidl.brandCheck(this, Headers);
			webidl.argumentLengthCheck(arguments, 1, "Headers.delete");
			name = webidl.converters.ByteString(name, "Headers.delete", "name");
			if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({
				prefix: "Headers.delete",
				value: name,
				type: "header name"
			});
			if (this.#guard === "immutable") throw new TypeError("immutable");
			if (!this.#headersList.contains(name, false)) return;
			this.#headersList.delete(name, false);
		}
		get(name) {
			webidl.brandCheck(this, Headers);
			webidl.argumentLengthCheck(arguments, 1, "Headers.get");
			const prefix = "Headers.get";
			name = webidl.converters.ByteString(name, prefix, "name");
			if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({
				prefix,
				value: name,
				type: "header name"
			});
			return this.#headersList.get(name, false);
		}
		has(name) {
			webidl.brandCheck(this, Headers);
			webidl.argumentLengthCheck(arguments, 1, "Headers.has");
			const prefix = "Headers.has";
			name = webidl.converters.ByteString(name, prefix, "name");
			if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({
				prefix,
				value: name,
				type: "header name"
			});
			return this.#headersList.contains(name, false);
		}
		set(name, value) {
			webidl.brandCheck(this, Headers);
			webidl.argumentLengthCheck(arguments, 2, "Headers.set");
			const prefix = "Headers.set";
			name = webidl.converters.ByteString(name, prefix, "name");
			value = webidl.converters.ByteString(value, prefix, "value");
			value = headerValueNormalize(value);
			if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({
				prefix,
				value: name,
				type: "header name"
			});
			else if (!isValidHeaderValue(value)) throw webidl.errors.invalidArgument({
				prefix,
				value,
				type: "header value"
			});
			if (this.#guard === "immutable") throw new TypeError("immutable");
			this.#headersList.set(name, value, false);
		}
		getSetCookie() {
			webidl.brandCheck(this, Headers);
			const list = this.#headersList.cookies;
			if (list) return [...list];
			return [];
		}
		get [kHeadersSortedMap]() {
			if (this.#headersList[kHeadersSortedMap]) return this.#headersList[kHeadersSortedMap];
			const headers = [];
			const names = this.#headersList.toSortedArray();
			const cookies = this.#headersList.cookies;
			if (cookies === null || cookies.length === 1) return this.#headersList[kHeadersSortedMap] = names;
			for (let i = 0; i < names.length; ++i) {
				const { 0: name, 1: value } = names[i];
				if (name === "set-cookie") for (let j = 0; j < cookies.length; ++j) headers.push([name, cookies[j]]);
				else headers.push([name, value]);
			}
			return this.#headersList[kHeadersSortedMap] = headers;
		}
		[util.inspect.custom](depth, options) {
			options.depth ??= depth;
			return `Headers ${util.formatWithOptions(options, this.#headersList.entries)}`;
		}
		static getHeadersGuard(o) {
			return o.#guard;
		}
		static setHeadersGuard(o, guard) {
			o.#guard = guard;
		}
		static getHeadersList(o) {
			return o.#headersList;
		}
		static setHeadersList(o, list) {
			o.#headersList = list;
		}
	};
	var { getHeadersGuard, setHeadersGuard, getHeadersList, setHeadersList } = Headers;
	Reflect.deleteProperty(Headers, "getHeadersGuard");
	Reflect.deleteProperty(Headers, "setHeadersGuard");
	Reflect.deleteProperty(Headers, "getHeadersList");
	Reflect.deleteProperty(Headers, "setHeadersList");
	iteratorMixin("Headers", Headers, kHeadersSortedMap, 0, 1);
	Object.defineProperties(Headers.prototype, {
		append: kEnumerableProperty,
		delete: kEnumerableProperty,
		get: kEnumerableProperty,
		has: kEnumerableProperty,
		set: kEnumerableProperty,
		getSetCookie: kEnumerableProperty,
		[Symbol.toStringTag]: {
			value: "Headers",
			configurable: true
		},
		[util.inspect.custom]: { enumerable: false }
	});
	webidl.converters.HeadersInit = function(V, prefix, argument) {
		if (webidl.util.Type(V) === "Object") {
			const iterator = Reflect.get(V, Symbol.iterator);
			if (!util.types.isProxy(V) && iterator === Headers.prototype.entries) try {
				return getHeadersList(V).entriesList;
			} catch {}
			if (typeof iterator === "function") return webidl.converters["sequence<sequence<ByteString>>"](V, prefix, argument, iterator.bind(V));
			return webidl.converters["record<ByteString, ByteString>"](V, prefix, argument);
		}
		throw webidl.errors.conversionFailed({
			prefix: "Headers constructor",
			argument: "Argument 1",
			types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
		});
	};
	module.exports = {
		fill,
		compareHeaderName,
		Headers,
		HeadersList,
		getHeadersGuard,
		setHeadersGuard,
		setHeadersList,
		getHeadersList
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/response.js
var require_response = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Headers, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = require_headers();
	var { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = require_body();
	var util = require_util$8();
	var nodeUtil$1 = __require("node:util");
	var { kEnumerableProperty } = util;
	var { isValidReasonPhrase, isCancelled, isAborted, isBlobLike, serializeJavascriptValueToJSONString, isErrorLike, isomorphicEncode, environmentSettingsObject: relevantRealm } = require_util$7();
	var { redirectStatusSet, nullBodyStatus } = require_constants$2();
	var { kState, kHeaders } = require_symbols$3();
	var { webidl } = require_webidl();
	var { FormData } = require_formdata();
	var { URLSerializer } = require_data_url();
	var { kConstruct } = require_symbols$4();
	var assert$6 = __require("node:assert");
	var { types: types$2 } = __require("node:util");
	var textEncoder = new TextEncoder("utf-8");
	var Response = class Response {
		static error() {
			return fromInnerResponse(makeNetworkError(), "immutable");
		}
		static json(data, init = {}) {
			webidl.argumentLengthCheck(arguments, 1, "Response.json");
			if (init !== null) init = webidl.converters.ResponseInit(init);
			const body = extractBody(textEncoder.encode(serializeJavascriptValueToJSONString(data)));
			const responseObject = fromInnerResponse(makeResponse({}), "response");
			initializeResponse(responseObject, init, {
				body: body[0],
				type: "application/json"
			});
			return responseObject;
		}
		static redirect(url, status = 302) {
			webidl.argumentLengthCheck(arguments, 1, "Response.redirect");
			url = webidl.converters.USVString(url);
			status = webidl.converters["unsigned short"](status);
			let parsedURL;
			try {
				parsedURL = new URL(url, relevantRealm.settingsObject.baseUrl);
			} catch (err) {
				throw new TypeError(`Failed to parse URL from ${url}`, { cause: err });
			}
			if (!redirectStatusSet.has(status)) throw new RangeError(`Invalid status code ${status}`);
			const responseObject = fromInnerResponse(makeResponse({}), "immutable");
			responseObject[kState].status = status;
			const value = isomorphicEncode(URLSerializer(parsedURL));
			responseObject[kState].headersList.append("location", value, true);
			return responseObject;
		}
		constructor(body = null, init = {}) {
			webidl.util.markAsUncloneable(this);
			if (body === kConstruct) return;
			if (body !== null) body = webidl.converters.BodyInit(body);
			init = webidl.converters.ResponseInit(init);
			this[kState] = makeResponse({});
			this[kHeaders] = new Headers(kConstruct);
			setHeadersGuard(this[kHeaders], "response");
			setHeadersList(this[kHeaders], this[kState].headersList);
			let bodyWithType = null;
			if (body != null) {
				const [extractedBody, type] = extractBody(body);
				bodyWithType = {
					body: extractedBody,
					type
				};
			}
			initializeResponse(this, init, bodyWithType);
		}
		get type() {
			webidl.brandCheck(this, Response);
			return this[kState].type;
		}
		get url() {
			webidl.brandCheck(this, Response);
			const urlList = this[kState].urlList;
			const url = urlList[urlList.length - 1] ?? null;
			if (url === null) return "";
			return URLSerializer(url, true);
		}
		get redirected() {
			webidl.brandCheck(this, Response);
			return this[kState].urlList.length > 1;
		}
		get status() {
			webidl.brandCheck(this, Response);
			return this[kState].status;
		}
		get ok() {
			webidl.brandCheck(this, Response);
			return this[kState].status >= 200 && this[kState].status <= 299;
		}
		get statusText() {
			webidl.brandCheck(this, Response);
			return this[kState].statusText;
		}
		get headers() {
			webidl.brandCheck(this, Response);
			return this[kHeaders];
		}
		get body() {
			webidl.brandCheck(this, Response);
			return this[kState].body ? this[kState].body.stream : null;
		}
		get bodyUsed() {
			webidl.brandCheck(this, Response);
			return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
		}
		clone() {
			webidl.brandCheck(this, Response);
			if (bodyUnusable(this)) throw webidl.errors.exception({
				header: "Response.clone",
				message: "Body has already been consumed."
			});
			const clonedResponse = cloneResponse(this[kState]);
			if (hasFinalizationRegistry && this[kState].body?.stream) streamRegistry.register(this, new WeakRef(this[kState].body.stream));
			return fromInnerResponse(clonedResponse, getHeadersGuard(this[kHeaders]));
		}
		[nodeUtil$1.inspect.custom](depth, options) {
			if (options.depth === null) options.depth = 2;
			options.colors ??= true;
			const properties = {
				status: this.status,
				statusText: this.statusText,
				headers: this.headers,
				body: this.body,
				bodyUsed: this.bodyUsed,
				ok: this.ok,
				redirected: this.redirected,
				type: this.type,
				url: this.url
			};
			return `Response ${nodeUtil$1.formatWithOptions(options, properties)}`;
		}
	};
	mixinBody(Response);
	Object.defineProperties(Response.prototype, {
		type: kEnumerableProperty,
		url: kEnumerableProperty,
		status: kEnumerableProperty,
		ok: kEnumerableProperty,
		redirected: kEnumerableProperty,
		statusText: kEnumerableProperty,
		headers: kEnumerableProperty,
		clone: kEnumerableProperty,
		body: kEnumerableProperty,
		bodyUsed: kEnumerableProperty,
		[Symbol.toStringTag]: {
			value: "Response",
			configurable: true
		}
	});
	Object.defineProperties(Response, {
		json: kEnumerableProperty,
		redirect: kEnumerableProperty,
		error: kEnumerableProperty
	});
	function cloneResponse(response) {
		if (response.internalResponse) return filterResponse(cloneResponse(response.internalResponse), response.type);
		const newResponse = makeResponse({
			...response,
			body: null
		});
		if (response.body != null) newResponse.body = cloneBody(newResponse, response.body);
		return newResponse;
	}
	function makeResponse(init) {
		return {
			aborted: false,
			rangeRequested: false,
			timingAllowPassed: false,
			requestIncludesCredentials: false,
			type: "default",
			status: 200,
			timingInfo: null,
			cacheState: "",
			statusText: "",
			...init,
			headersList: init?.headersList ? new HeadersList(init?.headersList) : new HeadersList(),
			urlList: init?.urlList ? [...init.urlList] : []
		};
	}
	function makeNetworkError(reason) {
		return makeResponse({
			type: "error",
			status: 0,
			error: isErrorLike(reason) ? reason : new Error(reason ? String(reason) : reason),
			aborted: reason && reason.name === "AbortError"
		});
	}
	function isNetworkError(response) {
		return response.type === "error" && response.status === 0;
	}
	function makeFilteredResponse(response, state) {
		state = {
			internalResponse: response,
			...state
		};
		return new Proxy(response, {
			get(target, p) {
				return p in state ? state[p] : target[p];
			},
			set(target, p, value) {
				assert$6(!(p in state));
				target[p] = value;
				return true;
			}
		});
	}
	function filterResponse(response, type) {
		if (type === "basic") return makeFilteredResponse(response, {
			type: "basic",
			headersList: response.headersList
		});
		else if (type === "cors") return makeFilteredResponse(response, {
			type: "cors",
			headersList: response.headersList
		});
		else if (type === "opaque") return makeFilteredResponse(response, {
			type: "opaque",
			urlList: Object.freeze([]),
			status: 0,
			statusText: "",
			body: null
		});
		else if (type === "opaqueredirect") return makeFilteredResponse(response, {
			type: "opaqueredirect",
			status: 0,
			statusText: "",
			headersList: [],
			body: null
		});
		else assert$6(false);
	}
	function makeAppropriateNetworkError(fetchParams, err = null) {
		assert$6(isCancelled(fetchParams));
		return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException("Request was cancelled."), { cause: err }));
	}
	function initializeResponse(response, init, body) {
		if (init.status !== null && (init.status < 200 || init.status > 599)) throw new RangeError("init[\"status\"] must be in the range of 200 to 599, inclusive.");
		if ("statusText" in init && init.statusText != null) {
			if (!isValidReasonPhrase(String(init.statusText))) throw new TypeError("Invalid statusText");
		}
		if ("status" in init && init.status != null) response[kState].status = init.status;
		if ("statusText" in init && init.statusText != null) response[kState].statusText = init.statusText;
		if ("headers" in init && init.headers != null) fill(response[kHeaders], init.headers);
		if (body) {
			if (nullBodyStatus.includes(response.status)) throw webidl.errors.exception({
				header: "Response constructor",
				message: `Invalid response status code ${response.status}`
			});
			response[kState].body = body.body;
			if (body.type != null && !response[kState].headersList.contains("content-type", true)) response[kState].headersList.append("content-type", body.type, true);
		}
	}
	/**
	* @see https://fetch.spec.whatwg.org/#response-create
	* @param {any} innerResponse
	* @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard
	* @returns {Response}
	*/
	function fromInnerResponse(innerResponse, guard) {
		const response = new Response(kConstruct);
		response[kState] = innerResponse;
		response[kHeaders] = new Headers(kConstruct);
		setHeadersList(response[kHeaders], innerResponse.headersList);
		setHeadersGuard(response[kHeaders], guard);
		if (hasFinalizationRegistry && innerResponse.body?.stream) streamRegistry.register(response, new WeakRef(innerResponse.body.stream));
		return response;
	}
	webidl.converters.ReadableStream = webidl.interfaceConverter(ReadableStream);
	webidl.converters.FormData = webidl.interfaceConverter(FormData);
	webidl.converters.URLSearchParams = webidl.interfaceConverter(URLSearchParams);
	webidl.converters.XMLHttpRequestBodyInit = function(V, prefix, name) {
		if (typeof V === "string") return webidl.converters.USVString(V, prefix, name);
		if (isBlobLike(V)) return webidl.converters.Blob(V, prefix, name, { strict: false });
		if (ArrayBuffer.isView(V) || types$2.isArrayBuffer(V)) return webidl.converters.BufferSource(V, prefix, name);
		if (util.isFormDataLike(V)) return webidl.converters.FormData(V, prefix, name, { strict: false });
		if (V instanceof URLSearchParams) return webidl.converters.URLSearchParams(V, prefix, name);
		return webidl.converters.DOMString(V, prefix, name);
	};
	webidl.converters.BodyInit = function(V, prefix, argument) {
		if (V instanceof ReadableStream) return webidl.converters.ReadableStream(V, prefix, argument);
		if (V?.[Symbol.asyncIterator]) return V;
		return webidl.converters.XMLHttpRequestBodyInit(V, prefix, argument);
	};
	webidl.converters.ResponseInit = webidl.dictionaryConverter([
		{
			key: "status",
			converter: webidl.converters["unsigned short"],
			defaultValue: () => 200
		},
		{
			key: "statusText",
			converter: webidl.converters.ByteString,
			defaultValue: () => ""
		},
		{
			key: "headers",
			converter: webidl.converters.HeadersInit
		}
	]);
	module.exports = {
		isNetworkError,
		makeNetworkError,
		makeResponse,
		makeAppropriateNetworkError,
		filterResponse,
		Response,
		cloneResponse,
		fromInnerResponse
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/dispatcher-weakref.js
var require_dispatcher_weakref = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kConnected, kSize } = require_symbols$4();
	var CompatWeakRef = class {
		constructor(value) {
			this.value = value;
		}
		deref() {
			return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
		}
	};
	var CompatFinalizer = class {
		constructor(finalizer) {
			this.finalizer = finalizer;
		}
		register(dispatcher, key) {
			if (dispatcher.on) dispatcher.on("disconnect", () => {
				if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) this.finalizer(key);
			});
		}
		unregister(key) {}
	};
	module.exports = function() {
		if (process.env.NODE_V8_COVERAGE && process.version.startsWith("v18")) {
			process._rawDebug("Using compatibility WeakRef and FinalizationRegistry");
			return {
				WeakRef: CompatWeakRef,
				FinalizationRegistry: CompatFinalizer
			};
		}
		return {
			WeakRef,
			FinalizationRegistry
		};
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/request.js
var require_request = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { extractBody, mixinBody, cloneBody, bodyUnusable } = require_body();
	var { Headers, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = require_headers();
	var { FinalizationRegistry } = require_dispatcher_weakref()();
	var util = require_util$8();
	var nodeUtil = __require("node:util");
	var { isValidHTTPToken, sameOrigin, environmentSettingsObject } = require_util$7();
	var { forbiddenMethodsSet, corsSafeListedMethodsSet, referrerPolicy, requestRedirect, requestMode, requestCredentials, requestCache, requestDuplex } = require_constants$2();
	var { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util;
	var { kHeaders, kSignal, kState, kDispatcher } = require_symbols$3();
	var { webidl } = require_webidl();
	var { URLSerializer } = require_data_url();
	var { kConstruct } = require_symbols$4();
	var assert$5 = __require("node:assert");
	var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = __require("node:events");
	var kAbortController = Symbol("abortController");
	var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
		signal.removeEventListener("abort", abort);
	});
	var dependentControllerMap = /* @__PURE__ */ new WeakMap();
	function buildAbort(acRef) {
		return abort;
		function abort() {
			const ac = acRef.deref();
			if (ac !== void 0) {
				requestFinalizer.unregister(abort);
				this.removeEventListener("abort", abort);
				ac.abort(this.reason);
				const controllerList = dependentControllerMap.get(ac.signal);
				if (controllerList !== void 0) {
					if (controllerList.size !== 0) {
						for (const ref of controllerList) {
							const ctrl = ref.deref();
							if (ctrl !== void 0) ctrl.abort(this.reason);
						}
						controllerList.clear();
					}
					dependentControllerMap.delete(ac.signal);
				}
			}
		}
	}
	var patchMethodWarning = false;
	var Request = class Request {
		constructor(input, init = {}) {
			webidl.util.markAsUncloneable(this);
			if (input === kConstruct) return;
			const prefix = "Request constructor";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			input = webidl.converters.RequestInfo(input, prefix, "input");
			init = webidl.converters.RequestInit(init, prefix, "init");
			let request = null;
			let fallbackMode = null;
			const baseUrl = environmentSettingsObject.settingsObject.baseUrl;
			let signal = null;
			if (typeof input === "string") {
				this[kDispatcher] = init.dispatcher;
				let parsedURL;
				try {
					parsedURL = new URL(input, baseUrl);
				} catch (err) {
					throw new TypeError("Failed to parse URL from " + input, { cause: err });
				}
				if (parsedURL.username || parsedURL.password) throw new TypeError("Request cannot be constructed from a URL that includes credentials: " + input);
				request = makeRequest({ urlList: [parsedURL] });
				fallbackMode = "cors";
			} else {
				this[kDispatcher] = init.dispatcher || input[kDispatcher];
				assert$5(input instanceof Request);
				request = input[kState];
				signal = input[kSignal];
			}
			const origin = environmentSettingsObject.settingsObject.origin;
			let window = "client";
			if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) window = request.window;
			if (init.window != null) throw new TypeError(`'window' option '${window}' must be null`);
			if ("window" in init) window = "no-window";
			request = makeRequest({
				method: request.method,
				headersList: request.headersList,
				unsafeRequest: request.unsafeRequest,
				client: environmentSettingsObject.settingsObject,
				window,
				priority: request.priority,
				origin: request.origin,
				referrer: request.referrer,
				referrerPolicy: request.referrerPolicy,
				mode: request.mode,
				credentials: request.credentials,
				cache: request.cache,
				redirect: request.redirect,
				integrity: request.integrity,
				keepalive: request.keepalive,
				reloadNavigation: request.reloadNavigation,
				historyNavigation: request.historyNavigation,
				urlList: [...request.urlList]
			});
			const initHasKey = Object.keys(init).length !== 0;
			if (initHasKey) {
				if (request.mode === "navigate") request.mode = "same-origin";
				request.reloadNavigation = false;
				request.historyNavigation = false;
				request.origin = "client";
				request.referrer = "client";
				request.referrerPolicy = "";
				request.url = request.urlList[request.urlList.length - 1];
				request.urlList = [request.url];
			}
			if (init.referrer !== void 0) {
				const referrer = init.referrer;
				if (referrer === "") request.referrer = "no-referrer";
				else {
					let parsedReferrer;
					try {
						parsedReferrer = new URL(referrer, baseUrl);
					} catch (err) {
						throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err });
					}
					if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, environmentSettingsObject.settingsObject.baseUrl)) request.referrer = "client";
					else request.referrer = parsedReferrer;
				}
			}
			if (init.referrerPolicy !== void 0) request.referrerPolicy = init.referrerPolicy;
			let mode;
			if (init.mode !== void 0) mode = init.mode;
			else mode = fallbackMode;
			if (mode === "navigate") throw webidl.errors.exception({
				header: "Request constructor",
				message: "invalid request mode navigate."
			});
			if (mode != null) request.mode = mode;
			if (init.credentials !== void 0) request.credentials = init.credentials;
			if (init.cache !== void 0) request.cache = init.cache;
			if (request.cache === "only-if-cached" && request.mode !== "same-origin") throw new TypeError("'only-if-cached' can be set only with 'same-origin' mode");
			if (init.redirect !== void 0) request.redirect = init.redirect;
			if (init.integrity != null) request.integrity = String(init.integrity);
			if (init.keepalive !== void 0) request.keepalive = Boolean(init.keepalive);
			if (init.method !== void 0) {
				let method = init.method;
				const mayBeNormalized = normalizedMethodRecords[method];
				if (mayBeNormalized !== void 0) request.method = mayBeNormalized;
				else {
					if (!isValidHTTPToken(method)) throw new TypeError(`'${method}' is not a valid HTTP method.`);
					const upperCase = method.toUpperCase();
					if (forbiddenMethodsSet.has(upperCase)) throw new TypeError(`'${method}' HTTP method is unsupported.`);
					method = normalizedMethodRecordsBase[upperCase] ?? method;
					request.method = method;
				}
				if (!patchMethodWarning && request.method === "patch") {
					process.emitWarning("Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.", { code: "UNDICI-FETCH-patch" });
					patchMethodWarning = true;
				}
			}
			if (init.signal !== void 0) signal = init.signal;
			this[kState] = request;
			const ac = new AbortController();
			this[kSignal] = ac.signal;
			if (signal != null) {
				if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") throw new TypeError("Failed to construct 'Request': member signal is not of type AbortSignal.");
				if (signal.aborted) ac.abort(signal.reason);
				else {
					this[kAbortController] = ac;
					const abort = buildAbort(new WeakRef(ac));
					try {
						if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) setMaxListeners(1500, signal);
						else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) setMaxListeners(1500, signal);
					} catch {}
					util.addAbortListener(signal, abort);
					requestFinalizer.register(ac, {
						signal,
						abort
					}, abort);
				}
			}
			this[kHeaders] = new Headers(kConstruct);
			setHeadersList(this[kHeaders], request.headersList);
			setHeadersGuard(this[kHeaders], "request");
			if (mode === "no-cors") {
				if (!corsSafeListedMethodsSet.has(request.method)) throw new TypeError(`'${request.method} is unsupported in no-cors mode.`);
				setHeadersGuard(this[kHeaders], "request-no-cors");
			}
			if (initHasKey) {
				/** @type {HeadersList} */
				const headersList = getHeadersList(this[kHeaders]);
				const headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList);
				headersList.clear();
				if (headers instanceof HeadersList) {
					for (const { name, value } of headers.rawValues()) headersList.append(name, value, false);
					headersList.cookies = headers.cookies;
				} else fillHeaders(this[kHeaders], headers);
			}
			const inputBody = input instanceof Request ? input[kState].body : null;
			if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) throw new TypeError("Request with GET/HEAD method cannot have body.");
			let initBody = null;
			if (init.body != null) {
				const [extractedBody, contentType] = extractBody(init.body, request.keepalive);
				initBody = extractedBody;
				if (contentType && !getHeadersList(this[kHeaders]).contains("content-type", true)) this[kHeaders].append("content-type", contentType);
			}
			const inputOrInitBody = initBody ?? inputBody;
			if (inputOrInitBody != null && inputOrInitBody.source == null) {
				if (initBody != null && init.duplex == null) throw new TypeError("RequestInit: duplex option is required when sending a body.");
				if (request.mode !== "same-origin" && request.mode !== "cors") throw new TypeError("If request is made from ReadableStream, mode should be \"same-origin\" or \"cors\"");
				request.useCORSPreflightFlag = true;
			}
			let finalBody = inputOrInitBody;
			if (initBody == null && inputBody != null) {
				if (bodyUnusable(input)) throw new TypeError("Cannot construct a Request with a Request object that has already been used.");
				const identityTransform = new TransformStream();
				inputBody.stream.pipeThrough(identityTransform);
				finalBody = {
					source: inputBody.source,
					length: inputBody.length,
					stream: identityTransform.readable
				};
			}
			this[kState].body = finalBody;
		}
		get method() {
			webidl.brandCheck(this, Request);
			return this[kState].method;
		}
		get url() {
			webidl.brandCheck(this, Request);
			return URLSerializer(this[kState].url);
		}
		get headers() {
			webidl.brandCheck(this, Request);
			return this[kHeaders];
		}
		get destination() {
			webidl.brandCheck(this, Request);
			return this[kState].destination;
		}
		get referrer() {
			webidl.brandCheck(this, Request);
			if (this[kState].referrer === "no-referrer") return "";
			if (this[kState].referrer === "client") return "about:client";
			return this[kState].referrer.toString();
		}
		get referrerPolicy() {
			webidl.brandCheck(this, Request);
			return this[kState].referrerPolicy;
		}
		get mode() {
			webidl.brandCheck(this, Request);
			return this[kState].mode;
		}
		get credentials() {
			return this[kState].credentials;
		}
		get cache() {
			webidl.brandCheck(this, Request);
			return this[kState].cache;
		}
		get redirect() {
			webidl.brandCheck(this, Request);
			return this[kState].redirect;
		}
		get integrity() {
			webidl.brandCheck(this, Request);
			return this[kState].integrity;
		}
		get keepalive() {
			webidl.brandCheck(this, Request);
			return this[kState].keepalive;
		}
		get isReloadNavigation() {
			webidl.brandCheck(this, Request);
			return this[kState].reloadNavigation;
		}
		get isHistoryNavigation() {
			webidl.brandCheck(this, Request);
			return this[kState].historyNavigation;
		}
		get signal() {
			webidl.brandCheck(this, Request);
			return this[kSignal];
		}
		get body() {
			webidl.brandCheck(this, Request);
			return this[kState].body ? this[kState].body.stream : null;
		}
		get bodyUsed() {
			webidl.brandCheck(this, Request);
			return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
		}
		get duplex() {
			webidl.brandCheck(this, Request);
			return "half";
		}
		clone() {
			webidl.brandCheck(this, Request);
			if (bodyUnusable(this)) throw new TypeError("unusable");
			const clonedRequest = cloneRequest(this[kState]);
			const ac = new AbortController();
			if (this.signal.aborted) ac.abort(this.signal.reason);
			else {
				let list = dependentControllerMap.get(this.signal);
				if (list === void 0) {
					list = /* @__PURE__ */ new Set();
					dependentControllerMap.set(this.signal, list);
				}
				const acRef = new WeakRef(ac);
				list.add(acRef);
				util.addAbortListener(ac.signal, buildAbort(acRef));
			}
			return fromInnerRequest(clonedRequest, ac.signal, getHeadersGuard(this[kHeaders]));
		}
		[nodeUtil.inspect.custom](depth, options) {
			if (options.depth === null) options.depth = 2;
			options.colors ??= true;
			const properties = {
				method: this.method,
				url: this.url,
				headers: this.headers,
				destination: this.destination,
				referrer: this.referrer,
				referrerPolicy: this.referrerPolicy,
				mode: this.mode,
				credentials: this.credentials,
				cache: this.cache,
				redirect: this.redirect,
				integrity: this.integrity,
				keepalive: this.keepalive,
				isReloadNavigation: this.isReloadNavigation,
				isHistoryNavigation: this.isHistoryNavigation,
				signal: this.signal
			};
			return `Request ${nodeUtil.formatWithOptions(options, properties)}`;
		}
	};
	mixinBody(Request);
	function makeRequest(init) {
		return {
			method: init.method ?? "GET",
			localURLsOnly: init.localURLsOnly ?? false,
			unsafeRequest: init.unsafeRequest ?? false,
			body: init.body ?? null,
			client: init.client ?? null,
			reservedClient: init.reservedClient ?? null,
			replacesClientId: init.replacesClientId ?? "",
			window: init.window ?? "client",
			keepalive: init.keepalive ?? false,
			serviceWorkers: init.serviceWorkers ?? "all",
			initiator: init.initiator ?? "",
			destination: init.destination ?? "",
			priority: init.priority ?? null,
			origin: init.origin ?? "client",
			policyContainer: init.policyContainer ?? "client",
			referrer: init.referrer ?? "client",
			referrerPolicy: init.referrerPolicy ?? "",
			mode: init.mode ?? "no-cors",
			useCORSPreflightFlag: init.useCORSPreflightFlag ?? false,
			credentials: init.credentials ?? "same-origin",
			useCredentials: init.useCredentials ?? false,
			cache: init.cache ?? "default",
			redirect: init.redirect ?? "follow",
			integrity: init.integrity ?? "",
			cryptoGraphicsNonceMetadata: init.cryptoGraphicsNonceMetadata ?? "",
			parserMetadata: init.parserMetadata ?? "",
			reloadNavigation: init.reloadNavigation ?? false,
			historyNavigation: init.historyNavigation ?? false,
			userActivation: init.userActivation ?? false,
			taintedOrigin: init.taintedOrigin ?? false,
			redirectCount: init.redirectCount ?? 0,
			responseTainting: init.responseTainting ?? "basic",
			preventNoCacheCacheControlHeaderModification: init.preventNoCacheCacheControlHeaderModification ?? false,
			done: init.done ?? false,
			timingAllowFailed: init.timingAllowFailed ?? false,
			urlList: init.urlList,
			url: init.urlList[0],
			headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList()
		};
	}
	function cloneRequest(request) {
		const newRequest = makeRequest({
			...request,
			body: null
		});
		if (request.body != null) newRequest.body = cloneBody(newRequest, request.body);
		return newRequest;
	}
	/**
	* @see https://fetch.spec.whatwg.org/#request-create
	* @param {any} innerRequest
	* @param {AbortSignal} signal
	* @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard
	* @returns {Request}
	*/
	function fromInnerRequest(innerRequest, signal, guard) {
		const request = new Request(kConstruct);
		request[kState] = innerRequest;
		request[kSignal] = signal;
		request[kHeaders] = new Headers(kConstruct);
		setHeadersList(request[kHeaders], innerRequest.headersList);
		setHeadersGuard(request[kHeaders], guard);
		return request;
	}
	Object.defineProperties(Request.prototype, {
		method: kEnumerableProperty,
		url: kEnumerableProperty,
		headers: kEnumerableProperty,
		redirect: kEnumerableProperty,
		clone: kEnumerableProperty,
		signal: kEnumerableProperty,
		duplex: kEnumerableProperty,
		destination: kEnumerableProperty,
		body: kEnumerableProperty,
		bodyUsed: kEnumerableProperty,
		isHistoryNavigation: kEnumerableProperty,
		isReloadNavigation: kEnumerableProperty,
		keepalive: kEnumerableProperty,
		integrity: kEnumerableProperty,
		cache: kEnumerableProperty,
		credentials: kEnumerableProperty,
		attribute: kEnumerableProperty,
		referrerPolicy: kEnumerableProperty,
		referrer: kEnumerableProperty,
		mode: kEnumerableProperty,
		[Symbol.toStringTag]: {
			value: "Request",
			configurable: true
		}
	});
	webidl.converters.Request = webidl.interfaceConverter(Request);
	webidl.converters.RequestInfo = function(V, prefix, argument) {
		if (typeof V === "string") return webidl.converters.USVString(V, prefix, argument);
		if (V instanceof Request) return webidl.converters.Request(V, prefix, argument);
		return webidl.converters.USVString(V, prefix, argument);
	};
	webidl.converters.AbortSignal = webidl.interfaceConverter(AbortSignal);
	webidl.converters.RequestInit = webidl.dictionaryConverter([
		{
			key: "method",
			converter: webidl.converters.ByteString
		},
		{
			key: "headers",
			converter: webidl.converters.HeadersInit
		},
		{
			key: "body",
			converter: webidl.nullableConverter(webidl.converters.BodyInit)
		},
		{
			key: "referrer",
			converter: webidl.converters.USVString
		},
		{
			key: "referrerPolicy",
			converter: webidl.converters.DOMString,
			allowedValues: referrerPolicy
		},
		{
			key: "mode",
			converter: webidl.converters.DOMString,
			allowedValues: requestMode
		},
		{
			key: "credentials",
			converter: webidl.converters.DOMString,
			allowedValues: requestCredentials
		},
		{
			key: "cache",
			converter: webidl.converters.DOMString,
			allowedValues: requestCache
		},
		{
			key: "redirect",
			converter: webidl.converters.DOMString,
			allowedValues: requestRedirect
		},
		{
			key: "integrity",
			converter: webidl.converters.DOMString
		},
		{
			key: "keepalive",
			converter: webidl.converters.boolean
		},
		{
			key: "signal",
			converter: webidl.nullableConverter((signal) => webidl.converters.AbortSignal(signal, "RequestInit", "signal", { strict: false }))
		},
		{
			key: "window",
			converter: webidl.converters.any
		},
		{
			key: "duplex",
			converter: webidl.converters.DOMString,
			allowedValues: requestDuplex
		},
		{
			key: "dispatcher",
			converter: webidl.converters.any
		}
	]);
	module.exports = {
		Request,
		makeRequest,
		fromInnerRequest,
		cloneRequest
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fetch/index.js
var require_fetch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { makeNetworkError, makeAppropriateNetworkError, filterResponse, makeResponse, fromInnerResponse } = require_response();
	var { HeadersList } = require_headers();
	var { Request, cloneRequest } = require_request();
	var zlib = __require("node:zlib");
	var { bytesMatch, makePolicyContainer, clonePolicyContainer, requestBadPort, TAOCheck, appendRequestOriginHeader, responseLocationURL, requestCurrentURL, setRequestReferrerPolicyOnRedirect, tryUpgradeRequestToAPotentiallyTrustworthyURL, createOpaqueTimingInfo, appendFetchMetadata, corsCheck, crossOriginResourcePolicyCheck, determineRequestsReferrer, coarsenedSharedCurrentTime, createDeferredPromise, isBlobLike, sameOrigin, isCancelled, isAborted, isErrorLike, fullyReadBody, readableStreamClose, isomorphicEncode, urlIsLocal, urlIsHttpHttpsScheme, urlHasHttpsScheme, clampAndCoarsenConnectionTimingInfo, simpleRangeHeaderValue, buildContentRange, createInflate, extractMimeType } = require_util$7();
	var { kState, kDispatcher } = require_symbols$3();
	var assert$4 = __require("node:assert");
	var { safelyExtractBody, extractBody } = require_body();
	var { redirectStatusSet, nullBodyStatus, safeMethodsSet, requestBodyHeader, subresourceSet } = require_constants$2();
	var EE = __require("node:events");
	var { Readable, pipeline: pipeline$1, finished } = __require("node:stream");
	var { addAbortListener, isErrored, isReadable, bufferToLowerCasedHeaderName } = require_util$8();
	var { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_data_url();
	var { getGlobalDispatcher } = require_global();
	var { webidl } = require_webidl();
	var { STATUS_CODES } = __require("node:http");
	var GET_OR_HEAD = ["GET", "HEAD"];
	var defaultUserAgent = typeof __UNDICI_IS_NODE__ !== "undefined" || typeof esbuildDetection !== "undefined" ? "node" : "undici";
	/** @type {import('buffer').resolveObjectURL} */
	var resolveObjectURL;
	var Fetch = class extends EE {
		constructor(dispatcher) {
			super();
			this.dispatcher = dispatcher;
			this.connection = null;
			this.dump = false;
			this.state = "ongoing";
		}
		terminate(reason) {
			if (this.state !== "ongoing") return;
			this.state = "terminated";
			this.connection?.destroy(reason);
			this.emit("terminated", reason);
		}
		abort(error) {
			if (this.state !== "ongoing") return;
			this.state = "aborted";
			if (!error) error = new DOMException("The operation was aborted.", "AbortError");
			this.serializedAbortReason = error;
			this.connection?.destroy(error);
			this.emit("terminated", error);
		}
	};
	function handleFetchDone(response) {
		finalizeAndReportTiming(response, "fetch");
	}
	function fetch(input, init = void 0) {
		webidl.argumentLengthCheck(arguments, 1, "globalThis.fetch");
		let p = createDeferredPromise();
		let requestObject;
		try {
			requestObject = new Request(input, init);
		} catch (e) {
			p.reject(e);
			return p.promise;
		}
		const request = requestObject[kState];
		if (requestObject.signal.aborted) {
			abortFetch(p, request, null, requestObject.signal.reason);
			return p.promise;
		}
		if (request.client.globalObject?.constructor?.name === "ServiceWorkerGlobalScope") request.serviceWorkers = "none";
		let responseObject = null;
		let locallyAborted = false;
		let controller = null;
		addAbortListener(requestObject.signal, () => {
			locallyAborted = true;
			assert$4(controller != null);
			controller.abort(requestObject.signal.reason);
			const realResponse = responseObject?.deref();
			abortFetch(p, request, realResponse, requestObject.signal.reason);
		});
		const processResponse = (response) => {
			if (locallyAborted) return;
			if (response.aborted) {
				abortFetch(p, request, responseObject, controller.serializedAbortReason);
				return;
			}
			if (response.type === "error") {
				p.reject(new TypeError("fetch failed", { cause: response.error }));
				return;
			}
			responseObject = new WeakRef(fromInnerResponse(response, "immutable"));
			p.resolve(responseObject.deref());
			p = null;
		};
		controller = fetching({
			request,
			processResponseEndOfBody: handleFetchDone,
			processResponse,
			dispatcher: requestObject[kDispatcher]
		});
		return p.promise;
	}
	function finalizeAndReportTiming(response, initiatorType = "other") {
		if (response.type === "error" && response.aborted) return;
		if (!response.urlList?.length) return;
		const originalURL = response.urlList[0];
		let timingInfo = response.timingInfo;
		let cacheState = response.cacheState;
		if (!urlIsHttpHttpsScheme(originalURL)) return;
		if (timingInfo === null) return;
		if (!response.timingAllowPassed) {
			timingInfo = createOpaqueTimingInfo({ startTime: timingInfo.startTime });
			cacheState = "";
		}
		timingInfo.endTime = coarsenedSharedCurrentTime();
		response.timingInfo = timingInfo;
		markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis, cacheState);
	}
	var markResourceTiming = performance.markResourceTiming;
	function abortFetch(p, request, responseObject, error) {
		if (p) p.reject(error);
		if (request.body != null && isReadable(request.body?.stream)) request.body.stream.cancel(error).catch((err) => {
			if (err.code === "ERR_INVALID_STATE") return;
			throw err;
		});
		if (responseObject == null) return;
		const response = responseObject[kState];
		if (response.body != null && isReadable(response.body?.stream)) response.body.stream.cancel(error).catch((err) => {
			if (err.code === "ERR_INVALID_STATE") return;
			throw err;
		});
	}
	function fetching({ request, processRequestBodyChunkLength, processRequestEndOfBody, processResponse, processResponseEndOfBody, processResponseConsumeBody, useParallelQueue = false, dispatcher = getGlobalDispatcher() }) {
		assert$4(dispatcher);
		let taskDestination = null;
		let crossOriginIsolatedCapability = false;
		if (request.client != null) {
			taskDestination = request.client.globalObject;
			crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability;
		}
		const timingInfo = createOpaqueTimingInfo({ startTime: coarsenedSharedCurrentTime(crossOriginIsolatedCapability) });
		const fetchParams = {
			controller: new Fetch(dispatcher),
			request,
			timingInfo,
			processRequestBodyChunkLength,
			processRequestEndOfBody,
			processResponse,
			processResponseConsumeBody,
			processResponseEndOfBody,
			taskDestination,
			crossOriginIsolatedCapability
		};
		assert$4(!request.body || request.body.stream);
		if (request.window === "client") request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window";
		if (request.origin === "client") request.origin = request.client.origin;
		if (request.policyContainer === "client") if (request.client != null) request.policyContainer = clonePolicyContainer(request.client.policyContainer);
		else request.policyContainer = makePolicyContainer();
		if (!request.headersList.contains("accept", true)) request.headersList.append("accept", "*/*", true);
		if (!request.headersList.contains("accept-language", true)) request.headersList.append("accept-language", "*", true);
		if (request.priority === null) {}
		if (subresourceSet.has(request.destination)) {}
		mainFetch(fetchParams).catch((err) => {
			fetchParams.controller.terminate(err);
		});
		return fetchParams.controller;
	}
	async function mainFetch(fetchParams, recursive = false) {
		const request = fetchParams.request;
		let response = null;
		if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) response = makeNetworkError("local URLs only");
		tryUpgradeRequestToAPotentiallyTrustworthyURL(request);
		if (requestBadPort(request) === "blocked") response = makeNetworkError("bad port");
		if (request.referrerPolicy === "") request.referrerPolicy = request.policyContainer.referrerPolicy;
		if (request.referrer !== "no-referrer") request.referrer = determineRequestsReferrer(request);
		if (response === null) response = await (async () => {
			const currentURL = requestCurrentURL(request);
			if (sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || currentURL.protocol === "data:" || request.mode === "navigate" || request.mode === "websocket") {
				request.responseTainting = "basic";
				return await schemeFetch(fetchParams);
			}
			if (request.mode === "same-origin") return makeNetworkError("request mode cannot be \"same-origin\"");
			if (request.mode === "no-cors") {
				if (request.redirect !== "follow") return makeNetworkError("redirect mode cannot be \"follow\" for \"no-cors\" request");
				request.responseTainting = "opaque";
				return await schemeFetch(fetchParams);
			}
			if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) return makeNetworkError("URL scheme must be a HTTP(S) scheme");
			request.responseTainting = "cors";
			return await httpFetch(fetchParams);
		})();
		if (recursive) return response;
		if (response.status !== 0 && !response.internalResponse) {
			if (request.responseTainting === "cors") {}
			if (request.responseTainting === "basic") response = filterResponse(response, "basic");
			else if (request.responseTainting === "cors") response = filterResponse(response, "cors");
			else if (request.responseTainting === "opaque") response = filterResponse(response, "opaque");
			else assert$4(false);
		}
		let internalResponse = response.status === 0 ? response : response.internalResponse;
		if (internalResponse.urlList.length === 0) internalResponse.urlList.push(...request.urlList);
		if (!request.timingAllowFailed) response.timingAllowPassed = true;
		if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range", true)) response = internalResponse = makeNetworkError();
		if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
			internalResponse.body = null;
			fetchParams.controller.dump = true;
		}
		if (request.integrity) {
			const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason));
			if (request.responseTainting === "opaque" || response.body == null) {
				processBodyError(response.error);
				return;
			}
			const processBody = (bytes) => {
				if (!bytesMatch(bytes, request.integrity)) {
					processBodyError("integrity mismatch");
					return;
				}
				response.body = safelyExtractBody(bytes)[0];
				fetchFinale(fetchParams, response);
			};
			await fullyReadBody(response.body, processBody, processBodyError);
		} else fetchFinale(fetchParams, response);
	}
	function schemeFetch(fetchParams) {
		if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) return Promise.resolve(makeAppropriateNetworkError(fetchParams));
		const { request } = fetchParams;
		const { protocol: scheme } = requestCurrentURL(request);
		switch (scheme) {
			case "about:": return Promise.resolve(makeNetworkError("about scheme is not supported"));
			case "blob:": {
				if (!resolveObjectURL) resolveObjectURL = __require("node:buffer").resolveObjectURL;
				const blobURLEntry = requestCurrentURL(request);
				if (blobURLEntry.search.length !== 0) return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource."));
				const blob = resolveObjectURL(blobURLEntry.toString());
				if (request.method !== "GET" || !isBlobLike(blob)) return Promise.resolve(makeNetworkError("invalid method"));
				const response = makeResponse();
				const fullLength = blob.size;
				const serializedFullLength = isomorphicEncode(`${fullLength}`);
				const type = blob.type;
				if (!request.headersList.contains("range", true)) {
					const bodyWithType = extractBody(blob);
					response.statusText = "OK";
					response.body = bodyWithType[0];
					response.headersList.set("content-length", serializedFullLength, true);
					response.headersList.set("content-type", type, true);
				} else {
					response.rangeRequested = true;
					const rangeValue = simpleRangeHeaderValue(request.headersList.get("range", true), true);
					if (rangeValue === "failure") return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
					let { rangeStartValue: rangeStart, rangeEndValue: rangeEnd } = rangeValue;
					if (rangeStart === null) {
						rangeStart = fullLength - rangeEnd;
						rangeEnd = rangeStart + rangeEnd - 1;
					} else {
						if (rangeStart >= fullLength) return Promise.resolve(makeNetworkError("Range start is greater than the blob's size."));
						if (rangeEnd === null || rangeEnd >= fullLength) rangeEnd = fullLength - 1;
					}
					const slicedBlob = blob.slice(rangeStart, rangeEnd, type);
					response.body = extractBody(slicedBlob)[0];
					const serializedSlicedLength = isomorphicEncode(`${slicedBlob.size}`);
					const contentRange = buildContentRange(rangeStart, rangeEnd, fullLength);
					response.status = 206;
					response.statusText = "Partial Content";
					response.headersList.set("content-length", serializedSlicedLength, true);
					response.headersList.set("content-type", type, true);
					response.headersList.set("content-range", contentRange, true);
				}
				return Promise.resolve(response);
			}
			case "data:": {
				const dataURLStruct = dataURLProcessor(requestCurrentURL(request));
				if (dataURLStruct === "failure") return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
				const mimeType = serializeAMimeType(dataURLStruct.mimeType);
				return Promise.resolve(makeResponse({
					statusText: "OK",
					headersList: [["content-type", {
						name: "Content-Type",
						value: mimeType
					}]],
					body: safelyExtractBody(dataURLStruct.body)[0]
				}));
			}
			case "file:": return Promise.resolve(makeNetworkError("not implemented... yet..."));
			case "http:":
			case "https:": return httpFetch(fetchParams).catch((err) => makeNetworkError(err));
			default: return Promise.resolve(makeNetworkError("unknown scheme"));
		}
	}
	function finalizeResponse(fetchParams, response) {
		fetchParams.request.done = true;
		if (fetchParams.processResponseDone != null) queueMicrotask(() => fetchParams.processResponseDone(response));
	}
	function fetchFinale(fetchParams, response) {
		let timingInfo = fetchParams.timingInfo;
		const processResponseEndOfBody = () => {
			const unsafeEndTime = Date.now();
			if (fetchParams.request.destination === "document") fetchParams.controller.fullTimingInfo = timingInfo;
			fetchParams.controller.reportTimingSteps = () => {
				if (fetchParams.request.url.protocol !== "https:") return;
				timingInfo.endTime = unsafeEndTime;
				let cacheState = response.cacheState;
				const bodyInfo = response.bodyInfo;
				if (!response.timingAllowPassed) {
					timingInfo = createOpaqueTimingInfo(timingInfo);
					cacheState = "";
				}
				let responseStatus = 0;
				if (fetchParams.request.mode !== "navigator" || !response.hasCrossOriginRedirects) {
					responseStatus = response.status;
					const mimeType = extractMimeType(response.headersList);
					if (mimeType !== "failure") bodyInfo.contentType = minimizeSupportedMimeType(mimeType);
				}
				if (fetchParams.request.initiatorType != null) markResourceTiming(timingInfo, fetchParams.request.url.href, fetchParams.request.initiatorType, globalThis, cacheState, bodyInfo, responseStatus);
			};
			const processResponseEndOfBodyTask = () => {
				fetchParams.request.done = true;
				if (fetchParams.processResponseEndOfBody != null) queueMicrotask(() => fetchParams.processResponseEndOfBody(response));
				if (fetchParams.request.initiatorType != null) fetchParams.controller.reportTimingSteps();
			};
			queueMicrotask(() => processResponseEndOfBodyTask());
		};
		if (fetchParams.processResponse != null) queueMicrotask(() => {
			fetchParams.processResponse(response);
			fetchParams.processResponse = null;
		});
		const internalResponse = response.type === "error" ? response : response.internalResponse ?? response;
		if (internalResponse.body == null) processResponseEndOfBody();
		else finished(internalResponse.body.stream, () => {
			processResponseEndOfBody();
		});
	}
	async function httpFetch(fetchParams) {
		const request = fetchParams.request;
		let response = null;
		let actualResponse = null;
		const timingInfo = fetchParams.timingInfo;
		if (request.serviceWorkers === "all") {}
		if (response === null) {
			if (request.redirect === "follow") request.serviceWorkers = "none";
			actualResponse = response = await httpNetworkOrCacheFetch(fetchParams);
			if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") return makeNetworkError("cors failure");
			if (TAOCheck(request, response) === "failure") request.timingAllowFailed = true;
		}
		if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(request.origin, request.client, request.destination, actualResponse) === "blocked") return makeNetworkError("blocked");
		if (redirectStatusSet.has(actualResponse.status)) {
			if (request.redirect !== "manual") fetchParams.controller.connection.destroy(void 0, false);
			if (request.redirect === "error") response = makeNetworkError("unexpected redirect");
			else if (request.redirect === "manual") response = actualResponse;
			else if (request.redirect === "follow") response = await httpRedirectFetch(fetchParams, response);
			else assert$4(false);
		}
		response.timingInfo = timingInfo;
		return response;
	}
	function httpRedirectFetch(fetchParams, response) {
		const request = fetchParams.request;
		const actualResponse = response.internalResponse ? response.internalResponse : response;
		let locationURL;
		try {
			locationURL = responseLocationURL(actualResponse, requestCurrentURL(request).hash);
			if (locationURL == null) return response;
		} catch (err) {
			return Promise.resolve(makeNetworkError(err));
		}
		if (!urlIsHttpHttpsScheme(locationURL)) return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme"));
		if (request.redirectCount === 20) return Promise.resolve(makeNetworkError("redirect count exceeded"));
		request.redirectCount += 1;
		if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) return Promise.resolve(makeNetworkError("cross origin not allowed for request mode \"cors\""));
		if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) return Promise.resolve(makeNetworkError("URL cannot contain credentials for request mode \"cors\""));
		if (actualResponse.status !== 303 && request.body != null && request.body.source == null) return Promise.resolve(makeNetworkError());
		if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) {
			request.method = "GET";
			request.body = null;
			for (const headerName of requestBodyHeader) request.headersList.delete(headerName);
		}
		if (!sameOrigin(requestCurrentURL(request), locationURL)) {
			request.headersList.delete("authorization", true);
			request.headersList.delete("proxy-authorization", true);
			request.headersList.delete("cookie", true);
			request.headersList.delete("host", true);
		}
		if (request.body != null) {
			assert$4(request.body.source != null);
			request.body = safelyExtractBody(request.body.source)[0];
		}
		const timingInfo = fetchParams.timingInfo;
		timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
		if (timingInfo.redirectStartTime === 0) timingInfo.redirectStartTime = timingInfo.startTime;
		request.urlList.push(locationURL);
		setRequestReferrerPolicyOnRedirect(request, actualResponse);
		return mainFetch(fetchParams, true);
	}
	async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) {
		const request = fetchParams.request;
		let httpFetchParams = null;
		let httpRequest = null;
		let response = null;
		const httpCache = null;
		if (request.window === "no-window" && request.redirect === "error") {
			httpFetchParams = fetchParams;
			httpRequest = request;
		} else {
			httpRequest = cloneRequest(request);
			httpFetchParams = { ...fetchParams };
			httpFetchParams.request = httpRequest;
		}
		const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic";
		const contentLength = httpRequest.body ? httpRequest.body.length : null;
		let contentLengthHeaderValue = null;
		if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) contentLengthHeaderValue = "0";
		if (contentLength != null) contentLengthHeaderValue = isomorphicEncode(`${contentLength}`);
		if (contentLengthHeaderValue != null) httpRequest.headersList.append("content-length", contentLengthHeaderValue, true);
		if (contentLength != null && httpRequest.keepalive) {}
		if (httpRequest.referrer instanceof URL) httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href), true);
		appendRequestOriginHeader(httpRequest);
		appendFetchMetadata(httpRequest);
		if (!httpRequest.headersList.contains("user-agent", true)) httpRequest.headersList.append("user-agent", defaultUserAgent);
		if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since", true) || httpRequest.headersList.contains("if-none-match", true) || httpRequest.headersList.contains("if-unmodified-since", true) || httpRequest.headersList.contains("if-match", true) || httpRequest.headersList.contains("if-range", true))) httpRequest.cache = "no-store";
		if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control", true)) httpRequest.headersList.append("cache-control", "max-age=0", true);
		if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") {
			if (!httpRequest.headersList.contains("pragma", true)) httpRequest.headersList.append("pragma", "no-cache", true);
			if (!httpRequest.headersList.contains("cache-control", true)) httpRequest.headersList.append("cache-control", "no-cache", true);
		}
		if (httpRequest.headersList.contains("range", true)) httpRequest.headersList.append("accept-encoding", "identity", true);
		if (!httpRequest.headersList.contains("accept-encoding", true)) if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) httpRequest.headersList.append("accept-encoding", "br, gzip, deflate", true);
		else httpRequest.headersList.append("accept-encoding", "gzip, deflate", true);
		httpRequest.headersList.delete("host", true);
		if (includeCredentials) {}
		if (httpCache == null) httpRequest.cache = "no-store";
		if (httpRequest.cache !== "no-store" && httpRequest.cache !== "reload") {}
		if (response == null) {
			if (httpRequest.cache === "only-if-cached") return makeNetworkError("only if cached");
			const forwardResponse = await httpNetworkFetch(httpFetchParams, includeCredentials, isNewConnectionFetch);
			if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) {}
			if (response == null) response = forwardResponse;
		}
		response.urlList = [...httpRequest.urlList];
		if (httpRequest.headersList.contains("range", true)) response.rangeRequested = true;
		response.requestIncludesCredentials = includeCredentials;
		if (response.status === 407) {
			if (request.window === "no-window") return makeNetworkError();
			if (isCancelled(fetchParams)) return makeAppropriateNetworkError(fetchParams);
			return makeNetworkError("proxy authentication required");
		}
		if (response.status === 421 && !isNewConnectionFetch && (request.body == null || request.body.source != null)) {
			if (isCancelled(fetchParams)) return makeAppropriateNetworkError(fetchParams);
			fetchParams.controller.connection.destroy();
			response = await httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch, true);
		}
		if (isAuthenticationFetch) {}
		return response;
	}
	async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) {
		assert$4(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
		fetchParams.controller.connection = {
			abort: null,
			destroyed: false,
			destroy(err, abort = true) {
				if (!this.destroyed) {
					this.destroyed = true;
					if (abort) this.abort?.(err ?? new DOMException("The operation was aborted.", "AbortError"));
				}
			}
		};
		const request = fetchParams.request;
		let response = null;
		const timingInfo = fetchParams.timingInfo;
		request.cache = "no-store";
		if (request.mode === "websocket") {}
		let requestBody = null;
		if (request.body == null && fetchParams.processRequestEndOfBody) queueMicrotask(() => fetchParams.processRequestEndOfBody());
		else if (request.body != null) {
			const processBodyChunk = async function* (bytes) {
				if (isCancelled(fetchParams)) return;
				yield bytes;
				fetchParams.processRequestBodyChunkLength?.(bytes.byteLength);
			};
			const processEndOfBody = () => {
				if (isCancelled(fetchParams)) return;
				if (fetchParams.processRequestEndOfBody) fetchParams.processRequestEndOfBody();
			};
			const processBodyError = (e) => {
				if (isCancelled(fetchParams)) return;
				if (e.name === "AbortError") fetchParams.controller.abort();
				else fetchParams.controller.terminate(e);
			};
			requestBody = (async function* () {
				try {
					for await (const bytes of request.body.stream) yield* processBodyChunk(bytes);
					processEndOfBody();
				} catch (err) {
					processBodyError(err);
				}
			})();
		}
		try {
			const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody });
			if (socket) response = makeResponse({
				status,
				statusText,
				headersList,
				socket
			});
			else {
				const iterator = body[Symbol.asyncIterator]();
				fetchParams.controller.next = () => iterator.next();
				response = makeResponse({
					status,
					statusText,
					headersList
				});
			}
		} catch (err) {
			if (err.name === "AbortError") {
				fetchParams.controller.connection.destroy();
				return makeAppropriateNetworkError(fetchParams, err);
			}
			return makeNetworkError(err);
		}
		const pullAlgorithm = async () => {
			await fetchParams.controller.resume();
		};
		const cancelAlgorithm = (reason) => {
			if (!isCancelled(fetchParams)) fetchParams.controller.abort(reason);
		};
		const stream = new ReadableStream({
			async start(controller) {
				fetchParams.controller.controller = controller;
			},
			async pull(controller) {
				await pullAlgorithm(controller);
			},
			async cancel(reason) {
				await cancelAlgorithm(reason);
			},
			type: "bytes"
		});
		response.body = {
			stream,
			source: null,
			length: null
		};
		fetchParams.controller.onAborted = onAborted;
		fetchParams.controller.on("terminated", onAborted);
		fetchParams.controller.resume = async () => {
			while (true) {
				let bytes;
				let isFailure;
				try {
					const { done, value } = await fetchParams.controller.next();
					if (isAborted(fetchParams)) break;
					bytes = done ? void 0 : value;
				} catch (err) {
					if (fetchParams.controller.ended && !timingInfo.encodedBodySize) bytes = void 0;
					else {
						bytes = err;
						isFailure = true;
					}
				}
				if (bytes === void 0) {
					readableStreamClose(fetchParams.controller.controller);
					finalizeResponse(fetchParams, response);
					return;
				}
				timingInfo.decodedBodySize += bytes?.byteLength ?? 0;
				if (isFailure) {
					fetchParams.controller.terminate(bytes);
					return;
				}
				const buffer = new Uint8Array(bytes);
				if (buffer.byteLength) fetchParams.controller.controller.enqueue(buffer);
				if (isErrored(stream)) {
					fetchParams.controller.terminate();
					return;
				}
				if (fetchParams.controller.controller.desiredSize <= 0) return;
			}
		};
		function onAborted(reason) {
			if (isAborted(fetchParams)) {
				response.aborted = true;
				if (isReadable(stream)) fetchParams.controller.controller.error(fetchParams.controller.serializedAbortReason);
			} else if (isReadable(stream)) fetchParams.controller.controller.error(new TypeError("terminated", { cause: isErrorLike(reason) ? reason : void 0 }));
			fetchParams.controller.connection.destroy();
		}
		return response;
		function dispatch({ body }) {
			const url = requestCurrentURL(request);
			/** @type {import('../..').Agent} */
			const agent = fetchParams.controller.dispatcher;
			return new Promise((resolve, reject) => agent.dispatch({
				path: url.pathname + url.search,
				origin: url.origin,
				method: request.method,
				body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
				headers: request.headersList.entries,
				maxRedirections: 0,
				upgrade: request.mode === "websocket" ? "websocket" : void 0
			}, {
				body: null,
				abort: null,
				onConnect(abort) {
					const { connection } = fetchParams.controller;
					timingInfo.finalConnectionTimingInfo = clampAndCoarsenConnectionTimingInfo(void 0, timingInfo.postRedirectStartTime, fetchParams.crossOriginIsolatedCapability);
					if (connection.destroyed) abort(new DOMException("The operation was aborted.", "AbortError"));
					else {
						fetchParams.controller.on("terminated", abort);
						this.abort = connection.abort = abort;
					}
					timingInfo.finalNetworkRequestStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
				},
				onResponseStarted() {
					timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
				},
				onHeaders(status, rawHeaders, resume, statusText) {
					if (status < 200) return;
					let location = "";
					const headersList = new HeadersList();
					for (let i = 0; i < rawHeaders.length; i += 2) headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true);
					location = headersList.get("location", true);
					this.body = new Readable({ read: resume });
					const decoders = [];
					const willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status);
					if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
						const contentEncoding = headersList.get("content-encoding", true);
						/** @type {string[]} */
						const codings = contentEncoding ? contentEncoding.toLowerCase().split(",") : [];
						const maxContentEncodings = 5;
						if (codings.length > maxContentEncodings) {
							reject(/* @__PURE__ */ new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`));
							return true;
						}
						for (let i = codings.length - 1; i >= 0; --i) {
							const coding = codings[i].trim();
							if (coding === "x-gzip" || coding === "gzip") decoders.push(zlib.createGunzip({
								flush: zlib.constants.Z_SYNC_FLUSH,
								finishFlush: zlib.constants.Z_SYNC_FLUSH
							}));
							else if (coding === "deflate") decoders.push(createInflate({
								flush: zlib.constants.Z_SYNC_FLUSH,
								finishFlush: zlib.constants.Z_SYNC_FLUSH
							}));
							else if (coding === "br") decoders.push(zlib.createBrotliDecompress({
								flush: zlib.constants.BROTLI_OPERATION_FLUSH,
								finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
							}));
							else {
								decoders.length = 0;
								break;
							}
						}
					}
					const onError = this.onError.bind(this);
					resolve({
						status,
						statusText,
						headersList,
						body: decoders.length ? pipeline$1(this.body, ...decoders, (err) => {
							if (err) this.onError(err);
						}).on("error", onError) : this.body.on("error", onError)
					});
					return true;
				},
				onData(chunk) {
					if (fetchParams.controller.dump) return;
					const bytes = chunk;
					timingInfo.encodedBodySize += bytes.byteLength;
					return this.body.push(bytes);
				},
				onComplete() {
					if (this.abort) fetchParams.controller.off("terminated", this.abort);
					if (fetchParams.controller.onAborted) fetchParams.controller.off("terminated", fetchParams.controller.onAborted);
					fetchParams.controller.ended = true;
					this.body.push(null);
				},
				onError(error) {
					if (this.abort) fetchParams.controller.off("terminated", this.abort);
					this.body?.destroy(error);
					fetchParams.controller.terminate(error);
					reject(error);
				},
				onUpgrade(status, rawHeaders, socket) {
					if (status !== 101) return;
					const headersList = new HeadersList();
					for (let i = 0; i < rawHeaders.length; i += 2) headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true);
					resolve({
						status,
						statusText: STATUS_CODES[status],
						headersList,
						socket
					});
					return true;
				}
			}));
		}
	}
	module.exports = {
		fetch,
		Fetch,
		fetching,
		finalizeAndReportTiming
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fileapi/symbols.js
var require_symbols$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = {
		kState: Symbol("FileReader state"),
		kResult: Symbol("FileReader result"),
		kError: Symbol("FileReader error"),
		kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"),
		kEvents: Symbol("FileReader events"),
		kAborted: Symbol("FileReader aborted")
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fileapi/progressevent.js
var require_progressevent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { webidl } = require_webidl();
	var kState = Symbol("ProgressEvent state");
	/**
	* @see https://xhr.spec.whatwg.org/#progressevent
	*/
	var ProgressEvent = class ProgressEvent extends Event {
		constructor(type, eventInitDict = {}) {
			type = webidl.converters.DOMString(type, "ProgressEvent constructor", "type");
			eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {});
			super(type, eventInitDict);
			this[kState] = {
				lengthComputable: eventInitDict.lengthComputable,
				loaded: eventInitDict.loaded,
				total: eventInitDict.total
			};
		}
		get lengthComputable() {
			webidl.brandCheck(this, ProgressEvent);
			return this[kState].lengthComputable;
		}
		get loaded() {
			webidl.brandCheck(this, ProgressEvent);
			return this[kState].loaded;
		}
		get total() {
			webidl.brandCheck(this, ProgressEvent);
			return this[kState].total;
		}
	};
	webidl.converters.ProgressEventInit = webidl.dictionaryConverter([
		{
			key: "lengthComputable",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		},
		{
			key: "loaded",
			converter: webidl.converters["unsigned long long"],
			defaultValue: () => 0
		},
		{
			key: "total",
			converter: webidl.converters["unsigned long long"],
			defaultValue: () => 0
		},
		{
			key: "bubbles",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		},
		{
			key: "cancelable",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		},
		{
			key: "composed",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		}
	]);
	module.exports = { ProgressEvent };
}));
//#endregion
//#region node_modules/undici/lib/web/fileapi/encoding.js
var require_encoding = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/**
	* @see https://encoding.spec.whatwg.org/#concept-encoding-get
	* @param {string|undefined} label
	*/
	function getEncoding(label) {
		if (!label) return "failure";
		switch (label.trim().toLowerCase()) {
			case "unicode-1-1-utf-8":
			case "unicode11utf8":
			case "unicode20utf8":
			case "utf-8":
			case "utf8":
			case "x-unicode20utf8": return "UTF-8";
			case "866":
			case "cp866":
			case "csibm866":
			case "ibm866": return "IBM866";
			case "csisolatin2":
			case "iso-8859-2":
			case "iso-ir-101":
			case "iso8859-2":
			case "iso88592":
			case "iso_8859-2":
			case "iso_8859-2:1987":
			case "l2":
			case "latin2": return "ISO-8859-2";
			case "csisolatin3":
			case "iso-8859-3":
			case "iso-ir-109":
			case "iso8859-3":
			case "iso88593":
			case "iso_8859-3":
			case "iso_8859-3:1988":
			case "l3":
			case "latin3": return "ISO-8859-3";
			case "csisolatin4":
			case "iso-8859-4":
			case "iso-ir-110":
			case "iso8859-4":
			case "iso88594":
			case "iso_8859-4":
			case "iso_8859-4:1988":
			case "l4":
			case "latin4": return "ISO-8859-4";
			case "csisolatincyrillic":
			case "cyrillic":
			case "iso-8859-5":
			case "iso-ir-144":
			case "iso8859-5":
			case "iso88595":
			case "iso_8859-5":
			case "iso_8859-5:1988": return "ISO-8859-5";
			case "arabic":
			case "asmo-708":
			case "csiso88596e":
			case "csiso88596i":
			case "csisolatinarabic":
			case "ecma-114":
			case "iso-8859-6":
			case "iso-8859-6-e":
			case "iso-8859-6-i":
			case "iso-ir-127":
			case "iso8859-6":
			case "iso88596":
			case "iso_8859-6":
			case "iso_8859-6:1987": return "ISO-8859-6";
			case "csisolatingreek":
			case "ecma-118":
			case "elot_928":
			case "greek":
			case "greek8":
			case "iso-8859-7":
			case "iso-ir-126":
			case "iso8859-7":
			case "iso88597":
			case "iso_8859-7":
			case "iso_8859-7:1987":
			case "sun_eu_greek": return "ISO-8859-7";
			case "csiso88598e":
			case "csisolatinhebrew":
			case "hebrew":
			case "iso-8859-8":
			case "iso-8859-8-e":
			case "iso-ir-138":
			case "iso8859-8":
			case "iso88598":
			case "iso_8859-8":
			case "iso_8859-8:1988":
			case "visual": return "ISO-8859-8";
			case "csiso88598i":
			case "iso-8859-8-i":
			case "logical": return "ISO-8859-8-I";
			case "csisolatin6":
			case "iso-8859-10":
			case "iso-ir-157":
			case "iso8859-10":
			case "iso885910":
			case "l6":
			case "latin6": return "ISO-8859-10";
			case "iso-8859-13":
			case "iso8859-13":
			case "iso885913": return "ISO-8859-13";
			case "iso-8859-14":
			case "iso8859-14":
			case "iso885914": return "ISO-8859-14";
			case "csisolatin9":
			case "iso-8859-15":
			case "iso8859-15":
			case "iso885915":
			case "iso_8859-15":
			case "l9": return "ISO-8859-15";
			case "iso-8859-16": return "ISO-8859-16";
			case "cskoi8r":
			case "koi":
			case "koi8":
			case "koi8-r":
			case "koi8_r": return "KOI8-R";
			case "koi8-ru":
			case "koi8-u": return "KOI8-U";
			case "csmacintosh":
			case "mac":
			case "macintosh":
			case "x-mac-roman": return "macintosh";
			case "iso-8859-11":
			case "iso8859-11":
			case "iso885911":
			case "tis-620":
			case "windows-874": return "windows-874";
			case "cp1250":
			case "windows-1250":
			case "x-cp1250": return "windows-1250";
			case "cp1251":
			case "windows-1251":
			case "x-cp1251": return "windows-1251";
			case "ansi_x3.4-1968":
			case "ascii":
			case "cp1252":
			case "cp819":
			case "csisolatin1":
			case "ibm819":
			case "iso-8859-1":
			case "iso-ir-100":
			case "iso8859-1":
			case "iso88591":
			case "iso_8859-1":
			case "iso_8859-1:1987":
			case "l1":
			case "latin1":
			case "us-ascii":
			case "windows-1252":
			case "x-cp1252": return "windows-1252";
			case "cp1253":
			case "windows-1253":
			case "x-cp1253": return "windows-1253";
			case "cp1254":
			case "csisolatin5":
			case "iso-8859-9":
			case "iso-ir-148":
			case "iso8859-9":
			case "iso88599":
			case "iso_8859-9":
			case "iso_8859-9:1989":
			case "l5":
			case "latin5":
			case "windows-1254":
			case "x-cp1254": return "windows-1254";
			case "cp1255":
			case "windows-1255":
			case "x-cp1255": return "windows-1255";
			case "cp1256":
			case "windows-1256":
			case "x-cp1256": return "windows-1256";
			case "cp1257":
			case "windows-1257":
			case "x-cp1257": return "windows-1257";
			case "cp1258":
			case "windows-1258":
			case "x-cp1258": return "windows-1258";
			case "x-mac-cyrillic":
			case "x-mac-ukrainian": return "x-mac-cyrillic";
			case "chinese":
			case "csgb2312":
			case "csiso58gb231280":
			case "gb2312":
			case "gb_2312":
			case "gb_2312-80":
			case "gbk":
			case "iso-ir-58":
			case "x-gbk": return "GBK";
			case "gb18030": return "gb18030";
			case "big5":
			case "big5-hkscs":
			case "cn-big5":
			case "csbig5":
			case "x-x-big5": return "Big5";
			case "cseucpkdfmtjapanese":
			case "euc-jp":
			case "x-euc-jp": return "EUC-JP";
			case "csiso2022jp":
			case "iso-2022-jp": return "ISO-2022-JP";
			case "csshiftjis":
			case "ms932":
			case "ms_kanji":
			case "shift-jis":
			case "shift_jis":
			case "sjis":
			case "windows-31j":
			case "x-sjis": return "Shift_JIS";
			case "cseuckr":
			case "csksc56011987":
			case "euc-kr":
			case "iso-ir-149":
			case "korean":
			case "ks_c_5601-1987":
			case "ks_c_5601-1989":
			case "ksc5601":
			case "ksc_5601":
			case "windows-949": return "EUC-KR";
			case "csiso2022kr":
			case "hz-gb-2312":
			case "iso-2022-cn":
			case "iso-2022-cn-ext":
			case "iso-2022-kr":
			case "replacement": return "replacement";
			case "unicodefffe":
			case "utf-16be": return "UTF-16BE";
			case "csunicode":
			case "iso-10646-ucs-2":
			case "ucs-2":
			case "unicode":
			case "unicodefeff":
			case "utf-16":
			case "utf-16le": return "UTF-16LE";
			case "x-user-defined": return "x-user-defined";
			default: return "failure";
		}
	}
	module.exports = { getEncoding };
}));
//#endregion
//#region node_modules/undici/lib/web/fileapi/util.js
var require_util$5 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kState, kError, kResult, kAborted, kLastProgressEventFired } = require_symbols$2();
	var { ProgressEvent } = require_progressevent();
	var { getEncoding } = require_encoding();
	var { serializeAMimeType, parseMIMEType } = require_data_url();
	var { types: types$1 } = __require("node:util");
	var { StringDecoder } = __require("string_decoder");
	var { btoa: btoa$1 } = __require("node:buffer");
	/** @type {PropertyDescriptor} */
	var staticPropertyDescriptors = {
		enumerable: true,
		writable: false,
		configurable: false
	};
	/**
	* @see https://w3c.github.io/FileAPI/#readOperation
	* @param {import('./filereader').FileReader} fr
	* @param {import('buffer').Blob} blob
	* @param {string} type
	* @param {string?} encodingName
	*/
	function readOperation(fr, blob, type, encodingName) {
		if (fr[kState] === "loading") throw new DOMException("Invalid state", "InvalidStateError");
		fr[kState] = "loading";
		fr[kResult] = null;
		fr[kError] = null;
		const reader = blob.stream().getReader();
		/** @type {Uint8Array[]} */
		const bytes = [];
		let chunkPromise = reader.read();
		let isFirstChunk = true;
		(async () => {
			while (!fr[kAborted]) try {
				const { done, value } = await chunkPromise;
				if (isFirstChunk && !fr[kAborted]) queueMicrotask(() => {
					fireAProgressEvent("loadstart", fr);
				});
				isFirstChunk = false;
				if (!done && types$1.isUint8Array(value)) {
					bytes.push(value);
					if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) {
						fr[kLastProgressEventFired] = Date.now();
						queueMicrotask(() => {
							fireAProgressEvent("progress", fr);
						});
					}
					chunkPromise = reader.read();
				} else if (done) {
					queueMicrotask(() => {
						fr[kState] = "done";
						try {
							const result = packageData(bytes, type, blob.type, encodingName);
							if (fr[kAborted]) return;
							fr[kResult] = result;
							fireAProgressEvent("load", fr);
						} catch (error) {
							fr[kError] = error;
							fireAProgressEvent("error", fr);
						}
						if (fr[kState] !== "loading") fireAProgressEvent("loadend", fr);
					});
					break;
				}
			} catch (error) {
				if (fr[kAborted]) return;
				queueMicrotask(() => {
					fr[kState] = "done";
					fr[kError] = error;
					fireAProgressEvent("error", fr);
					if (fr[kState] !== "loading") fireAProgressEvent("loadend", fr);
				});
				break;
			}
		})();
	}
	/**
	* @see https://w3c.github.io/FileAPI/#fire-a-progress-event
	* @see https://dom.spec.whatwg.org/#concept-event-fire
	* @param {string} e The name of the event
	* @param {import('./filereader').FileReader} reader
	*/
	function fireAProgressEvent(e, reader) {
		const event = new ProgressEvent(e, {
			bubbles: false,
			cancelable: false
		});
		reader.dispatchEvent(event);
	}
	/**
	* @see https://w3c.github.io/FileAPI/#blob-package-data
	* @param {Uint8Array[]} bytes
	* @param {string} type
	* @param {string?} mimeType
	* @param {string?} encodingName
	*/
	function packageData(bytes, type, mimeType, encodingName) {
		switch (type) {
			case "DataURL": {
				let dataURL = "data:";
				const parsed = parseMIMEType(mimeType || "application/octet-stream");
				if (parsed !== "failure") dataURL += serializeAMimeType(parsed);
				dataURL += ";base64,";
				const decoder = new StringDecoder("latin1");
				for (const chunk of bytes) dataURL += btoa$1(decoder.write(chunk));
				dataURL += btoa$1(decoder.end());
				return dataURL;
			}
			case "Text": {
				let encoding = "failure";
				if (encodingName) encoding = getEncoding(encodingName);
				if (encoding === "failure" && mimeType) {
					const type = parseMIMEType(mimeType);
					if (type !== "failure") encoding = getEncoding(type.parameters.get("charset"));
				}
				if (encoding === "failure") encoding = "UTF-8";
				return decode(bytes, encoding);
			}
			case "ArrayBuffer": return combineByteSequences(bytes).buffer;
			case "BinaryString": {
				let binaryString = "";
				const decoder = new StringDecoder("latin1");
				for (const chunk of bytes) binaryString += decoder.write(chunk);
				binaryString += decoder.end();
				return binaryString;
			}
		}
	}
	/**
	* @see https://encoding.spec.whatwg.org/#decode
	* @param {Uint8Array[]} ioQueue
	* @param {string} encoding
	*/
	function decode(ioQueue, encoding) {
		const bytes = combineByteSequences(ioQueue);
		const BOMEncoding = BOMSniffing(bytes);
		let slice = 0;
		if (BOMEncoding !== null) {
			encoding = BOMEncoding;
			slice = BOMEncoding === "UTF-8" ? 3 : 2;
		}
		const sliced = bytes.slice(slice);
		return new TextDecoder(encoding).decode(sliced);
	}
	/**
	* @see https://encoding.spec.whatwg.org/#bom-sniff
	* @param {Uint8Array} ioQueue
	*/
	function BOMSniffing(ioQueue) {
		const [a, b, c] = ioQueue;
		if (a === 239 && b === 187 && c === 191) return "UTF-8";
		else if (a === 254 && b === 255) return "UTF-16BE";
		else if (a === 255 && b === 254) return "UTF-16LE";
		return null;
	}
	/**
	* @param {Uint8Array[]} sequences
	*/
	function combineByteSequences(sequences) {
		const size = sequences.reduce((a, b) => {
			return a + b.byteLength;
		}, 0);
		let offset = 0;
		return sequences.reduce((a, b) => {
			a.set(b, offset);
			offset += b.byteLength;
			return a;
		}, new Uint8Array(size));
	}
	module.exports = {
		staticPropertyDescriptors,
		readOperation,
		fireAProgressEvent
	};
}));
//#endregion
//#region node_modules/undici/lib/web/fileapi/filereader.js
var require_filereader = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { staticPropertyDescriptors, readOperation, fireAProgressEvent } = require_util$5();
	var { kState, kError, kResult, kEvents, kAborted } = require_symbols$2();
	var { webidl } = require_webidl();
	var { kEnumerableProperty } = require_util$8();
	var FileReader = class FileReader extends EventTarget {
		constructor() {
			super();
			this[kState] = "empty";
			this[kResult] = null;
			this[kError] = null;
			this[kEvents] = {
				loadend: null,
				error: null,
				abort: null,
				load: null,
				progress: null,
				loadstart: null
			};
		}
		/**
		* @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
		* @param {import('buffer').Blob} blob
		*/
		readAsArrayBuffer(blob) {
			webidl.brandCheck(this, FileReader);
			webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsArrayBuffer");
			blob = webidl.converters.Blob(blob, { strict: false });
			readOperation(this, blob, "ArrayBuffer");
		}
		/**
		* @see https://w3c.github.io/FileAPI/#readAsBinaryString
		* @param {import('buffer').Blob} blob
		*/
		readAsBinaryString(blob) {
			webidl.brandCheck(this, FileReader);
			webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsBinaryString");
			blob = webidl.converters.Blob(blob, { strict: false });
			readOperation(this, blob, "BinaryString");
		}
		/**
		* @see https://w3c.github.io/FileAPI/#readAsDataText
		* @param {import('buffer').Blob} blob
		* @param {string?} encoding
		*/
		readAsText(blob, encoding = void 0) {
			webidl.brandCheck(this, FileReader);
			webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsText");
			blob = webidl.converters.Blob(blob, { strict: false });
			if (encoding !== void 0) encoding = webidl.converters.DOMString(encoding, "FileReader.readAsText", "encoding");
			readOperation(this, blob, "Text", encoding);
		}
		/**
		* @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL
		* @param {import('buffer').Blob} blob
		*/
		readAsDataURL(blob) {
			webidl.brandCheck(this, FileReader);
			webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsDataURL");
			blob = webidl.converters.Blob(blob, { strict: false });
			readOperation(this, blob, "DataURL");
		}
		/**
		* @see https://w3c.github.io/FileAPI/#dfn-abort
		*/
		abort() {
			if (this[kState] === "empty" || this[kState] === "done") {
				this[kResult] = null;
				return;
			}
			if (this[kState] === "loading") {
				this[kState] = "done";
				this[kResult] = null;
			}
			this[kAborted] = true;
			fireAProgressEvent("abort", this);
			if (this[kState] !== "loading") fireAProgressEvent("loadend", this);
		}
		/**
		* @see https://w3c.github.io/FileAPI/#dom-filereader-readystate
		*/
		get readyState() {
			webidl.brandCheck(this, FileReader);
			switch (this[kState]) {
				case "empty": return this.EMPTY;
				case "loading": return this.LOADING;
				case "done": return this.DONE;
			}
		}
		/**
		* @see https://w3c.github.io/FileAPI/#dom-filereader-result
		*/
		get result() {
			webidl.brandCheck(this, FileReader);
			return this[kResult];
		}
		/**
		* @see https://w3c.github.io/FileAPI/#dom-filereader-error
		*/
		get error() {
			webidl.brandCheck(this, FileReader);
			return this[kError];
		}
		get onloadend() {
			webidl.brandCheck(this, FileReader);
			return this[kEvents].loadend;
		}
		set onloadend(fn) {
			webidl.brandCheck(this, FileReader);
			if (this[kEvents].loadend) this.removeEventListener("loadend", this[kEvents].loadend);
			if (typeof fn === "function") {
				this[kEvents].loadend = fn;
				this.addEventListener("loadend", fn);
			} else this[kEvents].loadend = null;
		}
		get onerror() {
			webidl.brandCheck(this, FileReader);
			return this[kEvents].error;
		}
		set onerror(fn) {
			webidl.brandCheck(this, FileReader);
			if (this[kEvents].error) this.removeEventListener("error", this[kEvents].error);
			if (typeof fn === "function") {
				this[kEvents].error = fn;
				this.addEventListener("error", fn);
			} else this[kEvents].error = null;
		}
		get onloadstart() {
			webidl.brandCheck(this, FileReader);
			return this[kEvents].loadstart;
		}
		set onloadstart(fn) {
			webidl.brandCheck(this, FileReader);
			if (this[kEvents].loadstart) this.removeEventListener("loadstart", this[kEvents].loadstart);
			if (typeof fn === "function") {
				this[kEvents].loadstart = fn;
				this.addEventListener("loadstart", fn);
			} else this[kEvents].loadstart = null;
		}
		get onprogress() {
			webidl.brandCheck(this, FileReader);
			return this[kEvents].progress;
		}
		set onprogress(fn) {
			webidl.brandCheck(this, FileReader);
			if (this[kEvents].progress) this.removeEventListener("progress", this[kEvents].progress);
			if (typeof fn === "function") {
				this[kEvents].progress = fn;
				this.addEventListener("progress", fn);
			} else this[kEvents].progress = null;
		}
		get onload() {
			webidl.brandCheck(this, FileReader);
			return this[kEvents].load;
		}
		set onload(fn) {
			webidl.brandCheck(this, FileReader);
			if (this[kEvents].load) this.removeEventListener("load", this[kEvents].load);
			if (typeof fn === "function") {
				this[kEvents].load = fn;
				this.addEventListener("load", fn);
			} else this[kEvents].load = null;
		}
		get onabort() {
			webidl.brandCheck(this, FileReader);
			return this[kEvents].abort;
		}
		set onabort(fn) {
			webidl.brandCheck(this, FileReader);
			if (this[kEvents].abort) this.removeEventListener("abort", this[kEvents].abort);
			if (typeof fn === "function") {
				this[kEvents].abort = fn;
				this.addEventListener("abort", fn);
			} else this[kEvents].abort = null;
		}
	};
	FileReader.EMPTY = FileReader.prototype.EMPTY = 0;
	FileReader.LOADING = FileReader.prototype.LOADING = 1;
	FileReader.DONE = FileReader.prototype.DONE = 2;
	Object.defineProperties(FileReader.prototype, {
		EMPTY: staticPropertyDescriptors,
		LOADING: staticPropertyDescriptors,
		DONE: staticPropertyDescriptors,
		readAsArrayBuffer: kEnumerableProperty,
		readAsBinaryString: kEnumerableProperty,
		readAsText: kEnumerableProperty,
		readAsDataURL: kEnumerableProperty,
		abort: kEnumerableProperty,
		readyState: kEnumerableProperty,
		result: kEnumerableProperty,
		error: kEnumerableProperty,
		onloadstart: kEnumerableProperty,
		onprogress: kEnumerableProperty,
		onload: kEnumerableProperty,
		onabort: kEnumerableProperty,
		onerror: kEnumerableProperty,
		onloadend: kEnumerableProperty,
		[Symbol.toStringTag]: {
			value: "FileReader",
			writable: false,
			enumerable: false,
			configurable: true
		}
	});
	Object.defineProperties(FileReader, {
		EMPTY: staticPropertyDescriptors,
		LOADING: staticPropertyDescriptors,
		DONE: staticPropertyDescriptors
	});
	module.exports = { FileReader };
}));
//#endregion
//#region node_modules/undici/lib/web/cache/symbols.js
var require_symbols$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = { kConstruct: require_symbols$4().kConstruct };
}));
//#endregion
//#region node_modules/undici/lib/web/cache/util.js
var require_util$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$3 = __require("node:assert");
	var { URLSerializer } = require_data_url();
	var { isValidHeaderName } = require_util$7();
	/**
	* @see https://url.spec.whatwg.org/#concept-url-equals
	* @param {URL} A
	* @param {URL} B
	* @param {boolean | undefined} excludeFragment
	* @returns {boolean}
	*/
	function urlEquals(A, B, excludeFragment = false) {
		return URLSerializer(A, excludeFragment) === URLSerializer(B, excludeFragment);
	}
	/**
	* @see https://github.com/chromium/chromium/blob/694d20d134cb553d8d89e5500b9148012b1ba299/content/browser/cache_storage/cache_storage_cache.cc#L260-L262
	* @param {string} header
	*/
	function getFieldValues(header) {
		assert$3(header !== null);
		const values = [];
		for (let value of header.split(",")) {
			value = value.trim();
			if (isValidHeaderName(value)) values.push(value);
		}
		return values;
	}
	module.exports = {
		urlEquals,
		getFieldValues
	};
}));
//#endregion
//#region node_modules/undici/lib/web/cache/cache.js
var require_cache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kConstruct } = require_symbols$1();
	var { urlEquals, getFieldValues } = require_util$4();
	var { kEnumerableProperty, isDisturbed } = require_util$8();
	var { webidl } = require_webidl();
	var { Response, cloneResponse, fromInnerResponse } = require_response();
	var { Request, fromInnerRequest } = require_request();
	var { kState } = require_symbols$3();
	var { fetching } = require_fetch();
	var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util$7();
	var assert$2 = __require("node:assert");
	/**
	* @see https://w3c.github.io/ServiceWorker/#dfn-cache-batch-operation
	* @typedef {Object} CacheBatchOperation
	* @property {'delete' | 'put'} type
	* @property {any} request
	* @property {any} response
	* @property {import('../../types/cache').CacheQueryOptions} options
	*/
	/**
	* @see https://w3c.github.io/ServiceWorker/#dfn-request-response-list
	* @typedef {[any, any][]} requestResponseList
	*/
	var Cache = class Cache {
		/**
		* @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list
		* @type {requestResponseList}
		*/
		#relevantRequestResponseList;
		constructor() {
			if (arguments[0] !== kConstruct) webidl.illegalConstructor();
			webidl.util.markAsUncloneable(this);
			this.#relevantRequestResponseList = arguments[1];
		}
		async match(request, options = {}) {
			webidl.brandCheck(this, Cache);
			const prefix = "Cache.match";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			request = webidl.converters.RequestInfo(request, prefix, "request");
			options = webidl.converters.CacheQueryOptions(options, prefix, "options");
			const p = this.#internalMatchAll(request, options, 1);
			if (p.length === 0) return;
			return p[0];
		}
		async matchAll(request = void 0, options = {}) {
			webidl.brandCheck(this, Cache);
			const prefix = "Cache.matchAll";
			if (request !== void 0) request = webidl.converters.RequestInfo(request, prefix, "request");
			options = webidl.converters.CacheQueryOptions(options, prefix, "options");
			return this.#internalMatchAll(request, options);
		}
		async add(request) {
			webidl.brandCheck(this, Cache);
			const prefix = "Cache.add";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			request = webidl.converters.RequestInfo(request, prefix, "request");
			const requests = [request];
			return await this.addAll(requests);
		}
		async addAll(requests) {
			webidl.brandCheck(this, Cache);
			const prefix = "Cache.addAll";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			const responsePromises = [];
			const requestList = [];
			for (let request of requests) {
				if (request === void 0) throw webidl.errors.conversionFailed({
					prefix,
					argument: "Argument 1",
					types: ["undefined is not allowed"]
				});
				request = webidl.converters.RequestInfo(request);
				if (typeof request === "string") continue;
				const r = request[kState];
				if (!urlIsHttpHttpsScheme(r.url) || r.method !== "GET") throw webidl.errors.exception({
					header: prefix,
					message: "Expected http/s scheme when method is not GET."
				});
			}
			/** @type {ReturnType<typeof fetching>[]} */
			const fetchControllers = [];
			for (const request of requests) {
				const r = new Request(request)[kState];
				if (!urlIsHttpHttpsScheme(r.url)) throw webidl.errors.exception({
					header: prefix,
					message: "Expected http/s scheme."
				});
				r.initiator = "fetch";
				r.destination = "subresource";
				requestList.push(r);
				const responsePromise = createDeferredPromise();
				fetchControllers.push(fetching({
					request: r,
					processResponse(response) {
						if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) responsePromise.reject(webidl.errors.exception({
							header: "Cache.addAll",
							message: "Received an invalid status code or the request failed."
						}));
						else if (response.headersList.contains("vary")) {
							const fieldValues = getFieldValues(response.headersList.get("vary"));
							for (const fieldValue of fieldValues) if (fieldValue === "*") {
								responsePromise.reject(webidl.errors.exception({
									header: "Cache.addAll",
									message: "invalid vary field value"
								}));
								for (const controller of fetchControllers) controller.abort();
								return;
							}
						}
					},
					processResponseEndOfBody(response) {
						if (response.aborted) {
							responsePromise.reject(new DOMException("aborted", "AbortError"));
							return;
						}
						responsePromise.resolve(response);
					}
				}));
				responsePromises.push(responsePromise.promise);
			}
			const responses = await Promise.all(responsePromises);
			const operations = [];
			let index = 0;
			for (const response of responses) {
				/** @type {CacheBatchOperation} */
				const operation = {
					type: "put",
					request: requestList[index],
					response
				};
				operations.push(operation);
				index++;
			}
			const cacheJobPromise = createDeferredPromise();
			let errorData = null;
			try {
				this.#batchCacheOperations(operations);
			} catch (e) {
				errorData = e;
			}
			queueMicrotask(() => {
				if (errorData === null) cacheJobPromise.resolve(void 0);
				else cacheJobPromise.reject(errorData);
			});
			return cacheJobPromise.promise;
		}
		async put(request, response) {
			webidl.brandCheck(this, Cache);
			const prefix = "Cache.put";
			webidl.argumentLengthCheck(arguments, 2, prefix);
			request = webidl.converters.RequestInfo(request, prefix, "request");
			response = webidl.converters.Response(response, prefix, "response");
			let innerRequest = null;
			if (request instanceof Request) innerRequest = request[kState];
			else innerRequest = new Request(request)[kState];
			if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") throw webidl.errors.exception({
				header: prefix,
				message: "Expected an http/s scheme when method is not GET"
			});
			const innerResponse = response[kState];
			if (innerResponse.status === 206) throw webidl.errors.exception({
				header: prefix,
				message: "Got 206 status"
			});
			if (innerResponse.headersList.contains("vary")) {
				const fieldValues = getFieldValues(innerResponse.headersList.get("vary"));
				for (const fieldValue of fieldValues) if (fieldValue === "*") throw webidl.errors.exception({
					header: prefix,
					message: "Got * vary field value"
				});
			}
			if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) throw webidl.errors.exception({
				header: prefix,
				message: "Response body is locked or disturbed"
			});
			const clonedResponse = cloneResponse(innerResponse);
			const bodyReadPromise = createDeferredPromise();
			if (innerResponse.body != null) readAllBytes(innerResponse.body.stream.getReader()).then(bodyReadPromise.resolve, bodyReadPromise.reject);
			else bodyReadPromise.resolve(void 0);
			/** @type {CacheBatchOperation[]} */
			const operations = [];
			/** @type {CacheBatchOperation} */
			const operation = {
				type: "put",
				request: innerRequest,
				response: clonedResponse
			};
			operations.push(operation);
			const bytes = await bodyReadPromise.promise;
			if (clonedResponse.body != null) clonedResponse.body.source = bytes;
			const cacheJobPromise = createDeferredPromise();
			let errorData = null;
			try {
				this.#batchCacheOperations(operations);
			} catch (e) {
				errorData = e;
			}
			queueMicrotask(() => {
				if (errorData === null) cacheJobPromise.resolve();
				else cacheJobPromise.reject(errorData);
			});
			return cacheJobPromise.promise;
		}
		async delete(request, options = {}) {
			webidl.brandCheck(this, Cache);
			const prefix = "Cache.delete";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			request = webidl.converters.RequestInfo(request, prefix, "request");
			options = webidl.converters.CacheQueryOptions(options, prefix, "options");
			/**
			* @type {Request}
			*/
			let r = null;
			if (request instanceof Request) {
				r = request[kState];
				if (r.method !== "GET" && !options.ignoreMethod) return false;
			} else {
				assert$2(typeof request === "string");
				r = new Request(request)[kState];
			}
			/** @type {CacheBatchOperation[]} */
			const operations = [];
			/** @type {CacheBatchOperation} */
			const operation = {
				type: "delete",
				request: r,
				options
			};
			operations.push(operation);
			const cacheJobPromise = createDeferredPromise();
			let errorData = null;
			let requestResponses;
			try {
				requestResponses = this.#batchCacheOperations(operations);
			} catch (e) {
				errorData = e;
			}
			queueMicrotask(() => {
				if (errorData === null) cacheJobPromise.resolve(!!requestResponses?.length);
				else cacheJobPromise.reject(errorData);
			});
			return cacheJobPromise.promise;
		}
		/**
		* @see https://w3c.github.io/ServiceWorker/#dom-cache-keys
		* @param {any} request
		* @param {import('../../types/cache').CacheQueryOptions} options
		* @returns {Promise<readonly Request[]>}
		*/
		async keys(request = void 0, options = {}) {
			webidl.brandCheck(this, Cache);
			const prefix = "Cache.keys";
			if (request !== void 0) request = webidl.converters.RequestInfo(request, prefix, "request");
			options = webidl.converters.CacheQueryOptions(options, prefix, "options");
			let r = null;
			if (request !== void 0) {
				if (request instanceof Request) {
					r = request[kState];
					if (r.method !== "GET" && !options.ignoreMethod) return [];
				} else if (typeof request === "string") r = new Request(request)[kState];
			}
			const promise = createDeferredPromise();
			const requests = [];
			if (request === void 0) for (const requestResponse of this.#relevantRequestResponseList) requests.push(requestResponse[0]);
			else {
				const requestResponses = this.#queryCache(r, options);
				for (const requestResponse of requestResponses) requests.push(requestResponse[0]);
			}
			queueMicrotask(() => {
				const requestList = [];
				for (const request of requests) {
					const requestObject = fromInnerRequest(request, new AbortController().signal, "immutable");
					requestList.push(requestObject);
				}
				promise.resolve(Object.freeze(requestList));
			});
			return promise.promise;
		}
		/**
		* @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm
		* @param {CacheBatchOperation[]} operations
		* @returns {requestResponseList}
		*/
		#batchCacheOperations(operations) {
			const cache = this.#relevantRequestResponseList;
			const backupCache = [...cache];
			const addedItems = [];
			const resultList = [];
			try {
				for (const operation of operations) {
					if (operation.type !== "delete" && operation.type !== "put") throw webidl.errors.exception({
						header: "Cache.#batchCacheOperations",
						message: "operation type does not match \"delete\" or \"put\""
					});
					if (operation.type === "delete" && operation.response != null) throw webidl.errors.exception({
						header: "Cache.#batchCacheOperations",
						message: "delete operation should not have an associated response"
					});
					if (this.#queryCache(operation.request, operation.options, addedItems).length) throw new DOMException("???", "InvalidStateError");
					let requestResponses;
					if (operation.type === "delete") {
						requestResponses = this.#queryCache(operation.request, operation.options);
						if (requestResponses.length === 0) return [];
						for (const requestResponse of requestResponses) {
							const idx = cache.indexOf(requestResponse);
							assert$2(idx !== -1);
							cache.splice(idx, 1);
						}
					} else if (operation.type === "put") {
						if (operation.response == null) throw webidl.errors.exception({
							header: "Cache.#batchCacheOperations",
							message: "put operation should have an associated response"
						});
						const r = operation.request;
						if (!urlIsHttpHttpsScheme(r.url)) throw webidl.errors.exception({
							header: "Cache.#batchCacheOperations",
							message: "expected http or https scheme"
						});
						if (r.method !== "GET") throw webidl.errors.exception({
							header: "Cache.#batchCacheOperations",
							message: "not get method"
						});
						if (operation.options != null) throw webidl.errors.exception({
							header: "Cache.#batchCacheOperations",
							message: "options must not be defined"
						});
						requestResponses = this.#queryCache(operation.request);
						for (const requestResponse of requestResponses) {
							const idx = cache.indexOf(requestResponse);
							assert$2(idx !== -1);
							cache.splice(idx, 1);
						}
						cache.push([operation.request, operation.response]);
						addedItems.push([operation.request, operation.response]);
					}
					resultList.push([operation.request, operation.response]);
				}
				return resultList;
			} catch (e) {
				this.#relevantRequestResponseList.length = 0;
				this.#relevantRequestResponseList = backupCache;
				throw e;
			}
		}
		/**
		* @see https://w3c.github.io/ServiceWorker/#query-cache
		* @param {any} requestQuery
		* @param {import('../../types/cache').CacheQueryOptions} options
		* @param {requestResponseList} targetStorage
		* @returns {requestResponseList}
		*/
		#queryCache(requestQuery, options, targetStorage) {
			/** @type {requestResponseList} */
			const resultList = [];
			const storage = targetStorage ?? this.#relevantRequestResponseList;
			for (const requestResponse of storage) {
				const [cachedRequest, cachedResponse] = requestResponse;
				if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) resultList.push(requestResponse);
			}
			return resultList;
		}
		/**
		* @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm
		* @param {any} requestQuery
		* @param {any} request
		* @param {any | null} response
		* @param {import('../../types/cache').CacheQueryOptions | undefined} options
		* @returns {boolean}
		*/
		#requestMatchesCachedItem(requestQuery, request, response = null, options) {
			const queryURL = new URL(requestQuery.url);
			const cachedURL = new URL(request.url);
			if (options?.ignoreSearch) {
				cachedURL.search = "";
				queryURL.search = "";
			}
			if (!urlEquals(queryURL, cachedURL, true)) return false;
			if (response == null || options?.ignoreVary || !response.headersList.contains("vary")) return true;
			const fieldValues = getFieldValues(response.headersList.get("vary"));
			for (const fieldValue of fieldValues) {
				if (fieldValue === "*") return false;
				if (request.headersList.get(fieldValue) !== requestQuery.headersList.get(fieldValue)) return false;
			}
			return true;
		}
		#internalMatchAll(request, options, maxResponses = Infinity) {
			let r = null;
			if (request !== void 0) {
				if (request instanceof Request) {
					r = request[kState];
					if (r.method !== "GET" && !options.ignoreMethod) return [];
				} else if (typeof request === "string") r = new Request(request)[kState];
			}
			const responses = [];
			if (request === void 0) for (const requestResponse of this.#relevantRequestResponseList) responses.push(requestResponse[1]);
			else {
				const requestResponses = this.#queryCache(r, options);
				for (const requestResponse of requestResponses) responses.push(requestResponse[1]);
			}
			const responseList = [];
			for (const response of responses) {
				const responseObject = fromInnerResponse(response, "immutable");
				responseList.push(responseObject.clone());
				if (responseList.length >= maxResponses) break;
			}
			return Object.freeze(responseList);
		}
	};
	Object.defineProperties(Cache.prototype, {
		[Symbol.toStringTag]: {
			value: "Cache",
			configurable: true
		},
		match: kEnumerableProperty,
		matchAll: kEnumerableProperty,
		add: kEnumerableProperty,
		addAll: kEnumerableProperty,
		put: kEnumerableProperty,
		delete: kEnumerableProperty,
		keys: kEnumerableProperty
	});
	var cacheQueryOptionConverters = [
		{
			key: "ignoreSearch",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		},
		{
			key: "ignoreMethod",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		},
		{
			key: "ignoreVary",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		}
	];
	webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters);
	webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([...cacheQueryOptionConverters, {
		key: "cacheName",
		converter: webidl.converters.DOMString
	}]);
	webidl.converters.Response = webidl.interfaceConverter(Response);
	webidl.converters["sequence<RequestInfo>"] = webidl.sequenceConverter(webidl.converters.RequestInfo);
	module.exports = { Cache };
}));
//#endregion
//#region node_modules/undici/lib/web/cache/cachestorage.js
var require_cachestorage = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kConstruct } = require_symbols$1();
	var { Cache } = require_cache();
	var { webidl } = require_webidl();
	var { kEnumerableProperty } = require_util$8();
	var CacheStorage = class CacheStorage {
		/**
		* @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map
		* @type {Map<string, import('./cache').requestResponseList}
		*/
		#caches = /* @__PURE__ */ new Map();
		constructor() {
			if (arguments[0] !== kConstruct) webidl.illegalConstructor();
			webidl.util.markAsUncloneable(this);
		}
		async match(request, options = {}) {
			webidl.brandCheck(this, CacheStorage);
			webidl.argumentLengthCheck(arguments, 1, "CacheStorage.match");
			request = webidl.converters.RequestInfo(request);
			options = webidl.converters.MultiCacheQueryOptions(options);
			if (options.cacheName != null) {
				if (this.#caches.has(options.cacheName)) return await new Cache(kConstruct, this.#caches.get(options.cacheName)).match(request, options);
			} else for (const cacheList of this.#caches.values()) {
				const response = await new Cache(kConstruct, cacheList).match(request, options);
				if (response !== void 0) return response;
			}
		}
		/**
		* @see https://w3c.github.io/ServiceWorker/#cache-storage-has
		* @param {string} cacheName
		* @returns {Promise<boolean>}
		*/
		async has(cacheName) {
			webidl.brandCheck(this, CacheStorage);
			const prefix = "CacheStorage.has";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			cacheName = webidl.converters.DOMString(cacheName, prefix, "cacheName");
			return this.#caches.has(cacheName);
		}
		/**
		* @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open
		* @param {string} cacheName
		* @returns {Promise<Cache>}
		*/
		async open(cacheName) {
			webidl.brandCheck(this, CacheStorage);
			const prefix = "CacheStorage.open";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			cacheName = webidl.converters.DOMString(cacheName, prefix, "cacheName");
			if (this.#caches.has(cacheName)) return new Cache(kConstruct, this.#caches.get(cacheName));
			const cache = [];
			this.#caches.set(cacheName, cache);
			return new Cache(kConstruct, cache);
		}
		/**
		* @see https://w3c.github.io/ServiceWorker/#cache-storage-delete
		* @param {string} cacheName
		* @returns {Promise<boolean>}
		*/
		async delete(cacheName) {
			webidl.brandCheck(this, CacheStorage);
			const prefix = "CacheStorage.delete";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			cacheName = webidl.converters.DOMString(cacheName, prefix, "cacheName");
			return this.#caches.delete(cacheName);
		}
		/**
		* @see https://w3c.github.io/ServiceWorker/#cache-storage-keys
		* @returns {Promise<string[]>}
		*/
		async keys() {
			webidl.brandCheck(this, CacheStorage);
			return [...this.#caches.keys()];
		}
	};
	Object.defineProperties(CacheStorage.prototype, {
		[Symbol.toStringTag]: {
			value: "CacheStorage",
			configurable: true
		},
		match: kEnumerableProperty,
		has: kEnumerableProperty,
		open: kEnumerableProperty,
		delete: kEnumerableProperty,
		keys: kEnumerableProperty
	});
	module.exports = { CacheStorage };
}));
//#endregion
//#region node_modules/undici/lib/web/cookies/constants.js
var require_constants$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = {
		maxAttributeValueSize: 1024,
		maxNameValuePairSize: 4096
	};
}));
//#endregion
//#region node_modules/undici/lib/web/cookies/util.js
var require_util$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/**
	* @param {string} value
	* @returns {boolean}
	*/
	function isCTLExcludingHtab(value) {
		for (let i = 0; i < value.length; ++i) {
			const code = value.charCodeAt(i);
			if (code >= 0 && code <= 8 || code >= 10 && code <= 31 || code === 127) return true;
		}
		return false;
	}
	/**
	CHAR           = <any US-ASCII character (octets 0 - 127)>
	token          = 1*<any CHAR except CTLs or separators>
	separators     = "(" | ")" | "<" | ">" | "@"
	| "," | ";" | ":" | "\" | <">
	| "/" | "[" | "]" | "?" | "="
	| "{" | "}" | SP | HT
	* @param {string} name
	*/
	function validateCookieName(name) {
		for (let i = 0; i < name.length; ++i) {
			const code = name.charCodeAt(i);
			if (code < 33 || code > 126 || code === 34 || code === 40 || code === 41 || code === 60 || code === 62 || code === 64 || code === 44 || code === 59 || code === 58 || code === 92 || code === 47 || code === 91 || code === 93 || code === 63 || code === 61 || code === 123 || code === 125) throw new Error("Invalid cookie name");
		}
	}
	/**
	cookie-value      = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
	cookie-octet      = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
	; US-ASCII characters excluding CTLs,
	; whitespace DQUOTE, comma, semicolon,
	; and backslash
	* @param {string} value
	*/
	function validateCookieValue(value) {
		let len = value.length;
		let i = 0;
		if (value[0] === "\"") {
			if (len === 1 || value[len - 1] !== "\"") throw new Error("Invalid cookie value");
			--len;
			++i;
		}
		while (i < len) {
			const code = value.charCodeAt(i++);
			if (code < 33 || code > 126 || code === 34 || code === 44 || code === 59 || code === 92) throw new Error("Invalid cookie value");
		}
	}
	/**
	* path-value        = <any CHAR except CTLs or ";">
	* @param {string} path
	*/
	function validateCookiePath(path) {
		for (let i = 0; i < path.length; ++i) {
			const code = path.charCodeAt(i);
			if (code < 32 || code === 127 || code === 59) throw new Error("Invalid cookie path");
		}
	}
	/**
	* I have no idea why these values aren't allowed to be honest,
	* but Deno tests these. - Khafra
	* @param {string} domain
	*/
	function validateCookieDomain(domain) {
		if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) throw new Error("Invalid cookie domain");
	}
	var IMFDays = [
		"Sun",
		"Mon",
		"Tue",
		"Wed",
		"Thu",
		"Fri",
		"Sat"
	];
	var IMFMonths = [
		"Jan",
		"Feb",
		"Mar",
		"Apr",
		"May",
		"Jun",
		"Jul",
		"Aug",
		"Sep",
		"Oct",
		"Nov",
		"Dec"
	];
	var IMFPaddedNumbers = Array(61).fill(0).map((_, i) => i.toString().padStart(2, "0"));
	/**
	* @see https://www.rfc-editor.org/rfc/rfc7231#section-7.1.1.1
	* @param {number|Date} date
	IMF-fixdate  = day-name "," SP date1 SP time-of-day SP GMT
	; fixed length/zone/capitalization subset of the format
	; see Section 3.3 of [RFC5322]
	
	day-name     = %x4D.6F.6E ; "Mon", case-sensitive
	/ %x54.75.65 ; "Tue", case-sensitive
	/ %x57.65.64 ; "Wed", case-sensitive
	/ %x54.68.75 ; "Thu", case-sensitive
	/ %x46.72.69 ; "Fri", case-sensitive
	/ %x53.61.74 ; "Sat", case-sensitive
	/ %x53.75.6E ; "Sun", case-sensitive
	date1        = day SP month SP year
	; e.g., 02 Jun 1982
	
	day          = 2DIGIT
	month        = %x4A.61.6E ; "Jan", case-sensitive
	/ %x46.65.62 ; "Feb", case-sensitive
	/ %x4D.61.72 ; "Mar", case-sensitive
	/ %x41.70.72 ; "Apr", case-sensitive
	/ %x4D.61.79 ; "May", case-sensitive
	/ %x4A.75.6E ; "Jun", case-sensitive
	/ %x4A.75.6C ; "Jul", case-sensitive
	/ %x41.75.67 ; "Aug", case-sensitive
	/ %x53.65.70 ; "Sep", case-sensitive
	/ %x4F.63.74 ; "Oct", case-sensitive
	/ %x4E.6F.76 ; "Nov", case-sensitive
	/ %x44.65.63 ; "Dec", case-sensitive
	year         = 4DIGIT
	
	GMT          = %x47.4D.54 ; "GMT", case-sensitive
	
	time-of-day  = hour ":" minute ":" second
	; 00:00:00 - 23:59:60 (leap second)
	
	hour         = 2DIGIT
	minute       = 2DIGIT
	second       = 2DIGIT
	*/
	function toIMFDate(date) {
		if (typeof date === "number") date = new Date(date);
		return `${IMFDays[date.getUTCDay()]}, ${IMFPaddedNumbers[date.getUTCDate()]} ${IMFMonths[date.getUTCMonth()]} ${date.getUTCFullYear()} ${IMFPaddedNumbers[date.getUTCHours()]}:${IMFPaddedNumbers[date.getUTCMinutes()]}:${IMFPaddedNumbers[date.getUTCSeconds()]} GMT`;
	}
	/**
	max-age-av        = "Max-Age=" non-zero-digit *DIGIT
	; In practice, both expires-av and max-age-av
	; are limited to dates representable by the
	; user agent.
	* @param {number} maxAge
	*/
	function validateCookieMaxAge(maxAge) {
		if (maxAge < 0) throw new Error("Invalid cookie max-age");
	}
	/**
	* @see https://www.rfc-editor.org/rfc/rfc6265#section-4.1.1
	* @param {import('./index').Cookie} cookie
	*/
	function stringify(cookie) {
		if (cookie.name.length === 0) return null;
		validateCookieName(cookie.name);
		validateCookieValue(cookie.value);
		const out = [`${cookie.name}=${cookie.value}`];
		if (cookie.name.startsWith("__Secure-")) cookie.secure = true;
		if (cookie.name.startsWith("__Host-")) {
			cookie.secure = true;
			cookie.domain = null;
			cookie.path = "/";
		}
		if (cookie.secure) out.push("Secure");
		if (cookie.httpOnly) out.push("HttpOnly");
		if (typeof cookie.maxAge === "number") {
			validateCookieMaxAge(cookie.maxAge);
			out.push(`Max-Age=${cookie.maxAge}`);
		}
		if (cookie.domain) {
			validateCookieDomain(cookie.domain);
			out.push(`Domain=${cookie.domain}`);
		}
		if (cookie.path) {
			validateCookiePath(cookie.path);
			out.push(`Path=${cookie.path}`);
		}
		if (cookie.expires && cookie.expires.toString() !== "Invalid Date") out.push(`Expires=${toIMFDate(cookie.expires)}`);
		if (cookie.sameSite) out.push(`SameSite=${cookie.sameSite}`);
		for (const part of cookie.unparsed) {
			if (!part.includes("=")) throw new Error("Invalid unparsed");
			const [key, ...value] = part.split("=");
			out.push(`${key.trim()}=${value.join("=")}`);
		}
		return out.join("; ");
	}
	module.exports = {
		isCTLExcludingHtab,
		validateCookieName,
		validateCookiePath,
		validateCookieValue,
		toIMFDate,
		stringify
	};
}));
//#endregion
//#region node_modules/undici/lib/web/cookies/parse.js
var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { maxNameValuePairSize, maxAttributeValueSize } = require_constants$1();
	var { isCTLExcludingHtab } = require_util$3();
	var { collectASequenceOfCodePointsFast } = require_data_url();
	var assert$1 = __require("node:assert");
	/**
	* @description Parses the field-value attributes of a set-cookie header string.
	* @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4
	* @param {string} header
	* @returns if the header is invalid, null will be returned
	*/
	function parseSetCookie(header) {
		if (isCTLExcludingHtab(header)) return null;
		let nameValuePair = "";
		let unparsedAttributes = "";
		let name = "";
		let value = "";
		if (header.includes(";")) {
			const position = { position: 0 };
			nameValuePair = collectASequenceOfCodePointsFast(";", header, position);
			unparsedAttributes = header.slice(position.position);
		} else nameValuePair = header;
		if (!nameValuePair.includes("=")) value = nameValuePair;
		else {
			const position = { position: 0 };
			name = collectASequenceOfCodePointsFast("=", nameValuePair, position);
			value = nameValuePair.slice(position.position + 1);
		}
		name = name.trim();
		value = value.trim();
		if (name.length + value.length > maxNameValuePairSize) return null;
		return {
			name,
			value,
			...parseUnparsedAttributes(unparsedAttributes)
		};
	}
	/**
	* Parses the remaining attributes of a set-cookie header
	* @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4
	* @param {string} unparsedAttributes
	* @param {[Object.<string, unknown>]={}} cookieAttributeList
	*/
	function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) {
		if (unparsedAttributes.length === 0) return cookieAttributeList;
		assert$1(unparsedAttributes[0] === ";");
		unparsedAttributes = unparsedAttributes.slice(1);
		let cookieAv = "";
		if (unparsedAttributes.includes(";")) {
			cookieAv = collectASequenceOfCodePointsFast(";", unparsedAttributes, { position: 0 });
			unparsedAttributes = unparsedAttributes.slice(cookieAv.length);
		} else {
			cookieAv = unparsedAttributes;
			unparsedAttributes = "";
		}
		let attributeName = "";
		let attributeValue = "";
		if (cookieAv.includes("=")) {
			const position = { position: 0 };
			attributeName = collectASequenceOfCodePointsFast("=", cookieAv, position);
			attributeValue = cookieAv.slice(position.position + 1);
		} else attributeName = cookieAv;
		attributeName = attributeName.trim();
		attributeValue = attributeValue.trim();
		if (attributeValue.length > maxAttributeValueSize) return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
		const attributeNameLowercase = attributeName.toLowerCase();
		if (attributeNameLowercase === "expires") cookieAttributeList.expires = new Date(attributeValue);
		else if (attributeNameLowercase === "max-age") {
			const charCode = attributeValue.charCodeAt(0);
			if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
			if (!/^\d+$/.test(attributeValue)) return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
			cookieAttributeList.maxAge = Number(attributeValue);
		} else if (attributeNameLowercase === "domain") {
			let cookieDomain = attributeValue;
			if (cookieDomain[0] === ".") cookieDomain = cookieDomain.slice(1);
			cookieDomain = cookieDomain.toLowerCase();
			cookieAttributeList.domain = cookieDomain;
		} else if (attributeNameLowercase === "path") {
			let cookiePath = "";
			if (attributeValue.length === 0 || attributeValue[0] !== "/") cookiePath = "/";
			else cookiePath = attributeValue;
			cookieAttributeList.path = cookiePath;
		} else if (attributeNameLowercase === "secure") cookieAttributeList.secure = true;
		else if (attributeNameLowercase === "httponly") cookieAttributeList.httpOnly = true;
		else if (attributeNameLowercase === "samesite") {
			let enforcement = "Default";
			const attributeValueLowercase = attributeValue.toLowerCase();
			if (attributeValueLowercase.includes("none")) enforcement = "None";
			if (attributeValueLowercase.includes("strict")) enforcement = "Strict";
			if (attributeValueLowercase.includes("lax")) enforcement = "Lax";
			cookieAttributeList.sameSite = enforcement;
		} else {
			cookieAttributeList.unparsed ??= [];
			cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`);
		}
		return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
	}
	module.exports = {
		parseSetCookie,
		parseUnparsedAttributes
	};
}));
//#endregion
//#region node_modules/undici/lib/web/cookies/index.js
var require_cookies = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { parseSetCookie } = require_parse();
	var { stringify } = require_util$3();
	var { webidl } = require_webidl();
	var { Headers } = require_headers();
	/**
	* @typedef {Object} Cookie
	* @property {string} name
	* @property {string} value
	* @property {Date|number|undefined} expires
	* @property {number|undefined} maxAge
	* @property {string|undefined} domain
	* @property {string|undefined} path
	* @property {boolean|undefined} secure
	* @property {boolean|undefined} httpOnly
	* @property {'Strict'|'Lax'|'None'} sameSite
	* @property {string[]} unparsed
	*/
	/**
	* @param {Headers} headers
	* @returns {Record<string, string>}
	*/
	function getCookies(headers) {
		webidl.argumentLengthCheck(arguments, 1, "getCookies");
		webidl.brandCheck(headers, Headers, { strict: false });
		const cookie = headers.get("cookie");
		const out = {};
		if (!cookie) return out;
		for (const piece of cookie.split(";")) {
			const [name, ...value] = piece.split("=");
			out[name.trim()] = value.join("=");
		}
		return out;
	}
	/**
	* @param {Headers} headers
	* @param {string} name
	* @param {{ path?: string, domain?: string }|undefined} attributes
	* @returns {void}
	*/
	function deleteCookie(headers, name, attributes) {
		webidl.brandCheck(headers, Headers, { strict: false });
		const prefix = "deleteCookie";
		webidl.argumentLengthCheck(arguments, 2, prefix);
		name = webidl.converters.DOMString(name, prefix, "name");
		attributes = webidl.converters.DeleteCookieAttributes(attributes);
		setCookie(headers, {
			name,
			value: "",
			expires: /* @__PURE__ */ new Date(0),
			...attributes
		});
	}
	/**
	* @param {Headers} headers
	* @returns {Cookie[]}
	*/
	function getSetCookies(headers) {
		webidl.argumentLengthCheck(arguments, 1, "getSetCookies");
		webidl.brandCheck(headers, Headers, { strict: false });
		const cookies = headers.getSetCookie();
		if (!cookies) return [];
		return cookies.map((pair) => parseSetCookie(pair));
	}
	/**
	* @param {Headers} headers
	* @param {Cookie} cookie
	* @returns {void}
	*/
	function setCookie(headers, cookie) {
		webidl.argumentLengthCheck(arguments, 2, "setCookie");
		webidl.brandCheck(headers, Headers, { strict: false });
		cookie = webidl.converters.Cookie(cookie);
		const str = stringify(cookie);
		if (str) headers.append("Set-Cookie", str);
	}
	webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([{
		converter: webidl.nullableConverter(webidl.converters.DOMString),
		key: "path",
		defaultValue: () => null
	}, {
		converter: webidl.nullableConverter(webidl.converters.DOMString),
		key: "domain",
		defaultValue: () => null
	}]);
	webidl.converters.Cookie = webidl.dictionaryConverter([
		{
			converter: webidl.converters.DOMString,
			key: "name"
		},
		{
			converter: webidl.converters.DOMString,
			key: "value"
		},
		{
			converter: webidl.nullableConverter((value) => {
				if (typeof value === "number") return webidl.converters["unsigned long long"](value);
				return new Date(value);
			}),
			key: "expires",
			defaultValue: () => null
		},
		{
			converter: webidl.nullableConverter(webidl.converters["long long"]),
			key: "maxAge",
			defaultValue: () => null
		},
		{
			converter: webidl.nullableConverter(webidl.converters.DOMString),
			key: "domain",
			defaultValue: () => null
		},
		{
			converter: webidl.nullableConverter(webidl.converters.DOMString),
			key: "path",
			defaultValue: () => null
		},
		{
			converter: webidl.nullableConverter(webidl.converters.boolean),
			key: "secure",
			defaultValue: () => null
		},
		{
			converter: webidl.nullableConverter(webidl.converters.boolean),
			key: "httpOnly",
			defaultValue: () => null
		},
		{
			converter: webidl.converters.USVString,
			key: "sameSite",
			allowedValues: [
				"Strict",
				"Lax",
				"None"
			]
		},
		{
			converter: webidl.sequenceConverter(webidl.converters.DOMString),
			key: "unparsed",
			defaultValue: () => new Array(0)
		}
	]);
	module.exports = {
		getCookies,
		deleteCookie,
		getSetCookies,
		setCookie
	};
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/events.js
var require_events = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { webidl } = require_webidl();
	var { kEnumerableProperty } = require_util$8();
	var { kConstruct } = require_symbols$4();
	var { MessagePort } = __require("node:worker_threads");
	/**
	* @see https://html.spec.whatwg.org/multipage/comms.html#messageevent
	*/
	var MessageEvent = class MessageEvent extends Event {
		#eventInit;
		constructor(type, eventInitDict = {}) {
			if (type === kConstruct) {
				super(arguments[1], arguments[2]);
				webidl.util.markAsUncloneable(this);
				return;
			}
			const prefix = "MessageEvent constructor";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			type = webidl.converters.DOMString(type, prefix, "type");
			eventInitDict = webidl.converters.MessageEventInit(eventInitDict, prefix, "eventInitDict");
			super(type, eventInitDict);
			this.#eventInit = eventInitDict;
			webidl.util.markAsUncloneable(this);
		}
		get data() {
			webidl.brandCheck(this, MessageEvent);
			return this.#eventInit.data;
		}
		get origin() {
			webidl.brandCheck(this, MessageEvent);
			return this.#eventInit.origin;
		}
		get lastEventId() {
			webidl.brandCheck(this, MessageEvent);
			return this.#eventInit.lastEventId;
		}
		get source() {
			webidl.brandCheck(this, MessageEvent);
			return this.#eventInit.source;
		}
		get ports() {
			webidl.brandCheck(this, MessageEvent);
			if (!Object.isFrozen(this.#eventInit.ports)) Object.freeze(this.#eventInit.ports);
			return this.#eventInit.ports;
		}
		initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) {
			webidl.brandCheck(this, MessageEvent);
			webidl.argumentLengthCheck(arguments, 1, "MessageEvent.initMessageEvent");
			return new MessageEvent(type, {
				bubbles,
				cancelable,
				data,
				origin,
				lastEventId,
				source,
				ports
			});
		}
		static createFastMessageEvent(type, init) {
			const messageEvent = new MessageEvent(kConstruct, type, init);
			messageEvent.#eventInit = init;
			messageEvent.#eventInit.data ??= null;
			messageEvent.#eventInit.origin ??= "";
			messageEvent.#eventInit.lastEventId ??= "";
			messageEvent.#eventInit.source ??= null;
			messageEvent.#eventInit.ports ??= [];
			return messageEvent;
		}
	};
	var { createFastMessageEvent } = MessageEvent;
	delete MessageEvent.createFastMessageEvent;
	/**
	* @see https://websockets.spec.whatwg.org/#the-closeevent-interface
	*/
	var CloseEvent = class CloseEvent extends Event {
		#eventInit;
		constructor(type, eventInitDict = {}) {
			const prefix = "CloseEvent constructor";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			type = webidl.converters.DOMString(type, prefix, "type");
			eventInitDict = webidl.converters.CloseEventInit(eventInitDict);
			super(type, eventInitDict);
			this.#eventInit = eventInitDict;
			webidl.util.markAsUncloneable(this);
		}
		get wasClean() {
			webidl.brandCheck(this, CloseEvent);
			return this.#eventInit.wasClean;
		}
		get code() {
			webidl.brandCheck(this, CloseEvent);
			return this.#eventInit.code;
		}
		get reason() {
			webidl.brandCheck(this, CloseEvent);
			return this.#eventInit.reason;
		}
	};
	var ErrorEvent = class ErrorEvent extends Event {
		#eventInit;
		constructor(type, eventInitDict) {
			const prefix = "ErrorEvent constructor";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			super(type, eventInitDict);
			webidl.util.markAsUncloneable(this);
			type = webidl.converters.DOMString(type, prefix, "type");
			eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {});
			this.#eventInit = eventInitDict;
		}
		get message() {
			webidl.brandCheck(this, ErrorEvent);
			return this.#eventInit.message;
		}
		get filename() {
			webidl.brandCheck(this, ErrorEvent);
			return this.#eventInit.filename;
		}
		get lineno() {
			webidl.brandCheck(this, ErrorEvent);
			return this.#eventInit.lineno;
		}
		get colno() {
			webidl.brandCheck(this, ErrorEvent);
			return this.#eventInit.colno;
		}
		get error() {
			webidl.brandCheck(this, ErrorEvent);
			return this.#eventInit.error;
		}
	};
	Object.defineProperties(MessageEvent.prototype, {
		[Symbol.toStringTag]: {
			value: "MessageEvent",
			configurable: true
		},
		data: kEnumerableProperty,
		origin: kEnumerableProperty,
		lastEventId: kEnumerableProperty,
		source: kEnumerableProperty,
		ports: kEnumerableProperty,
		initMessageEvent: kEnumerableProperty
	});
	Object.defineProperties(CloseEvent.prototype, {
		[Symbol.toStringTag]: {
			value: "CloseEvent",
			configurable: true
		},
		reason: kEnumerableProperty,
		code: kEnumerableProperty,
		wasClean: kEnumerableProperty
	});
	Object.defineProperties(ErrorEvent.prototype, {
		[Symbol.toStringTag]: {
			value: "ErrorEvent",
			configurable: true
		},
		message: kEnumerableProperty,
		filename: kEnumerableProperty,
		lineno: kEnumerableProperty,
		colno: kEnumerableProperty,
		error: kEnumerableProperty
	});
	webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort);
	webidl.converters["sequence<MessagePort>"] = webidl.sequenceConverter(webidl.converters.MessagePort);
	var eventInit = [
		{
			key: "bubbles",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		},
		{
			key: "cancelable",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		},
		{
			key: "composed",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		}
	];
	webidl.converters.MessageEventInit = webidl.dictionaryConverter([
		...eventInit,
		{
			key: "data",
			converter: webidl.converters.any,
			defaultValue: () => null
		},
		{
			key: "origin",
			converter: webidl.converters.USVString,
			defaultValue: () => ""
		},
		{
			key: "lastEventId",
			converter: webidl.converters.DOMString,
			defaultValue: () => ""
		},
		{
			key: "source",
			converter: webidl.nullableConverter(webidl.converters.MessagePort),
			defaultValue: () => null
		},
		{
			key: "ports",
			converter: webidl.converters["sequence<MessagePort>"],
			defaultValue: () => new Array(0)
		}
	]);
	webidl.converters.CloseEventInit = webidl.dictionaryConverter([
		...eventInit,
		{
			key: "wasClean",
			converter: webidl.converters.boolean,
			defaultValue: () => false
		},
		{
			key: "code",
			converter: webidl.converters["unsigned short"],
			defaultValue: () => 0
		},
		{
			key: "reason",
			converter: webidl.converters.USVString,
			defaultValue: () => ""
		}
	]);
	webidl.converters.ErrorEventInit = webidl.dictionaryConverter([
		...eventInit,
		{
			key: "message",
			converter: webidl.converters.DOMString,
			defaultValue: () => ""
		},
		{
			key: "filename",
			converter: webidl.converters.USVString,
			defaultValue: () => ""
		},
		{
			key: "lineno",
			converter: webidl.converters["unsigned long"],
			defaultValue: () => 0
		},
		{
			key: "colno",
			converter: webidl.converters["unsigned long"],
			defaultValue: () => 0
		},
		{
			key: "error",
			converter: webidl.converters.any
		}
	]);
	module.exports = {
		MessageEvent,
		CloseEvent,
		ErrorEvent,
		createFastMessageEvent
	};
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/constants.js
var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = {
		uid: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
		sentCloseFrameState: {
			NOT_SENT: 0,
			PROCESSING: 1,
			SENT: 2
		},
		staticPropertyDescriptors: {
			enumerable: true,
			writable: false,
			configurable: false
		},
		states: {
			CONNECTING: 0,
			OPEN: 1,
			CLOSING: 2,
			CLOSED: 3
		},
		opcodes: {
			CONTINUATION: 0,
			TEXT: 1,
			BINARY: 2,
			CLOSE: 8,
			PING: 9,
			PONG: 10
		},
		maxUnsigned16Bit: 2 ** 16 - 1,
		parserStates: {
			INFO: 0,
			PAYLOADLENGTH_16: 2,
			PAYLOADLENGTH_64: 3,
			READ_DATA: 4
		},
		emptyBuffer: Buffer.allocUnsafe(0),
		sendHints: {
			string: 1,
			typedArray: 2,
			arrayBuffer: 3,
			blob: 4
		}
	};
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/symbols.js
var require_symbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = {
		kWebSocketURL: Symbol("url"),
		kReadyState: Symbol("ready state"),
		kController: Symbol("controller"),
		kResponse: Symbol("response"),
		kBinaryType: Symbol("binary type"),
		kSentClose: Symbol("sent close"),
		kReceivedClose: Symbol("received close"),
		kByteParser: Symbol("byte parser")
	};
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/util.js
var require_util$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols();
	var { states, opcodes } = require_constants();
	var { ErrorEvent, createFastMessageEvent } = require_events();
	var { isUtf8 } = __require("node:buffer");
	var { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = require_data_url();
	/**
	* @param {import('./websocket').WebSocket} ws
	* @returns {boolean}
	*/
	function isConnecting(ws) {
		return ws[kReadyState] === states.CONNECTING;
	}
	/**
	* @param {import('./websocket').WebSocket} ws
	* @returns {boolean}
	*/
	function isEstablished(ws) {
		return ws[kReadyState] === states.OPEN;
	}
	/**
	* @param {import('./websocket').WebSocket} ws
	* @returns {boolean}
	*/
	function isClosing(ws) {
		return ws[kReadyState] === states.CLOSING;
	}
	/**
	* @param {import('./websocket').WebSocket} ws
	* @returns {boolean}
	*/
	function isClosed(ws) {
		return ws[kReadyState] === states.CLOSED;
	}
	/**
	* @see https://dom.spec.whatwg.org/#concept-event-fire
	* @param {string} e
	* @param {EventTarget} target
	* @param {(...args: ConstructorParameters<typeof Event>) => Event} eventFactory
	* @param {EventInit | undefined} eventInitDict
	*/
	function fireEvent(e, target, eventFactory = (type, init) => new Event(type, init), eventInitDict = {}) {
		const event = eventFactory(e, eventInitDict);
		target.dispatchEvent(event);
	}
	/**
	* @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
	* @param {import('./websocket').WebSocket} ws
	* @param {number} type Opcode
	* @param {Buffer} data application data
	*/
	function websocketMessageReceived(ws, type, data) {
		if (ws[kReadyState] !== states.OPEN) return;
		let dataForEvent;
		if (type === opcodes.TEXT) try {
			dataForEvent = utf8Decode(data);
		} catch {
			failWebsocketConnection(ws, "Received invalid UTF-8 in text frame.");
			return;
		}
		else if (type === opcodes.BINARY) if (ws[kBinaryType] === "blob") dataForEvent = new Blob([data]);
		else dataForEvent = toArrayBuffer(data);
		fireEvent("message", ws, createFastMessageEvent, {
			origin: ws[kWebSocketURL].origin,
			data: dataForEvent
		});
	}
	function toArrayBuffer(buffer) {
		if (buffer.byteLength === buffer.buffer.byteLength) return buffer.buffer;
		return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
	}
	/**
	* @see https://datatracker.ietf.org/doc/html/rfc6455
	* @see https://datatracker.ietf.org/doc/html/rfc2616
	* @see https://bugs.chromium.org/p/chromium/issues/detail?id=398407
	* @param {string} protocol
	*/
	function isValidSubprotocol(protocol) {
		if (protocol.length === 0) return false;
		for (let i = 0; i < protocol.length; ++i) {
			const code = protocol.charCodeAt(i);
			if (code < 33 || code > 126 || code === 34 || code === 40 || code === 41 || code === 44 || code === 47 || code === 58 || code === 59 || code === 60 || code === 61 || code === 62 || code === 63 || code === 64 || code === 91 || code === 92 || code === 93 || code === 123 || code === 125) return false;
		}
		return true;
	}
	/**
	* @see https://datatracker.ietf.org/doc/html/rfc6455#section-7-4
	* @param {number} code
	*/
	function isValidStatusCode(code) {
		if (code >= 1e3 && code < 1015) return code !== 1004 && code !== 1005 && code !== 1006;
		return code >= 3e3 && code <= 4999;
	}
	/**
	* @param {import('./websocket').WebSocket} ws
	* @param {string|undefined} reason
	*/
	function failWebsocketConnection(ws, reason) {
		const { [kController]: controller, [kResponse]: response } = ws;
		controller.abort();
		if (response?.socket && !response.socket.destroyed) response.socket.destroy();
		if (reason) fireEvent("error", ws, (type, init) => new ErrorEvent(type, init), {
			error: new Error(reason),
			message: reason
		});
	}
	/**
	* @see https://datatracker.ietf.org/doc/html/rfc6455#section-5.5
	* @param {number} opcode
	*/
	function isControlFrame(opcode) {
		return opcode === opcodes.CLOSE || opcode === opcodes.PING || opcode === opcodes.PONG;
	}
	function isContinuationFrame(opcode) {
		return opcode === opcodes.CONTINUATION;
	}
	function isTextBinaryFrame(opcode) {
		return opcode === opcodes.TEXT || opcode === opcodes.BINARY;
	}
	function isValidOpcode(opcode) {
		return isTextBinaryFrame(opcode) || isContinuationFrame(opcode) || isControlFrame(opcode);
	}
	/**
	* Parses a Sec-WebSocket-Extensions header value.
	* @param {string} extensions
	* @returns {Map<string, string>}
	*/
	function parseExtensions(extensions) {
		const position = { position: 0 };
		const extensionList = /* @__PURE__ */ new Map();
		while (position.position < extensions.length) {
			const [name, value = ""] = collectASequenceOfCodePointsFast(";", extensions, position).split("=");
			extensionList.set(removeHTTPWhitespace(name, true, false), removeHTTPWhitespace(value, false, true));
			position.position++;
		}
		return extensionList;
	}
	/**
	* @see https://www.rfc-editor.org/rfc/rfc7692#section-7.1.2.2
	* @description "client-max-window-bits = 1*DIGIT"
	* @param {string} value
	*/
	function isValidClientWindowBits(value) {
		if (value.length === 0) return false;
		for (let i = 0; i < value.length; i++) {
			const byte = value.charCodeAt(i);
			if (byte < 48 || byte > 57) return false;
		}
		const num = Number.parseInt(value, 10);
		return num >= 8 && num <= 15;
	}
	var hasIntl = typeof process.versions.icu === "string";
	var fatalDecoder = hasIntl ? new TextDecoder("utf-8", { fatal: true }) : void 0;
	/**
	* Converts a Buffer to utf-8, even on platforms without icu.
	* @param {Buffer} buffer
	*/
	var utf8Decode = hasIntl ? fatalDecoder.decode.bind(fatalDecoder) : function(buffer) {
		if (isUtf8(buffer)) return buffer.toString("utf-8");
		throw new TypeError("Invalid utf-8 received.");
	};
	module.exports = {
		isConnecting,
		isEstablished,
		isClosing,
		isClosed,
		fireEvent,
		isValidSubprotocol,
		isValidStatusCode,
		failWebsocketConnection,
		websocketMessageReceived,
		utf8Decode,
		isControlFrame,
		isContinuationFrame,
		isTextBinaryFrame,
		isValidOpcode,
		parseExtensions,
		isValidClientWindowBits
	};
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/frame.js
var require_frame = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { maxUnsigned16Bit } = require_constants();
	var BUFFER_SIZE = 16386;
	/** @type {import('crypto')} */
	var crypto;
	var buffer = null;
	var bufIdx = BUFFER_SIZE;
	try {
		crypto = __require("node:crypto");
	} catch {
		crypto = { randomFillSync: function randomFillSync(buffer, _offset, _size) {
			for (let i = 0; i < buffer.length; ++i) buffer[i] = Math.random() * 255 | 0;
			return buffer;
		} };
	}
	function generateMask() {
		if (bufIdx === BUFFER_SIZE) {
			bufIdx = 0;
			crypto.randomFillSync(buffer ??= Buffer.allocUnsafe(BUFFER_SIZE), 0, BUFFER_SIZE);
		}
		return [
			buffer[bufIdx++],
			buffer[bufIdx++],
			buffer[bufIdx++],
			buffer[bufIdx++]
		];
	}
	var WebsocketFrameSend = class {
		/**
		* @param {Buffer|undefined} data
		*/
		constructor(data) {
			this.frameData = data;
		}
		createFrame(opcode) {
			const frameData = this.frameData;
			const maskKey = generateMask();
			const bodyLength = frameData?.byteLength ?? 0;
			/** @type {number} */
			let payloadLength = bodyLength;
			let offset = 6;
			if (bodyLength > maxUnsigned16Bit) {
				offset += 8;
				payloadLength = 127;
			} else if (bodyLength > 125) {
				offset += 2;
				payloadLength = 126;
			}
			const buffer = Buffer.allocUnsafe(bodyLength + offset);
			buffer[0] = buffer[1] = 0;
			buffer[0] |= 128;
			buffer[0] = (buffer[0] & 240) + opcode;
			/*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> */
			buffer[offset - 4] = maskKey[0];
			buffer[offset - 3] = maskKey[1];
			buffer[offset - 2] = maskKey[2];
			buffer[offset - 1] = maskKey[3];
			buffer[1] = payloadLength;
			if (payloadLength === 126) buffer.writeUInt16BE(bodyLength, 2);
			else if (payloadLength === 127) {
				buffer[2] = buffer[3] = 0;
				buffer.writeUIntBE(bodyLength, 4, 6);
			}
			buffer[1] |= 128;
			for (let i = 0; i < bodyLength; ++i) buffer[offset + i] = frameData[i] ^ maskKey[i & 3];
			return buffer;
		}
	};
	module.exports = { WebsocketFrameSend };
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/connection.js
var require_connection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require_constants();
	var { kReadyState, kSentClose, kByteParser, kReceivedClose, kResponse } = require_symbols();
	var { fireEvent, failWebsocketConnection, isClosing, isClosed, isEstablished, parseExtensions } = require_util$2();
	var { channels } = require_diagnostics();
	var { CloseEvent } = require_events();
	var { makeRequest } = require_request();
	var { fetching } = require_fetch();
	var { Headers, getHeadersList } = require_headers();
	var { getDecodeSplit } = require_util$7();
	var { WebsocketFrameSend } = require_frame();
	/** @type {import('crypto')} */
	var crypto;
	try {
		crypto = __require("node:crypto");
	} catch {}
	/**
	* @see https://websockets.spec.whatwg.org/#concept-websocket-establish
	* @param {URL} url
	* @param {string|string[]} protocols
	* @param {import('./websocket').WebSocket} ws
	* @param {(response: any, extensions: string[] | undefined) => void} onEstablish
	* @param {Partial<import('../../types/websocket').WebSocketInit>} options
	*/
	function establishWebSocketConnection(url, protocols, client, ws, onEstablish, options) {
		const requestURL = url;
		requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:";
		const request = makeRequest({
			urlList: [requestURL],
			client,
			serviceWorkers: "none",
			referrer: "no-referrer",
			mode: "websocket",
			credentials: "include",
			cache: "no-store",
			redirect: "error"
		});
		if (options.headers) request.headersList = getHeadersList(new Headers(options.headers));
		const keyValue = crypto.randomBytes(16).toString("base64");
		request.headersList.append("sec-websocket-key", keyValue);
		request.headersList.append("sec-websocket-version", "13");
		for (const protocol of protocols) request.headersList.append("sec-websocket-protocol", protocol);
		request.headersList.append("sec-websocket-extensions", "permessage-deflate; client_max_window_bits");
		return fetching({
			request,
			useParallelQueue: true,
			dispatcher: options.dispatcher,
			processResponse(response) {
				if (response.type === "error" || response.status !== 101) {
					failWebsocketConnection(ws, "Received network error or non-101 status code.");
					return;
				}
				if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) {
					failWebsocketConnection(ws, "Server did not respond with sent protocols.");
					return;
				}
				if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") {
					failWebsocketConnection(ws, "Server did not set Upgrade header to \"websocket\".");
					return;
				}
				if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") {
					failWebsocketConnection(ws, "Server did not set Connection header to \"upgrade\".");
					return;
				}
				if (response.headersList.get("Sec-WebSocket-Accept") !== crypto.createHash("sha1").update(keyValue + uid).digest("base64")) {
					failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
					return;
				}
				const secExtension = response.headersList.get("Sec-WebSocket-Extensions");
				let extensions;
				if (secExtension !== null) {
					extensions = parseExtensions(secExtension);
					if (!extensions.has("permessage-deflate")) {
						failWebsocketConnection(ws, "Sec-WebSocket-Extensions header does not match.");
						return;
					}
				}
				const secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
				if (secProtocol !== null) {
					if (!getDecodeSplit("sec-websocket-protocol", request.headersList).includes(secProtocol)) {
						failWebsocketConnection(ws, "Protocol was not set in the opening handshake.");
						return;
					}
				}
				response.socket.on("data", onSocketData);
				response.socket.on("close", onSocketClose);
				response.socket.on("error", onSocketError);
				if (channels.open.hasSubscribers) channels.open.publish({
					address: response.socket.address(),
					protocol: secProtocol,
					extensions: secExtension
				});
				onEstablish(response, extensions);
			}
		});
	}
	function closeWebSocketConnection(ws, code, reason, reasonByteLength) {
		if (isClosing(ws) || isClosed(ws)) {} else if (!isEstablished(ws)) {
			failWebsocketConnection(ws, "Connection was closed before it was established.");
			ws[kReadyState] = states.CLOSING;
		} else if (ws[kSentClose] === sentCloseFrameState.NOT_SENT) {
			ws[kSentClose] = sentCloseFrameState.PROCESSING;
			const frame = new WebsocketFrameSend();
			if (code !== void 0 && reason === void 0) {
				frame.frameData = Buffer.allocUnsafe(2);
				frame.frameData.writeUInt16BE(code, 0);
			} else if (code !== void 0 && reason !== void 0) {
				frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength);
				frame.frameData.writeUInt16BE(code, 0);
				frame.frameData.write(reason, 2, "utf-8");
			} else frame.frameData = emptyBuffer;
			ws[kResponse].socket.write(frame.createFrame(opcodes.CLOSE));
			ws[kSentClose] = sentCloseFrameState.SENT;
			ws[kReadyState] = states.CLOSING;
		} else ws[kReadyState] = states.CLOSING;
	}
	/**
	* @param {Buffer} chunk
	*/
	function onSocketData(chunk) {
		if (!this.ws[kByteParser].write(chunk)) this.pause();
	}
	/**
	* @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
	* @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4
	*/
	function onSocketClose() {
		const { ws } = this;
		const { [kResponse]: response } = ws;
		response.socket.off("data", onSocketData);
		response.socket.off("close", onSocketClose);
		response.socket.off("error", onSocketError);
		const wasClean = ws[kSentClose] === sentCloseFrameState.SENT && ws[kReceivedClose];
		let code = 1005;
		let reason = "";
		const result = ws[kByteParser].closingInfo;
		if (result && !result.error) {
			code = result.code ?? 1005;
			reason = result.reason;
		} else if (!ws[kReceivedClose]) code = 1006;
		ws[kReadyState] = states.CLOSED;
		fireEvent("close", ws, (type, init) => new CloseEvent(type, init), {
			wasClean,
			code,
			reason
		});
		if (channels.close.hasSubscribers) channels.close.publish({
			websocket: ws,
			code,
			reason
		});
	}
	function onSocketError(error) {
		const { ws } = this;
		ws[kReadyState] = states.CLOSING;
		if (channels.socketError.hasSubscribers) channels.socketError.publish(error);
		this.destroy();
	}
	module.exports = {
		establishWebSocketConnection,
		closeWebSocketConnection
	};
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/permessage-deflate.js
var require_permessage_deflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __require("node:zlib");
	var { isValidClientWindowBits } = require_util$2();
	var { MessageSizeExceededError } = require_errors();
	var tail = Buffer.from([
		0,
		0,
		255,
		255
	]);
	var kBuffer = Symbol("kBuffer");
	var kLength = Symbol("kLength");
	var kDefaultMaxDecompressedSize = 4 * 1024 * 1024;
	var PerMessageDeflate = class {
		/** @type {import('node:zlib').InflateRaw} */
		#inflate;
		#options = {};
		/** @type {boolean} */
		#aborted = false;
		/** @type {Function|null} */
		#currentCallback = null;
		/**
		* @param {Map<string, string>} extensions
		*/
		constructor(extensions) {
			this.#options.serverNoContextTakeover = extensions.has("server_no_context_takeover");
			this.#options.serverMaxWindowBits = extensions.get("server_max_window_bits");
		}
		decompress(chunk, fin, callback) {
			if (this.#aborted) {
				callback(new MessageSizeExceededError());
				return;
			}
			if (!this.#inflate) {
				let windowBits = Z_DEFAULT_WINDOWBITS;
				if (this.#options.serverMaxWindowBits) {
					if (!isValidClientWindowBits(this.#options.serverMaxWindowBits)) {
						callback(/* @__PURE__ */ new Error("Invalid server_max_window_bits"));
						return;
					}
					windowBits = Number.parseInt(this.#options.serverMaxWindowBits);
				}
				try {
					this.#inflate = createInflateRaw({ windowBits });
				} catch (err) {
					callback(err);
					return;
				}
				this.#inflate[kBuffer] = [];
				this.#inflate[kLength] = 0;
				this.#inflate.on("data", (data) => {
					if (this.#aborted) return;
					this.#inflate[kLength] += data.length;
					if (this.#inflate[kLength] > kDefaultMaxDecompressedSize) {
						this.#aborted = true;
						this.#inflate.removeAllListeners();
						this.#inflate.destroy();
						this.#inflate = null;
						if (this.#currentCallback) {
							const cb = this.#currentCallback;
							this.#currentCallback = null;
							cb(new MessageSizeExceededError());
						}
						return;
					}
					this.#inflate[kBuffer].push(data);
				});
				this.#inflate.on("error", (err) => {
					this.#inflate = null;
					callback(err);
				});
			}
			this.#currentCallback = callback;
			this.#inflate.write(chunk);
			if (fin) this.#inflate.write(tail);
			this.#inflate.flush(() => {
				if (this.#aborted || !this.#inflate) return;
				const full = Buffer.concat(this.#inflate[kBuffer], this.#inflate[kLength]);
				this.#inflate[kBuffer].length = 0;
				this.#inflate[kLength] = 0;
				this.#currentCallback = null;
				callback(null, full);
			});
		}
	};
	module.exports = { PerMessageDeflate };
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/receiver.js
var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Writable } = __require("node:stream");
	var assert = __require("node:assert");
	var { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require_constants();
	var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols();
	var { channels } = require_diagnostics();
	var { isValidStatusCode, isValidOpcode, failWebsocketConnection, websocketMessageReceived, utf8Decode, isControlFrame, isTextBinaryFrame, isContinuationFrame } = require_util$2();
	var { WebsocketFrameSend } = require_frame();
	var { closeWebSocketConnection } = require_connection();
	var { PerMessageDeflate } = require_permessage_deflate();
	var ByteParser = class extends Writable {
		#buffers = [];
		#byteOffset = 0;
		#loop = false;
		#state = parserStates.INFO;
		#info = {};
		#fragments = [];
		/** @type {Map<string, PerMessageDeflate>} */
		#extensions;
		/**
		* @param {import('./websocket').WebSocket} ws
		* @param {Map<string, string>|null} extensions
		*/
		constructor(ws, extensions) {
			super();
			this.ws = ws;
			this.#extensions = extensions == null ? /* @__PURE__ */ new Map() : extensions;
			if (this.#extensions.has("permessage-deflate")) this.#extensions.set("permessage-deflate", new PerMessageDeflate(extensions));
		}
		/**
		* @param {Buffer} chunk
		* @param {() => void} callback
		*/
		_write(chunk, _, callback) {
			this.#buffers.push(chunk);
			this.#byteOffset += chunk.length;
			this.#loop = true;
			this.run(callback);
		}
		/**
		* Runs whenever a new chunk is received.
		* Callback is called whenever there are no more chunks buffering,
		* or not enough bytes are buffered to parse.
		*/
		run(callback) {
			while (this.#loop) if (this.#state === parserStates.INFO) {
				if (this.#byteOffset < 2) return callback();
				const buffer = this.consume(2);
				const fin = (buffer[0] & 128) !== 0;
				const opcode = buffer[0] & 15;
				const masked = (buffer[1] & 128) === 128;
				const fragmented = !fin && opcode !== opcodes.CONTINUATION;
				const payloadLength = buffer[1] & 127;
				const rsv1 = buffer[0] & 64;
				const rsv2 = buffer[0] & 32;
				const rsv3 = buffer[0] & 16;
				if (!isValidOpcode(opcode)) {
					failWebsocketConnection(this.ws, "Invalid opcode received");
					return callback();
				}
				if (masked) {
					failWebsocketConnection(this.ws, "Frame cannot be masked");
					return callback();
				}
				if (rsv1 !== 0 && !this.#extensions.has("permessage-deflate")) {
					failWebsocketConnection(this.ws, "Expected RSV1 to be clear.");
					return;
				}
				if (rsv2 !== 0 || rsv3 !== 0) {
					failWebsocketConnection(this.ws, "RSV1, RSV2, RSV3 must be clear");
					return;
				}
				if (fragmented && !isTextBinaryFrame(opcode)) {
					failWebsocketConnection(this.ws, "Invalid frame type was fragmented.");
					return;
				}
				if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) {
					failWebsocketConnection(this.ws, "Expected continuation frame");
					return;
				}
				if (this.#info.fragmented && fragmented) {
					failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes.");
					return;
				}
				if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) {
					failWebsocketConnection(this.ws, "Control frame either too large or fragmented");
					return;
				}
				if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) {
					failWebsocketConnection(this.ws, "Unexpected continuation frame");
					return;
				}
				if (payloadLength <= 125) {
					this.#info.payloadLength = payloadLength;
					this.#state = parserStates.READ_DATA;
				} else if (payloadLength === 126) this.#state = parserStates.PAYLOADLENGTH_16;
				else if (payloadLength === 127) this.#state = parserStates.PAYLOADLENGTH_64;
				if (isTextBinaryFrame(opcode)) {
					this.#info.binaryType = opcode;
					this.#info.compressed = rsv1 !== 0;
				}
				this.#info.opcode = opcode;
				this.#info.masked = masked;
				this.#info.fin = fin;
				this.#info.fragmented = fragmented;
			} else if (this.#state === parserStates.PAYLOADLENGTH_16) {
				if (this.#byteOffset < 2) return callback();
				const buffer = this.consume(2);
				this.#info.payloadLength = buffer.readUInt16BE(0);
				this.#state = parserStates.READ_DATA;
			} else if (this.#state === parserStates.PAYLOADLENGTH_64) {
				if (this.#byteOffset < 8) return callback();
				const buffer = this.consume(8);
				const upper = buffer.readUInt32BE(0);
				const lower = buffer.readUInt32BE(4);
				if (upper !== 0 || lower > 2 ** 31 - 1) {
					failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes.");
					return;
				}
				this.#info.payloadLength = lower;
				this.#state = parserStates.READ_DATA;
			} else if (this.#state === parserStates.READ_DATA) {
				if (this.#byteOffset < this.#info.payloadLength) return callback();
				const body = this.consume(this.#info.payloadLength);
				if (isControlFrame(this.#info.opcode)) {
					this.#loop = this.parseControlFrame(body);
					this.#state = parserStates.INFO;
				} else if (!this.#info.compressed) {
					this.#fragments.push(body);
					if (!this.#info.fragmented && this.#info.fin) {
						const fullMessage = Buffer.concat(this.#fragments);
						websocketMessageReceived(this.ws, this.#info.binaryType, fullMessage);
						this.#fragments.length = 0;
					}
					this.#state = parserStates.INFO;
				} else {
					this.#extensions.get("permessage-deflate").decompress(body, this.#info.fin, (error, data) => {
						if (error) {
							failWebsocketConnection(this.ws, error.message);
							return;
						}
						this.#fragments.push(data);
						if (!this.#info.fin) {
							this.#state = parserStates.INFO;
							this.#loop = true;
							this.run(callback);
							return;
						}
						websocketMessageReceived(this.ws, this.#info.binaryType, Buffer.concat(this.#fragments));
						this.#loop = true;
						this.#state = parserStates.INFO;
						this.#fragments.length = 0;
						this.run(callback);
					});
					this.#loop = false;
					break;
				}
			}
		}
		/**
		* Take n bytes from the buffered Buffers
		* @param {number} n
		* @returns {Buffer}
		*/
		consume(n) {
			if (n > this.#byteOffset) throw new Error("Called consume() before buffers satiated.");
			else if (n === 0) return emptyBuffer;
			if (this.#buffers[0].length === n) {
				this.#byteOffset -= this.#buffers[0].length;
				return this.#buffers.shift();
			}
			const buffer = Buffer.allocUnsafe(n);
			let offset = 0;
			while (offset !== n) {
				const next = this.#buffers[0];
				const { length } = next;
				if (length + offset === n) {
					buffer.set(this.#buffers.shift(), offset);
					break;
				} else if (length + offset > n) {
					buffer.set(next.subarray(0, n - offset), offset);
					this.#buffers[0] = next.subarray(n - offset);
					break;
				} else {
					buffer.set(this.#buffers.shift(), offset);
					offset += next.length;
				}
			}
			this.#byteOffset -= n;
			return buffer;
		}
		parseCloseBody(data) {
			assert(data.length !== 1);
			/** @type {number|undefined} */
			let code;
			if (data.length >= 2) code = data.readUInt16BE(0);
			if (code !== void 0 && !isValidStatusCode(code)) return {
				code: 1002,
				reason: "Invalid status code",
				error: true
			};
			/** @type {Buffer} */
			let reason = data.subarray(2);
			if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) reason = reason.subarray(3);
			try {
				reason = utf8Decode(reason);
			} catch {
				return {
					code: 1007,
					reason: "Invalid UTF-8",
					error: true
				};
			}
			return {
				code,
				reason,
				error: false
			};
		}
		/**
		* Parses control frames.
		* @param {Buffer} body
		*/
		parseControlFrame(body) {
			const { opcode, payloadLength } = this.#info;
			if (opcode === opcodes.CLOSE) {
				if (payloadLength === 1) {
					failWebsocketConnection(this.ws, "Received close frame with a 1-byte body.");
					return false;
				}
				this.#info.closeInfo = this.parseCloseBody(body);
				if (this.#info.closeInfo.error) {
					const { code, reason } = this.#info.closeInfo;
					closeWebSocketConnection(this.ws, code, reason, reason.length);
					failWebsocketConnection(this.ws, reason);
					return false;
				}
				if (this.ws[kSentClose] !== sentCloseFrameState.SENT) {
					let body = emptyBuffer;
					if (this.#info.closeInfo.code) {
						body = Buffer.allocUnsafe(2);
						body.writeUInt16BE(this.#info.closeInfo.code, 0);
					}
					const closeFrame = new WebsocketFrameSend(body);
					this.ws[kResponse].socket.write(closeFrame.createFrame(opcodes.CLOSE), (err) => {
						if (!err) this.ws[kSentClose] = sentCloseFrameState.SENT;
					});
				}
				this.ws[kReadyState] = states.CLOSING;
				this.ws[kReceivedClose] = true;
				return false;
			} else if (opcode === opcodes.PING) {
				if (!this.ws[kReceivedClose]) {
					const frame = new WebsocketFrameSend(body);
					this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG));
					if (channels.ping.hasSubscribers) channels.ping.publish({ payload: body });
				}
			} else if (opcode === opcodes.PONG) {
				if (channels.pong.hasSubscribers) channels.pong.publish({ payload: body });
			}
			return true;
		}
		get closingInfo() {
			return this.#info.closeInfo;
		}
	};
	module.exports = { ByteParser };
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/sender.js
var require_sender = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { WebsocketFrameSend } = require_frame();
	var { opcodes, sendHints } = require_constants();
	var FixedQueue = require_fixed_queue();
	/** @type {typeof Uint8Array} */
	var FastBuffer = Buffer[Symbol.species];
	/**
	* @typedef {object} SendQueueNode
	* @property {Promise<void> | null} promise
	* @property {((...args: any[]) => any)} callback
	* @property {Buffer | null} frame
	*/
	var SendQueue = class {
		/**
		* @type {FixedQueue}
		*/
		#queue = new FixedQueue();
		/**
		* @type {boolean}
		*/
		#running = false;
		/** @type {import('node:net').Socket} */
		#socket;
		constructor(socket) {
			this.#socket = socket;
		}
		add(item, cb, hint) {
			if (hint !== sendHints.blob) {
				const frame = createFrame(item, hint);
				if (!this.#running) this.#socket.write(frame, cb);
				else {
					/** @type {SendQueueNode} */
					const node = {
						promise: null,
						callback: cb,
						frame
					};
					this.#queue.push(node);
				}
				return;
			}
			/** @type {SendQueueNode} */
			const node = {
				promise: item.arrayBuffer().then((ab) => {
					node.promise = null;
					node.frame = createFrame(ab, hint);
				}),
				callback: cb,
				frame: null
			};
			this.#queue.push(node);
			if (!this.#running) this.#run();
		}
		async #run() {
			this.#running = true;
			const queue = this.#queue;
			while (!queue.isEmpty()) {
				const node = queue.shift();
				if (node.promise !== null) await node.promise;
				this.#socket.write(node.frame, node.callback);
				node.callback = node.frame = null;
			}
			this.#running = false;
		}
	};
	function createFrame(data, hint) {
		return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY);
	}
	function toBuffer(data, hint) {
		switch (hint) {
			case sendHints.string: return Buffer.from(data);
			case sendHints.arrayBuffer:
			case sendHints.blob: return new FastBuffer(data);
			case sendHints.typedArray: return new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
		}
	}
	module.exports = { SendQueue };
}));
//#endregion
//#region node_modules/undici/lib/web/websocket/websocket.js
var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { webidl } = require_webidl();
	var { URLSerializer } = require_data_url();
	var { environmentSettingsObject } = require_util$7();
	var { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = require_constants();
	var { kWebSocketURL, kReadyState, kController, kBinaryType, kResponse, kSentClose, kByteParser } = require_symbols();
	var { isConnecting, isEstablished, isClosing, isValidSubprotocol, fireEvent } = require_util$2();
	var { establishWebSocketConnection, closeWebSocketConnection } = require_connection();
	var { ByteParser } = require_receiver();
	var { kEnumerableProperty, isBlobLike } = require_util$8();
	var { getGlobalDispatcher } = require_global();
	var { types } = __require("node:util");
	var { ErrorEvent, CloseEvent } = require_events();
	var { SendQueue } = require_sender();
	var WebSocket = class WebSocket extends EventTarget {
		#events = {
			open: null,
			error: null,
			close: null,
			message: null
		};
		#bufferedAmount = 0;
		#protocol = "";
		#extensions = "";
		/** @type {SendQueue} */
		#sendQueue;
		/**
		* @param {string} url
		* @param {string|string[]} protocols
		*/
		constructor(url, protocols = []) {
			super();
			webidl.util.markAsUncloneable(this);
			const prefix = "WebSocket constructor";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			const options = webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"](protocols, prefix, "options");
			url = webidl.converters.USVString(url, prefix, "url");
			protocols = options.protocols;
			const baseURL = environmentSettingsObject.settingsObject.baseUrl;
			let urlRecord;
			try {
				urlRecord = new URL(url, baseURL);
			} catch (e) {
				throw new DOMException(e, "SyntaxError");
			}
			if (urlRecord.protocol === "http:") urlRecord.protocol = "ws:";
			else if (urlRecord.protocol === "https:") urlRecord.protocol = "wss:";
			if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") throw new DOMException(`Expected a ws: or wss: protocol, got ${urlRecord.protocol}`, "SyntaxError");
			if (urlRecord.hash || urlRecord.href.endsWith("#")) throw new DOMException("Got fragment", "SyntaxError");
			if (typeof protocols === "string") protocols = [protocols];
			if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size) throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
			if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p))) throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
			this[kWebSocketURL] = new URL(urlRecord.href);
			const client = environmentSettingsObject.settingsObject;
			this[kController] = establishWebSocketConnection(urlRecord, protocols, client, this, (response, extensions) => this.#onConnectionEstablished(response, extensions), options);
			this[kReadyState] = WebSocket.CONNECTING;
			this[kSentClose] = sentCloseFrameState.NOT_SENT;
			this[kBinaryType] = "blob";
		}
		/**
		* @see https://websockets.spec.whatwg.org/#dom-websocket-close
		* @param {number|undefined} code
		* @param {string|undefined} reason
		*/
		close(code = void 0, reason = void 0) {
			webidl.brandCheck(this, WebSocket);
			const prefix = "WebSocket.close";
			if (code !== void 0) code = webidl.converters["unsigned short"](code, prefix, "code", { clamp: true });
			if (reason !== void 0) reason = webidl.converters.USVString(reason, prefix, "reason");
			if (code !== void 0) {
				if (code !== 1e3 && (code < 3e3 || code > 4999)) throw new DOMException("invalid code", "InvalidAccessError");
			}
			let reasonByteLength = 0;
			if (reason !== void 0) {
				reasonByteLength = Buffer.byteLength(reason);
				if (reasonByteLength > 123) throw new DOMException(`Reason must be less than 123 bytes; received ${reasonByteLength}`, "SyntaxError");
			}
			closeWebSocketConnection(this, code, reason, reasonByteLength);
		}
		/**
		* @see https://websockets.spec.whatwg.org/#dom-websocket-send
		* @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
		*/
		send(data) {
			webidl.brandCheck(this, WebSocket);
			const prefix = "WebSocket.send";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			data = webidl.converters.WebSocketSendData(data, prefix, "data");
			if (isConnecting(this)) throw new DOMException("Sent before connected.", "InvalidStateError");
			if (!isEstablished(this) || isClosing(this)) return;
			if (typeof data === "string") {
				const length = Buffer.byteLength(data);
				this.#bufferedAmount += length;
				this.#sendQueue.add(data, () => {
					this.#bufferedAmount -= length;
				}, sendHints.string);
			} else if (types.isArrayBuffer(data)) {
				this.#bufferedAmount += data.byteLength;
				this.#sendQueue.add(data, () => {
					this.#bufferedAmount -= data.byteLength;
				}, sendHints.arrayBuffer);
			} else if (ArrayBuffer.isView(data)) {
				this.#bufferedAmount += data.byteLength;
				this.#sendQueue.add(data, () => {
					this.#bufferedAmount -= data.byteLength;
				}, sendHints.typedArray);
			} else if (isBlobLike(data)) {
				this.#bufferedAmount += data.size;
				this.#sendQueue.add(data, () => {
					this.#bufferedAmount -= data.size;
				}, sendHints.blob);
			}
		}
		get readyState() {
			webidl.brandCheck(this, WebSocket);
			return this[kReadyState];
		}
		get bufferedAmount() {
			webidl.brandCheck(this, WebSocket);
			return this.#bufferedAmount;
		}
		get url() {
			webidl.brandCheck(this, WebSocket);
			return URLSerializer(this[kWebSocketURL]);
		}
		get extensions() {
			webidl.brandCheck(this, WebSocket);
			return this.#extensions;
		}
		get protocol() {
			webidl.brandCheck(this, WebSocket);
			return this.#protocol;
		}
		get onopen() {
			webidl.brandCheck(this, WebSocket);
			return this.#events.open;
		}
		set onopen(fn) {
			webidl.brandCheck(this, WebSocket);
			if (this.#events.open) this.removeEventListener("open", this.#events.open);
			if (typeof fn === "function") {
				this.#events.open = fn;
				this.addEventListener("open", fn);
			} else this.#events.open = null;
		}
		get onerror() {
			webidl.brandCheck(this, WebSocket);
			return this.#events.error;
		}
		set onerror(fn) {
			webidl.brandCheck(this, WebSocket);
			if (this.#events.error) this.removeEventListener("error", this.#events.error);
			if (typeof fn === "function") {
				this.#events.error = fn;
				this.addEventListener("error", fn);
			} else this.#events.error = null;
		}
		get onclose() {
			webidl.brandCheck(this, WebSocket);
			return this.#events.close;
		}
		set onclose(fn) {
			webidl.brandCheck(this, WebSocket);
			if (this.#events.close) this.removeEventListener("close", this.#events.close);
			if (typeof fn === "function") {
				this.#events.close = fn;
				this.addEventListener("close", fn);
			} else this.#events.close = null;
		}
		get onmessage() {
			webidl.brandCheck(this, WebSocket);
			return this.#events.message;
		}
		set onmessage(fn) {
			webidl.brandCheck(this, WebSocket);
			if (this.#events.message) this.removeEventListener("message", this.#events.message);
			if (typeof fn === "function") {
				this.#events.message = fn;
				this.addEventListener("message", fn);
			} else this.#events.message = null;
		}
		get binaryType() {
			webidl.brandCheck(this, WebSocket);
			return this[kBinaryType];
		}
		set binaryType(type) {
			webidl.brandCheck(this, WebSocket);
			if (type !== "blob" && type !== "arraybuffer") this[kBinaryType] = "blob";
			else this[kBinaryType] = type;
		}
		/**
		* @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
		*/
		#onConnectionEstablished(response, parsedExtensions) {
			this[kResponse] = response;
			const parser = new ByteParser(this, parsedExtensions);
			parser.on("drain", onParserDrain);
			parser.on("error", onParserError.bind(this));
			response.socket.ws = this;
			this[kByteParser] = parser;
			this.#sendQueue = new SendQueue(response.socket);
			this[kReadyState] = states.OPEN;
			const extensions = response.headersList.get("sec-websocket-extensions");
			if (extensions !== null) this.#extensions = extensions;
			const protocol = response.headersList.get("sec-websocket-protocol");
			if (protocol !== null) this.#protocol = protocol;
			fireEvent("open", this);
		}
	};
	WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING;
	WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN;
	WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING;
	WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED;
	Object.defineProperties(WebSocket.prototype, {
		CONNECTING: staticPropertyDescriptors,
		OPEN: staticPropertyDescriptors,
		CLOSING: staticPropertyDescriptors,
		CLOSED: staticPropertyDescriptors,
		url: kEnumerableProperty,
		readyState: kEnumerableProperty,
		bufferedAmount: kEnumerableProperty,
		onopen: kEnumerableProperty,
		onerror: kEnumerableProperty,
		onclose: kEnumerableProperty,
		close: kEnumerableProperty,
		onmessage: kEnumerableProperty,
		binaryType: kEnumerableProperty,
		send: kEnumerableProperty,
		extensions: kEnumerableProperty,
		protocol: kEnumerableProperty,
		[Symbol.toStringTag]: {
			value: "WebSocket",
			writable: false,
			enumerable: false,
			configurable: true
		}
	});
	Object.defineProperties(WebSocket, {
		CONNECTING: staticPropertyDescriptors,
		OPEN: staticPropertyDescriptors,
		CLOSING: staticPropertyDescriptors,
		CLOSED: staticPropertyDescriptors
	});
	webidl.converters["sequence<DOMString>"] = webidl.sequenceConverter(webidl.converters.DOMString);
	webidl.converters["DOMString or sequence<DOMString>"] = function(V, prefix, argument) {
		if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) return webidl.converters["sequence<DOMString>"](V);
		return webidl.converters.DOMString(V, prefix, argument);
	};
	webidl.converters.WebSocketInit = webidl.dictionaryConverter([
		{
			key: "protocols",
			converter: webidl.converters["DOMString or sequence<DOMString>"],
			defaultValue: () => new Array(0)
		},
		{
			key: "dispatcher",
			converter: webidl.converters.any,
			defaultValue: () => getGlobalDispatcher()
		},
		{
			key: "headers",
			converter: webidl.nullableConverter(webidl.converters.HeadersInit)
		}
	]);
	webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"] = function(V) {
		if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) return webidl.converters.WebSocketInit(V);
		return { protocols: webidl.converters["DOMString or sequence<DOMString>"](V) };
	};
	webidl.converters.WebSocketSendData = function(V) {
		if (webidl.util.Type(V) === "Object") {
			if (isBlobLike(V)) return webidl.converters.Blob(V, { strict: false });
			if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) return webidl.converters.BufferSource(V);
		}
		return webidl.converters.USVString(V);
	};
	function onParserDrain() {
		this.ws[kResponse].socket.resume();
	}
	function onParserError(err) {
		let message;
		let code;
		if (err instanceof CloseEvent) {
			message = err.reason;
			code = err.code;
		} else message = err.message;
		fireEvent("error", this, () => new ErrorEvent("error", {
			error: err,
			message
		}));
		closeWebSocketConnection(this, code);
	}
	module.exports = { WebSocket };
}));
//#endregion
//#region node_modules/undici/lib/web/eventsource/util.js
var require_util$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/**
	* Checks if the given value is a valid LastEventId.
	* @param {string} value
	* @returns {boolean}
	*/
	function isValidLastEventId(value) {
		return value.indexOf("\0") === -1;
	}
	/**
	* Checks if the given value is a base 10 digit.
	* @param {string} value
	* @returns {boolean}
	*/
	function isASCIINumber(value) {
		if (value.length === 0) return false;
		for (let i = 0; i < value.length; i++) if (value.charCodeAt(i) < 48 || value.charCodeAt(i) > 57) return false;
		return true;
	}
	function delay(ms) {
		return new Promise((resolve) => {
			setTimeout(resolve, ms).unref();
		});
	}
	module.exports = {
		isValidLastEventId,
		isASCIINumber,
		delay
	};
}));
//#endregion
//#region node_modules/undici/lib/web/eventsource/eventsource-stream.js
var require_eventsource_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Transform } = __require("node:stream");
	var { isASCIINumber, isValidLastEventId } = require_util$1();
	/**
	* @type {number[]} BOM
	*/
	var BOM = [
		239,
		187,
		191
	];
	/**
	* @type {10} LF
	*/
	var LF = 10;
	/**
	* @type {13} CR
	*/
	var CR = 13;
	/**
	* @type {58} COLON
	*/
	var COLON = 58;
	/**
	* @type {32} SPACE
	*/
	var SPACE = 32;
	/**
	* @typedef {object} EventSourceStreamEvent
	* @type {object}
	* @property {string} [event] The event type.
	* @property {string} [data] The data of the message.
	* @property {string} [id] A unique ID for the event.
	* @property {string} [retry] The reconnection time, in milliseconds.
	*/
	/**
	* @typedef eventSourceSettings
	* @type {object}
	* @property {string} lastEventId The last event ID received from the server.
	* @property {string} origin The origin of the event source.
	* @property {number} reconnectionTime The reconnection time, in milliseconds.
	*/
	var EventSourceStream = class extends Transform {
		/**
		* @type {eventSourceSettings}
		*/
		state = null;
		/**
		* Leading byte-order-mark check.
		* @type {boolean}
		*/
		checkBOM = true;
		/**
		* @type {boolean}
		*/
		crlfCheck = false;
		/**
		* @type {boolean}
		*/
		eventEndCheck = false;
		/**
		* @type {Buffer}
		*/
		buffer = null;
		pos = 0;
		event = {
			data: void 0,
			event: void 0,
			id: void 0,
			retry: void 0
		};
		/**
		* @param {object} options
		* @param {eventSourceSettings} options.eventSourceSettings
		* @param {Function} [options.push]
		*/
		constructor(options = {}) {
			options.readableObjectMode = true;
			super(options);
			this.state = options.eventSourceSettings || {};
			if (options.push) this.push = options.push;
		}
		/**
		* @param {Buffer} chunk
		* @param {string} _encoding
		* @param {Function} callback
		* @returns {void}
		*/
		_transform(chunk, _encoding, callback) {
			if (chunk.length === 0) {
				callback();
				return;
			}
			if (this.buffer) this.buffer = Buffer.concat([this.buffer, chunk]);
			else this.buffer = chunk;
			if (this.checkBOM) switch (this.buffer.length) {
				case 1:
					if (this.buffer[0] === BOM[0]) {
						callback();
						return;
					}
					this.checkBOM = false;
					callback();
					return;
				case 2:
					if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1]) {
						callback();
						return;
					}
					this.checkBOM = false;
					break;
				case 3:
					if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) {
						this.buffer = Buffer.alloc(0);
						this.checkBOM = false;
						callback();
						return;
					}
					this.checkBOM = false;
					break;
				default:
					if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) this.buffer = this.buffer.subarray(3);
					this.checkBOM = false;
					break;
			}
			while (this.pos < this.buffer.length) {
				if (this.eventEndCheck) {
					if (this.crlfCheck) {
						if (this.buffer[this.pos] === LF) {
							this.buffer = this.buffer.subarray(this.pos + 1);
							this.pos = 0;
							this.crlfCheck = false;
							continue;
						}
						this.crlfCheck = false;
					}
					if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
						if (this.buffer[this.pos] === CR) this.crlfCheck = true;
						this.buffer = this.buffer.subarray(this.pos + 1);
						this.pos = 0;
						if (this.event.data !== void 0 || this.event.event || this.event.id || this.event.retry) this.processEvent(this.event);
						this.clearEvent();
						continue;
					}
					this.eventEndCheck = false;
					continue;
				}
				if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
					if (this.buffer[this.pos] === CR) this.crlfCheck = true;
					this.parseLine(this.buffer.subarray(0, this.pos), this.event);
					this.buffer = this.buffer.subarray(this.pos + 1);
					this.pos = 0;
					this.eventEndCheck = true;
					continue;
				}
				this.pos++;
			}
			callback();
		}
		/**
		* @param {Buffer} line
		* @param {EventStreamEvent} event
		*/
		parseLine(line, event) {
			if (line.length === 0) return;
			const colonPosition = line.indexOf(COLON);
			if (colonPosition === 0) return;
			let field = "";
			let value = "";
			if (colonPosition !== -1) {
				field = line.subarray(0, colonPosition).toString("utf8");
				let valueStart = colonPosition + 1;
				if (line[valueStart] === SPACE) ++valueStart;
				value = line.subarray(valueStart).toString("utf8");
			} else {
				field = line.toString("utf8");
				value = "";
			}
			switch (field) {
				case "data":
					if (event[field] === void 0) event[field] = value;
					else event[field] += `\n${value}`;
					break;
				case "retry":
					if (isASCIINumber(value)) event[field] = value;
					break;
				case "id":
					if (isValidLastEventId(value)) event[field] = value;
					break;
				case "event":
					if (value.length > 0) event[field] = value;
					break;
			}
		}
		/**
		* @param {EventSourceStreamEvent} event
		*/
		processEvent(event) {
			if (event.retry && isASCIINumber(event.retry)) this.state.reconnectionTime = parseInt(event.retry, 10);
			if (event.id && isValidLastEventId(event.id)) this.state.lastEventId = event.id;
			if (event.data !== void 0) this.push({
				type: event.event || "message",
				options: {
					data: event.data,
					lastEventId: this.state.lastEventId,
					origin: this.state.origin
				}
			});
		}
		clearEvent() {
			this.event = {
				data: void 0,
				event: void 0,
				id: void 0,
				retry: void 0
			};
		}
	};
	module.exports = { EventSourceStream };
}));
//#endregion
//#region node_modules/undici/lib/web/eventsource/eventsource.js
var require_eventsource = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { pipeline } = __require("node:stream");
	var { fetching } = require_fetch();
	var { makeRequest } = require_request();
	var { webidl } = require_webidl();
	var { EventSourceStream } = require_eventsource_stream();
	var { parseMIMEType } = require_data_url();
	var { createFastMessageEvent } = require_events();
	var { isNetworkError } = require_response();
	var { delay } = require_util$1();
	var { kEnumerableProperty } = require_util$8();
	var { environmentSettingsObject } = require_util$7();
	var experimentalWarned = false;
	/**
	* A reconnection time, in milliseconds. This must initially be an implementation-defined value,
	* probably in the region of a few seconds.
	*
	* In Comparison:
	* - Chrome uses 3000ms.
	* - Deno uses 5000ms.
	*
	* @type {3000}
	*/
	var defaultReconnectionTime = 3e3;
	/**
	* The readyState attribute represents the state of the connection.
	* @enum
	* @readonly
	* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#dom-eventsource-readystate-dev
	*/
	/**
	* The connection has not yet been established, or it was closed and the user
	* agent is reconnecting.
	* @type {0}
	*/
	var CONNECTING = 0;
	/**
	* The user agent has an open connection and is dispatching events as it
	* receives them.
	* @type {1}
	*/
	var OPEN = 1;
	/**
	* The connection is not open, and the user agent is not trying to reconnect.
	* @type {2}
	*/
	var CLOSED = 2;
	/**
	* Requests for the element will have their mode set to "cors" and their credentials mode set to "same-origin".
	* @type {'anonymous'}
	*/
	var ANONYMOUS = "anonymous";
	/**
	* Requests for the element will have their mode set to "cors" and their credentials mode set to "include".
	* @type {'use-credentials'}
	*/
	var USE_CREDENTIALS = "use-credentials";
	/**
	* The EventSource interface is used to receive server-sent events. It
	* connects to a server over HTTP and receives events in text/event-stream
	* format without closing the connection.
	* @extends {EventTarget}
	* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
	* @api public
	*/
	var EventSource = class EventSource extends EventTarget {
		#events = {
			open: null,
			error: null,
			message: null
		};
		#url = null;
		#withCredentials = false;
		#readyState = CONNECTING;
		#request = null;
		#controller = null;
		#dispatcher;
		/**
		* @type {import('./eventsource-stream').eventSourceSettings}
		*/
		#state;
		/**
		* Creates a new EventSource object.
		* @param {string} url
		* @param {EventSourceInit} [eventSourceInitDict]
		* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
		*/
		constructor(url, eventSourceInitDict = {}) {
			super();
			webidl.util.markAsUncloneable(this);
			const prefix = "EventSource constructor";
			webidl.argumentLengthCheck(arguments, 1, prefix);
			if (!experimentalWarned) {
				experimentalWarned = true;
				process.emitWarning("EventSource is experimental, expect them to change at any time.", { code: "UNDICI-ES" });
			}
			url = webidl.converters.USVString(url, prefix, "url");
			eventSourceInitDict = webidl.converters.EventSourceInitDict(eventSourceInitDict, prefix, "eventSourceInitDict");
			this.#dispatcher = eventSourceInitDict.dispatcher;
			this.#state = {
				lastEventId: "",
				reconnectionTime: defaultReconnectionTime
			};
			const settings = environmentSettingsObject;
			let urlRecord;
			try {
				urlRecord = new URL(url, settings.settingsObject.baseUrl);
				this.#state.origin = urlRecord.origin;
			} catch (e) {
				throw new DOMException(e, "SyntaxError");
			}
			this.#url = urlRecord.href;
			let corsAttributeState = ANONYMOUS;
			if (eventSourceInitDict.withCredentials) {
				corsAttributeState = USE_CREDENTIALS;
				this.#withCredentials = true;
			}
			const initRequest = {
				redirect: "follow",
				keepalive: true,
				mode: "cors",
				credentials: corsAttributeState === "anonymous" ? "same-origin" : "omit",
				referrer: "no-referrer"
			};
			initRequest.client = environmentSettingsObject.settingsObject;
			initRequest.headersList = [["accept", {
				name: "accept",
				value: "text/event-stream"
			}]];
			initRequest.cache = "no-store";
			initRequest.initiator = "other";
			initRequest.urlList = [new URL(this.#url)];
			this.#request = makeRequest(initRequest);
			this.#connect();
		}
		/**
		* Returns the state of this EventSource object's connection. It can have the
		* values described below.
		* @returns {0|1|2}
		* @readonly
		*/
		get readyState() {
			return this.#readyState;
		}
		/**
		* Returns the URL providing the event stream.
		* @readonly
		* @returns {string}
		*/
		get url() {
			return this.#url;
		}
		/**
		* Returns a boolean indicating whether the EventSource object was
		* instantiated with CORS credentials set (true), or not (false, the default).
		*/
		get withCredentials() {
			return this.#withCredentials;
		}
		#connect() {
			if (this.#readyState === CLOSED) return;
			this.#readyState = CONNECTING;
			const fetchParams = {
				request: this.#request,
				dispatcher: this.#dispatcher
			};
			const processEventSourceEndOfBody = (response) => {
				if (isNetworkError(response)) {
					this.dispatchEvent(new Event("error"));
					this.close();
				}
				this.#reconnect();
			};
			fetchParams.processResponseEndOfBody = processEventSourceEndOfBody;
			fetchParams.processResponse = (response) => {
				if (isNetworkError(response)) if (response.aborted) {
					this.close();
					this.dispatchEvent(new Event("error"));
					return;
				} else {
					this.#reconnect();
					return;
				}
				const contentType = response.headersList.get("content-type", true);
				const mimeType = contentType !== null ? parseMIMEType(contentType) : "failure";
				const contentTypeValid = mimeType !== "failure" && mimeType.essence === "text/event-stream";
				if (response.status !== 200 || contentTypeValid === false) {
					this.close();
					this.dispatchEvent(new Event("error"));
					return;
				}
				this.#readyState = OPEN;
				this.dispatchEvent(new Event("open"));
				this.#state.origin = response.urlList[response.urlList.length - 1].origin;
				const eventSourceStream = new EventSourceStream({
					eventSourceSettings: this.#state,
					push: (event) => {
						this.dispatchEvent(createFastMessageEvent(event.type, event.options));
					}
				});
				pipeline(response.body.stream, eventSourceStream, (error) => {
					if (error?.aborted === false) {
						this.close();
						this.dispatchEvent(new Event("error"));
					}
				});
			};
			this.#controller = fetching(fetchParams);
		}
		/**
		* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
		* @returns {Promise<void>}
		*/
		async #reconnect() {
			if (this.#readyState === CLOSED) return;
			this.#readyState = CONNECTING;
			this.dispatchEvent(new Event("error"));
			await delay(this.#state.reconnectionTime);
			if (this.#readyState !== CONNECTING) return;
			if (this.#state.lastEventId.length) this.#request.headersList.set("last-event-id", this.#state.lastEventId, true);
			this.#connect();
		}
		/**
		* Closes the connection, if any, and sets the readyState attribute to
		* CLOSED.
		*/
		close() {
			webidl.brandCheck(this, EventSource);
			if (this.#readyState === CLOSED) return;
			this.#readyState = CLOSED;
			this.#controller.abort();
			this.#request = null;
		}
		get onopen() {
			return this.#events.open;
		}
		set onopen(fn) {
			if (this.#events.open) this.removeEventListener("open", this.#events.open);
			if (typeof fn === "function") {
				this.#events.open = fn;
				this.addEventListener("open", fn);
			} else this.#events.open = null;
		}
		get onmessage() {
			return this.#events.message;
		}
		set onmessage(fn) {
			if (this.#events.message) this.removeEventListener("message", this.#events.message);
			if (typeof fn === "function") {
				this.#events.message = fn;
				this.addEventListener("message", fn);
			} else this.#events.message = null;
		}
		get onerror() {
			return this.#events.error;
		}
		set onerror(fn) {
			if (this.#events.error) this.removeEventListener("error", this.#events.error);
			if (typeof fn === "function") {
				this.#events.error = fn;
				this.addEventListener("error", fn);
			} else this.#events.error = null;
		}
	};
	var constantsPropertyDescriptors = {
		CONNECTING: {
			__proto__: null,
			configurable: false,
			enumerable: true,
			value: CONNECTING,
			writable: false
		},
		OPEN: {
			__proto__: null,
			configurable: false,
			enumerable: true,
			value: OPEN,
			writable: false
		},
		CLOSED: {
			__proto__: null,
			configurable: false,
			enumerable: true,
			value: CLOSED,
			writable: false
		}
	};
	Object.defineProperties(EventSource, constantsPropertyDescriptors);
	Object.defineProperties(EventSource.prototype, constantsPropertyDescriptors);
	Object.defineProperties(EventSource.prototype, {
		close: kEnumerableProperty,
		onerror: kEnumerableProperty,
		onmessage: kEnumerableProperty,
		onopen: kEnumerableProperty,
		readyState: kEnumerableProperty,
		url: kEnumerableProperty,
		withCredentials: kEnumerableProperty
	});
	webidl.converters.EventSourceInitDict = webidl.dictionaryConverter([{
		key: "withCredentials",
		converter: webidl.converters.boolean,
		defaultValue: () => false
	}, {
		key: "dispatcher",
		converter: webidl.converters.any
	}]);
	module.exports = {
		EventSource,
		defaultReconnectionTime
	};
}));
//#endregion
//#region node_modules/undici/index.js
var require_undici = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var Client = require_client();
	var Dispatcher = require_dispatcher();
	var Pool = require_pool();
	var BalancedPool = require_balanced_pool();
	var Agent = require_agent();
	var ProxyAgent = require_proxy_agent();
	var EnvHttpProxyAgent = require_env_http_proxy_agent();
	var RetryAgent = require_retry_agent();
	var errors = require_errors();
	var util = require_util$8();
	var { InvalidArgumentError } = errors;
	var api = require_api();
	var buildConnector = require_connect();
	var MockClient = require_mock_client();
	var MockAgent = require_mock_agent();
	var MockPool = require_mock_pool();
	var mockErrors = require_mock_errors();
	var RetryHandler = require_retry_handler();
	var { getGlobalDispatcher, setGlobalDispatcher } = require_global();
	var DecoratorHandler = require_decorator_handler();
	var RedirectHandler = require_redirect_handler();
	var createRedirectInterceptor = require_redirect_interceptor();
	Object.assign(Dispatcher.prototype, api);
	module.exports.Dispatcher = Dispatcher;
	module.exports.Client = Client;
	module.exports.Pool = Pool;
	module.exports.BalancedPool = BalancedPool;
	module.exports.Agent = Agent;
	module.exports.ProxyAgent = ProxyAgent;
	module.exports.EnvHttpProxyAgent = EnvHttpProxyAgent;
	module.exports.RetryAgent = RetryAgent;
	module.exports.RetryHandler = RetryHandler;
	module.exports.DecoratorHandler = DecoratorHandler;
	module.exports.RedirectHandler = RedirectHandler;
	module.exports.createRedirectInterceptor = createRedirectInterceptor;
	module.exports.interceptors = {
		redirect: require_redirect(),
		retry: require_retry(),
		dump: require_dump(),
		dns: require_dns()
	};
	module.exports.buildConnector = buildConnector;
	module.exports.errors = errors;
	module.exports.util = {
		parseHeaders: util.parseHeaders,
		headerNameToString: util.headerNameToString
	};
	function makeDispatcher(fn) {
		return (url, opts, handler) => {
			if (typeof opts === "function") {
				handler = opts;
				opts = null;
			}
			if (!url || typeof url !== "string" && typeof url !== "object" && !(url instanceof URL)) throw new InvalidArgumentError("invalid url");
			if (opts != null && typeof opts !== "object") throw new InvalidArgumentError("invalid opts");
			if (opts && opts.path != null) {
				if (typeof opts.path !== "string") throw new InvalidArgumentError("invalid opts.path");
				let path = opts.path;
				if (!opts.path.startsWith("/")) path = `/${path}`;
				url = new URL(util.parseOrigin(url).origin + path);
			} else {
				if (!opts) opts = typeof url === "object" ? url : {};
				url = util.parseURL(url);
			}
			const { agent, dispatcher = getGlobalDispatcher() } = opts;
			if (agent) throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?");
			return fn.call(dispatcher, {
				...opts,
				origin: url.origin,
				path: url.search ? `${url.pathname}${url.search}` : url.pathname,
				method: opts.method || (opts.body ? "PUT" : "GET")
			}, handler);
		};
	}
	module.exports.setGlobalDispatcher = setGlobalDispatcher;
	module.exports.getGlobalDispatcher = getGlobalDispatcher;
	var fetchImpl = require_fetch().fetch;
	module.exports.fetch = async function fetch(init, options = void 0) {
		try {
			return await fetchImpl(init, options);
		} catch (err) {
			if (err && typeof err === "object") Error.captureStackTrace(err);
			throw err;
		}
	};
	module.exports.Headers = require_headers().Headers;
	module.exports.Response = require_response().Response;
	module.exports.Request = require_request().Request;
	module.exports.FormData = require_formdata().FormData;
	module.exports.File = globalThis.File ?? __require("node:buffer").File;
	module.exports.FileReader = require_filereader().FileReader;
	var { setGlobalOrigin, getGlobalOrigin } = require_global$1();
	module.exports.setGlobalOrigin = setGlobalOrigin;
	module.exports.getGlobalOrigin = getGlobalOrigin;
	var { CacheStorage } = require_cachestorage();
	var { kConstruct } = require_symbols$1();
	module.exports.caches = new CacheStorage(kConstruct);
	var { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies();
	module.exports.deleteCookie = deleteCookie;
	module.exports.getCookies = getCookies;
	module.exports.getSetCookies = getSetCookies;
	module.exports.setCookie = setCookie;
	var { parseMIMEType, serializeAMimeType } = require_data_url();
	module.exports.parseMIMEType = parseMIMEType;
	module.exports.serializeAMimeType = serializeAMimeType;
	var { CloseEvent, ErrorEvent, MessageEvent } = require_events();
	module.exports.WebSocket = require_websocket().WebSocket;
	module.exports.CloseEvent = CloseEvent;
	module.exports.ErrorEvent = ErrorEvent;
	module.exports.MessageEvent = MessageEvent;
	module.exports.request = makeDispatcher(api.request);
	module.exports.stream = makeDispatcher(api.stream);
	module.exports.pipeline = makeDispatcher(api.pipeline);
	module.exports.connect = makeDispatcher(api.connect);
	module.exports.upgrade = makeDispatcher(api.upgrade);
	module.exports.MockClient = MockClient;
	module.exports.MockPool = MockPool;
	module.exports.MockAgent = MockAgent;
	module.exports.mockErrors = mockErrors;
	var { EventSource } = require_eventsource();
	module.exports.EventSource = EventSource;
}));
require_tunnel();
require_undici();
var HttpCodes;
(function(HttpCodes) {
	HttpCodes[HttpCodes["OK"] = 200] = "OK";
	HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices";
	HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently";
	HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved";
	HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther";
	HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified";
	HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy";
	HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy";
	HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect";
	HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect";
	HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest";
	HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized";
	HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired";
	HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden";
	HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound";
	HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
	HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable";
	HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
	HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout";
	HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict";
	HttpCodes[HttpCodes["Gone"] = 410] = "Gone";
	HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests";
	HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError";
	HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented";
	HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway";
	HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
	HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout";
})(HttpCodes || (HttpCodes = {}));
var Headers;
(function(Headers) {
	Headers["Accept"] = "accept";
	Headers["ContentType"] = "content-type";
})(Headers || (Headers = {}));
var MediaTypes;
(function(MediaTypes) {
	MediaTypes["ApplicationJson"] = "application/json";
})(MediaTypes || (MediaTypes = {}));
HttpCodes.MovedPermanently, HttpCodes.ResourceMoved, HttpCodes.SeeOther, HttpCodes.TemporaryRedirect, HttpCodes.PermanentRedirect;
HttpCodes.BadGateway, HttpCodes.ServiceUnavailable, HttpCodes.GatewayTimeout;
//#endregion
//#region node_modules/@actions/core/lib/summary.js
var __awaiter$6 = function(thisArg, _arguments, P, generator) {
	function adopt(value) {
		return value instanceof P ? value : new P(function(resolve) {
			resolve(value);
		});
	}
	return new (P || (P = Promise))(function(resolve, reject) {
		function fulfilled(value) {
			try {
				step(generator.next(value));
			} catch (e) {
				reject(e);
			}
		}
		function rejected(value) {
			try {
				step(generator["throw"](value));
			} catch (e) {
				reject(e);
			}
		}
		function step(result) {
			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
		}
		step((generator = generator.apply(thisArg, _arguments || [])).next());
	});
};
var { access, appendFile, writeFile } = promises;
var SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY";
var Summary = class {
	constructor() {
		this._buffer = "";
	}
	/**
	* Finds the summary file path from the environment, rejects if env var is not found or file does not exist
	* Also checks r/w permissions.
	*
	* @returns step summary file path
	*/
	filePath() {
		return __awaiter$6(this, void 0, void 0, function* () {
			if (this._filePath) return this._filePath;
			const pathFromEnv = process.env[SUMMARY_ENV_VAR];
			if (!pathFromEnv) throw new Error(`Unable to find environment variable for $${SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`);
			try {
				yield access(pathFromEnv, constants.R_OK | constants.W_OK);
			} catch (_a) {
				throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`);
			}
			this._filePath = pathFromEnv;
			return this._filePath;
		});
	}
	/**
	* Wraps content in an HTML tag, adding any HTML attributes
	*
	* @param {string} tag HTML tag to wrap
	* @param {string | null} content content within the tag
	* @param {[attribute: string]: string} attrs key-value list of HTML attributes to add
	*
	* @returns {string} content wrapped in HTML element
	*/
	wrap(tag, content, attrs = {}) {
		const htmlAttrs = Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join("");
		if (!content) return `<${tag}${htmlAttrs}>`;
		return `<${tag}${htmlAttrs}>${content}</${tag}>`;
	}
	/**
	* Writes text in the buffer to the summary buffer file and empties buffer. Will append by default.
	*
	* @param {SummaryWriteOptions} [options] (optional) options for write operation
	*
	* @returns {Promise<Summary>} summary instance
	*/
	write(options) {
		return __awaiter$6(this, void 0, void 0, function* () {
			const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite);
			const filePath = yield this.filePath();
			yield (overwrite ? writeFile : appendFile)(filePath, this._buffer, { encoding: "utf8" });
			return this.emptyBuffer();
		});
	}
	/**
	* Clears the summary buffer and wipes the summary file
	*
	* @returns {Summary} summary instance
	*/
	clear() {
		return __awaiter$6(this, void 0, void 0, function* () {
			return this.emptyBuffer().write({ overwrite: true });
		});
	}
	/**
	* Returns the current summary buffer as a string
	*
	* @returns {string} string of summary buffer
	*/
	stringify() {
		return this._buffer;
	}
	/**
	* If the summary buffer is empty
	*
	* @returns {boolen} true if the buffer is empty
	*/
	isEmptyBuffer() {
		return this._buffer.length === 0;
	}
	/**
	* Resets the summary buffer without writing to summary file
	*
	* @returns {Summary} summary instance
	*/
	emptyBuffer() {
		this._buffer = "";
		return this;
	}
	/**
	* Adds raw text to the summary buffer
	*
	* @param {string} text content to add
	* @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false)
	*
	* @returns {Summary} summary instance
	*/
	addRaw(text, addEOL = false) {
		this._buffer += text;
		return addEOL ? this.addEOL() : this;
	}
	/**
	* Adds the operating system-specific end-of-line marker to the buffer
	*
	* @returns {Summary} summary instance
	*/
	addEOL() {
		return this.addRaw(EOL);
	}
	/**
	* Adds an HTML codeblock to the summary buffer
	*
	* @param {string} code content to render within fenced code block
	* @param {string} lang (optional) language to syntax highlight code
	*
	* @returns {Summary} summary instance
	*/
	addCodeBlock(code, lang) {
		const attrs = Object.assign({}, lang && { lang });
		const element = this.wrap("pre", this.wrap("code", code), attrs);
		return this.addRaw(element).addEOL();
	}
	/**
	* Adds an HTML list to the summary buffer
	*
	* @param {string[]} items list of items to render
	* @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false)
	*
	* @returns {Summary} summary instance
	*/
	addList(items, ordered = false) {
		const tag = ordered ? "ol" : "ul";
		const listItems = items.map((item) => this.wrap("li", item)).join("");
		const element = this.wrap(tag, listItems);
		return this.addRaw(element).addEOL();
	}
	/**
	* Adds an HTML table to the summary buffer
	*
	* @param {SummaryTableCell[]} rows table rows
	*
	* @returns {Summary} summary instance
	*/
	addTable(rows) {
		const tableBody = rows.map((row) => {
			const cells = row.map((cell) => {
				if (typeof cell === "string") return this.wrap("td", cell);
				const { header, data, colspan, rowspan } = cell;
				const tag = header ? "th" : "td";
				const attrs = Object.assign(Object.assign({}, colspan && { colspan }), rowspan && { rowspan });
				return this.wrap(tag, data, attrs);
			}).join("");
			return this.wrap("tr", cells);
		}).join("");
		const element = this.wrap("table", tableBody);
		return this.addRaw(element).addEOL();
	}
	/**
	* Adds a collapsable HTML details element to the summary buffer
	*
	* @param {string} label text for the closed state
	* @param {string} content collapsable content
	*
	* @returns {Summary} summary instance
	*/
	addDetails(label, content) {
		const element = this.wrap("details", this.wrap("summary", label) + content);
		return this.addRaw(element).addEOL();
	}
	/**
	* Adds an HTML image tag to the summary buffer
	*
	* @param {string} src path to the image you to embed
	* @param {string} alt text description of the image
	* @param {SummaryImageOptions} options (optional) addition image attributes
	*
	* @returns {Summary} summary instance
	*/
	addImage(src, alt, options) {
		const { width, height } = options || {};
		const attrs = Object.assign(Object.assign({}, width && { width }), height && { height });
		const element = this.wrap("img", null, Object.assign({
			src,
			alt
		}, attrs));
		return this.addRaw(element).addEOL();
	}
	/**
	* Adds an HTML section heading element
	*
	* @param {string} text heading text
	* @param {number | string} [level=1] (optional) the heading level, default: 1
	*
	* @returns {Summary} summary instance
	*/
	addHeading(text, level) {
		const tag = `h${level}`;
		const allowedTag = [
			"h1",
			"h2",
			"h3",
			"h4",
			"h5",
			"h6"
		].includes(tag) ? tag : "h1";
		const element = this.wrap(allowedTag, text);
		return this.addRaw(element).addEOL();
	}
	/**
	* Adds an HTML thematic break (<hr>) to the summary buffer
	*
	* @returns {Summary} summary instance
	*/
	addSeparator() {
		const element = this.wrap("hr", null);
		return this.addRaw(element).addEOL();
	}
	/**
	* Adds an HTML line break (<br>) to the summary buffer
	*
	* @returns {Summary} summary instance
	*/
	addBreak() {
		const element = this.wrap("br", null);
		return this.addRaw(element).addEOL();
	}
	/**
	* Adds an HTML blockquote to the summary buffer
	*
	* @param {string} text quote text
	* @param {string} cite (optional) citation url
	*
	* @returns {Summary} summary instance
	*/
	addQuote(text, cite) {
		const attrs = Object.assign({}, cite && { cite });
		const element = this.wrap("blockquote", text, attrs);
		return this.addRaw(element).addEOL();
	}
	/**
	* Adds an HTML anchor tag to the summary buffer
	*
	* @param {string} text link text/content
	* @param {string} href hyperlink
	*
	* @returns {Summary} summary instance
	*/
	addLink(text, href) {
		const element = this.wrap("a", text, { href });
		return this.addRaw(element).addEOL();
	}
};
new Summary();
//#endregion
//#region node_modules/@actions/io/lib/io-util.js
var __awaiter$5 = function(thisArg, _arguments, P, generator) {
	function adopt(value) {
		return value instanceof P ? value : new P(function(resolve) {
			resolve(value);
		});
	}
	return new (P || (P = Promise))(function(resolve, reject) {
		function fulfilled(value) {
			try {
				step(generator.next(value));
			} catch (e) {
				reject(e);
			}
		}
		function rejected(value) {
			try {
				step(generator["throw"](value));
			} catch (e) {
				reject(e);
			}
		}
		function step(result) {
			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
		}
		step((generator = generator.apply(thisArg, _arguments || [])).next());
	});
};
var { chmod, copyFile, lstat, mkdir, open, readdir, rename, rm, rmdir, stat, symlink, unlink } = fs$1.promises;
var IS_WINDOWS$1 = process.platform === "win32";
fs$1.constants.O_RDONLY;
/**
* On OSX/Linux, true if path starts with '/'. On Windows, true for paths like:
* \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases).
*/
function isRooted(p) {
	p = normalizeSeparators(p);
	if (!p) throw new Error("isRooted() parameter \"p\" cannot be empty");
	if (IS_WINDOWS$1) return p.startsWith("\\") || /^[A-Z]:/i.test(p);
	return p.startsWith("/");
}
/**
* Best effort attempt to determine whether a file exists and is executable.
* @param filePath    file path to check
* @param extensions  additional file extensions to try
* @return if file exists and is executable, returns the file path. otherwise empty string.
*/
function tryGetExecutablePath(filePath, extensions) {
	return __awaiter$5(this, void 0, void 0, function* () {
		let stats = void 0;
		try {
			stats = yield stat(filePath);
		} catch (err) {
			if (err.code !== "ENOENT") console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
		}
		if (stats && stats.isFile()) {
			if (IS_WINDOWS$1) {
				const upperExt = path$1.extname(filePath).toUpperCase();
				if (extensions.some((validExt) => validExt.toUpperCase() === upperExt)) return filePath;
			} else if (isUnixExecutable(stats)) return filePath;
		}
		const originalFilePath = filePath;
		for (const extension of extensions) {
			filePath = originalFilePath + extension;
			stats = void 0;
			try {
				stats = yield stat(filePath);
			} catch (err) {
				if (err.code !== "ENOENT") console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
			}
			if (stats && stats.isFile()) {
				if (IS_WINDOWS$1) {
					try {
						const directory = path$1.dirname(filePath);
						const upperName = path$1.basename(filePath).toUpperCase();
						for (const actualName of yield readdir(directory)) if (upperName === actualName.toUpperCase()) {
							filePath = path$1.join(directory, actualName);
							break;
						}
					} catch (err) {
						console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`);
					}
					return filePath;
				} else if (isUnixExecutable(stats)) return filePath;
			}
		}
		return "";
	});
}
function normalizeSeparators(p) {
	p = p || "";
	if (IS_WINDOWS$1) {
		p = p.replace(/\//g, "\\");
		return p.replace(/\\\\+/g, "\\");
	}
	return p.replace(/\/\/+/g, "/");
}
function isUnixExecutable(stats) {
	return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && process.getgid !== void 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && process.getuid !== void 0 && stats.uid === process.getuid();
}
//#endregion
//#region node_modules/@actions/io/lib/io.js
var __awaiter$4 = function(thisArg, _arguments, P, generator) {
	function adopt(value) {
		return value instanceof P ? value : new P(function(resolve) {
			resolve(value);
		});
	}
	return new (P || (P = Promise))(function(resolve, reject) {
		function fulfilled(value) {
			try {
				step(generator.next(value));
			} catch (e) {
				reject(e);
			}
		}
		function rejected(value) {
			try {
				step(generator["throw"](value));
			} catch (e) {
				reject(e);
			}
		}
		function step(result) {
			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
		}
		step((generator = generator.apply(thisArg, _arguments || [])).next());
	});
};
/**
* Returns path of a tool had the tool actually been invoked.  Resolves via paths.
* If you check and the tool does not exist, it will throw.
*
* @param     tool              name of the tool
* @param     check             whether to check if tool exists
* @returns   Promise<string>   path to tool
*/
function which$1(tool, check) {
	return __awaiter$4(this, void 0, void 0, function* () {
		if (!tool) throw new Error("parameter 'tool' is required");
		if (check) {
			const result = yield which$1(tool, false);
			if (!result) if (IS_WINDOWS$1) throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);
			else throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);
			return result;
		}
		const matches = yield findInPath(tool);
		if (matches && matches.length > 0) return matches[0];
		return "";
	});
}
/**
* Returns a list of all occurrences of the given tool on the system path.
*
* @returns   Promise<string[]>  the paths of the tool
*/
function findInPath(tool) {
	return __awaiter$4(this, void 0, void 0, function* () {
		if (!tool) throw new Error("parameter 'tool' is required");
		const extensions = [];
		if (IS_WINDOWS$1 && process.env["PATHEXT"]) {
			for (const extension of process.env["PATHEXT"].split(path$1.delimiter)) if (extension) extensions.push(extension);
		}
		if (isRooted(tool)) {
			const filePath = yield tryGetExecutablePath(tool, extensions);
			if (filePath) return [filePath];
			return [];
		}
		if (tool.includes(path$1.sep)) return [];
		const directories = [];
		if (process.env.PATH) {
			for (const p of process.env.PATH.split(path$1.delimiter)) if (p) directories.push(p);
		}
		const matches = [];
		for (const directory of directories) {
			const filePath = yield tryGetExecutablePath(path$1.join(directory, tool), extensions);
			if (filePath) matches.push(filePath);
		}
		return matches;
	});
}
process.platform;
events.EventEmitter;
events.EventEmitter;
os.platform();
os.arch();
/**
* The code to exit an action
*/
var ExitCode;
(function(ExitCode) {
	/**
	* A code indicating that the action was successful
	*/
	ExitCode[ExitCode["Success"] = 0] = "Success";
	/**
	* A code indicating that the action was a failure
	*/
	ExitCode[ExitCode["Failure"] = 1] = "Failure";
})(ExitCode || (ExitCode = {}));
/**
* Sets env variable for this action and future actions in the job
* @param name the name of the variable to set
* @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
*/
function exportVariable(name, val) {
	const convertedVal = toCommandValue(val);
	process.env[name] = convertedVal;
	if (process.env["GITHUB_ENV"] || "") return issueFileCommand("ENV", prepareKeyValueMessage(name, val));
	issueCommand("set-env", { name }, convertedVal);
}
/**
* Gets the value of an input.
* Unless trimWhitespace is set to false in InputOptions, the value is also trimmed.
* Returns an empty string if the value is not defined.
*
* @param     name     name of the input to get
* @param     options  optional. See InputOptions.
* @returns   string
*/
function getInput(name, options) {
	const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || "";
	if (options && options.required && !val) throw new Error(`Input required and not supplied: ${name}`);
	if (options && options.trimWhitespace === false) return val;
	return val.trim();
}
/**
* Gets the input value of the boolean type in the YAML 1.2 "core schema" specification.
* Support boolean input list: `true | True | TRUE | false | False | FALSE` .
* The return value is also in boolean type.
* ref: https://yaml.org/spec/1.2/spec.html#id2804923
*
* @param     name     name of the input to get
* @param     options  optional. See InputOptions.
* @returns   boolean
*/
function getBooleanInput(name, options) {
	const trueValue = [
		"true",
		"True",
		"TRUE"
	];
	const falseValue = [
		"false",
		"False",
		"FALSE"
	];
	const val = getInput(name, options);
	if (trueValue.includes(val)) return true;
	if (falseValue.includes(val)) return false;
	throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\nSupport boolean input list: \`true | True | TRUE | false | False | FALSE\``);
}
/**
* Sets the action status to failed.
* When the action exits it will be with an exit code of 1
* @param message add error issue message
*/
function setFailed(message) {
	process.exitCode = ExitCode.Failure;
	error(message);
}
/**
* Adds an error issue
* @param message error issue message. Errors will be converted to string via toString()
* @param properties optional properties to add to the annotation.
*/
function error(message, properties = {}) {
	issueCommand("error", toCommandProperties(properties), message instanceof Error ? message.toString() : message);
}
//#endregion
//#region node_modules/zx/build/deno.js
if (globalThis.Deno) {
	globalThis.require = createRequire(import.meta.url);
	globalThis.__filename = new URL(import.meta.url).pathname;
	globalThis.__dirname = new URL(".", import.meta.url).pathname;
	globalThis.module = new Proxy({}, { set() {
		return true;
	} });
	const p = globalThis.process = globalThis.process || process$1;
	p.version || (p.version = "v18.0.0");
	p.version || (p.version = { node: "18.0.0" });
	p.env || (p.env = globalThis.Deno.env.toObject());
	p.argv || (p.argv = [
		globalThis.Deno.execPath(),
		globalThis.Deno.mainModule.replace("file://", ""),
		...globalThis.Deno.args
	]);
}
//#endregion
//#region node_modules/zx/build/esblib.cjs
var require_esblib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var __create = Object.create;
	var __defProp = Object.defineProperty;
	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames = Object.getOwnPropertyNames;
	var __getProtoOf = Object.getPrototypeOf;
	var __hasOwnProp = Object.prototype.hasOwnProperty;
	var __export = (target, all) => {
		for (var name in all) __defProp(target, name, {
			get: all[name],
			enumerable: true
		});
	};
	var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
	var __async = (__this, __arguments, generator) => {
		return new Promise((resolve, reject) => {
			var fulfilled = (value) => {
				try {
					step(generator.next(value));
				} catch (e) {
					reject(e);
				}
			};
			var rejected = (value) => {
				try {
					step(generator.throw(value));
				} catch (e) {
					reject(e);
				}
			};
			var step = (x2) => x2.done ? resolve(x2.value) : Promise.resolve(x2.value).then(fulfilled, rejected);
			step((generator = generator.apply(__this, __arguments)).next());
		});
	};
	var __defProps = Object.defineProperties;
	var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
	var __getOwnPropSymbols = Object.getOwnPropertySymbols;
	var __propIsEnum = Object.prototype.propertyIsEnumerable;
	var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
	var __typeError = (msg) => {
		throw TypeError(msg);
	};
	var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
		enumerable: true,
		configurable: true,
		writable: true,
		value
	}) : obj[key] = value;
	var __spreadValues = (a, b) => {
		for (var prop in b || (b = {})) if (__hasOwnProp.call(b, prop)) __defNormalProp(a, prop, b[prop]);
		if (__getOwnPropSymbols) {
			for (var prop of __getOwnPropSymbols(b)) if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
		}
		return a;
	};
	var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
	var __await = function(promise, isYieldStar) {
		this[0] = promise;
		this[1] = isYieldStar;
	};
	var __asyncGenerator = (__this, __arguments, generator) => {
		var resume = (k2, v2, yes, no) => {
			try {
				var x2 = generator[k2](v2), isAwait = (v2 = x2.value) instanceof __await, done = x2.done;
				Promise.resolve(isAwait ? v2[0] : v2).then((y) => isAwait ? resume(k2 === "return" ? k2 : "next", v2[1] ? {
					done: y.done,
					value: y.value
				} : y, yes, no) : yes({
					value: y,
					done
				})).catch((e) => resume("throw", e, yes, no));
			} catch (e) {
				no(e);
			}
		}, method = (k2) => it[k2] = (x2) => new Promise((yes, no) => resume(k2, x2, yes, no)), it = {};
		return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
	};
	var __yieldStar = (value) => {
		var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
		if (obj == null) {
			obj = value[__knownSymbol("iterator")]();
			method = (k2) => it[k2] = (x2) => obj[k2](x2);
		} else {
			obj = obj.call(value);
			method = (k2) => it[k2] = (v2) => {
				if (isAwait) {
					isAwait = false;
					if (k2 === "throw") throw v2;
					return v2;
				}
				isAwait = true;
				return {
					done: false,
					value: new __await(new Promise((resolve) => {
						var x2 = obj[k2](v2);
						if (!(x2 instanceof Object)) __typeError("Object expected");
						resolve(x2);
					}), 1)
				};
			};
		}
		return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x2) => {
			throw x2;
		}, "return" in obj && method("return"), it;
	};
	var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({
		value,
		done
	}), no)))), method("next"), method("return"), it);
	var __pow = Math.pow;
	var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
	var __commonJS = (cb, mod) => function __require() {
		return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
	};
	var __esm = (fn, res) => function __init() {
		return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
	};
	var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
	var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
	var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
	var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
	module.exports = {
		__create,
		__defProp,
		__getOwnPropDesc,
		__getOwnPropNames,
		__getProtoOf,
		__hasOwnProp,
		__export,
		__copyProps,
		__toESM,
		__toCommonJS,
		__async,
		__defProps,
		__getOwnPropDescs,
		__getOwnPropSymbols,
		__propIsEnum,
		__knownSymbol,
		__typeError,
		__defNormalProp,
		__spreadValues,
		__spreadProps,
		__await,
		__asyncGenerator,
		__yieldStar,
		__forAwait,
		__pow,
		__reExport,
		__commonJS,
		__esm,
		__accessCheck,
		__privateGet,
		__privateAdd,
		__privateSet
	};
}));
//#endregion
//#region node_modules/zx/build/internals.cjs
var require_internals = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { __export, __toCommonJS } = require_esblib();
	var internals_exports = {};
	__export(internals_exports, { bus: () => bus });
	module.exports = __toCommonJS(internals_exports);
	var locked = false;
	var lock = () => locked = true;
	var store = /* @__PURE__ */ new Map();
	var override = store.set.bind(store);
	function wrap(name, api) {
		if (locked) throw new Error("bus is locked");
		override(name, api);
		return new Proxy(api, {
			get(_, key) {
				var _a, _b;
				return store.get(name)[key] || ((_b = (_a = store.get(name)) == null ? void 0 : _a.default) == null ? void 0 : _b[key]);
			},
			apply(_, self, args) {
				return store.get(name).apply(self, args);
			}
		});
	}
	var bus = {
		override,
		wrap,
		lock
	};
}));
//#endregion
//#region node_modules/zx/build/vendor-core.cjs
var require_vendor_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { __create, __spreadValues, __spreadProps, __commonJS, __export, __toESM, __toCommonJS, __async } = require_esblib();
	var require_posix = __commonJS({ "node_modules/isexe/dist/cjs/posix.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.sync = exports2.isexe = void 0;
		var fs_1 = __require("fs");
		var promises_1 = __require("fs").promises;
		var isexe = (_0, ..._1) => __async(null, [_0, ..._1], function* (path, options = {}) {
			const { ignoreErrors = false } = options;
			try {
				return checkStat(yield (0, promises_1.stat)(path), options);
			} catch (e) {
				const er = e;
				if (ignoreErrors || er.code === "EACCES") return false;
				throw er;
			}
		});
		exports2.isexe = isexe;
		var sync = (path, options = {}) => {
			const { ignoreErrors = false } = options;
			try {
				return checkStat((0, fs_1.statSync)(path), options);
			} catch (e) {
				const er = e;
				if (ignoreErrors || er.code === "EACCES") return false;
				throw er;
			}
		};
		exports2.sync = sync;
		var checkStat = (stat, options) => stat.isFile() && checkMode(stat, options);
		var checkMode = (stat, options) => {
			var _a, _b, _c, _d, _e, _f, _g, _h;
			const myUid = (_b = options.uid) != null ? _b : (_a = process.getuid) == null ? void 0 : _a.call(process);
			const myGroups = (_e = (_d = options.groups) != null ? _d : (_c = process.getgroups) == null ? void 0 : _c.call(process)) != null ? _e : [];
			const myGid = (_h = (_g = options.gid) != null ? _g : (_f = process.getgid) == null ? void 0 : _f.call(process)) != null ? _h : myGroups[0];
			if (myUid === void 0 || myGid === void 0) throw new Error("cannot get uid or gid");
			const groups = /* @__PURE__ */ new Set([myGid, ...myGroups]);
			const mod = stat.mode;
			const uid = stat.uid;
			const gid = stat.gid;
			const u = parseInt("100", 8);
			const g2 = parseInt("010", 8);
			const o = parseInt("001", 8);
			const ug = u | g2;
			return !!(mod & o || mod & g2 && groups.has(gid) || mod & u && uid === myUid || mod & ug && myUid === 0);
		};
	} });
	var require_win32 = __commonJS({ "node_modules/isexe/dist/cjs/win32.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.sync = exports2.isexe = void 0;
		var fs_1 = __require("fs");
		var promises_1 = __require("fs").promises;
		var isexe = (_0, ..._1) => __async(null, [_0, ..._1], function* (path, options = {}) {
			const { ignoreErrors = false } = options;
			try {
				return checkStat(yield (0, promises_1.stat)(path), path, options);
			} catch (e) {
				const er = e;
				if (ignoreErrors || er.code === "EACCES") return false;
				throw er;
			}
		});
		exports2.isexe = isexe;
		var sync = (path, options = {}) => {
			const { ignoreErrors = false } = options;
			try {
				return checkStat((0, fs_1.statSync)(path), path, options);
			} catch (e) {
				const er = e;
				if (ignoreErrors || er.code === "EACCES") return false;
				throw er;
			}
		};
		exports2.sync = sync;
		var checkPathExt = (path, options) => {
			const { pathExt = process.env.PATHEXT || "" } = options;
			const peSplit = pathExt.split(";");
			if (peSplit.indexOf("") !== -1) return true;
			for (let i = 0; i < peSplit.length; i++) {
				const p = peSplit[i].toLowerCase();
				const ext = path.substring(path.length - p.length).toLowerCase();
				if (p && ext === p) return true;
			}
			return false;
		};
		var checkStat = (stat, path, options) => stat.isFile() && checkPathExt(path, options);
	} });
	var require_options = __commonJS({ "node_modules/isexe/dist/cjs/options.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
	} });
	var require_cjs = __commonJS({ "node_modules/isexe/dist/cjs/index.js"(exports2) {
		"use strict";
		var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
			if (k2 === void 0) k2 = k;
			var desc = Object.getOwnPropertyDescriptor(m, k);
			if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
				enumerable: true,
				get: function() {
					return m[k];
				}
			};
			Object.defineProperty(o, k2, desc);
		}) : (function(o, m, k, k2) {
			if (k2 === void 0) k2 = k;
			o[k2] = m[k];
		}));
		var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
			Object.defineProperty(o, "default", {
				enumerable: true,
				value: v
			});
		}) : function(o, v) {
			o["default"] = v;
		});
		var __importStar = exports2 && exports2.__importStar || function(mod) {
			if (mod && mod.__esModule) return mod;
			var result = {};
			if (mod != null) {
				for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
			}
			__setModuleDefault(result, mod);
			return result;
		};
		var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
			for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
		};
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.sync = exports2.isexe = exports2.posix = exports2.win32 = void 0;
		var posix = __importStar(require_posix());
		exports2.posix = posix;
		var win32 = __importStar(require_win32());
		exports2.win32 = win32;
		__exportStar(require_options(), exports2);
		var impl = (process.env._ISEXE_TEST_PLATFORM_ || process.platform) === "win32" ? win32 : posix;
		exports2.isexe = impl.isexe;
		exports2.sync = impl.sync;
	} });
	var require_lib = __commonJS({ "node_modules/which/lib/index.js"(exports2, module2) {
		"use strict";
		var { isexe, sync: isexeSync } = require_cjs();
		var { join, delimiter, sep, posix } = __require("path");
		var isWindows = process.platform === "win32";
		var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
		var rRel = new RegExp(`^\\.${rSlash.source}`);
		var getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
		var getPathInfo = (cmd, { path: optPath = process.env.PATH, pathExt: optPathExt = process.env.PATHEXT, delimiter: optDelimiter = delimiter }) => {
			const pathEnv = cmd.match(rSlash) ? [""] : [...isWindows ? [process.cwd()] : [], ...(optPath || "").split(optDelimiter)];
			if (isWindows) {
				const pathExtExe = optPathExt || [
					".EXE",
					".CMD",
					".BAT",
					".COM"
				].join(optDelimiter);
				const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
				if (cmd.includes(".") && pathExt[0] !== "") pathExt.unshift("");
				return {
					pathEnv,
					pathExt,
					pathExtExe
				};
			}
			return {
				pathEnv,
				pathExt: [""]
			};
		};
		var getPathPart = (raw, cmd) => {
			const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
			return (!pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "") + join(pathPart, cmd);
		};
		var which2 = (_0, ..._1) => __async(null, [_0, ..._1], function* (cmd, opt = {}) {
			const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
			const found = [];
			for (const envPart of pathEnv) {
				const p = getPathPart(envPart, cmd);
				for (const ext of pathExt) {
					const withExt = p + ext;
					if (yield isexe(withExt, {
						pathExt: pathExtExe,
						ignoreErrors: true
					})) {
						if (!opt.all) return withExt;
						found.push(withExt);
					}
				}
			}
			if (opt.all && found.length) return found;
			if (opt.nothrow) return null;
			throw getNotFoundError(cmd);
		});
		var whichSync = (cmd, opt = {}) => {
			const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
			const found = [];
			for (const pathEnvPart of pathEnv) {
				const p = getPathPart(pathEnvPart, cmd);
				for (const ext of pathExt) {
					const withExt = p + ext;
					if (isexeSync(withExt, {
						pathExt: pathExtExe,
						ignoreErrors: true
					})) {
						if (!opt.all) return withExt;
						found.push(withExt);
					}
				}
			}
			if (opt.all && found.length) return found;
			if (opt.nothrow) return null;
			throw getNotFoundError(cmd);
		};
		module2.exports = which2;
		which2.sync = whichSync;
	} });
	var vendor_core_exports = {};
	__export(vendor_core_exports, {
		VoidStream: () => VoidStream,
		buildCmd: () => buildCmd,
		chalk: () => chalk2,
		exec: () => exec,
		isStringLiteral: () => isStringLiteral,
		ps: () => ps,
		which: () => which
	});
	module.exports = __toCommonJS(vendor_core_exports);
	var ANSI_BACKGROUND_OFFSET = 10;
	var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
	var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
	var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
	var styles = {
		modifier: {
			reset: [0, 0],
			bold: [1, 22],
			dim: [2, 22],
			italic: [3, 23],
			underline: [4, 24],
			overline: [53, 55],
			inverse: [7, 27],
			hidden: [8, 28],
			strikethrough: [9, 29]
		},
		color: {
			black: [30, 39],
			red: [31, 39],
			green: [32, 39],
			yellow: [33, 39],
			blue: [34, 39],
			magenta: [35, 39],
			cyan: [36, 39],
			white: [37, 39],
			blackBright: [90, 39],
			gray: [90, 39],
			grey: [90, 39],
			redBright: [91, 39],
			greenBright: [92, 39],
			yellowBright: [93, 39],
			blueBright: [94, 39],
			magentaBright: [95, 39],
			cyanBright: [96, 39],
			whiteBright: [97, 39]
		},
		bgColor: {
			bgBlack: [40, 49],
			bgRed: [41, 49],
			bgGreen: [42, 49],
			bgYellow: [43, 49],
			bgBlue: [44, 49],
			bgMagenta: [45, 49],
			bgCyan: [46, 49],
			bgWhite: [47, 49],
			bgBlackBright: [100, 49],
			bgGray: [100, 49],
			bgGrey: [100, 49],
			bgRedBright: [101, 49],
			bgGreenBright: [102, 49],
			bgYellowBright: [103, 49],
			bgBlueBright: [104, 49],
			bgMagentaBright: [105, 49],
			bgCyanBright: [106, 49],
			bgWhiteBright: [107, 49]
		}
	};
	Object.keys(styles.modifier);
	var foregroundColorNames = Object.keys(styles.color);
	var backgroundColorNames = Object.keys(styles.bgColor);
	[...foregroundColorNames, ...backgroundColorNames];
	function assembleStyles() {
		const codes = /* @__PURE__ */ new Map();
		for (const [groupName, group] of Object.entries(styles)) {
			for (const [styleName, style] of Object.entries(group)) {
				styles[styleName] = {
					open: `\x1B[${style[0]}m`,
					close: `\x1B[${style[1]}m`
				};
				group[styleName] = styles[styleName];
				codes.set(style[0], style[1]);
			}
			Object.defineProperty(styles, groupName, {
				value: group,
				enumerable: false
			});
		}
		Object.defineProperty(styles, "codes", {
			value: codes,
			enumerable: false
		});
		styles.color.close = "\x1B[39m";
		styles.bgColor.close = "\x1B[49m";
		styles.color.ansi = wrapAnsi16();
		styles.color.ansi256 = wrapAnsi256();
		styles.color.ansi16m = wrapAnsi16m();
		styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
		styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
		styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
		Object.defineProperties(styles, {
			rgbToAnsi256: {
				value(red, green, blue) {
					if (red === green && green === blue) {
						if (red < 8) return 16;
						if (red > 248) return 231;
						return Math.round((red - 8) / 247 * 24) + 232;
					}
					return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
				},
				enumerable: false
			},
			hexToRgb: {
				value(hex) {
					const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
					if (!matches) return [
						0,
						0,
						0
					];
					let [colorString] = matches;
					if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
					const integer = Number.parseInt(colorString, 16);
					return [
						integer >> 16 & 255,
						integer >> 8 & 255,
						integer & 255
					];
				},
				enumerable: false
			},
			hexToAnsi256: {
				value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
				enumerable: false
			},
			ansi256ToAnsi: {
				value(code) {
					if (code < 8) return 30 + code;
					if (code < 16) return 90 + (code - 8);
					let red;
					let green;
					let blue;
					if (code >= 232) {
						red = ((code - 232) * 10 + 8) / 255;
						green = red;
						blue = red;
					} else {
						code -= 16;
						const remainder = code % 36;
						red = Math.floor(code / 36) / 5;
						green = Math.floor(remainder / 6) / 5;
						blue = remainder % 6 / 5;
					}
					const value = Math.max(red, green, blue) * 2;
					if (value === 0) return 30;
					let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
					if (value === 2) result += 60;
					return result;
				},
				enumerable: false
			},
			rgbToAnsi: {
				value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
				enumerable: false
			},
			hexToAnsi: {
				value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
				enumerable: false
			}
		});
		return styles;
	}
	var ansi_styles_default = assembleStyles();
	var import_node_process$4 = __toESM(__require("process"), 1);
	var import_node_os$1 = __toESM(__require("os"), 1);
	var import_node_tty = __toESM(__require("tty"), 1);
	function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process$4.default.argv) {
		const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
		const position = argv.indexOf(prefix + flag);
		const terminatorPosition = argv.indexOf("--");
		return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
	}
	var { env } = import_node_process$4.default;
	var flagForceColor;
	if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
	else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
	function envForceColor() {
		if ("FORCE_COLOR" in env) {
			if (env.FORCE_COLOR === "true") return 1;
			if (env.FORCE_COLOR === "false") return 0;
			return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
		}
	}
	function translateLevel(level) {
		if (level === 0) return false;
		return {
			level,
			hasBasic: true,
			has256: level >= 2,
			has16m: level >= 3
		};
	}
	function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
		const noFlagForceColor = envForceColor();
		if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
		const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
		if (forceColor === 0) return 0;
		if (sniffFlags) {
			if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
			if (hasFlag("color=256")) return 2;
		}
		if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
		if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
		const min = forceColor || 0;
		if (env.TERM === "dumb") return min;
		if (import_node_process$4.default.platform === "win32") {
			const osRelease = import_node_os$1.default.release().split(".");
			if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
			return 1;
		}
		if ("CI" in env) {
			if ([
				"GITHUB_ACTIONS",
				"GITEA_ACTIONS",
				"CIRCLECI"
			].some((key) => key in env)) return 3;
			if ([
				"TRAVIS",
				"APPVEYOR",
				"GITLAB_CI",
				"BUILDKITE",
				"DRONE"
			].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
			return min;
		}
		if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
		if (env.COLORTERM === "truecolor") return 3;
		if (env.TERM === "xterm-kitty") return 3;
		if (env.TERM === "xterm-ghostty") return 3;
		if (env.TERM === "wezterm") return 3;
		if ("TERM_PROGRAM" in env) {
			const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
			switch (env.TERM_PROGRAM) {
				case "iTerm.app": return version >= 3 ? 3 : 2;
				case "Apple_Terminal": return 2;
			}
		}
		if (/-256(color)?$/i.test(env.TERM)) return 2;
		if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
		if ("COLORTERM" in env) return 1;
		return min;
	}
	function createSupportsColor(stream, options = {}) {
		return translateLevel(_supportsColor(stream, __spreadValues({ streamIsTTY: stream && stream.isTTY }, options)));
	}
	var supports_color_default = {
		stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
		stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
	};
	function stringReplaceAll(string, substring, replacer) {
		let index = string.indexOf(substring);
		if (index === -1) return string;
		const substringLength = substring.length;
		let endIndex = 0;
		let returnValue = "";
		do {
			returnValue += string.slice(endIndex, index) + substring + replacer;
			endIndex = index + substringLength;
			index = string.indexOf(substring, endIndex);
		} while (index !== -1);
		returnValue += string.slice(endIndex);
		return returnValue;
	}
	function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
		let endIndex = 0;
		let returnValue = "";
		do {
			const gotCR = string[index - 1] === "\r";
			returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
			endIndex = index + 1;
			index = string.indexOf("\n", endIndex);
		} while (index !== -1);
		returnValue += string.slice(endIndex);
		return returnValue;
	}
	var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
	var GENERATOR = Symbol("GENERATOR");
	var STYLER = Symbol("STYLER");
	var IS_EMPTY = Symbol("IS_EMPTY");
	var levelMapping = [
		"ansi",
		"ansi",
		"ansi256",
		"ansi16m"
	];
	var styles2 = /* @__PURE__ */ Object.create(null);
	var applyOptions = (object, options = {}) => {
		if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
		const colorLevel = stdoutColor ? stdoutColor.level : 0;
		object.level = options.level === void 0 ? colorLevel : options.level;
	};
	var chalkFactory = (options) => {
		const chalk3 = (...strings) => strings.join(" ");
		applyOptions(chalk3, options);
		Object.setPrototypeOf(chalk3, createChalk.prototype);
		return chalk3;
	};
	function createChalk(options) {
		return chalkFactory(options);
	}
	Object.setPrototypeOf(createChalk.prototype, Function.prototype);
	for (const [styleName, style] of Object.entries(ansi_styles_default)) styles2[styleName] = { get() {
		const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
		Object.defineProperty(this, styleName, { value: builder });
		return builder;
	} };
	styles2.visible = { get() {
		const builder = createBuilder(this, this[STYLER], true);
		Object.defineProperty(this, "visible", { value: builder });
		return builder;
	} };
	var getModelAnsi = (model, level, type, ...arguments_) => {
		if (model === "rgb") {
			if (level === "ansi16m") return ansi_styles_default[type].ansi16m(...arguments_);
			if (level === "ansi256") return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
			return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
		}
		if (model === "hex") return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
		return ansi_styles_default[type][model](...arguments_);
	};
	for (const model of [
		"rgb",
		"hex",
		"ansi256"
	]) {
		styles2[model] = { get() {
			const { level } = this;
			return function(...arguments_) {
				const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
				return createBuilder(this, styler, this[IS_EMPTY]);
			};
		} };
		const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
		styles2[bgModel] = { get() {
			const { level } = this;
			return function(...arguments_) {
				const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
				return createBuilder(this, styler, this[IS_EMPTY]);
			};
		} };
	}
	var proto = Object.defineProperties(() => {}, __spreadProps(__spreadValues({}, styles2), { level: {
		enumerable: true,
		get() {
			return this[GENERATOR].level;
		},
		set(level) {
			this[GENERATOR].level = level;
		}
	} }));
	var createStyler = (open, close, parent) => {
		let openAll;
		let closeAll;
		if (parent === void 0) {
			openAll = open;
			closeAll = close;
		} else {
			openAll = parent.openAll + open;
			closeAll = close + parent.closeAll;
		}
		return {
			open,
			close,
			openAll,
			closeAll,
			parent
		};
	};
	var createBuilder = (self, _styler, _isEmpty) => {
		const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
		Object.setPrototypeOf(builder, proto);
		builder[GENERATOR] = self;
		builder[STYLER] = _styler;
		builder[IS_EMPTY] = _isEmpty;
		return builder;
	};
	var applyStyle = (self, string) => {
		if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
		let styler = self[STYLER];
		if (styler === void 0) return string;
		const { openAll, closeAll } = styler;
		if (string.includes("\x1B")) while (styler !== void 0) {
			string = stringReplaceAll(string, styler.close, styler.open);
			styler = styler.parent;
		}
		const lfIndex = string.indexOf("\n");
		if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
		return openAll + string + closeAll;
	};
	Object.defineProperties(createChalk.prototype, styles2);
	var chalk = createChalk();
	createChalk({ level: stderrColor ? stderrColor.level : 0 });
	var source_default = chalk;
	var import_which = __toESM(require_lib(), 1);
	var import_node_process4 = __toESM(__require("process"), 1);
	var import_node_fs$2 = __toESM(__require("fs"), 1);
	var import_node_os2 = __toESM(__require("os"), 1);
	var EOL = /\r?\n|\r|\n/;
	var EMPTY = "-";
	var parseLine = (line, sep = " ") => {
		if (typeof line !== "string") throw new Error("parseLine: line must be a string");
		const result = {
			spaces: [],
			words: []
		};
		const capture = () => {
			if (word) {
				result.words.push({
					s,
					e: s + word.length - 1,
					w: word
				});
				word = "";
				s = -1;
			}
		};
		let bb;
		let word = "";
		let s = -1;
		for (const i in [...line]) {
			const prev = line[+i - 1];
			const char = line[i];
			if (bb) {
				word += char;
				if (char === bb && prev !== "\\") bb = void 0;
				continue;
			}
			if (char === sep) {
				result.spaces.push(+i);
				capture();
				continue;
			}
			if (s === -1) s = +i;
			if (char === "\"" || char === "'") bb = char;
			word += char;
		}
		capture();
		return result;
	};
	var parseLines = (input, sep) => input.split(EOL).filter(Boolean).map((l) => parseLine(l, sep));
	var countWordsByIndex = ({ words }, index) => words.filter(({ e }) => e < index).length;
	var getBorders = (lines) => lines[0].spaces.reduce((m, i) => {
		const c = countWordsByIndex(lines[0], i);
		if (lines.every((l) => l.spaces.includes(i) && c === countWordsByIndex(l, i))) m.push(i);
		return m;
	}, []);
	var parseUnixGrid = (input) => {
		const lines = parseLines(input);
		const borders = getBorders(lines);
		const _borders = [
			Number.NEGATIVE_INFINITY,
			...borders,
			Number.POSITIVE_INFINITY
		];
		const grid = [];
		for (const { words } of lines) {
			const row = [];
			grid.push(row);
			for (const n in words) {
				const { w, s, e } = words[n];
				for (const _b in _borders) {
					const a = _borders[+_b];
					const b = _borders[+_b + 1];
					if (b === void 0) break;
					const block = row[_b] || (row[_b] = []);
					if (s > a && e < b) block.push(w);
				}
			}
		}
		return gridToData(grid);
	};
	var gridToData = (grid) => {
		const data = [];
		const [headers, ...body] = grid;
		for (const row of body) {
			const entry = {};
			data.push(entry);
			for (const i in headers) {
				const keys = headers[i];
				if (keys.length === 0) continue;
				if (keys.length > row[i].length) throw new Error("Malformed grid: row has more columns than headers");
				for (const k in keys) {
					const key = keys[k];
					const to = +k + 1 === keys.length ? Number.POSITIVE_INFINITY : +k + 1;
					entry[key] = row[i].slice(+k, to);
				}
			}
		}
		return data;
	};
	var parseWinGrid = (input, debug = false) => {
		const lines = input.split(/\r*\n+/).filter(Boolean);
		const headline = lines.shift();
		const headers = headline.trim().split(/\s\s+/);
		const hl = headers.length;
		const ll = headline.length;
		if (debug) {
			console.log("Headers:", headers);
			console.log("Line lengths:", lines.map((l) => l.length));
		}
		if (lines.every((l) => ll / l.length < 2)) {
			const borders = Array.from({ length: ll }).map((_, i) => lines.every((l) => l[i] === " ")).reduce((m, v, i, a) => {
				if (v && !a[i - 1]) m.push(i);
				return m;
			}, [0]);
			const data2 = [];
			debug && console.log("Borders:", borders);
			for (const line of lines) {
				const props = [];
				for (const i in headers) {
					const k = headers[i];
					const s = borders[i];
					const e = borders[+i + 1] || ll;
					const v = line.slice(s, e).trim();
					props.push([k, [v || EMPTY]]);
				}
				data2.push(Object.fromEntries(props));
			}
			return data2;
		}
		let w = "";
		let p;
		const body = input.slice(headline.length);
		const vals = [];
		const data = [];
		const cap = (v) => {
			const _v = w.trim() || (vals.length === 0 ? v : w.trim());
			if (!_v) return;
			vals.push(_v);
			if (vals.length === hl) {
				data.push(Object.fromEntries(headers.map((h, i) => [h, [vals[i]]])));
				vals.length = 0;
			}
			w = "";
		};
		for (const c of body) {
			w += c;
			if (c === " ") {
				if (p === "\n") cap(EMPTY);
				else if (p === " ") cap();
			} else if (c === "\n") cap();
			p = c;
		}
		cap();
		return data;
	};
	var parsers = {
		unix: parseUnixGrid,
		win: parseWinGrid
	};
	var parse = (input, { format = "unix", debug = false } = {}) => {
		const parser = parsers[format];
		if (!parser) throw new Error(`unsupported format: ${format}`);
		return parser(input, debug);
	};
	var cp = __toESM(__require("child_process"), 1);
	var import_node_process3 = __toESM(__require("process"), 1);
	var import_node_events$2 = __toESM(__require("events"), 1);
	var import_node_stream$2 = __require("stream");
	var g = !__toESM(__require("process"), 1).default.versions.deno && global || globalThis;
	var immediate = g.setImmediate || ((f) => g.setTimeout(f, 0));
	var noop = () => {};
	var randomId = () => Math.random().toString(36).slice(2);
	var isPromiseLike = (value) => typeof (value == null ? void 0 : value.then) === "function";
	var isStringLiteral = (pieces, ...rest) => {
		var _a;
		return (pieces == null ? void 0 : pieces.length) > 0 && ((_a = pieces.raw) == null ? void 0 : _a.length) === pieces.length && rest.length + 1 === pieces.length;
	};
	var assign = (target, ...extras) => Object.defineProperties(target, extras.reduce((m, extra) => __spreadValues(__spreadValues({}, m), Object.fromEntries(Object.entries(Object.getOwnPropertyDescriptors(extra)).filter(([, v]) => !Object.prototype.hasOwnProperty.call(v, "value") || v.value !== void 0))), {}));
	var buildCmd = (quote2, pieces, args, subs = substitute) => {
		if (args.some(isPromiseLike)) return Promise.all(args).then((args2) => buildCmd(quote2, pieces, args2, subs));
		let cmd = pieces[0], i = 0;
		while (i < args.length) {
			const s = Array.isArray(args[i]) ? args[i].map((x) => quote2(subs(x))).join(" ") : quote2(subs(args[i]));
			cmd += s + pieces[++i];
		}
		return cmd;
	};
	var substitute = (arg) => typeof (arg == null ? void 0 : arg.stdout) === "string" ? arg.stdout.replace(/\n$/, "") : `${arg}`;
	var defaults = {
		get id() {
			return randomId();
		},
		cmd: "",
		get cwd() {
			return import_node_process3.default.cwd();
		},
		sync: false,
		args: [],
		input: null,
		env: import_node_process3.default.env,
		get ee() {
			return new import_node_events$2.default();
		},
		get ac() {
			return g.AbortController && new AbortController();
		},
		get signal() {
			var _a;
			return (_a = this.ac) == null ? void 0 : _a.signal;
		},
		on: {},
		detached: import_node_process3.default.platform !== "win32",
		shell: true,
		spawn: cp.spawn,
		spawnSync: cp.spawnSync,
		spawnOpts: {},
		get store() {
			return createStore();
		},
		callback: noop,
		get stdin() {
			return new VoidStream();
		},
		get stdout() {
			return new VoidStream();
		},
		get stderr() {
			return new VoidStream();
		},
		stdio: [
			"pipe",
			"pipe",
			"pipe"
		],
		run: immediate,
		stack: ""
	};
	var normalizeCtx = (...ctxs) => assign(__spreadValues({}, defaults), { get signal() {
		var _a;
		return (_a = this.ac) == null ? void 0 : _a.signal;
	} }, ...ctxs);
	var processInput = (child, input) => {
		if (input && child.stdin && !child.stdin.destroyed) if (input instanceof import_node_stream$2.Readable) input.pipe(child.stdin);
		else {
			child.stdin.write(input);
			child.stdin.end();
		}
	};
	var VoidStream = class extends import_node_stream$2.Transform {
		_transform(chunk, _, cb) {
			this.emit("data", chunk);
			cb();
		}
	};
	var buildSpawnOpts = ({ spawnOpts, stdio, cwd, shell, input, env: env2, detached, signal }) => __spreadProps(__spreadValues({}, spawnOpts), {
		env: env2,
		cwd,
		stdio,
		shell,
		input,
		windowsHide: true,
		detached,
		signal
	});
	var toggleListeners = (pos, ee, on = {}) => {
		for (const [name, listener] of Object.entries(on)) ee[pos](name, listener);
		if (pos === "on") ee.once("end", () => toggleListeners("off", ee, on));
	};
	var createStore = () => ({
		stdout: [],
		stderr: [],
		stdall: []
	});
	var invoke = (c) => {
		var _a, _b;
		const now = Date.now();
		const stdio = [
			c.stdin,
			c.stdout,
			c.stderr
		];
		const push = (kind, data) => {
			c.store[kind].push(data);
			c.store.stdall.push(data);
			c.ee.emit(kind, data, c);
			c.ee.emit("stdall", data, c);
		};
		try {
			if (c.sync) {
				toggleListeners("on", c.ee, c.on);
				const opts = buildSpawnOpts(c);
				const r = c.spawnSync(c.cmd, c.args, opts);
				c.ee.emit("start", r, c);
				if (((_a = r.stdout) == null ? void 0 : _a.length) > 0) {
					c.stdout.write(r.stdout);
					push("stdout", r.stdout);
				}
				if (((_b = r.stderr) == null ? void 0 : _b.length) > 0) {
					c.stderr.write(r.stderr);
					push("stderr", r.stderr);
				}
				c.callback(null, c.fulfilled = __spreadProps(__spreadValues({}, r), {
					get stdout() {
						return c.store.stdout.join("");
					},
					get stderr() {
						return c.store.stderr.join("");
					},
					get stdall() {
						return c.store.stdall.join("");
					},
					stdio,
					duration: Date.now() - now,
					ctx: c
				}));
				c.ee.emit("end", c.fulfilled, c);
			} else c.run(() => {
				var _a2, _b2, _c;
				toggleListeners("on", c.ee, c.on);
				let error = null;
				let aborted = false;
				const opts = buildSpawnOpts(c);
				const child = c.spawn(c.cmd, c.args, opts);
				const onAbort = (event) => {
					if (opts.detached && child.pid) try {
						import_node_process3.default.kill(-child.pid);
					} catch (e) {
						child.kill();
					}
					aborted = true;
					c.ee.emit("abort", event, c);
				};
				c.child = child;
				c.ee.emit("start", child, c);
				(_a2 = opts.signal) == null || _a2.addEventListener("abort", onAbort);
				processInput(child, c.input || c.stdin);
				(_b2 = child.stdout) == null || _b2.on("data", (d) => {
					push("stdout", d);
				}).pipe(c.stdout);
				(_c = child.stderr) == null || _c.on("data", (d) => {
					push("stderr", d);
				}).pipe(c.stderr);
				child.once("error", (e) => {
					error = e;
					c.ee.emit("err", error, c);
				}).once("exit", () => {
					var _a3, _b3;
					if (aborted) {
						(_a3 = child.stdout) == null || _a3.destroy();
						(_b3 = child.stderr) == null || _b3.destroy();
					}
				}).once("close", (status, signal) => {
					var _a3;
					c.fulfilled = {
						error,
						status,
						signal,
						get stdout() {
							return c.store.stdout.join("");
						},
						get stderr() {
							return c.store.stderr.join("");
						},
						get stdall() {
							return c.store.stdall.join("");
						},
						stdio,
						duration: Date.now() - now,
						ctx: c
					};
					(_a3 = opts.signal) == null || _a3.removeEventListener("abort", onAbort);
					c.callback(error, c.fulfilled);
					c.ee.emit("end", c.fulfilled, c);
				});
			}, c);
		} catch (error) {
			c.callback(error, c.fulfilled = {
				error,
				status: null,
				signal: null,
				stdout: "",
				stderr: "",
				stdall: "",
				stdio,
				duration: Date.now() - now,
				ctx: c
			});
			c.ee.emit("err", error, c);
			c.ee.emit("end", c.fulfilled, c);
		}
		return c;
	};
	var exec = (ctx) => invoke(normalizeCtx(ctx));
	var IS_WIN = import_node_process4.default.platform === "win32";
	var IS_WIN2025_PLUS = IS_WIN && Number.parseInt(import_node_os2.default.release().split(".")[2], 10) >= 26e3;
	var LOOKUPS = {
		wmic: {
			cmd: "wmic process get ProcessId,ParentProcessId,CommandLine",
			args: [],
			parse(stdout) {
				return parse(removeWmicPrefix(stdout), { format: "win" });
			}
		},
		ps: {
			cmd: "ps",
			args: ["-lx"],
			parse(stdout) {
				return parse(stdout, { format: "unix" });
			}
		},
		pwsh: {
			cmd: "pwsh",
			args: [
				"-NoProfile",
				"-Command",
				"\"Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine | ConvertTo-Json -Compress\""
			],
			parse(stdout) {
				let arr = [];
				try {
					arr = JSON.parse(stdout);
				} catch (e) {
					return [];
				}
				return arr.map((p) => ({
					ProcessId: [p.ProcessId + ""],
					ParentProcessId: [p.ParentProcessId + ""],
					CommandLine: p.CommandLine ? [p.CommandLine] : []
				}));
			}
		}
	};
	var isBin = (f) => {
		if (f === "") return false;
		if (!f.includes("/") && !f.includes("\\")) return true;
		if (f.length > 3 && f[0] === "\"") return f[f.length - 1] === "\"" ? isBin(f.slice(1, -1)) : false;
		try {
			if (!import_node_fs$2.default.existsSync(f)) return false;
			const stat = import_node_fs$2.default.lstatSync(f);
			return stat.isFile() || stat.isSymbolicLink();
		} catch (e) {
			return false;
		}
	};
	var lookup = (query = {}, cb = noop2) => _lookup({
		query,
		cb,
		sync: false
	});
	var lookupSync = (query = {}, cb = noop2) => _lookup({
		query,
		cb,
		sync: true
	});
	lookup.sync = lookupSync;
	var _lookup = ({ query = {}, cb = noop2, sync = false }) => {
		const { promise, resolve, reject } = (sync ? makePseudoDeferred.bind(null, []) : makeDeferred)();
		const result = [];
		const { parse: parse2, cmd, args } = LOOKUPS[IS_WIN ? IS_WIN2025_PLUS ? "pwsh" : "wmic" : "ps"];
		const callback = (err, { stdout }) => {
			if (err) {
				reject(err);
				cb(err);
				return;
			}
			result.push(...filterProcessList(normalizeOutput(parse2(stdout)), query));
			resolve(result);
			cb(null, result);
		};
		exec({
			cmd,
			args,
			callback,
			sync,
			run(cb2) {
				cb2();
			}
		});
		return Object.assign(promise, result);
	};
	var filterProcessList = (processList, query = {}) => {
		const pidList = (query.pid === void 0 ? [] : [query.pid].flat(1)).map((v) => v + "");
		const filters = [
			(p) => query.command ? new RegExp(query.command, "i").test(p.command) : true,
			(p) => query.arguments ? new RegExp(query.arguments, "i").test(p.arguments.join(" ")) : true,
			(p) => query.ppid ? query.ppid + "" === p.ppid : true
		];
		return processList.filter((p) => (pidList.length === 0 || pidList.includes(p.pid)) && filters.every((f) => f(p)));
	};
	var removeWmicPrefix = (stdout) => {
		const s = stdout.indexOf(LOOKUPS.wmic.cmd + import_node_os2.default.EOL);
		const e = stdout.includes(">") ? stdout.trimEnd().lastIndexOf(import_node_os2.default.EOL) : stdout.length;
		return (s > 0 ? stdout.slice(s + LOOKUPS.wmic.cmd.length, e) : stdout.slice(0, e)).trimStart();
	};
	var pickTree = (list, pid, recursive = false) => {
		const children = list.filter((p) => p.ppid === pid + "");
		return [...children, ...children.flatMap((p) => recursive ? pickTree(list, p.pid, true) : [])];
	};
	var _tree = ({ cb = noop2, opts, sync = false }) => {
		if (typeof opts === "string" || typeof opts === "number") return _tree({
			opts: { pid: opts },
			cb,
			sync
		});
		const onError = (err) => cb(err);
		const onData = (all) => {
			if (opts === void 0) return all;
			const { pid, recursive = false } = opts;
			const list = pickTree(all, pid, recursive);
			cb(null, list);
			return list;
		};
		try {
			const all = _lookup({ sync });
			return sync ? onData(all) : all.then(onData, (err) => {
				onError(err);
				throw err;
			});
		} catch (err) {
			onError(err);
			return Promise.reject(err);
		}
	};
	var tree = (opts, cb) => __async(null, null, function* () {
		return _tree({
			opts,
			cb
		});
	});
	var treeSync = (opts, cb) => _tree({
		opts,
		cb,
		sync: true
	});
	tree.sync = treeSync;
	var kill = (pid, opts, next) => {
		if (typeof opts == "function") return kill(pid, void 0, opts);
		if (typeof opts == "string" || typeof opts == "number") return kill(pid, { signal: opts }, next);
		const { promise, resolve, reject } = makeDeferred();
		const { timeout = 30, signal = "SIGTERM" } = opts || {};
		try {
			import_node_process4.default.kill(+pid, signal);
		} catch (e) {
			reject(e);
			next?.(e);
			return promise;
		}
		let checkConfident = 0;
		let checkTimeoutTimer;
		let checkIsTimeout = false;
		const checkKilled = (finishCallback) => lookup({ pid }, (err, list = []) => {
			if (checkIsTimeout) return;
			if (err) {
				clearTimeout(checkTimeoutTimer);
				reject(err);
				finishCallback?.(err, pid);
			} else if (list.length > 0) {
				checkConfident = checkConfident - 1 || 0;
				checkKilled(finishCallback);
			} else {
				checkConfident++;
				if (checkConfident === 5) {
					clearTimeout(checkTimeoutTimer);
					resolve(pid);
					finishCallback?.(null, pid);
				} else checkKilled(finishCallback);
			}
		});
		if (next) {
			checkKilled(next);
			checkTimeoutTimer = setTimeout(() => {
				checkIsTimeout = true;
				next(/* @__PURE__ */ new Error("Kill process timeout"));
			}, timeout * 1e3);
		} else resolve(pid);
		return promise;
	};
	var normalizeOutput = (data) => data.reduce((m, d) => {
		var _a, _b;
		const pid = (_a = d.PID || d.ProcessId) == null ? void 0 : _a[0];
		const ppid = (_b = d.PPID || d.ParentProcessId) == null ? void 0 : _b[0];
		const _cmd = d.CMD || d.CommandLine || d.COMMAND || [];
		const cmd = _cmd.length === 1 ? _cmd[0].split(/\s+/) : _cmd;
		if (pid && cmd.length > 0) {
			const c = cmd.findIndex((_v, i) => isBin(cmd.slice(0, i).join(" ")));
			const command = (c === -1 ? cmd : cmd.slice(0, c)).join(" ");
			const args = c === -1 ? [] : cmd.slice(c);
			m.push({
				pid,
				ppid,
				command,
				arguments: args
			});
		}
		return m;
	}, []);
	var makeDeferred = () => {
		let resolve;
		let reject;
		const promise = new Promise((res, rej) => {
			resolve = res;
			reject = rej;
		});
		return {
			resolve,
			reject,
			promise
		};
	};
	var makePseudoDeferred = (r = {}) => ({
		promise: r,
		resolve: identity,
		reject(e) {
			throw e;
		}
	});
	var noop2 = () => {};
	var identity = (v) => v;
	var index_default = {
		kill,
		lookup,
		lookupSync,
		tree,
		treeSync
	};
	var import_internals = require_internals();
	var chalk2 = import_internals.bus.wrap("chalk", source_default);
	var which = import_internals.bus.wrap("which", import_which.default);
	var ps = import_internals.bus.wrap("ps", index_default);
}));
//#endregion
//#region node_modules/zx/build/util.cjs
var require_util = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { __spreadValues, __spreadProps, __export, __toESM, __toCommonJS } = require_esblib();
	var util_exports = {};
	__export(util_exports, {
		bufArrJoin: () => bufArrJoin,
		bufToString: () => bufToString,
		getLast: () => getLast,
		getLines: () => getLines,
		identity: () => identity,
		isString: () => isString,
		isStringLiteral: () => import_vendor_core.isStringLiteral,
		iteratorToArray: () => iteratorToArray,
		noop: () => noop,
		once: () => once,
		parseBool: () => parseBool,
		parseDuration: () => parseDuration,
		preferLocalBin: () => preferLocalBin,
		proxyOverride: () => proxyOverride,
		quote: () => quote,
		quotePowerShell: () => quotePowerShell,
		randomId: () => randomId,
		toCamelCase: () => toCamelCase
	});
	module.exports = __toCommonJS(util_exports);
	var import_node_path$2 = __toESM(__require("path"), 1);
	var import_node_process$3 = __toESM(__require("process"), 1);
	var import_vendor_core = require_vendor_core();
	function noop() {}
	function identity(v) {
		return v;
	}
	function randomId() {
		return Math.random().toString(36).slice(2);
	}
	function isString(obj) {
		return typeof obj === "string";
	}
	var utf8Decoder = new TextDecoder("utf-8");
	var bufToString = (buf) => isString(buf) ? buf : utf8Decoder.decode(buf);
	var bufArrJoin = (arr) => arr.reduce((acc, buf) => acc + bufToString(buf), "");
	var getLast = (arr) => arr[arr.length - 1];
	function preferLocalBin(env, ...dirs) {
		const pathKey = import_node_process$3.default.platform === "win32" ? Object.keys(env).reverse().find((key) => key.toUpperCase() === "PATH") || "Path" : "PATH";
		const pathValue = dirs.map((c) => c && [import_node_path$2.default.resolve(c, "node_modules", ".bin"), import_node_path$2.default.resolve(c)]).flat().concat(env[pathKey]).filter(Boolean).join(import_node_path$2.default.delimiter);
		return __spreadProps(__spreadValues({}, env), { [pathKey]: pathValue });
	}
	function quote(arg) {
		if (arg === "") return `$''`;
		if (/^[\w/.\-@:=]+$/.test(arg)) return arg;
		return `$'` + arg.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\f/g, "\\f").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\v/g, "\\v").replace(/\0/g, "\\0") + `'`;
	}
	function quotePowerShell(arg) {
		if (arg === "") return `''`;
		if (/^[\w/.\-]+$/.test(arg)) return arg;
		return `'` + arg.replace(/'/g, "''") + `'`;
	}
	function parseDuration(d) {
		if (typeof d === "number") {
			if (isNaN(d) || d < 0) throw new Error(`Invalid duration: "${d}".`);
			return d;
		}
		const [m, v, u] = d.match(/^(\d+)(m?s?)$/) || [];
		if (!m) throw new Error(`Unknown duration: "${d}".`);
		return +v * ({
			s: 1e3,
			ms: 1,
			m: 6e4
		}[u] || 1);
	}
	var once = (fn) => {
		let called = false;
		let result;
		return (...args) => called ? result : (called = true, result = fn(...args));
	};
	var proxyOverride = (origin, ...fallbacks) => new Proxy(origin, { get(target, key) {
		var _a, _b;
		return (_b = (_a = fallbacks.find((f) => key in f)) == null ? void 0 : _a[key]) != null ? _b : Reflect.get(target, key);
	} });
	var toCamelCase = (str) => str.toLowerCase().replace(/([a-z])[_-]+([a-z])/g, (_, p1, p2) => p1 + p2.toUpperCase());
	var parseBool = (v) => v === "true" || v !== "false" && v;
	var getLines = (chunk, next, delimiter) => {
		const lines = ((next.pop() || "") + bufToString(chunk)).split(delimiter);
		next.push(lines.pop());
		return lines;
	};
	var iteratorToArray = (it) => {
		const arr = [];
		let entry;
		while (!(entry = it.next()).done) arr.push(entry.value);
		return arr;
	};
}));
//#endregion
//#region node_modules/zx/build/core.cjs
var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { __spreadValues, __spreadProps, __export, __toESM, __toCommonJS, __async, __await, __asyncGenerator, __yieldStar, __forAwait } = require_esblib();
	var core_exports = {};
	__export(core_exports, {
		$: () => $,
		Fail: () => Fail,
		ProcessOutput: () => ProcessOutput,
		ProcessPromise: () => ProcessPromise,
		bus: () => import_internals.bus,
		cd: () => cd,
		chalk: () => import_vendor_core3.chalk,
		defaults: () => defaults,
		kill: () => kill,
		log: () => log,
		os: () => os$2,
		path: () => import_node_path$1.default,
		ps: () => import_vendor_core3.ps,
		quote: () => import_util2.quote,
		quotePowerShell: () => import_util2.quotePowerShell,
		resolveDefaults: () => resolveDefaults,
		syncProcessCwd: () => syncProcessCwd,
		useBash: () => useBash,
		usePowerShell: () => usePowerShell,
		usePwsh: () => usePwsh,
		which: () => import_vendor_core3.which,
		within: () => within
	});
	module.exports = __toCommonJS(core_exports);
	var import_node_async_hooks = __require("async_hooks");
	var import_node_buffer$1 = __require("buffer");
	var import_node_child_process$1 = __toESM(__require("child_process"), 1);
	var import_node_events$1 = __require("events");
	var import_node_fs$1 = __toESM(__require("fs"), 1);
	var import_node_os = __require("os");
	var import_node_process2$1 = __toESM(__require("process"), 1);
	var import_node_util2 = __require("util");
	var EXIT_CODES = {
		2: "Misuse of shell builtins",
		126: "Invoked command cannot execute",
		127: "Command not found",
		128: "Invalid exit argument",
		129: "Hangup",
		130: "Interrupt",
		131: "Quit and dump core",
		132: "Illegal instruction",
		133: "Trace/breakpoint trap",
		134: "Process aborted",
		135: "Bus error: \"access to undefined portion of memory object\"",
		136: "Floating point exception: \"erroneous arithmetic operation\"",
		137: "Kill (terminate immediately)",
		138: "User-defined 1",
		139: "Segmentation violation",
		140: "User-defined 2",
		141: "Write to pipe with no one reading",
		142: "Signal raised by alarm",
		143: "Termination (request to terminate)",
		145: "Child process terminated, stopped (or continued*)",
		146: "Continue if stopped",
		147: "Stop executing temporarily",
		148: "Terminal stop signal",
		149: "Background process attempting to read from tty (\"in\")",
		150: "Background process attempting to write to tty (\"out\")",
		151: "Urgent data available on socket",
		152: "CPU time limit exceeded",
		153: "File size limit exceeded",
		154: "Signal raised by timer counting virtual time: \"virtual timer expired\"",
		155: "Profiling timer expired",
		157: "Pollable event",
		159: "Bad syscall"
	};
	var ERRNO_CODES = {
		0: "Success",
		1: "Not super-user",
		2: "No such file or directory",
		3: "No such process",
		4: "Interrupted system call",
		5: "I/O error",
		6: "No such device or address",
		7: "Arg list too long",
		8: "Exec format error",
		9: "Bad file number",
		10: "No children",
		11: "No more processes",
		12: "Not enough core",
		13: "Permission denied",
		14: "Bad address",
		15: "Block device required",
		16: "Mount device busy",
		17: "File exists",
		18: "Cross-device link",
		19: "No such device",
		20: "Not a directory",
		21: "Is a directory",
		22: "Invalid argument",
		23: "Too many open files in system",
		24: "Too many open files",
		25: "Not a typewriter",
		26: "Text file busy",
		27: "File too large",
		28: "No space left on device",
		29: "Illegal seek",
		30: "Read only file system",
		31: "Too many links",
		32: "Broken pipe",
		33: "Math arg out of domain of func",
		34: "Math result not representable",
		35: "File locking deadlock error",
		36: "File or path name too long",
		37: "No record locks available",
		38: "Function not implemented",
		39: "Directory not empty",
		40: "Too many symbolic links",
		42: "No message of desired type",
		43: "Identifier removed",
		44: "Channel number out of range",
		45: "Level 2 not synchronized",
		46: "Level 3 halted",
		47: "Level 3 reset",
		48: "Link number out of range",
		49: "Protocol driver not attached",
		50: "No CSI structure available",
		51: "Level 2 halted",
		52: "Invalid exchange",
		53: "Invalid request descriptor",
		54: "Exchange full",
		55: "No anode",
		56: "Invalid request code",
		57: "Invalid slot",
		59: "Bad font file fmt",
		60: "Device not a stream",
		61: "No data (for no delay io)",
		62: "Timer expired",
		63: "Out of streams resources",
		64: "Machine is not on the network",
		65: "Package not installed",
		66: "The object is remote",
		67: "The link has been severed",
		68: "Advertise error",
		69: "Srmount error",
		70: "Communication error on send",
		71: "Protocol error",
		72: "Multihop attempted",
		73: "Cross mount point (not really error)",
		74: "Trying to read unreadable message",
		75: "Value too large for defined data type",
		76: "Given log. name not unique",
		77: "f.d. invalid for this operation",
		78: "Remote address changed",
		79: "Can   access a needed shared lib",
		80: "Accessing a corrupted shared lib",
		81: ".lib section in a.out corrupted",
		82: "Attempting to link in too many libs",
		83: "Attempting to exec a shared library",
		84: "Illegal byte sequence",
		86: "Streams pipe error",
		87: "Too many users",
		88: "Socket operation on non-socket",
		89: "Destination address required",
		90: "Message too long",
		91: "Protocol wrong type for socket",
		92: "Protocol not available",
		93: "Unknown protocol",
		94: "Socket type not supported",
		95: "Not supported",
		96: "Protocol family not supported",
		97: "Address family not supported by protocol family",
		98: "Address already in use",
		99: "Address not available",
		100: "Network interface is not configured",
		101: "Network is unreachable",
		102: "Connection reset by network",
		103: "Connection aborted",
		104: "Connection reset by peer",
		105: "No buffer space available",
		106: "Socket is already connected",
		107: "Socket is not connected",
		108: "Can't send after socket shutdown",
		109: "Too many references",
		110: "Connection timed out",
		111: "Connection refused",
		112: "Host is down",
		113: "Host is unreachable",
		114: "Socket already connected",
		115: "Connection already in progress",
		116: "Stale file handle",
		122: "Quota exceeded",
		123: "No medium (in tape drive)",
		125: "Operation canceled",
		130: "Previous owner died",
		131: "State not recoverable"
	};
	var DOCS_URL = "https://google.github.io/zx";
	var _Fail = class _Fail extends Error {
		static formatExitMessage(code, signal, stderr, from, details = "") {
			if (code == 0 && signal == null) return `exit code: ${code}`;
			const codeInfo = _Fail.getExitCodeInfo(code);
			let message = `${stderr}
    at ${from}
    exit code: ${code}${codeInfo ? " (" + codeInfo + ")" : ""}`;
			if (signal != null) message += `
    signal: ${signal}`;
			if (details) message += `
    details: 
${details}`;
			return message;
		}
		static formatErrorMessage(err, from) {
			return `${err.message}
    errno: ${err.errno} (${_Fail.getErrnoMessage(err.errno)})
    code: ${err.code}
    at ${from}`;
		}
		static formatErrorDetails(lines = [], lim = 20) {
			if (lines.length < lim) return lines.join("\n");
			let errors = lines.filter((l) => /(fail|error|not ok|exception)/i.test(l));
			if (errors.length === 0) errors = lines;
			return errors.slice(0, lim).join("\n") + (errors.length > lim ? "\n..." : "");
		}
		static getExitCodeInfo(exitCode) {
			return EXIT_CODES[exitCode];
		}
		static getCallerLocationFromString(stackString = "unknown") {
			const lines = stackString.split(/^\s*(at\s)?/m).filter((s) => s == null ? void 0 : s.includes(":"));
			const i = lines.findIndex((l) => l.includes("Proxy.set"));
			const offset = i < 0 ? i : i + 2;
			return (lines.find((l) => l.includes("file://")) || lines[offset] || stackString).trim();
		}
		static getCallerLocation(err = /* @__PURE__ */ new Error("zx error")) {
			return _Fail.getCallerLocationFromString(err.stack);
		}
		static getErrnoMessage(errno) {
			return ERRNO_CODES[-errno] || "Unknown error";
		}
	};
	_Fail.DOCS_URL = DOCS_URL;
	_Fail.EXIT_CODES = EXIT_CODES;
	_Fail.ERRNO_CODES = ERRNO_CODES;
	var Fail = _Fail;
	var import_vendor_core = require_vendor_core();
	var import_node_util$1 = __require("util");
	var import_node_process$2 = __toESM(__require("process"), 1);
	var formatters = {
		cmd({ cmd }) {
			return formatCmd(cmd);
		},
		stdout({ data }) {
			return data;
		},
		stderr({ data }) {
			return data;
		},
		custom({ data }) {
			return data;
		},
		fetch(entry) {
			const init = entry.init ? " " + (0, import_node_util$1.inspect)(entry.init) : "";
			return `$ ${import_vendor_core.chalk.greenBright("fetch")} ${entry.url}${init}
`;
		},
		cd(entry) {
			return `$ ${import_vendor_core.chalk.greenBright("cd")} ${entry.dir}
`;
		},
		retry(entry) {
			const attempt = `Attempt: ${entry.attempt}${entry.total == Infinity ? "" : `/${entry.total}`}`;
			const delay = entry.delay > 0 ? `; next in ${entry.delay}ms` : "";
			return `${import_vendor_core.chalk.bgRed.white(" FAIL ")} ${attempt}${delay}
`;
		},
		end() {
			return "";
		},
		kill() {
			return "";
		}
	};
	var log = function(entry) {
		var _a;
		if (!entry.verbose) return;
		const stream = log.output || import_node_process$2.default.stderr;
		const format = ((_a = log.formatters) == null ? void 0 : _a[entry.kind]) || formatters[entry.kind];
		if (!format) return;
		stream.write(format(entry));
	};
	var SPACE_RE = /\s/;
	var SYNTAX = "()[]{}<>;:+|&=";
	var CMD_BREAK = "|&;><";
	var RESERVED_WORDS = /* @__PURE__ */ new Set([
		"if",
		"then",
		"else",
		"elif",
		"fi",
		"case",
		"esac",
		"for",
		"select",
		"while",
		"until",
		"do",
		"done",
		"in",
		"EOF"
	]);
	function formatCmd(cmd) {
		if (cmd == void 0) return import_vendor_core.chalk.grey("undefined");
		let q = "";
		let out = "$ ";
		let buf = "";
		let mode = "";
		let pos = 0;
		const cap = () => {
			const word = buf.trim();
			if (word) {
				pos++;
				if (mode === "syntax") {
					if (CMD_BREAK.includes(word)) pos = 0;
					out += import_vendor_core.chalk.red(buf);
				} else if (mode === "quote" || mode === "dollar") out += import_vendor_core.chalk.yellowBright(buf);
				else if (RESERVED_WORDS.has(word)) out += import_vendor_core.chalk.cyanBright(buf);
				else if (pos === 1) {
					out += import_vendor_core.chalk.greenBright(buf);
					pos = Infinity;
				} else out += buf;
			} else out += buf;
			mode = "";
			buf = "";
		};
		for (const c of [...cmd]) if (!q) if (c === "$") {
			cap();
			mode = "dollar";
			buf += c;
			cap();
		} else if (c === "'" || c === "\"") {
			cap();
			mode = "quote";
			q = c;
			buf += c;
		} else if (SPACE_RE.test(c)) {
			cap();
			buf += c;
		} else if (SYNTAX.includes(c)) {
			const isEnv = c === "=" && pos === 0;
			isEnv && (pos = 1);
			cap();
			mode = "syntax";
			buf += c;
			cap();
			isEnv && (pos = -1);
		} else buf += c;
		else {
			buf += c;
			if (c === q) {
				cap();
				q = "";
			}
		}
		cap();
		return out.replaceAll("\n", import_vendor_core.chalk.reset("\n> ")) + "\n";
	}
	var import_vendor_core2 = require_vendor_core();
	var import_util = require_util();
	var import_internals = require_internals();
	var import_node_path$1 = __toESM(__require("path"), 1);
	var os$2 = __toESM(__require("os"), 1);
	var import_vendor_core3 = require_vendor_core();
	var import_util2 = require_util();
	var CWD = Symbol("processCwd");
	var SYNC = Symbol("syncExec");
	var EPF = Symbol("end-piped-from");
	var SHOT = Symbol("snapshot");
	var EOL = import_node_buffer$1.Buffer.from(import_node_os.EOL);
	var BR_CC = "\n".charCodeAt(0);
	var DLMTR = /\r?\n/;
	var SIGTERM = "SIGTERM";
	var ENV_PREFIX = "ZX_";
	var ENV_OPTS = /* @__PURE__ */ new Set([
		"cwd",
		"preferLocal",
		"detached",
		"verbose",
		"quiet",
		"timeout",
		"timeoutSignal",
		"killSignal",
		"prefix",
		"postfix",
		"shell"
	]);
	var defaults = resolveDefaults({
		[CWD]: import_node_process2$1.default.cwd(),
		[SYNC]: false,
		verbose: false,
		env: import_node_process2$1.default.env,
		sync: false,
		shell: true,
		stdio: "pipe",
		nothrow: false,
		quiet: false,
		detached: false,
		preferLocal: false,
		spawn: import_node_child_process$1.default.spawn,
		spawnSync: import_node_child_process$1.default.spawnSync,
		log,
		kill,
		killSignal: SIGTERM,
		timeoutSignal: SIGTERM
	});
	var storage = new import_node_async_hooks.AsyncLocalStorage();
	var getStore = () => storage.getStore() || defaults;
	var getSnapshot = (opts, from, pieces, args) => __spreadProps(__spreadValues({}, opts), {
		ac: opts.ac || new AbortController(),
		ee: new import_node_events$1.EventEmitter(),
		from,
		pieces,
		args,
		cmd: ""
	});
	function within(callback) {
		return storage.run(__spreadValues({}, getStore()), callback);
	}
	var $ = new Proxy(function(pieces, ...args) {
		const opts = getStore();
		if (!Array.isArray(pieces)) return function(...args2) {
			return within(() => Object.assign($, opts, pieces).apply(this, args2));
		};
		const from = Fail.getCallerLocation();
		const cb = () => cb[SHOT] = getSnapshot(opts, from, pieces, args);
		const pp = new ProcessPromise(cb);
		if (!pp.isHalted()) pp.run();
		return pp.sync ? pp.output : pp;
	}, {
		set(t, key, value) {
			return Reflect.set(key in Function.prototype ? t : getStore(), key === "sync" ? SYNC : key, value);
		},
		get(t, key) {
			return key === "sync" ? $({ sync: true }) : Reflect.get(key in Function.prototype ? t : getStore(), key);
		}
	});
	var _ProcessPromise = class _ProcessPromise extends Promise {
		constructor(executor) {
			let resolve;
			let reject;
			super((...args) => {
				[resolve = import_util.noop, reject = import_util.noop] = args;
				executor(...args);
			});
			this._stage = "initial";
			this._id = (0, import_util.randomId)();
			this._piped = false;
			this._stdin = new import_vendor_core2.VoidStream();
			this._zurk = null;
			this._output = null;
			this.writable = true;
			const snapshot = executor[SHOT];
			if (snapshot) {
				this._snapshot = snapshot;
				this._resolve = resolve;
				this._reject = reject;
				if (snapshot.halt) this._stage = "halted";
				try {
					this.build();
				} catch (err) {
					this.finalize(ProcessOutput.fromError(err), true);
				}
			} else _ProcessPromise.disarm(this);
		}
		build() {
			const $2 = this._snapshot;
			if (!$2.shell) throw new Fail(`No shell is available: ${Fail.DOCS_URL}/shell`);
			if (!$2.quote) throw new Fail(`No quote function is defined: ${Fail.DOCS_URL}/quotes`);
			if ($2.pieces.some((p) => p == null)) throw new Fail(`Malformed command at ${$2.from}`);
			$2.cmd = (0, import_vendor_core2.buildCmd)($2.quote, $2.pieces, $2.args);
		}
		run() {
			var _a, _b;
			_ProcessPromise.bus.runBack(this);
			if (this.isRunning() || this.isSettled()) return this;
			this._stage = "running";
			const self = this;
			const $2 = self._snapshot;
			const id = self.id;
			const cwd = $2.cwd || $2[CWD];
			if ($2.preferLocal) {
				const dirs = $2.preferLocal === true ? [$2.cwd, $2[CWD]] : [$2.preferLocal].flat();
				$2.env = (0, import_util.preferLocalBin)($2.env, ...dirs);
			}
			this._zurk = (0, import_vendor_core2.exec)({
				cmd: self.fullCmd,
				cwd,
				input: (_b = (_a = $2.input) == null ? void 0 : _a.stdout) != null ? _b : $2.input,
				stdin: self._stdin,
				sync: self.sync,
				signal: self.signal,
				shell: (0, import_util.isString)($2.shell) ? $2.shell : true,
				id,
				env: $2.env,
				spawn: $2.spawn,
				spawnSync: $2.spawnSync,
				store: $2.store,
				stdio: $2.stdio,
				detached: $2.detached,
				ee: $2.ee,
				run(cb, ctx) {
					var _a2, _b2;
					(_b2 = (_a2 = self.cmd).then) != null && _b2.call(_a2, (cmd) => {
						$2.cmd = cmd;
						ctx.cmd = self.fullCmd;
						cb();
					}, (error) => self.finalize(ProcessOutput.fromError(error))) || cb();
				},
				on: {
					start: () => {
						$2.log({
							kind: "cmd",
							cmd: $2.cmd,
							cwd,
							verbose: self.isVerbose(),
							id
						});
						self.timeout($2.timeout, $2.timeoutSignal);
					},
					stdout: (data) => {
						$2.log({
							kind: "stdout",
							data,
							verbose: !self._piped && self.isVerbose(),
							id
						});
					},
					stderr: (data) => {
						$2.log({
							kind: "stderr",
							data,
							verbose: !self.isQuiet(),
							id
						});
					},
					end: (data, c) => {
						const { error: _error, status, signal: __signal, duration, ctx: { store } } = data;
						const { stdout, stderr } = store;
						const { cause, exitCode, signal: _signal } = self._breakerData || {};
						const signal = _signal != null ? _signal : __signal;
						const code = exitCode != null ? exitCode : status;
						const error = cause != null ? cause : _error;
						const output = new ProcessOutput({
							code,
							signal,
							error,
							duration,
							store,
							from: $2.from
						});
						$2.log({
							kind: "end",
							signal,
							exitCode: code,
							duration,
							error,
							verbose: self.isVerbose(),
							id
						});
						if (stdout.length && (0, import_util.getLast)((0, import_util.getLast)(stdout)) !== BR_CC) c.on.stdout(EOL, c);
						if (stderr.length && (0, import_util.getLast)((0, import_util.getLast)(stderr)) !== BR_CC) c.on.stderr(EOL, c);
						self.finalize(output);
					}
				}
			});
			return this;
		}
		break(exitCode, signal, cause) {
			if (!this.isRunning()) return;
			this._breakerData = {
				exitCode,
				signal,
				cause
			};
			this.kill(signal);
		}
		finalize(output, legacy = false) {
			if (this.isSettled()) return;
			this._output = output;
			_ProcessPromise.bus.unpipeBack(this);
			if (output.ok || this.isNothrow()) {
				this._stage = "fulfilled";
				this._resolve(output);
			} else {
				this._stage = "rejected";
				if (legacy) {
					this._resolve(output);
					throw output.cause || output;
				}
				this._reject(output);
				if (this.sync) throw output;
			}
		}
		abort(reason) {
			if (this.isSettled()) throw new Fail("Too late to abort the process.");
			if (this.signal !== this.ac.signal) throw new Fail("The signal is controlled by another process.");
			if (!this.child) throw new Fail("Trying to abort a process without creating one.");
			this.ac.abort(reason);
		}
		kill(signal) {
			if (this.isSettled()) throw new Fail("Too late to kill the process.");
			if (!this.child) throw new Fail("Trying to kill a process without creating one.");
			if (!this.pid) throw new Fail("The process pid is undefined.");
			return $.kill(this.pid, signal || this._snapshot.killSignal || $.killSignal);
		}
		stdio(stdin, stdout = "pipe", stderr = "pipe") {
			this._snapshot.stdio = Array.isArray(stdin) ? stdin : [
				stdin,
				stdout,
				stderr
			];
			return this;
		}
		nothrow(v = true) {
			this._snapshot.nothrow = v;
			return this;
		}
		quiet(v = true) {
			this._snapshot.quiet = v;
			return this;
		}
		verbose(v = true) {
			this._snapshot.verbose = v;
			return this;
		}
		timeout(d = 0, signal = $.timeoutSignal) {
			if (this.isSettled()) return this;
			const $2 = this._snapshot;
			$2.timeout = (0, import_util.parseDuration)(d);
			$2.timeoutSignal = signal;
			if (this._timeoutId) clearTimeout(this._timeoutId);
			if ($2.timeout && this.isRunning()) {
				this._timeoutId = setTimeout(() => this.kill($2.timeoutSignal), $2.timeout);
				this.finally(() => clearTimeout(this._timeoutId)).catch(import_util.noop);
			}
			return this;
		}
		/**
		*  @deprecated Use $({halt: true})`cmd` instead.
		*/
		halt() {
			return this;
		}
		get id() {
			return this._id;
		}
		get pid() {
			var _a;
			return (_a = this.child) == null ? void 0 : _a.pid;
		}
		get cmd() {
			return this._snapshot.cmd;
		}
		get fullCmd() {
			const { prefix = "", postfix = "", cmd } = this._snapshot;
			return prefix + cmd + postfix;
		}
		get child() {
			var _a;
			return (_a = this._zurk) == null ? void 0 : _a.child;
		}
		get stdin() {
			var _a;
			return (_a = this.child) == null ? void 0 : _a.stdin;
		}
		get stdout() {
			var _a;
			return (_a = this.child) == null ? void 0 : _a.stdout;
		}
		get stderr() {
			var _a;
			return (_a = this.child) == null ? void 0 : _a.stderr;
		}
		get exitCode() {
			return this.then((o) => o.exitCode, (o) => o.exitCode);
		}
		get signal() {
			return this._snapshot.signal || this.ac.signal;
		}
		get ac() {
			return this._snapshot.ac;
		}
		get output() {
			return this._output;
		}
		get stage() {
			return this._stage;
		}
		get sync() {
			return this._snapshot[SYNC];
		}
		get [Symbol.toStringTag]() {
			return "ProcessPromise";
		}
		[Symbol.toPrimitive]() {
			return this.toString();
		}
		json() {
			return this.then((o) => o.json());
		}
		text(encoding) {
			return this.then((o) => o.text(encoding));
		}
		lines(delimiter) {
			return this.then((o) => o.lines(delimiter));
		}
		buffer() {
			return this.then((o) => o.buffer());
		}
		blob(type) {
			return this.then((o) => o.blob(type));
		}
		isQuiet() {
			return this._snapshot.quiet;
		}
		isVerbose() {
			return this._snapshot.verbose && !this.isQuiet();
		}
		isNothrow() {
			return this._snapshot.nothrow;
		}
		isHalted() {
			return this.stage === "halted" && !this.sync;
		}
		isSettled() {
			return !!this.output;
		}
		isRunning() {
			return this.stage === "running";
		}
		get pipe() {
			const getPipeMethod = (kind) => this._pipe.bind(this, kind);
			const stdout = getPipeMethod("stdout");
			const stderr = getPipeMethod("stderr");
			const stdall = getPipeMethod("stdall");
			return Object.assign(stdout, {
				stdout,
				stderr,
				stdall
			});
		}
		unpipe(to) {
			_ProcessPromise.bus.unpipe(this, to);
			return this;
		}
		_pipe(source, dest, ...args) {
			if ((0, import_util.isString)(dest)) return this._pipe(source, import_node_fs$1.default.createWriteStream(dest));
			if ((0, import_util.isStringLiteral)(dest, ...args)) return this._pipe(source, $({
				halt: true,
				signal: this.signal
			})(dest, ...args));
			const isP = dest instanceof _ProcessPromise;
			if (isP && dest.isSettled()) throw new Fail("Cannot pipe to a settled process.");
			if (!isP && dest.writableEnded) throw new Fail("Cannot pipe to a closed stream.");
			this._piped = true;
			_ProcessPromise.bus.pipe(this, dest);
			const { ee } = this._snapshot;
			const output = this.output;
			const from = new import_vendor_core2.VoidStream();
			const check = () => {
				var _a;
				return !!((_a = _ProcessPromise.bus.refs.get(this)) == null ? void 0 : _a.has(dest));
			};
			const end = () => {
				if (!check()) return;
				setImmediate(() => {
					_ProcessPromise.bus.unpipe(this, dest);
					_ProcessPromise.bus.sources(dest).length === 0 && from.end();
				});
			};
			const fill = () => {
				for (const chunk of this._zurk.store[source]) from.write(chunk);
			};
			const fillSettled = () => {
				if (!output) return;
				if (isP && !output.ok) dest.break(output.exitCode, output.signal, output.cause);
				fill();
				end();
			};
			if (!output) {
				const onData = (chunk) => check() && from.write(chunk);
				ee.once(source, () => {
					fill();
					ee.on(source, onData);
				}).once("end", () => {
					ee.removeListener(source, onData);
					end();
				});
			}
			if (isP) {
				from.pipe(dest._stdin);
				if (this.isHalted()) ee.once("start", () => dest.run());
				else {
					dest.run();
					this.catch((e) => dest.break(e.exitCode, e.signal, e.cause));
				}
				fillSettled();
				return dest;
			}
			from.once("end", () => dest.emit(EPF)).pipe(dest);
			fillSettled();
			return _ProcessPromise.promisifyStream(dest, this);
		}
		then(onfulfilled, onrejected) {
			return super.then(onfulfilled, onrejected);
		}
		catch(onrejected) {
			return super.catch(onrejected);
		}
		[Symbol.asyncIterator]() {
			return __asyncGenerator(this, null, function* () {
				const memo = [];
				const dlmtr = this._snapshot.delimiter || $.delimiter || DLMTR;
				for (const chunk of this._zurk.store.stdout) yield* __yieldStar((0, import_util.getLines)(chunk, memo, dlmtr));
				try {
					for (var iter = __forAwait(this.stdout || []), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
						const chunk = temp.value;
						yield* __yieldStar((0, import_util.getLines)(chunk, memo, dlmtr));
					}
				} catch (temp) {
					error = [temp];
				} finally {
					try {
						more && (temp = iter.return) && (yield new __await(temp.call(iter)));
					} finally {
						if (error) throw error[0];
					}
				}
				if (memo[0]) yield memo[0];
				yield new __await(this);
			});
		}
		emit(event, ...args) {
			return this;
		}
		on(event, cb) {
			this._stdin.on(event, cb);
			return this;
		}
		once(event, cb) {
			this._stdin.once(event, cb);
			return this;
		}
		write(data, encoding, cb) {
			this._stdin.write(data, encoding, cb);
			return this;
		}
		end(chunk, cb) {
			this._stdin.end(chunk, cb);
			return this;
		}
		removeListener(event, cb) {
			this._stdin.removeListener(event, cb);
			return this;
		}
		static disarm(p, toggle = true) {
			Object.getOwnPropertyNames(_ProcessPromise.prototype).forEach((k) => {
				if (k in Promise.prototype) return;
				if (!toggle) {
					Reflect.deleteProperty(p, k);
					return;
				}
				Object.defineProperty(p, k, {
					configurable: true,
					get() {
						throw new Fail("Inappropriate usage. Apply $ instead of direct instantiation.");
					}
				});
			});
		}
	};
	_ProcessPromise.bus = {
		refs: /* @__PURE__ */ new Map(),
		streams: /* @__PURE__ */ new WeakMap(),
		pipe(from, to) {
			(this.refs.get(from) || this.refs.set(from, /* @__PURE__ */ new Set()).get(from)).add(to);
		},
		unpipe(from, to) {
			const set = this.refs.get(from);
			if (!set) return;
			if (to) set.delete(to);
			if (set.size) return;
			this.refs.delete(from);
			from._piped = false;
		},
		unpipeBack(to, from) {
			if (from) return this.unpipe(from, to);
			for (const _from of this.refs.keys()) this.unpipe(_from, to);
		},
		runBack(p) {
			var _a;
			for (const from of this.sources(p)) if (from instanceof _ProcessPromise) from.run();
			else (_a = this.streams.get(from)) == null || _a.run();
		},
		sources(p) {
			const refs = [];
			for (const [from, set] of this.refs.entries()) set.has(p) && refs.push(from);
			return refs;
		}
	};
	_ProcessPromise.promisifyStream = (stream, from) => {
		const proxy = _ProcessPromise.bus.streams.get(stream) || (0, import_util.proxyOverride)(stream, {
			then(res = import_util.noop, rej = import_util.noop) {
				return new Promise((_res, _rej) => {
					const end = () => _res(res((0, import_util.proxyOverride)(stream, from.output)));
					stream.once("error", (e) => _rej(rej(e))).once("finish", end).once(EPF, end);
				});
			},
			run() {
				from.run();
			},
			pipe(...args) {
				const dest = stream.pipe.apply(stream, args);
				return dest instanceof _ProcessPromise ? dest : _ProcessPromise.promisifyStream(dest, from);
			}
		});
		_ProcessPromise.bus.streams.set(stream, proxy);
		return proxy;
	};
	var ProcessPromise = _ProcessPromise;
	var _ProcessOutput = class _ProcessOutput extends Error {
		constructor(code = null, signal = null, stdout = "", stderr = "", stdall = "", message = "", duration = 0, error = null, from = "", store = {
			stdout: [stdout],
			stderr: [stderr],
			stdall: [stdall]
		}) {
			super(message);
			const dto = code !== null && typeof code === "object" ? code : {
				code,
				signal,
				duration,
				error,
				from,
				store
			};
			Object.defineProperties(this, {
				_dto: {
					value: dto,
					enumerable: false
				},
				cause: {
					get() {
						return dto.error;
					},
					enumerable: false
				},
				stdout: { get: (0, import_util.once)(() => (0, import_util.bufArrJoin)(dto.store.stdout)) },
				stderr: { get: (0, import_util.once)(() => (0, import_util.bufArrJoin)(dto.store.stderr)) },
				stdall: { get: (0, import_util.once)(() => (0, import_util.bufArrJoin)(dto.store.stdall)) },
				message: { get: (0, import_util.once)(() => dto.error || message ? _ProcessOutput.getErrorMessage(dto.error || new Error(message), dto.from) : _ProcessOutput.getExitMessage(dto.code, dto.signal, this.stderr, dto.from, this.stderr.trim() ? "" : _ProcessOutput.getErrorDetails(this.lines()))) }
			});
		}
		get exitCode() {
			return this._dto.code;
		}
		get signal() {
			return this._dto.signal;
		}
		get duration() {
			return this._dto.duration;
		}
		get [Symbol.toStringTag]() {
			return "ProcessOutput";
		}
		get ok() {
			return !this._dto.error && this.exitCode === 0;
		}
		json() {
			return JSON.parse(this.stdall);
		}
		buffer() {
			return import_node_buffer$1.Buffer.from(this.stdall);
		}
		blob(type = "text/plain") {
			if (!globalThis.Blob) throw new Fail("Blob is not supported in this environment. Provide a polyfill");
			return new Blob([this.buffer()], { type });
		}
		text(encoding = "utf8") {
			return encoding === "utf8" ? this.toString() : this.buffer().toString(encoding);
		}
		lines(delimiter) {
			return (0, import_util.iteratorToArray)(this[Symbol.iterator](delimiter));
		}
		toString() {
			return this.stdall;
		}
		valueOf() {
			return this.stdall.trim();
		}
		[Symbol.toPrimitive]() {
			return this.valueOf();
		}
		*[Symbol.iterator](dlmtr = this._dto.delimiter || $.delimiter || DLMTR) {
			const memo = [];
			for (const chunk of this._dto.store.stdall) yield* __yieldStar((0, import_util.getLines)(chunk, memo, dlmtr));
			if (memo[0]) yield memo[0];
		}
		[import_node_util2.inspect.custom]() {
			const codeInfo = _ProcessOutput.getExitCodeInfo(this.exitCode);
			return `ProcessOutput {
  stdout: ${import_vendor_core2.chalk.green((0, import_node_util2.inspect)(this.stdout))},
  stderr: ${import_vendor_core2.chalk.red((0, import_node_util2.inspect)(this.stderr))},
  signal: ${(0, import_node_util2.inspect)(this.signal)},
  exitCode: ${(this.ok ? import_vendor_core2.chalk.green : import_vendor_core2.chalk.red)(this.exitCode)}${codeInfo ? import_vendor_core2.chalk.grey(" (" + codeInfo + ")") : ""},
  duration: ${this.duration}
}`;
		}
		static fromError(error) {
			const output = new _ProcessOutput();
			output._dto.error = error;
			return output;
		}
	};
	_ProcessOutput.getExitMessage = Fail.formatExitMessage;
	_ProcessOutput.getErrorMessage = Fail.formatErrorMessage;
	_ProcessOutput.getErrorDetails = Fail.formatErrorDetails;
	_ProcessOutput.getExitCodeInfo = Fail.getExitCodeInfo;
	var ProcessOutput = _ProcessOutput;
	var useBash = () => setShell("bash", false);
	var usePwsh = () => setShell("pwsh");
	var usePowerShell = () => setShell("powershell.exe");
	function setShell(n, ps3 = true) {
		$.shell = import_vendor_core2.which.sync(n);
		$.prefix = ps3 ? "" : "set -euo pipefail;";
		$.postfix = ps3 ? "; exit $LastExitCode" : "";
		$.quote = ps3 ? import_util.quotePowerShell : import_util.quote;
	}
	try {
		const { shell, prefix, postfix } = $;
		useBash();
		if ((0, import_util.isString)(shell)) $.shell = shell;
		if ((0, import_util.isString)(prefix)) $.prefix = prefix;
		if ((0, import_util.isString)(postfix)) $.postfix = postfix;
	} catch (err) {}
	var cwdSyncHook;
	function syncProcessCwd(flag = true) {
		cwdSyncHook = cwdSyncHook || (0, import_node_async_hooks.createHook)({
			init: syncCwd,
			before: syncCwd,
			promiseResolve: syncCwd,
			after: syncCwd,
			destroy: syncCwd
		});
		if (flag) cwdSyncHook.enable();
		else cwdSyncHook.disable();
	}
	function syncCwd() {
		if ($[CWD] != import_node_process2$1.default.cwd()) import_node_process2$1.default.chdir($[CWD]);
	}
	function cd(dir) {
		if (dir instanceof ProcessOutput) dir = dir.toString().trim();
		$.log({
			kind: "cd",
			dir,
			verbose: !$.quiet && $.verbose
		});
		import_node_process2$1.default.chdir(dir);
		$[CWD] = import_node_process2$1.default.cwd();
	}
	function kill(_0) {
		return __async(this, arguments, function* (pid, signal = $.killSignal || SIGTERM) {
			if (typeof pid !== "number" && typeof pid !== "string" || !/^\d+$/.test(pid)) throw new Fail(`Invalid pid: ${pid}`);
			$.log({
				kind: "kill",
				pid,
				signal,
				verbose: !$.quiet && $.verbose
			});
			if (import_node_process2$1.default.platform === "win32" && (yield new Promise((resolve) => {
				import_node_child_process$1.default.exec(`taskkill /pid ${pid} /t /f`, (err) => resolve(!err));
			}))) return;
			for (const p of yield import_vendor_core2.ps.tree({
				pid,
				recursive: true
			})) try {
				import_node_process2$1.default.kill(+p.pid, signal);
			} catch (e) {}
			try {
				import_node_process2$1.default.kill(-pid, signal);
			} catch (e) {
				try {
					import_node_process2$1.default.kill(+pid, signal);
				} catch (e2) {}
			}
		});
	}
	function resolveDefaults(defs = defaults, prefix = ENV_PREFIX, env = import_node_process2$1.default.env, allowed = ENV_OPTS) {
		return Object.entries(env).reduce((m, [k, v]) => {
			if (v && k.startsWith(prefix)) {
				const _k = (0, import_util.toCamelCase)(k.slice(prefix.length));
				const _v = (0, import_util.parseBool)(v);
				if (allowed.has(_k)) m[_k] = _v;
			}
			return m;
		}, defs);
	}
}));
//#endregion
//#region node_modules/zx/build/vendor-extra.cjs
var require_vendor_extra = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { __spreadValues, __spreadProps, __esm, __commonJS, __export, __toESM, __toCommonJS, __privateGet, __privateAdd, __privateSet, __async, __await, __asyncGenerator, __yieldStar, __forAwait } = require_esblib();
	var require_array = __commonJS({ "node_modules/fast-glob/out/utils/array.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.splitWhen = exports2.flatten = void 0;
		function flatten(items) {
			return items.reduce((collection, item) => [].concat(collection, item), []);
		}
		exports2.flatten = flatten;
		function splitWhen(items, predicate) {
			const result = [[]];
			let groupIndex = 0;
			for (const item of items) if (predicate(item)) {
				groupIndex++;
				result[groupIndex] = [];
			} else result[groupIndex].push(item);
			return result;
		}
		exports2.splitWhen = splitWhen;
	} });
	var require_errno = __commonJS({ "node_modules/fast-glob/out/utils/errno.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.isEnoentCodeError = void 0;
		function isEnoentCodeError(error) {
			return error.code === "ENOENT";
		}
		exports2.isEnoentCodeError = isEnoentCodeError;
	} });
	var require_fs = __commonJS({ "node_modules/fast-glob/out/utils/fs.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.createDirentFromStats = void 0;
		var DirentFromStats = class {
			constructor(name, stats) {
				this.name = name;
				this.isBlockDevice = stats.isBlockDevice.bind(stats);
				this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
				this.isDirectory = stats.isDirectory.bind(stats);
				this.isFIFO = stats.isFIFO.bind(stats);
				this.isFile = stats.isFile.bind(stats);
				this.isSocket = stats.isSocket.bind(stats);
				this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
			}
		};
		function createDirentFromStats(name, stats) {
			return new DirentFromStats(name, stats);
		}
		exports2.createDirentFromStats = createDirentFromStats;
	} });
	var require_path = __commonJS({ "node_modules/fast-glob/out/utils/path.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.convertPosixPathToPattern = exports2.convertWindowsPathToPattern = exports2.convertPathToPattern = exports2.escapePosixPath = exports2.escapeWindowsPath = exports2.escape = exports2.removeLeadingDotSegment = exports2.makeAbsolute = exports2.unixify = void 0;
		var os = __require("os");
		var path3 = __require("path");
		var IS_WINDOWS_PLATFORM = os.platform() === "win32";
		var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
		var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
		var WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
		var DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
		var WINDOWS_BACKSLASHES_RE = /\\(?![!()+@[\]{}])/g;
		function unixify(filepath) {
			return filepath.replace(/\\/g, "/");
		}
		exports2.unixify = unixify;
		function makeAbsolute(cwd, filepath) {
			return path3.resolve(cwd, filepath);
		}
		exports2.makeAbsolute = makeAbsolute;
		function removeLeadingDotSegment(entry) {
			if (entry.charAt(0) === ".") {
				const secondCharactery = entry.charAt(1);
				if (secondCharactery === "/" || secondCharactery === "\\") return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
			}
			return entry;
		}
		exports2.removeLeadingDotSegment = removeLeadingDotSegment;
		exports2.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
		function escapeWindowsPath(pattern) {
			return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
		}
		exports2.escapeWindowsPath = escapeWindowsPath;
		function escapePosixPath(pattern) {
			return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
		}
		exports2.escapePosixPath = escapePosixPath;
		exports2.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
		function convertWindowsPathToPattern(filepath) {
			return escapeWindowsPath(filepath).replace(DOS_DEVICE_PATH_RE, "//$1").replace(WINDOWS_BACKSLASHES_RE, "/");
		}
		exports2.convertWindowsPathToPattern = convertWindowsPathToPattern;
		function convertPosixPathToPattern(filepath) {
			return escapePosixPath(filepath);
		}
		exports2.convertPosixPathToPattern = convertPosixPathToPattern;
	} });
	var require_is_extglob = __commonJS({ "node_modules/is-extglob/index.js"(exports2, module2) {
		"use strict";
		module2.exports = function isExtglob(str) {
			if (typeof str !== "string" || str === "") return false;
			var match;
			while (match = /(\\).|([@?!+*]\(.*\))/g.exec(str)) {
				if (match[2]) return true;
				str = str.slice(match.index + match[0].length);
			}
			return false;
		};
	} });
	var require_is_glob = __commonJS({ "node_modules/is-glob/index.js"(exports2, module2) {
		"use strict";
		var isExtglob = require_is_extglob();
		var chars = {
			"{": "}",
			"(": ")",
			"[": "]"
		};
		var strictCheck = function(str) {
			if (str[0] === "!") return true;
			var index = 0;
			var pipeIndex = -2;
			var closeSquareIndex = -2;
			var closeCurlyIndex = -2;
			var closeParenIndex = -2;
			var backSlashIndex = -2;
			while (index < str.length) {
				if (str[index] === "*") return true;
				if (str[index + 1] === "?" && /[\].+)]/.test(str[index])) return true;
				if (closeSquareIndex !== -1 && str[index] === "[" && str[index + 1] !== "]") {
					if (closeSquareIndex < index) closeSquareIndex = str.indexOf("]", index);
					if (closeSquareIndex > index) {
						if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) return true;
						backSlashIndex = str.indexOf("\\", index);
						if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) return true;
					}
				}
				if (closeCurlyIndex !== -1 && str[index] === "{" && str[index + 1] !== "}") {
					closeCurlyIndex = str.indexOf("}", index);
					if (closeCurlyIndex > index) {
						backSlashIndex = str.indexOf("\\", index);
						if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) return true;
					}
				}
				if (closeParenIndex !== -1 && str[index] === "(" && str[index + 1] === "?" && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ")") {
					closeParenIndex = str.indexOf(")", index);
					if (closeParenIndex > index) {
						backSlashIndex = str.indexOf("\\", index);
						if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) return true;
					}
				}
				if (pipeIndex !== -1 && str[index] === "(" && str[index + 1] !== "|") {
					if (pipeIndex < index) pipeIndex = str.indexOf("|", index);
					if (pipeIndex !== -1 && str[pipeIndex + 1] !== ")") {
						closeParenIndex = str.indexOf(")", pipeIndex);
						if (closeParenIndex > pipeIndex) {
							backSlashIndex = str.indexOf("\\", pipeIndex);
							if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) return true;
						}
					}
				}
				if (str[index] === "\\") {
					var open = str[index + 1];
					index += 2;
					var close = chars[open];
					if (close) {
						var n4 = str.indexOf(close, index);
						if (n4 !== -1) index = n4 + 1;
					}
					if (str[index] === "!") return true;
				} else index++;
			}
			return false;
		};
		var relaxedCheck = function(str) {
			if (str[0] === "!") return true;
			var index = 0;
			while (index < str.length) {
				if (/[*?{}()[\]]/.test(str[index])) return true;
				if (str[index] === "\\") {
					var open = str[index + 1];
					index += 2;
					var close = chars[open];
					if (close) {
						var n4 = str.indexOf(close, index);
						if (n4 !== -1) index = n4 + 1;
					}
					if (str[index] === "!") return true;
				} else index++;
			}
			return false;
		};
		module2.exports = function isGlob(str, options) {
			if (typeof str !== "string" || str === "") return false;
			if (isExtglob(str)) return true;
			var check = strictCheck;
			if (options && options.strict === false) check = relaxedCheck;
			return check(str);
		};
	} });
	var require_glob_parent = __commonJS({ "node_modules/glob-parent/index.js"(exports2, module2) {
		"use strict";
		var isGlob = require_is_glob();
		var pathPosixDirname = __require("path").posix.dirname;
		var isWin32 = __require("os").platform() === "win32";
		var slash2 = "/";
		var backslash = /\\/g;
		var enclosure = /[\{\[].*[\}\]]$/;
		var globby3 = /(^|[^\\])([\{\[]|\([^\)]+$)/;
		var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
		module2.exports = function globParent(str, opts) {
			if (Object.assign({ flipBackslashes: true }, opts).flipBackslashes && isWin32 && str.indexOf(slash2) < 0) str = str.replace(backslash, slash2);
			if (enclosure.test(str)) str += slash2;
			str += "a";
			do
				str = pathPosixDirname(str);
			while (isGlob(str) || globby3.test(str));
			return str.replace(escaped, "$1");
		};
	} });
	var require_utils = __commonJS({ "node_modules/braces/lib/utils.js"(exports2) {
		"use strict";
		exports2.isInteger = (num) => {
			if (typeof num === "number") return Number.isInteger(num);
			if (typeof num === "string" && num.trim() !== "") return Number.isInteger(Number(num));
			return false;
		};
		exports2.find = (node, type) => node.nodes.find((node2) => node2.type === type);
		exports2.exceedsLimit = (min, max, step = 1, limit) => {
			if (limit === false) return false;
			if (!exports2.isInteger(min) || !exports2.isInteger(max)) return false;
			return (Number(max) - Number(min)) / Number(step) >= limit;
		};
		exports2.escapeNode = (block, n4 = 0, type) => {
			const node = block.nodes[n4];
			if (!node) return;
			if (type && node.type === type || node.type === "open" || node.type === "close") {
				if (node.escaped !== true) {
					node.value = "\\" + node.value;
					node.escaped = true;
				}
			}
		};
		exports2.encloseBrace = (node) => {
			if (node.type !== "brace") return false;
			if (node.commas >> 0 + node.ranges >> 0 === 0) {
				node.invalid = true;
				return true;
			}
			return false;
		};
		exports2.isInvalidBrace = (block) => {
			if (block.type !== "brace") return false;
			if (block.invalid === true || block.dollar) return true;
			if (block.commas >> 0 + block.ranges >> 0 === 0) {
				block.invalid = true;
				return true;
			}
			if (block.open !== true || block.close !== true) {
				block.invalid = true;
				return true;
			}
			return false;
		};
		exports2.isOpenOrClose = (node) => {
			if (node.type === "open" || node.type === "close") return true;
			return node.open === true || node.close === true;
		};
		exports2.reduce = (nodes) => nodes.reduce((acc, node) => {
			if (node.type === "text") acc.push(node.value);
			if (node.type === "range") node.type = "text";
			return acc;
		}, []);
		exports2.flatten = (...args) => {
			const result = [];
			const flat = (arr) => {
				for (let i = 0; i < arr.length; i++) {
					const ele = arr[i];
					if (Array.isArray(ele)) {
						flat(ele);
						continue;
					}
					if (ele !== void 0) result.push(ele);
				}
				return result;
			};
			flat(args);
			return result;
		};
	} });
	var require_stringify = __commonJS({ "node_modules/braces/lib/stringify.js"(exports2, module2) {
		"use strict";
		var utils = require_utils();
		module2.exports = (ast, options = {}) => {
			const stringify5 = (node, parent = {}) => {
				const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
				const invalidNode = node.invalid === true && options.escapeInvalid === true;
				let output = "";
				if (node.value) {
					if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) return "\\" + node.value;
					return node.value;
				}
				if (node.value) return node.value;
				if (node.nodes) for (const child of node.nodes) output += stringify5(child);
				return output;
			};
			return stringify5(ast);
		};
	} });
	var require_is_number = __commonJS({ "node_modules/is-number/index.js"(exports2, module2) {
		"use strict";
		module2.exports = function(num) {
			if (typeof num === "number") return num - num === 0;
			if (typeof num === "string" && num.trim() !== "") return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
			return false;
		};
	} });
	var require_to_regex_range = __commonJS({ "node_modules/to-regex-range/index.js"(exports2, module2) {
		"use strict";
		var isNumber = require_is_number();
		var toRegexRange = (min, max, options) => {
			if (isNumber(min) === false) throw new TypeError("toRegexRange: expected the first argument to be a number");
			if (max === void 0 || min === max) return String(min);
			if (isNumber(max) === false) throw new TypeError("toRegexRange: expected the second argument to be a number.");
			let opts = __spreadValues({ relaxZeros: true }, options);
			if (typeof opts.strictZeros === "boolean") opts.relaxZeros = opts.strictZeros === false;
			let relax = String(opts.relaxZeros);
			let shorthand = String(opts.shorthand);
			let capture = String(opts.capture);
			let wrap2 = String(opts.wrap);
			let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap2;
			if (toRegexRange.cache.hasOwnProperty(cacheKey)) return toRegexRange.cache[cacheKey].result;
			let a = Math.min(min, max);
			let b = Math.max(min, max);
			if (Math.abs(a - b) === 1) {
				let result = min + "|" + max;
				if (opts.capture) return `(${result})`;
				if (opts.wrap === false) return result;
				return `(?:${result})`;
			}
			let isPadded = hasPadding(min) || hasPadding(max);
			let state = {
				min,
				max,
				a,
				b
			};
			let positives = [];
			let negatives = [];
			if (isPadded) {
				state.isPadded = isPadded;
				state.maxLen = String(state.max).length;
			}
			if (a < 0) {
				negatives = splitToPatterns(b < 0 ? Math.abs(b) : 1, Math.abs(a), state, opts);
				a = state.a = 0;
			}
			if (b >= 0) positives = splitToPatterns(a, b, state, opts);
			state.negatives = negatives;
			state.positives = positives;
			state.result = collatePatterns(negatives, positives, opts);
			if (opts.capture === true) state.result = `(${state.result})`;
			else if (opts.wrap !== false && positives.length + negatives.length > 1) state.result = `(?:${state.result})`;
			toRegexRange.cache[cacheKey] = state;
			return state.result;
		};
		function collatePatterns(neg, pos, options) {
			let onlyNegative = filterPatterns(neg, pos, "-", false, options) || [];
			let onlyPositive = filterPatterns(pos, neg, "", false, options) || [];
			let intersected = filterPatterns(neg, pos, "-?", true, options) || [];
			return onlyNegative.concat(intersected).concat(onlyPositive).join("|");
		}
		function splitToRanges(min, max) {
			let nines = 1;
			let zeros = 1;
			let stop = countNines(min, nines);
			let stops = /* @__PURE__ */ new Set([max]);
			while (min <= stop && stop <= max) {
				stops.add(stop);
				nines += 1;
				stop = countNines(min, nines);
			}
			stop = countZeros(max + 1, zeros) - 1;
			while (min < stop && stop <= max) {
				stops.add(stop);
				zeros += 1;
				stop = countZeros(max + 1, zeros) - 1;
			}
			stops = [...stops];
			stops.sort(compare);
			return stops;
		}
		function rangeToPattern(start, stop, options) {
			if (start === stop) return {
				pattern: start,
				count: [],
				digits: 0
			};
			let zipped = zip(start, stop);
			let digits = zipped.length;
			let pattern = "";
			let count = 0;
			for (let i = 0; i < digits; i++) {
				let [startDigit, stopDigit] = zipped[i];
				if (startDigit === stopDigit) pattern += startDigit;
				else if (startDigit !== "0" || stopDigit !== "9") pattern += toCharacterClass(startDigit, stopDigit, options);
				else count++;
			}
			if (count) pattern += options.shorthand === true ? "\\d" : "[0-9]";
			return {
				pattern,
				count: [count],
				digits
			};
		}
		function splitToPatterns(min, max, tok, options) {
			let ranges = splitToRanges(min, max);
			let tokens = [];
			let start = min;
			let prev;
			for (let i = 0; i < ranges.length; i++) {
				let max2 = ranges[i];
				let obj = rangeToPattern(String(start), String(max2), options);
				let zeros = "";
				if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
					if (prev.count.length > 1) prev.count.pop();
					prev.count.push(obj.count[0]);
					prev.string = prev.pattern + toQuantifier(prev.count);
					start = max2 + 1;
					continue;
				}
				if (tok.isPadded) zeros = padZeros(max2, tok, options);
				obj.string = zeros + obj.pattern + toQuantifier(obj.count);
				tokens.push(obj);
				start = max2 + 1;
				prev = obj;
			}
			return tokens;
		}
		function filterPatterns(arr, comparison, prefix, intersection, options) {
			let result = [];
			for (let ele of arr) {
				let { string: string2 } = ele;
				if (!intersection && !contains(comparison, "string", string2)) result.push(prefix + string2);
				if (intersection && contains(comparison, "string", string2)) result.push(prefix + string2);
			}
			return result;
		}
		function zip(a, b) {
			let arr = [];
			for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
			return arr;
		}
		function compare(a, b) {
			return a > b ? 1 : b > a ? -1 : 0;
		}
		function contains(arr, key, val) {
			return arr.some((ele) => ele[key] === val);
		}
		function countNines(min, len) {
			return Number(String(min).slice(0, -len) + "9".repeat(len));
		}
		function countZeros(integer, zeros) {
			return integer - integer % Math.pow(10, zeros);
		}
		function toQuantifier(digits) {
			let [start = 0, stop = ""] = digits;
			if (stop || start > 1) return `{${start + (stop ? "," + stop : "")}}`;
			return "";
		}
		function toCharacterClass(a, b, options) {
			return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
		}
		function hasPadding(str) {
			return /^-?(0+)\d/.test(str);
		}
		function padZeros(value, tok, options) {
			if (!tok.isPadded) return value;
			let diff = Math.abs(tok.maxLen - String(value).length);
			let relax = options.relaxZeros !== false;
			switch (diff) {
				case 0: return "";
				case 1: return relax ? "0?" : "0";
				case 2: return relax ? "0{0,2}" : "00";
				default: return relax ? `0{0,${diff}}` : `0{${diff}}`;
			}
		}
		toRegexRange.cache = {};
		toRegexRange.clearCache = () => toRegexRange.cache = {};
		module2.exports = toRegexRange;
	} });
	var require_fill_range = __commonJS({ "node_modules/fill-range/index.js"(exports2, module2) {
		"use strict";
		var util = __require("util");
		var toRegexRange = require_to_regex_range();
		var isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
		var transform = (toNumber) => {
			return (value) => toNumber === true ? Number(value) : String(value);
		};
		var isValidValue = (value) => {
			return typeof value === "number" || typeof value === "string" && value !== "";
		};
		var isNumber = (num) => Number.isInteger(+num);
		var zeros = (input) => {
			let value = `${input}`;
			let index = -1;
			if (value[0] === "-") value = value.slice(1);
			if (value === "0") return false;
			while (value[++index] === "0");
			return index > 0;
		};
		var stringify5 = (start, end, options) => {
			if (typeof start === "string" || typeof end === "string") return true;
			return options.stringify === true;
		};
		var pad = (input, maxLength, toNumber) => {
			if (maxLength > 0) {
				let dash = input[0] === "-" ? "-" : "";
				if (dash) input = input.slice(1);
				input = dash + input.padStart(dash ? maxLength - 1 : maxLength, "0");
			}
			if (toNumber === false) return String(input);
			return input;
		};
		var toMaxLen = (input, maxLength) => {
			let negative = input[0] === "-" ? "-" : "";
			if (negative) {
				input = input.slice(1);
				maxLength--;
			}
			while (input.length < maxLength) input = "0" + input;
			return negative ? "-" + input : input;
		};
		var toSequence = (parts, options, maxLen) => {
			parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
			parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
			let prefix = options.capture ? "" : "?:";
			let positives = "";
			let negatives = "";
			let result;
			if (parts.positives.length) positives = parts.positives.map((v2) => toMaxLen(String(v2), maxLen)).join("|");
			if (parts.negatives.length) negatives = `-(${prefix}${parts.negatives.map((v2) => toMaxLen(String(v2), maxLen)).join("|")})`;
			if (positives && negatives) result = `${positives}|${negatives}`;
			else result = positives || negatives;
			if (options.wrap) return `(${prefix}${result})`;
			return result;
		};
		var toRange = (a, b, isNumbers, options) => {
			if (isNumbers) return toRegexRange(a, b, __spreadValues({ wrap: false }, options));
			let start = String.fromCharCode(a);
			if (a === b) return start;
			return `[${start}-${String.fromCharCode(b)}]`;
		};
		var toRegex = (start, end, options) => {
			if (Array.isArray(start)) {
				let wrap2 = options.wrap === true;
				let prefix = options.capture ? "" : "?:";
				return wrap2 ? `(${prefix}${start.join("|")})` : start.join("|");
			}
			return toRegexRange(start, end, options);
		};
		var rangeError = (...args) => {
			return /* @__PURE__ */ new RangeError("Invalid range arguments: " + util.inspect(...args));
		};
		var invalidRange = (start, end, options) => {
			if (options.strictRanges === true) throw rangeError([start, end]);
			return [];
		};
		var invalidStep = (step, options) => {
			if (options.strictRanges === true) throw new TypeError(`Expected step "${step}" to be a number`);
			return [];
		};
		var fillNumbers = (start, end, step = 1, options = {}) => {
			let a = Number(start);
			let b = Number(end);
			if (!Number.isInteger(a) || !Number.isInteger(b)) {
				if (options.strictRanges === true) throw rangeError([start, end]);
				return [];
			}
			if (a === 0) a = 0;
			if (b === 0) b = 0;
			let descending = a > b;
			let startString = String(start);
			let endString = String(end);
			let stepString = String(step);
			step = Math.max(Math.abs(step), 1);
			let padded = zeros(startString) || zeros(endString) || zeros(stepString);
			let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
			let toNumber = padded === false && stringify5(start, end, options) === false;
			let format = options.transform || transform(toNumber);
			if (options.toRegex && step === 1) return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
			let parts = {
				negatives: [],
				positives: []
			};
			let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
			let range = [];
			let index = 0;
			while (descending ? a >= b : a <= b) {
				if (options.toRegex === true && step > 1) push(a);
				else range.push(pad(format(a, index), maxLen, toNumber));
				a = descending ? a - step : a + step;
				index++;
			}
			if (options.toRegex === true) return step > 1 ? toSequence(parts, options, maxLen) : toRegex(range, null, __spreadValues({ wrap: false }, options));
			return range;
		};
		var fillLetters = (start, end, step = 1, options = {}) => {
			if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) return invalidRange(start, end, options);
			let format = options.transform || ((val) => String.fromCharCode(val));
			let a = `${start}`.charCodeAt(0);
			let b = `${end}`.charCodeAt(0);
			let descending = a > b;
			let min = Math.min(a, b);
			let max = Math.max(a, b);
			if (options.toRegex && step === 1) return toRange(min, max, false, options);
			let range = [];
			let index = 0;
			while (descending ? a >= b : a <= b) {
				range.push(format(a, index));
				a = descending ? a - step : a + step;
				index++;
			}
			if (options.toRegex === true) return toRegex(range, null, {
				wrap: false,
				options
			});
			return range;
		};
		var fill = (start, end, step, options = {}) => {
			if (end == null && isValidValue(start)) return [start];
			if (!isValidValue(start) || !isValidValue(end)) return invalidRange(start, end, options);
			if (typeof step === "function") return fill(start, end, 1, { transform: step });
			if (isObject(step)) return fill(start, end, 0, step);
			let opts = __spreadValues({}, options);
			if (opts.capture === true) opts.wrap = true;
			step = step || opts.step || 1;
			if (!isNumber(step)) {
				if (step != null && !isObject(step)) return invalidStep(step, opts);
				return fill(start, end, 1, step);
			}
			if (isNumber(start) && isNumber(end)) return fillNumbers(start, end, step, opts);
			return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
		};
		module2.exports = fill;
	} });
	var require_compile = __commonJS({ "node_modules/braces/lib/compile.js"(exports2, module2) {
		"use strict";
		var fill = require_fill_range();
		var utils = require_utils();
		var compile = (ast, options = {}) => {
			const walk = (node, parent = {}) => {
				const invalidBlock = utils.isInvalidBrace(parent);
				const invalidNode = node.invalid === true && options.escapeInvalid === true;
				const invalid = invalidBlock === true || invalidNode === true;
				const prefix = options.escapeInvalid === true ? "\\" : "";
				let output = "";
				if (node.isOpen === true) return prefix + node.value;
				if (node.isClose === true) {
					console.log("node.isClose", prefix, node.value);
					return prefix + node.value;
				}
				if (node.type === "open") return invalid ? prefix + node.value : "(";
				if (node.type === "close") return invalid ? prefix + node.value : ")";
				if (node.type === "comma") return node.prev.type === "comma" ? "" : invalid ? node.value : "|";
				if (node.value) return node.value;
				if (node.nodes && node.ranges > 0) {
					const args = utils.reduce(node.nodes);
					const range = fill(...args, __spreadProps(__spreadValues({}, options), {
						wrap: false,
						toRegex: true,
						strictZeros: true
					}));
					if (range.length !== 0) return args.length > 1 && range.length > 1 ? `(${range})` : range;
				}
				if (node.nodes) for (const child of node.nodes) output += walk(child, node);
				return output;
			};
			return walk(ast);
		};
		module2.exports = compile;
	} });
	var require_expand = __commonJS({ "node_modules/braces/lib/expand.js"(exports2, module2) {
		"use strict";
		var fill = require_fill_range();
		var stringify5 = require_stringify();
		var utils = require_utils();
		var append = (queue = "", stash = "", enclose = false) => {
			const result = [];
			queue = [].concat(queue);
			stash = [].concat(stash);
			if (!stash.length) return queue;
			if (!queue.length) return enclose ? utils.flatten(stash).map((ele) => `{${ele}}`) : stash;
			for (const item of queue) if (Array.isArray(item)) for (const value of item) result.push(append(value, stash, enclose));
			else for (let ele of stash) {
				if (enclose === true && typeof ele === "string") ele = `{${ele}}`;
				result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
			}
			return utils.flatten(result);
		};
		var expand = (ast, options = {}) => {
			const rangeLimit = options.rangeLimit === void 0 ? 1e3 : options.rangeLimit;
			const walk = (node, parent = {}) => {
				node.queue = [];
				let p2 = parent;
				let q = parent.queue;
				while (p2.type !== "brace" && p2.type !== "root" && p2.parent) {
					p2 = p2.parent;
					q = p2.queue;
				}
				if (node.invalid || node.dollar) {
					q.push(append(q.pop(), stringify5(node, options)));
					return;
				}
				if (node.type === "brace" && node.invalid !== true && node.nodes.length === 2) {
					q.push(append(q.pop(), ["{}"]));
					return;
				}
				if (node.nodes && node.ranges > 0) {
					const args = utils.reduce(node.nodes);
					if (utils.exceedsLimit(...args, options.step, rangeLimit)) throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
					let range = fill(...args, options);
					if (range.length === 0) range = stringify5(node, options);
					q.push(append(q.pop(), range));
					node.nodes = [];
					return;
				}
				const enclose = utils.encloseBrace(node);
				let queue = node.queue;
				let block = node;
				while (block.type !== "brace" && block.type !== "root" && block.parent) {
					block = block.parent;
					queue = block.queue;
				}
				for (let i = 0; i < node.nodes.length; i++) {
					const child = node.nodes[i];
					if (child.type === "comma" && node.type === "brace") {
						if (i === 1) queue.push("");
						queue.push("");
						continue;
					}
					if (child.type === "close") {
						q.push(append(q.pop(), queue, enclose));
						continue;
					}
					if (child.value && child.type !== "open") {
						queue.push(append(queue.pop(), child.value));
						continue;
					}
					if (child.nodes) walk(child, node);
				}
				return queue;
			};
			return utils.flatten(walk(ast));
		};
		module2.exports = expand;
	} });
	var require_constants = __commonJS({ "node_modules/braces/lib/constants.js"(exports2, module2) {
		"use strict";
		module2.exports = {
			MAX_LENGTH: 1e4,
			CHAR_0: "0",
			CHAR_9: "9",
			CHAR_UPPERCASE_A: "A",
			CHAR_LOWERCASE_A: "a",
			CHAR_UPPERCASE_Z: "Z",
			CHAR_LOWERCASE_Z: "z",
			CHAR_LEFT_PARENTHESES: "(",
			CHAR_RIGHT_PARENTHESES: ")",
			CHAR_ASTERISK: "*",
			CHAR_AMPERSAND: "&",
			CHAR_AT: "@",
			CHAR_BACKSLASH: "\\",
			CHAR_BACKTICK: "`",
			CHAR_CARRIAGE_RETURN: "\r",
			CHAR_CIRCUMFLEX_ACCENT: "^",
			CHAR_COLON: ":",
			CHAR_COMMA: ",",
			CHAR_DOLLAR: "$",
			CHAR_DOT: ".",
			CHAR_DOUBLE_QUOTE: "\"",
			CHAR_EQUAL: "=",
			CHAR_EXCLAMATION_MARK: "!",
			CHAR_FORM_FEED: "\f",
			CHAR_FORWARD_SLASH: "/",
			CHAR_HASH: "#",
			CHAR_HYPHEN_MINUS: "-",
			CHAR_LEFT_ANGLE_BRACKET: "<",
			CHAR_LEFT_CURLY_BRACE: "{",
			CHAR_LEFT_SQUARE_BRACKET: "[",
			CHAR_LINE_FEED: "\n",
			CHAR_NO_BREAK_SPACE: "\xA0",
			CHAR_PERCENT: "%",
			CHAR_PLUS: "+",
			CHAR_QUESTION_MARK: "?",
			CHAR_RIGHT_ANGLE_BRACKET: ">",
			CHAR_RIGHT_CURLY_BRACE: "}",
			CHAR_RIGHT_SQUARE_BRACKET: "]",
			CHAR_SEMICOLON: ";",
			CHAR_SINGLE_QUOTE: "'",
			CHAR_SPACE: " ",
			CHAR_TAB: "	",
			CHAR_UNDERSCORE: "_",
			CHAR_VERTICAL_LINE: "|",
			CHAR_ZERO_WIDTH_NOBREAK_SPACE: ""
		};
	} });
	var require_parse = __commonJS({ "node_modules/braces/lib/parse.js"(exports2, module2) {
		"use strict";
		var stringify5 = require_stringify();
		var { MAX_LENGTH, CHAR_BACKSLASH, CHAR_BACKTICK, CHAR_COMMA, CHAR_DOT, CHAR_LEFT_PARENTHESES, CHAR_RIGHT_PARENTHESES, CHAR_LEFT_CURLY_BRACE, CHAR_RIGHT_CURLY_BRACE, CHAR_LEFT_SQUARE_BRACKET, CHAR_RIGHT_SQUARE_BRACKET, CHAR_DOUBLE_QUOTE, CHAR_SINGLE_QUOTE, CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = require_constants();
		var parse3 = (input, options = {}) => {
			if (typeof input !== "string") throw new TypeError("Expected a string");
			const opts = options || {};
			const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
			if (input.length > max) throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
			const ast = {
				type: "root",
				input,
				nodes: []
			};
			const stack = [ast];
			let block = ast;
			let prev = ast;
			let brackets = 0;
			const length = input.length;
			let index = 0;
			let depth = 0;
			let value;
			const advance = () => input[index++];
			const push = (node) => {
				if (node.type === "text" && prev.type === "dot") prev.type = "text";
				if (prev && prev.type === "text" && node.type === "text") {
					prev.value += node.value;
					return;
				}
				block.nodes.push(node);
				node.parent = block;
				node.prev = prev;
				prev = node;
				return node;
			};
			push({ type: "bos" });
			while (index < length) {
				block = stack[stack.length - 1];
				value = advance();
				if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) continue;
				if (value === CHAR_BACKSLASH) {
					push({
						type: "text",
						value: (options.keepEscaping ? value : "") + advance()
					});
					continue;
				}
				if (value === CHAR_RIGHT_SQUARE_BRACKET) {
					push({
						type: "text",
						value: "\\" + value
					});
					continue;
				}
				if (value === CHAR_LEFT_SQUARE_BRACKET) {
					brackets++;
					let next;
					while (index < length && (next = advance())) {
						value += next;
						if (next === CHAR_LEFT_SQUARE_BRACKET) {
							brackets++;
							continue;
						}
						if (next === CHAR_BACKSLASH) {
							value += advance();
							continue;
						}
						if (next === CHAR_RIGHT_SQUARE_BRACKET) {
							brackets--;
							if (brackets === 0) break;
						}
					}
					push({
						type: "text",
						value
					});
					continue;
				}
				if (value === CHAR_LEFT_PARENTHESES) {
					block = push({
						type: "paren",
						nodes: []
					});
					stack.push(block);
					push({
						type: "text",
						value
					});
					continue;
				}
				if (value === CHAR_RIGHT_PARENTHESES) {
					if (block.type !== "paren") {
						push({
							type: "text",
							value
						});
						continue;
					}
					block = stack.pop();
					push({
						type: "text",
						value
					});
					block = stack[stack.length - 1];
					continue;
				}
				if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
					const open = value;
					let next;
					if (options.keepQuotes !== true) value = "";
					while (index < length && (next = advance())) {
						if (next === CHAR_BACKSLASH) {
							value += next + advance();
							continue;
						}
						if (next === open) {
							if (options.keepQuotes === true) value += next;
							break;
						}
						value += next;
					}
					push({
						type: "text",
						value
					});
					continue;
				}
				if (value === CHAR_LEFT_CURLY_BRACE) {
					depth++;
					block = push({
						type: "brace",
						open: true,
						close: false,
						dollar: prev.value && prev.value.slice(-1) === "$" || block.dollar === true,
						depth,
						commas: 0,
						ranges: 0,
						nodes: []
					});
					stack.push(block);
					push({
						type: "open",
						value
					});
					continue;
				}
				if (value === CHAR_RIGHT_CURLY_BRACE) {
					if (block.type !== "brace") {
						push({
							type: "text",
							value
						});
						continue;
					}
					const type = "close";
					block = stack.pop();
					block.close = true;
					push({
						type,
						value
					});
					depth--;
					block = stack[stack.length - 1];
					continue;
				}
				if (value === CHAR_COMMA && depth > 0) {
					if (block.ranges > 0) {
						block.ranges = 0;
						const open = block.nodes.shift();
						block.nodes = [open, {
							type: "text",
							value: stringify5(block)
						}];
					}
					push({
						type: "comma",
						value
					});
					block.commas++;
					continue;
				}
				if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
					const siblings = block.nodes;
					if (depth === 0 || siblings.length === 0) {
						push({
							type: "text",
							value
						});
						continue;
					}
					if (prev.type === "dot") {
						block.range = [];
						prev.value += value;
						prev.type = "range";
						if (block.nodes.length !== 3 && block.nodes.length !== 5) {
							block.invalid = true;
							block.ranges = 0;
							prev.type = "text";
							continue;
						}
						block.ranges++;
						block.args = [];
						continue;
					}
					if (prev.type === "range") {
						siblings.pop();
						const before = siblings[siblings.length - 1];
						before.value += prev.value + value;
						prev = before;
						block.ranges--;
						continue;
					}
					push({
						type: "dot",
						value
					});
					continue;
				}
				push({
					type: "text",
					value
				});
			}
			do {
				block = stack.pop();
				if (block.type !== "root") {
					block.nodes.forEach((node) => {
						if (!node.nodes) {
							if (node.type === "open") node.isOpen = true;
							if (node.type === "close") node.isClose = true;
							if (!node.nodes) node.type = "text";
							node.invalid = true;
						}
					});
					const parent = stack[stack.length - 1];
					const index2 = parent.nodes.indexOf(block);
					parent.nodes.splice(index2, 1, ...block.nodes);
				}
			} while (stack.length > 0);
			push({ type: "eos" });
			return ast;
		};
		module2.exports = parse3;
	} });
	var require_braces = __commonJS({ "node_modules/braces/index.js"(exports2, module2) {
		"use strict";
		var stringify5 = require_stringify();
		var compile = require_compile();
		var expand = require_expand();
		var parse3 = require_parse();
		var braces = (input, options = {}) => {
			let output = [];
			if (Array.isArray(input)) for (const pattern of input) {
				const result = braces.create(pattern, options);
				if (Array.isArray(result)) output.push(...result);
				else output.push(result);
			}
			else output = [].concat(braces.create(input, options));
			if (options && options.expand === true && options.nodupes === true) output = [...new Set(output)];
			return output;
		};
		braces.parse = (input, options = {}) => parse3(input, options);
		braces.stringify = (input, options = {}) => {
			if (typeof input === "string") return stringify5(braces.parse(input, options), options);
			return stringify5(input, options);
		};
		braces.compile = (input, options = {}) => {
			if (typeof input === "string") input = braces.parse(input, options);
			return compile(input, options);
		};
		braces.expand = (input, options = {}) => {
			if (typeof input === "string") input = braces.parse(input, options);
			let result = expand(input, options);
			if (options.noempty === true) result = result.filter(Boolean);
			if (options.nodupes === true) result = [...new Set(result)];
			return result;
		};
		braces.create = (input, options = {}) => {
			if (input === "" || input.length < 3) return [input];
			return options.expand !== true ? braces.compile(input, options) : braces.expand(input, options);
		};
		module2.exports = braces;
	} });
	var require_constants2 = __commonJS({ "node_modules/picomatch/lib/constants.js"(exports2, module2) {
		"use strict";
		var path3 = __require("path");
		var WIN_SLASH = "\\\\/";
		var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
		var DOT_LITERAL = "\\.";
		var PLUS_LITERAL = "\\+";
		var QMARK_LITERAL = "\\?";
		var SLASH_LITERAL = "\\/";
		var ONE_CHAR = "(?=.)";
		var QMARK = "[^/]";
		var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
		var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
		var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
		var POSIX_CHARS = {
			DOT_LITERAL,
			PLUS_LITERAL,
			QMARK_LITERAL,
			SLASH_LITERAL,
			ONE_CHAR,
			QMARK,
			END_ANCHOR,
			DOTS_SLASH,
			NO_DOT: `(?!${DOT_LITERAL})`,
			NO_DOTS: `(?!${START_ANCHOR}${DOTS_SLASH})`,
			NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`,
			NO_DOTS_SLASH: `(?!${DOTS_SLASH})`,
			QMARK_NO_DOT: `[^.${SLASH_LITERAL}]`,
			STAR: `${QMARK}*?`,
			START_ANCHOR
		};
		var WINDOWS_CHARS = __spreadProps(__spreadValues({}, POSIX_CHARS), {
			SLASH_LITERAL: `[${WIN_SLASH}]`,
			QMARK: WIN_NO_SLASH,
			STAR: `${WIN_NO_SLASH}*?`,
			DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
			NO_DOT: `(?!${DOT_LITERAL})`,
			NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
			NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
			NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
			QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
			START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
			END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
		});
		module2.exports = {
			MAX_LENGTH: 1024 * 64,
			POSIX_REGEX_SOURCE: {
				alnum: "a-zA-Z0-9",
				alpha: "a-zA-Z",
				ascii: "\\x00-\\x7F",
				blank: " \\t",
				cntrl: "\\x00-\\x1F\\x7F",
				digit: "0-9",
				graph: "\\x21-\\x7E",
				lower: "a-z",
				print: "\\x20-\\x7E ",
				punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
				space: " \\t\\r\\n\\v\\f",
				upper: "A-Z",
				word: "A-Za-z0-9_",
				xdigit: "A-Fa-f0-9"
			},
			REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
			REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
			REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
			REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
			REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
			REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
			REPLACEMENTS: {
				"***": "*",
				"**/**": "**",
				"**/**/**": "**"
			},
			CHAR_0: 48,
			CHAR_9: 57,
			CHAR_UPPERCASE_A: 65,
			CHAR_LOWERCASE_A: 97,
			CHAR_UPPERCASE_Z: 90,
			CHAR_LOWERCASE_Z: 122,
			CHAR_LEFT_PARENTHESES: 40,
			CHAR_RIGHT_PARENTHESES: 41,
			CHAR_ASTERISK: 42,
			CHAR_AMPERSAND: 38,
			CHAR_AT: 64,
			CHAR_BACKWARD_SLASH: 92,
			CHAR_CARRIAGE_RETURN: 13,
			CHAR_CIRCUMFLEX_ACCENT: 94,
			CHAR_COLON: 58,
			CHAR_COMMA: 44,
			CHAR_DOT: 46,
			CHAR_DOUBLE_QUOTE: 34,
			CHAR_EQUAL: 61,
			CHAR_EXCLAMATION_MARK: 33,
			CHAR_FORM_FEED: 12,
			CHAR_FORWARD_SLASH: 47,
			CHAR_GRAVE_ACCENT: 96,
			CHAR_HASH: 35,
			CHAR_HYPHEN_MINUS: 45,
			CHAR_LEFT_ANGLE_BRACKET: 60,
			CHAR_LEFT_CURLY_BRACE: 123,
			CHAR_LEFT_SQUARE_BRACKET: 91,
			CHAR_LINE_FEED: 10,
			CHAR_NO_BREAK_SPACE: 160,
			CHAR_PERCENT: 37,
			CHAR_PLUS: 43,
			CHAR_QUESTION_MARK: 63,
			CHAR_RIGHT_ANGLE_BRACKET: 62,
			CHAR_RIGHT_CURLY_BRACE: 125,
			CHAR_RIGHT_SQUARE_BRACKET: 93,
			CHAR_SEMICOLON: 59,
			CHAR_SINGLE_QUOTE: 39,
			CHAR_SPACE: 32,
			CHAR_TAB: 9,
			CHAR_UNDERSCORE: 95,
			CHAR_VERTICAL_LINE: 124,
			CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
			SEP: path3.sep,
			extglobChars(chars) {
				return {
					"!": {
						type: "negate",
						open: "(?:(?!(?:",
						close: `))${chars.STAR})`
					},
					"?": {
						type: "qmark",
						open: "(?:",
						close: ")?"
					},
					"+": {
						type: "plus",
						open: "(?:",
						close: ")+"
					},
					"*": {
						type: "star",
						open: "(?:",
						close: ")*"
					},
					"@": {
						type: "at",
						open: "(?:",
						close: ")"
					}
				};
			},
			globChars(win32) {
				return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
			}
		};
	} });
	var require_utils2 = __commonJS({ "node_modules/picomatch/lib/utils.js"(exports2) {
		"use strict";
		var path3 = __require("path");
		var win32 = process.platform === "win32";
		var { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants2();
		exports2.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
		exports2.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
		exports2.isRegexChar = (str) => str.length === 1 && exports2.hasRegexChars(str);
		exports2.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
		exports2.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
		exports2.removeBackslashes = (str) => {
			return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
				return match === "\\" ? "" : match;
			});
		};
		exports2.supportsLookbehinds = () => {
			const segs = process.version.slice(1).split(".").map(Number);
			if (segs.length === 3 && segs[0] >= 9 || segs[0] === 8 && segs[1] >= 10) return true;
			return false;
		};
		exports2.isWindows = (options) => {
			if (options && typeof options.windows === "boolean") return options.windows;
			return win32 === true || path3.sep === "\\";
		};
		exports2.escapeLast = (input, char, lastIdx) => {
			const idx = input.lastIndexOf(char, lastIdx);
			if (idx === -1) return input;
			if (input[idx - 1] === "\\") return exports2.escapeLast(input, char, idx - 1);
			return `${input.slice(0, idx)}\\${input.slice(idx)}`;
		};
		exports2.removePrefix = (input, state = {}) => {
			let output = input;
			if (output.startsWith("./")) {
				output = output.slice(2);
				state.prefix = "./";
			}
			return output;
		};
		exports2.wrapOutput = (input, state = {}, options = {}) => {
			let output = `${options.contains ? "" : "^"}(?:${input})${options.contains ? "" : "$"}`;
			if (state.negated === true) output = `(?:^(?!${output}).*$)`;
			return output;
		};
	} });
	var require_scan = __commonJS({ "node_modules/picomatch/lib/scan.js"(exports2, module2) {
		"use strict";
		var utils = require_utils2();
		var { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants2();
		var isPathSeparator = (code) => {
			return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
		};
		var depth = (token) => {
			if (token.isPrefix !== true) token.depth = token.isGlobstar ? Infinity : 1;
		};
		var scan = (input, options) => {
			const opts = options || {};
			const length = input.length - 1;
			const scanToEnd = opts.parts === true || opts.scanToEnd === true;
			const slashes = [];
			const tokens = [];
			const parts = [];
			let str = input;
			let index = -1;
			let start = 0;
			let lastIndex = 0;
			let isBrace = false;
			let isBracket = false;
			let isGlob = false;
			let isExtglob = false;
			let isGlobstar = false;
			let braceEscaped = false;
			let backslashes = false;
			let negated = false;
			let negatedExtglob = false;
			let finished2 = false;
			let braces = 0;
			let prev;
			let code;
			let token = {
				value: "",
				depth: 0,
				isGlob: false
			};
			const eos = () => index >= length;
			const peek = () => str.charCodeAt(index + 1);
			const advance = () => {
				prev = code;
				return str.charCodeAt(++index);
			};
			while (index < length) {
				code = advance();
				let next;
				if (code === CHAR_BACKWARD_SLASH) {
					backslashes = token.backslashes = true;
					code = advance();
					if (code === CHAR_LEFT_CURLY_BRACE) braceEscaped = true;
					continue;
				}
				if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
					braces++;
					while (eos() !== true && (code = advance())) {
						if (code === CHAR_BACKWARD_SLASH) {
							backslashes = token.backslashes = true;
							advance();
							continue;
						}
						if (code === CHAR_LEFT_CURLY_BRACE) {
							braces++;
							continue;
						}
						if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
							isBrace = token.isBrace = true;
							isGlob = token.isGlob = true;
							finished2 = true;
							if (scanToEnd === true) continue;
							break;
						}
						if (braceEscaped !== true && code === CHAR_COMMA) {
							isBrace = token.isBrace = true;
							isGlob = token.isGlob = true;
							finished2 = true;
							if (scanToEnd === true) continue;
							break;
						}
						if (code === CHAR_RIGHT_CURLY_BRACE) {
							braces--;
							if (braces === 0) {
								braceEscaped = false;
								isBrace = token.isBrace = true;
								finished2 = true;
								break;
							}
						}
					}
					if (scanToEnd === true) continue;
					break;
				}
				if (code === CHAR_FORWARD_SLASH) {
					slashes.push(index);
					tokens.push(token);
					token = {
						value: "",
						depth: 0,
						isGlob: false
					};
					if (finished2 === true) continue;
					if (prev === CHAR_DOT && index === start + 1) {
						start += 2;
						continue;
					}
					lastIndex = index + 1;
					continue;
				}
				if (opts.noext !== true) {
					if ((code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK) === true && peek() === CHAR_LEFT_PARENTHESES) {
						isGlob = token.isGlob = true;
						isExtglob = token.isExtglob = true;
						finished2 = true;
						if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
						if (scanToEnd === true) {
							while (eos() !== true && (code = advance())) {
								if (code === CHAR_BACKWARD_SLASH) {
									backslashes = token.backslashes = true;
									code = advance();
									continue;
								}
								if (code === CHAR_RIGHT_PARENTHESES) {
									isGlob = token.isGlob = true;
									finished2 = true;
									break;
								}
							}
							continue;
						}
						break;
					}
				}
				if (code === CHAR_ASTERISK) {
					if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
					isGlob = token.isGlob = true;
					finished2 = true;
					if (scanToEnd === true) continue;
					break;
				}
				if (code === CHAR_QUESTION_MARK) {
					isGlob = token.isGlob = true;
					finished2 = true;
					if (scanToEnd === true) continue;
					break;
				}
				if (code === CHAR_LEFT_SQUARE_BRACKET) {
					while (eos() !== true && (next = advance())) {
						if (next === CHAR_BACKWARD_SLASH) {
							backslashes = token.backslashes = true;
							advance();
							continue;
						}
						if (next === CHAR_RIGHT_SQUARE_BRACKET) {
							isBracket = token.isBracket = true;
							isGlob = token.isGlob = true;
							finished2 = true;
							break;
						}
					}
					if (scanToEnd === true) continue;
					break;
				}
				if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
					negated = token.negated = true;
					start++;
					continue;
				}
				if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
					isGlob = token.isGlob = true;
					if (scanToEnd === true) {
						while (eos() !== true && (code = advance())) {
							if (code === CHAR_LEFT_PARENTHESES) {
								backslashes = token.backslashes = true;
								code = advance();
								continue;
							}
							if (code === CHAR_RIGHT_PARENTHESES) {
								finished2 = true;
								break;
							}
						}
						continue;
					}
					break;
				}
				if (isGlob === true) {
					finished2 = true;
					if (scanToEnd === true) continue;
					break;
				}
			}
			if (opts.noext === true) {
				isExtglob = false;
				isGlob = false;
			}
			let base = str;
			let prefix = "";
			let glob2 = "";
			if (start > 0) {
				prefix = str.slice(0, start);
				str = str.slice(start);
				lastIndex -= start;
			}
			if (base && isGlob === true && lastIndex > 0) {
				base = str.slice(0, lastIndex);
				glob2 = str.slice(lastIndex);
			} else if (isGlob === true) {
				base = "";
				glob2 = str;
			} else base = str;
			if (base && base !== "" && base !== "/" && base !== str) {
				if (isPathSeparator(base.charCodeAt(base.length - 1))) base = base.slice(0, -1);
			}
			if (opts.unescape === true) {
				if (glob2) glob2 = utils.removeBackslashes(glob2);
				if (base && backslashes === true) base = utils.removeBackslashes(base);
			}
			const state = {
				prefix,
				input,
				start,
				base,
				glob: glob2,
				isBrace,
				isBracket,
				isGlob,
				isExtglob,
				isGlobstar,
				negated,
				negatedExtglob
			};
			if (opts.tokens === true) {
				state.maxDepth = 0;
				if (!isPathSeparator(code)) tokens.push(token);
				state.tokens = tokens;
			}
			if (opts.parts === true || opts.tokens === true) {
				let prevIndex;
				for (let idx = 0; idx < slashes.length; idx++) {
					const n4 = prevIndex ? prevIndex + 1 : start;
					const i = slashes[idx];
					const value = input.slice(n4, i);
					if (opts.tokens) {
						if (idx === 0 && start !== 0) {
							tokens[idx].isPrefix = true;
							tokens[idx].value = prefix;
						} else tokens[idx].value = value;
						depth(tokens[idx]);
						state.maxDepth += tokens[idx].depth;
					}
					if (idx !== 0 || value !== "") parts.push(value);
					prevIndex = i;
				}
				if (prevIndex && prevIndex + 1 < input.length) {
					const value = input.slice(prevIndex + 1);
					parts.push(value);
					if (opts.tokens) {
						tokens[tokens.length - 1].value = value;
						depth(tokens[tokens.length - 1]);
						state.maxDepth += tokens[tokens.length - 1].depth;
					}
				}
				state.slashes = slashes;
				state.parts = parts;
			}
			return state;
		};
		module2.exports = scan;
	} });
	var require_parse2 = __commonJS({ "node_modules/picomatch/lib/parse.js"(exports2, module2) {
		"use strict";
		var constants = require_constants2();
		var utils = require_utils2();
		var { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
		var expandRange = (args, options) => {
			if (typeof options.expandRange === "function") return options.expandRange(...args, options);
			args.sort();
			const value = `[${args.join("-")}]`;
			try {
				new RegExp(value);
			} catch (ex) {
				return args.map((v2) => utils.escapeRegex(v2)).join("..");
			}
			return value;
		};
		var syntaxError = (type, char) => {
			return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
		};
		var parse3 = (input, options) => {
			if (typeof input !== "string") throw new TypeError("Expected a string");
			input = REPLACEMENTS[input] || input;
			const opts = __spreadValues({}, options);
			const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
			let len = input.length;
			if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
			const bos = {
				type: "bos",
				value: "",
				output: opts.prepend || ""
			};
			const tokens = [bos];
			const capture = opts.capture ? "" : "?:";
			const win32 = utils.isWindows(options);
			const PLATFORM_CHARS = constants.globChars(win32);
			const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
			const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;
			const globstar = (opts2) => {
				return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
			};
			const nodot = opts.dot ? "" : NO_DOT;
			const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
			let star = opts.bash === true ? globstar(opts) : STAR;
			if (opts.capture) star = `(${star})`;
			if (typeof opts.noext === "boolean") opts.noextglob = opts.noext;
			const state = {
				input,
				index: -1,
				start: 0,
				dot: opts.dot === true,
				consumed: "",
				output: "",
				prefix: "",
				backtrack: false,
				negated: false,
				brackets: 0,
				braces: 0,
				parens: 0,
				quotes: 0,
				globstar: false,
				tokens
			};
			input = utils.removePrefix(input, state);
			len = input.length;
			const extglobs = [];
			const braces = [];
			const stack = [];
			let prev = bos;
			let value;
			const eos = () => state.index === len - 1;
			const peek = state.peek = (n4 = 1) => input[state.index + n4];
			const advance = state.advance = () => input[++state.index] || "";
			const remaining = () => input.slice(state.index + 1);
			const consume = (value2 = "", num = 0) => {
				state.consumed += value2;
				state.index += num;
			};
			const append = (token) => {
				state.output += token.output != null ? token.output : token.value;
				consume(token.value);
			};
			const negate = () => {
				let count = 1;
				while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
					advance();
					state.start++;
					count++;
				}
				if (count % 2 === 0) return false;
				state.negated = true;
				state.start++;
				return true;
			};
			const increment = (type) => {
				state[type]++;
				stack.push(type);
			};
			const decrement = (type) => {
				state[type]--;
				stack.pop();
			};
			const push = (tok) => {
				if (prev.type === "globstar") {
					const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
					const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
					if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
						state.output = state.output.slice(0, -prev.output.length);
						prev.type = "star";
						prev.value = "*";
						prev.output = star;
						state.output += prev.output;
					}
				}
				if (extglobs.length && tok.type !== "paren") extglobs[extglobs.length - 1].inner += tok.value;
				if (tok.value || tok.output) append(tok);
				if (prev && prev.type === "text" && tok.type === "text") {
					prev.value += tok.value;
					prev.output = (prev.output || "") + tok.value;
					return;
				}
				tok.prev = prev;
				tokens.push(tok);
				prev = tok;
			};
			const extglobOpen = (type, value2) => {
				const token = __spreadProps(__spreadValues({}, EXTGLOB_CHARS[value2]), {
					conditions: 1,
					inner: ""
				});
				token.prev = prev;
				token.parens = state.parens;
				token.output = state.output;
				const output = (opts.capture ? "(" : "") + token.open;
				increment("parens");
				push({
					type,
					value: value2,
					output: state.output ? "" : ONE_CHAR
				});
				push({
					type: "paren",
					extglob: true,
					value: advance(),
					output
				});
				extglobs.push(token);
			};
			const extglobClose = (token) => {
				let output = token.close + (opts.capture ? ")" : "");
				let rest;
				if (token.type === "negate") {
					let extglobStar = star;
					if (token.inner && token.inner.length > 1 && token.inner.includes("/")) extglobStar = globstar(opts);
					if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
					if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) output = token.close = `)${parse3(rest, __spreadProps(__spreadValues({}, options), { fastpaths: false })).output})${extglobStar})`;
					if (token.prev.type === "bos") state.negatedExtglob = true;
				}
				push({
					type: "paren",
					extglob: true,
					value,
					output
				});
				decrement("parens");
			};
			if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
				let backslashes = false;
				let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m2, esc, chars, first, rest, index) => {
					if (first === "\\") {
						backslashes = true;
						return m2;
					}
					if (first === "?") {
						if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : "");
						if (index === 0) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
						return QMARK.repeat(chars.length);
					}
					if (first === ".") return DOT_LITERAL.repeat(chars.length);
					if (first === "*") {
						if (esc) return esc + first + (rest ? star : "");
						return star;
					}
					return esc ? m2 : `\\${m2}`;
				});
				if (backslashes === true) if (opts.unescape === true) output = output.replace(/\\/g, "");
				else output = output.replace(/\\+/g, (m2) => {
					return m2.length % 2 === 0 ? "\\\\" : m2 ? "\\" : "";
				});
				if (output === input && opts.contains === true) {
					state.output = input;
					return state;
				}
				state.output = utils.wrapOutput(output, state, options);
				return state;
			}
			while (!eos()) {
				value = advance();
				if (value === "\0") continue;
				if (value === "\\") {
					const next = peek();
					if (next === "/" && opts.bash !== true) continue;
					if (next === "." || next === ";") continue;
					if (!next) {
						value += "\\";
						push({
							type: "text",
							value
						});
						continue;
					}
					const match = /^\\+/.exec(remaining());
					let slashes = 0;
					if (match && match[0].length > 2) {
						slashes = match[0].length;
						state.index += slashes;
						if (slashes % 2 !== 0) value += "\\";
					}
					if (opts.unescape === true) value = advance();
					else value += advance();
					if (state.brackets === 0) {
						push({
							type: "text",
							value
						});
						continue;
					}
				}
				if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
					if (opts.posix !== false && value === ":") {
						const inner = prev.value.slice(1);
						if (inner.includes("[")) {
							prev.posix = true;
							if (inner.includes(":")) {
								const idx = prev.value.lastIndexOf("[");
								const pre = prev.value.slice(0, idx);
								const posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
								if (posix) {
									prev.value = pre + posix;
									state.backtrack = true;
									advance();
									if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR;
									continue;
								}
							}
						}
					}
					if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") value = `\\${value}`;
					if (value === "]" && (prev.value === "[" || prev.value === "[^")) value = `\\${value}`;
					if (opts.posix === true && value === "!" && prev.value === "[") value = "^";
					prev.value += value;
					append({ value });
					continue;
				}
				if (state.quotes === 1 && value !== "\"") {
					value = utils.escapeRegex(value);
					prev.value += value;
					append({ value });
					continue;
				}
				if (value === "\"") {
					state.quotes = state.quotes === 1 ? 0 : 1;
					if (opts.keepQuotes === true) push({
						type: "text",
						value
					});
					continue;
				}
				if (value === "(") {
					increment("parens");
					push({
						type: "paren",
						value
					});
					continue;
				}
				if (value === ")") {
					if (state.parens === 0 && opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "("));
					const extglob = extglobs[extglobs.length - 1];
					if (extglob && state.parens === extglob.parens + 1) {
						extglobClose(extglobs.pop());
						continue;
					}
					push({
						type: "paren",
						value,
						output: state.parens ? ")" : "\\)"
					});
					decrement("parens");
					continue;
				}
				if (value === "[") {
					if (opts.nobracket === true || !remaining().includes("]")) {
						if (opts.nobracket !== true && opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
						value = `\\${value}`;
					} else increment("brackets");
					push({
						type: "bracket",
						value
					});
					continue;
				}
				if (value === "]") {
					if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
						push({
							type: "text",
							value,
							output: `\\${value}`
						});
						continue;
					}
					if (state.brackets === 0) {
						if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "["));
						push({
							type: "text",
							value,
							output: `\\${value}`
						});
						continue;
					}
					decrement("brackets");
					const prevValue = prev.value.slice(1);
					if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value = `/${value}`;
					prev.value += value;
					append({ value });
					if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) continue;
					const escaped = utils.escapeRegex(prev.value);
					state.output = state.output.slice(0, -prev.value.length);
					if (opts.literalBrackets === true) {
						state.output += escaped;
						prev.value = escaped;
						continue;
					}
					prev.value = `(${capture}${escaped}|${prev.value})`;
					state.output += prev.value;
					continue;
				}
				if (value === "{" && opts.nobrace !== true) {
					increment("braces");
					const open = {
						type: "brace",
						value,
						output: "(",
						outputIndex: state.output.length,
						tokensIndex: state.tokens.length
					};
					braces.push(open);
					push(open);
					continue;
				}
				if (value === "}") {
					const brace = braces[braces.length - 1];
					if (opts.nobrace === true || !brace) {
						push({
							type: "text",
							value,
							output: value
						});
						continue;
					}
					let output = ")";
					if (brace.dots === true) {
						const arr = tokens.slice();
						const range = [];
						for (let i = arr.length - 1; i >= 0; i--) {
							tokens.pop();
							if (arr[i].type === "brace") break;
							if (arr[i].type !== "dots") range.unshift(arr[i].value);
						}
						output = expandRange(range, opts);
						state.backtrack = true;
					}
					if (brace.comma !== true && brace.dots !== true) {
						const out = state.output.slice(0, brace.outputIndex);
						const toks = state.tokens.slice(brace.tokensIndex);
						brace.value = brace.output = "\\{";
						value = output = "\\}";
						state.output = out;
						for (const t3 of toks) state.output += t3.output || t3.value;
					}
					push({
						type: "brace",
						value,
						output
					});
					decrement("braces");
					braces.pop();
					continue;
				}
				if (value === "|") {
					if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
					push({
						type: "text",
						value
					});
					continue;
				}
				if (value === ",") {
					let output = value;
					const brace = braces[braces.length - 1];
					if (brace && stack[stack.length - 1] === "braces") {
						brace.comma = true;
						output = "|";
					}
					push({
						type: "comma",
						value,
						output
					});
					continue;
				}
				if (value === "/") {
					if (prev.type === "dot" && state.index === state.start + 1) {
						state.start = state.index + 1;
						state.consumed = "";
						state.output = "";
						tokens.pop();
						prev = bos;
						continue;
					}
					push({
						type: "slash",
						value,
						output: SLASH_LITERAL
					});
					continue;
				}
				if (value === ".") {
					if (state.braces > 0 && prev.type === "dot") {
						if (prev.value === ".") prev.output = DOT_LITERAL;
						const brace = braces[braces.length - 1];
						prev.type = "dots";
						prev.output += value;
						prev.value += value;
						brace.dots = true;
						continue;
					}
					if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
						push({
							type: "text",
							value,
							output: DOT_LITERAL
						});
						continue;
					}
					push({
						type: "dot",
						value,
						output: DOT_LITERAL
					});
					continue;
				}
				if (value === "?") {
					if (!(prev && prev.value === "(") && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
						extglobOpen("qmark", value);
						continue;
					}
					if (prev && prev.type === "paren") {
						const next = peek();
						let output = value;
						if (next === "<" && !utils.supportsLookbehinds()) throw new Error("Node.js v10 or higher is required for regex lookbehinds");
						if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
						push({
							type: "text",
							value,
							output
						});
						continue;
					}
					if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
						push({
							type: "qmark",
							value,
							output: QMARK_NO_DOT
						});
						continue;
					}
					push({
						type: "qmark",
						value,
						output: QMARK
					});
					continue;
				}
				if (value === "!") {
					if (opts.noextglob !== true && peek() === "(") {
						if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
							extglobOpen("negate", value);
							continue;
						}
					}
					if (opts.nonegate !== true && state.index === 0) {
						negate();
						continue;
					}
				}
				if (value === "+") {
					if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
						extglobOpen("plus", value);
						continue;
					}
					if (prev && prev.value === "(" || opts.regex === false) {
						push({
							type: "plus",
							value,
							output: PLUS_LITERAL
						});
						continue;
					}
					if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
						push({
							type: "plus",
							value
						});
						continue;
					}
					push({
						type: "plus",
						value: PLUS_LITERAL
					});
					continue;
				}
				if (value === "@") {
					if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
						push({
							type: "at",
							extglob: true,
							value,
							output: ""
						});
						continue;
					}
					push({
						type: "text",
						value
					});
					continue;
				}
				if (value !== "*") {
					if (value === "$" || value === "^") value = `\\${value}`;
					const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
					if (match) {
						value += match[0];
						state.index += match[0].length;
					}
					push({
						type: "text",
						value
					});
					continue;
				}
				if (prev && (prev.type === "globstar" || prev.star === true)) {
					prev.type = "star";
					prev.star = true;
					prev.value += value;
					prev.output = star;
					state.backtrack = true;
					state.globstar = true;
					consume(value);
					continue;
				}
				let rest = remaining();
				if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
					extglobOpen("star", value);
					continue;
				}
				if (prev.type === "star") {
					if (opts.noglobstar === true) {
						consume(value);
						continue;
					}
					const prior = prev.prev;
					const before = prior.prev;
					const isStart = prior.type === "slash" || prior.type === "bos";
					const afterStar = before && (before.type === "star" || before.type === "globstar");
					if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
						push({
							type: "star",
							value,
							output: ""
						});
						continue;
					}
					const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
					const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
					if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
						push({
							type: "star",
							value,
							output: ""
						});
						continue;
					}
					while (rest.slice(0, 3) === "/**") {
						const after = input[state.index + 4];
						if (after && after !== "/") break;
						rest = rest.slice(3);
						consume("/**", 3);
					}
					if (prior.type === "bos" && eos()) {
						prev.type = "globstar";
						prev.value += value;
						prev.output = globstar(opts);
						state.output = prev.output;
						state.globstar = true;
						consume(value);
						continue;
					}
					if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
						state.output = state.output.slice(0, -(prior.output + prev.output).length);
						prior.output = `(?:${prior.output}`;
						prev.type = "globstar";
						prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
						prev.value += value;
						state.globstar = true;
						state.output += prior.output + prev.output;
						consume(value);
						continue;
					}
					if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
						const end = rest[1] !== void 0 ? "|$" : "";
						state.output = state.output.slice(0, -(prior.output + prev.output).length);
						prior.output = `(?:${prior.output}`;
						prev.type = "globstar";
						prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
						prev.value += value;
						state.output += prior.output + prev.output;
						state.globstar = true;
						consume(value + advance());
						push({
							type: "slash",
							value: "/",
							output: ""
						});
						continue;
					}
					if (prior.type === "bos" && rest[0] === "/") {
						prev.type = "globstar";
						prev.value += value;
						prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
						state.output = prev.output;
						state.globstar = true;
						consume(value + advance());
						push({
							type: "slash",
							value: "/",
							output: ""
						});
						continue;
					}
					state.output = state.output.slice(0, -prev.output.length);
					prev.type = "globstar";
					prev.output = globstar(opts);
					prev.value += value;
					state.output += prev.output;
					state.globstar = true;
					consume(value);
					continue;
				}
				const token = {
					type: "star",
					value,
					output: star
				};
				if (opts.bash === true) {
					token.output = ".*?";
					if (prev.type === "bos" || prev.type === "slash") token.output = nodot + token.output;
					push(token);
					continue;
				}
				if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
					token.output = value;
					push(token);
					continue;
				}
				if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
					if (prev.type === "dot") {
						state.output += NO_DOT_SLASH;
						prev.output += NO_DOT_SLASH;
					} else if (opts.dot === true) {
						state.output += NO_DOTS_SLASH;
						prev.output += NO_DOTS_SLASH;
					} else {
						state.output += nodot;
						prev.output += nodot;
					}
					if (peek() !== "*") {
						state.output += ONE_CHAR;
						prev.output += ONE_CHAR;
					}
				}
				push(token);
			}
			while (state.brackets > 0) {
				if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
				state.output = utils.escapeLast(state.output, "[");
				decrement("brackets");
			}
			while (state.parens > 0) {
				if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
				state.output = utils.escapeLast(state.output, "(");
				decrement("parens");
			}
			while (state.braces > 0) {
				if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
				state.output = utils.escapeLast(state.output, "{");
				decrement("braces");
			}
			if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
				type: "maybe_slash",
				value: "",
				output: `${SLASH_LITERAL}?`
			});
			if (state.backtrack === true) {
				state.output = "";
				for (const token of state.tokens) {
					state.output += token.output != null ? token.output : token.value;
					if (token.suffix) state.output += token.suffix;
				}
			}
			return state;
		};
		parse3.fastpaths = (input, options) => {
			const opts = __spreadValues({}, options);
			const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
			const len = input.length;
			if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
			input = REPLACEMENTS[input] || input;
			const win32 = utils.isWindows(options);
			const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(win32);
			const nodot = opts.dot ? NO_DOTS : NO_DOT;
			const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
			const capture = opts.capture ? "" : "?:";
			const state = {
				negated: false,
				prefix: ""
			};
			let star = opts.bash === true ? ".*?" : STAR;
			if (opts.capture) star = `(${star})`;
			const globstar = (opts2) => {
				if (opts2.noglobstar === true) return star;
				return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
			};
			const create = (str) => {
				switch (str) {
					case "*": return `${nodot}${ONE_CHAR}${star}`;
					case ".*": return `${DOT_LITERAL}${ONE_CHAR}${star}`;
					case "*.*": return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
					case "*/*": return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
					case "**": return nodot + globstar(opts);
					case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
					case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
					case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
					default: {
						const match = /^(.*?)\.(\w+)$/.exec(str);
						if (!match) return;
						const source2 = create(match[1]);
						if (!source2) return;
						return source2 + DOT_LITERAL + match[2];
					}
				}
			};
			let source = create(utils.removePrefix(input, state));
			if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL}?`;
			return source;
		};
		module2.exports = parse3;
	} });
	var require_picomatch = __commonJS({ "node_modules/picomatch/lib/picomatch.js"(exports2, module2) {
		"use strict";
		var path3 = __require("path");
		var scan = require_scan();
		var parse3 = require_parse2();
		var utils = require_utils2();
		var constants = require_constants2();
		var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
		var picomatch = (glob2, options, returnState = false) => {
			if (Array.isArray(glob2)) {
				const fns = glob2.map((input) => picomatch(input, options, returnState));
				const arrayMatcher = (str) => {
					for (const isMatch of fns) {
						const state2 = isMatch(str);
						if (state2) return state2;
					}
					return false;
				};
				return arrayMatcher;
			}
			const isState = isObject(glob2) && glob2.tokens && glob2.input;
			if (glob2 === "" || typeof glob2 !== "string" && !isState) throw new TypeError("Expected pattern to be a non-empty string");
			const opts = options || {};
			const posix = utils.isWindows(options);
			const regex = isState ? picomatch.compileRe(glob2, options) : picomatch.makeRe(glob2, options, false, true);
			const state = regex.state;
			delete regex.state;
			let isIgnored = () => false;
			if (opts.ignore) {
				const ignoreOpts = __spreadProps(__spreadValues({}, options), {
					ignore: null,
					onMatch: null,
					onResult: null
				});
				isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
			}
			const matcher = (input, returnObject = false) => {
				const { isMatch, match, output } = picomatch.test(input, regex, options, {
					glob: glob2,
					posix
				});
				const result = {
					glob: glob2,
					state,
					regex,
					posix,
					input,
					output,
					match,
					isMatch
				};
				if (typeof opts.onResult === "function") opts.onResult(result);
				if (isMatch === false) {
					result.isMatch = false;
					return returnObject ? result : false;
				}
				if (isIgnored(input)) {
					if (typeof opts.onIgnore === "function") opts.onIgnore(result);
					result.isMatch = false;
					return returnObject ? result : false;
				}
				if (typeof opts.onMatch === "function") opts.onMatch(result);
				return returnObject ? result : true;
			};
			if (returnState) matcher.state = state;
			return matcher;
		};
		picomatch.test = (input, regex, options, { glob: glob2, posix } = {}) => {
			if (typeof input !== "string") throw new TypeError("Expected input to be a string");
			if (input === "") return {
				isMatch: false,
				output: ""
			};
			const opts = options || {};
			const format = opts.format || (posix ? utils.toPosixSlashes : null);
			let match = input === glob2;
			let output = match && format ? format(input) : input;
			if (match === false) {
				output = format ? format(input) : input;
				match = output === glob2;
			}
			if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch.matchBase(input, regex, options, posix);
			else match = regex.exec(output);
			return {
				isMatch: Boolean(match),
				match,
				output
			};
		};
		picomatch.matchBase = (input, glob2, options, posix = utils.isWindows(options)) => {
			return (glob2 instanceof RegExp ? glob2 : picomatch.makeRe(glob2, options)).test(path3.basename(input));
		};
		picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
		picomatch.parse = (pattern, options) => {
			if (Array.isArray(pattern)) return pattern.map((p2) => picomatch.parse(p2, options));
			return parse3(pattern, __spreadProps(__spreadValues({}, options), { fastpaths: false }));
		};
		picomatch.scan = (input, options) => scan(input, options);
		picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
			if (returnOutput === true) return state.output;
			const opts = options || {};
			const prepend = opts.contains ? "" : "^";
			const append = opts.contains ? "" : "$";
			let source = `${prepend}(?:${state.output})${append}`;
			if (state && state.negated === true) source = `^(?!${source}).*$`;
			const regex = picomatch.toRegex(source, options);
			if (returnState === true) regex.state = state;
			return regex;
		};
		picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
			if (!input || typeof input !== "string") throw new TypeError("Expected a non-empty string");
			let parsed = {
				negated: false,
				fastpaths: true
			};
			if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) parsed.output = parse3.fastpaths(input, options);
			if (!parsed.output) parsed = parse3(input, options);
			return picomatch.compileRe(parsed, options, returnOutput, returnState);
		};
		picomatch.toRegex = (source, options) => {
			try {
				const opts = options || {};
				return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
			} catch (err) {
				if (options && options.debug === true) throw err;
				return /$^/;
			}
		};
		picomatch.constants = constants;
		module2.exports = picomatch;
	} });
	var require_picomatch2 = __commonJS({ "node_modules/picomatch/index.js"(exports2, module2) {
		"use strict";
		module2.exports = require_picomatch();
	} });
	var require_micromatch = __commonJS({ "node_modules/micromatch/index.js"(exports2, module2) {
		"use strict";
		var util = __require("util");
		var braces = require_braces();
		var picomatch = require_picomatch2();
		var utils = require_utils2();
		var isEmptyString = (v2) => v2 === "" || v2 === "./";
		var hasBraces = (v2) => {
			const index = v2.indexOf("{");
			return index > -1 && v2.indexOf("}", index) > -1;
		};
		var micromatch = (list, patterns, options) => {
			patterns = [].concat(patterns);
			list = [].concat(list);
			let omit = /* @__PURE__ */ new Set();
			let keep = /* @__PURE__ */ new Set();
			let items = /* @__PURE__ */ new Set();
			let negatives = 0;
			let onResult = (state) => {
				items.add(state.output);
				if (options && options.onResult) options.onResult(state);
			};
			for (let i = 0; i < patterns.length; i++) {
				let isMatch = picomatch(String(patterns[i]), __spreadProps(__spreadValues({}, options), { onResult }), true);
				let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
				if (negated) negatives++;
				for (let item of list) {
					let matched = isMatch(item, true);
					if (!(negated ? !matched.isMatch : matched.isMatch)) continue;
					if (negated) omit.add(matched.output);
					else {
						omit.delete(matched.output);
						keep.add(matched.output);
					}
				}
			}
			let matches = (negatives === patterns.length ? [...items] : [...keep]).filter((item) => !omit.has(item));
			if (options && matches.length === 0) {
				if (options.failglob === true) throw new Error(`No matches found for "${patterns.join(", ")}"`);
				if (options.nonull === true || options.nullglob === true) return options.unescape ? patterns.map((p2) => p2.replace(/\\/g, "")) : patterns;
			}
			return matches;
		};
		micromatch.match = micromatch;
		micromatch.matcher = (pattern, options) => picomatch(pattern, options);
		micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
		micromatch.any = micromatch.isMatch;
		micromatch.not = (list, patterns, options = {}) => {
			patterns = [].concat(patterns).map(String);
			let result = /* @__PURE__ */ new Set();
			let items = [];
			let onResult = (state) => {
				if (options.onResult) options.onResult(state);
				items.push(state.output);
			};
			let matches = new Set(micromatch(list, patterns, __spreadProps(__spreadValues({}, options), { onResult })));
			for (let item of items) if (!matches.has(item)) result.add(item);
			return [...result];
		};
		micromatch.contains = (str, pattern, options) => {
			if (typeof str !== "string") throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
			if (Array.isArray(pattern)) return pattern.some((p2) => micromatch.contains(str, p2, options));
			if (typeof pattern === "string") {
				if (isEmptyString(str) || isEmptyString(pattern)) return false;
				if (str.includes(pattern) || str.startsWith("./") && str.slice(2).includes(pattern)) return true;
			}
			return micromatch.isMatch(str, pattern, __spreadProps(__spreadValues({}, options), { contains: true }));
		};
		micromatch.matchKeys = (obj, patterns, options) => {
			if (!utils.isObject(obj)) throw new TypeError("Expected the first argument to be an object");
			let keys = micromatch(Object.keys(obj), patterns, options);
			let res = {};
			for (let key of keys) res[key] = obj[key];
			return res;
		};
		micromatch.some = (list, patterns, options) => {
			let items = [].concat(list);
			for (let pattern of [].concat(patterns)) {
				let isMatch = picomatch(String(pattern), options);
				if (items.some((item) => isMatch(item))) return true;
			}
			return false;
		};
		micromatch.every = (list, patterns, options) => {
			let items = [].concat(list);
			for (let pattern of [].concat(patterns)) {
				let isMatch = picomatch(String(pattern), options);
				if (!items.every((item) => isMatch(item))) return false;
			}
			return true;
		};
		micromatch.all = (str, patterns, options) => {
			if (typeof str !== "string") throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
			return [].concat(patterns).every((p2) => picomatch(p2, options)(str));
		};
		micromatch.capture = (glob2, input, options) => {
			let posix = utils.isWindows(options);
			let match = picomatch.makeRe(String(glob2), __spreadProps(__spreadValues({}, options), { capture: true })).exec(posix ? utils.toPosixSlashes(input) : input);
			if (match) return match.slice(1).map((v2) => v2 === void 0 ? "" : v2);
		};
		micromatch.makeRe = (...args) => picomatch.makeRe(...args);
		micromatch.scan = (...args) => picomatch.scan(...args);
		micromatch.parse = (patterns, options) => {
			let res = [];
			for (let pattern of [].concat(patterns || [])) for (let str of braces(String(pattern), options)) res.push(picomatch.parse(str, options));
			return res;
		};
		micromatch.braces = (pattern, options) => {
			if (typeof pattern !== "string") throw new TypeError("Expected a string");
			if (options && options.nobrace === true || !hasBraces(pattern)) return [pattern];
			return braces(pattern, options);
		};
		micromatch.braceExpand = (pattern, options) => {
			if (typeof pattern !== "string") throw new TypeError("Expected a string");
			return micromatch.braces(pattern, __spreadProps(__spreadValues({}, options), { expand: true }));
		};
		micromatch.hasBraces = hasBraces;
		module2.exports = micromatch;
	} });
	var require_pattern = __commonJS({ "node_modules/fast-glob/out/utils/pattern.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.isAbsolute = exports2.partitionAbsoluteAndRelative = exports2.removeDuplicateSlashes = exports2.matchAny = exports2.convertPatternsToRe = exports2.makeRe = exports2.getPatternParts = exports2.expandBraceExpansion = exports2.expandPatternsWithBraceExpansion = exports2.isAffectDepthOfReadingPattern = exports2.endsWithSlashGlobStar = exports2.hasGlobStar = exports2.getBaseDirectory = exports2.isPatternRelatedToParentDirectory = exports2.getPatternsOutsideCurrentDirectory = exports2.getPatternsInsideCurrentDirectory = exports2.getPositivePatterns = exports2.getNegativePatterns = exports2.isPositivePattern = exports2.isNegativePattern = exports2.convertToNegativePattern = exports2.convertToPositivePattern = exports2.isDynamicPattern = exports2.isStaticPattern = void 0;
		var path3 = __require("path");
		var globParent = require_glob_parent();
		var micromatch = require_micromatch();
		var GLOBSTAR = "**";
		var ESCAPE_SYMBOL = "\\";
		var COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
		var REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
		var REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
		var GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
		var BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
		var DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
		function isStaticPattern(pattern, options = {}) {
			return !isDynamicPattern2(pattern, options);
		}
		exports2.isStaticPattern = isStaticPattern;
		function isDynamicPattern2(pattern, options = {}) {
			if (pattern === "") return false;
			if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) return true;
			if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) return true;
			if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) return true;
			if (options.braceExpansion !== false && hasBraceExpansion(pattern)) return true;
			return false;
		}
		exports2.isDynamicPattern = isDynamicPattern2;
		function hasBraceExpansion(pattern) {
			const openingBraceIndex = pattern.indexOf("{");
			if (openingBraceIndex === -1) return false;
			const closingBraceIndex = pattern.indexOf("}", openingBraceIndex + 1);
			if (closingBraceIndex === -1) return false;
			const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
			return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
		}
		function convertToPositivePattern(pattern) {
			return isNegativePattern2(pattern) ? pattern.slice(1) : pattern;
		}
		exports2.convertToPositivePattern = convertToPositivePattern;
		function convertToNegativePattern(pattern) {
			return "!" + pattern;
		}
		exports2.convertToNegativePattern = convertToNegativePattern;
		function isNegativePattern2(pattern) {
			return pattern.startsWith("!") && pattern[1] !== "(";
		}
		exports2.isNegativePattern = isNegativePattern2;
		function isPositivePattern(pattern) {
			return !isNegativePattern2(pattern);
		}
		exports2.isPositivePattern = isPositivePattern;
		function getNegativePatterns(patterns) {
			return patterns.filter(isNegativePattern2);
		}
		exports2.getNegativePatterns = getNegativePatterns;
		function getPositivePatterns(patterns) {
			return patterns.filter(isPositivePattern);
		}
		exports2.getPositivePatterns = getPositivePatterns;
		function getPatternsInsideCurrentDirectory(patterns) {
			return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
		}
		exports2.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
		function getPatternsOutsideCurrentDirectory(patterns) {
			return patterns.filter(isPatternRelatedToParentDirectory);
		}
		exports2.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
		function isPatternRelatedToParentDirectory(pattern) {
			return pattern.startsWith("..") || pattern.startsWith("./..");
		}
		exports2.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
		function getBaseDirectory(pattern) {
			return globParent(pattern, { flipBackslashes: false });
		}
		exports2.getBaseDirectory = getBaseDirectory;
		function hasGlobStar(pattern) {
			return pattern.includes(GLOBSTAR);
		}
		exports2.hasGlobStar = hasGlobStar;
		function endsWithSlashGlobStar(pattern) {
			return pattern.endsWith("/" + GLOBSTAR);
		}
		exports2.endsWithSlashGlobStar = endsWithSlashGlobStar;
		function isAffectDepthOfReadingPattern(pattern) {
			const basename = path3.basename(pattern);
			return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
		}
		exports2.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
		function expandPatternsWithBraceExpansion(patterns) {
			return patterns.reduce((collection, pattern) => {
				return collection.concat(expandBraceExpansion(pattern));
			}, []);
		}
		exports2.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
		function expandBraceExpansion(pattern) {
			const patterns = micromatch.braces(pattern, {
				expand: true,
				nodupes: true,
				keepEscaping: true
			});
			patterns.sort((a, b) => a.length - b.length);
			return patterns.filter((pattern2) => pattern2 !== "");
		}
		exports2.expandBraceExpansion = expandBraceExpansion;
		function getPatternParts(pattern, options) {
			let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
			if (parts.length === 0) parts = [pattern];
			if (parts[0].startsWith("/")) {
				parts[0] = parts[0].slice(1);
				parts.unshift("");
			}
			return parts;
		}
		exports2.getPatternParts = getPatternParts;
		function makeRe(pattern, options) {
			return micromatch.makeRe(pattern, options);
		}
		exports2.makeRe = makeRe;
		function convertPatternsToRe(patterns, options) {
			return patterns.map((pattern) => makeRe(pattern, options));
		}
		exports2.convertPatternsToRe = convertPatternsToRe;
		function matchAny(entry, patternsRe) {
			return patternsRe.some((patternRe) => patternRe.test(entry));
		}
		exports2.matchAny = matchAny;
		function removeDuplicateSlashes(pattern) {
			return pattern.replace(DOUBLE_SLASH_RE, "/");
		}
		exports2.removeDuplicateSlashes = removeDuplicateSlashes;
		function partitionAbsoluteAndRelative(patterns) {
			const absolute = [];
			const relative = [];
			for (const pattern of patterns) if (isAbsolute(pattern)) absolute.push(pattern);
			else relative.push(pattern);
			return [absolute, relative];
		}
		exports2.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
		function isAbsolute(pattern) {
			return path3.isAbsolute(pattern);
		}
		exports2.isAbsolute = isAbsolute;
	} });
	var require_merge2 = __commonJS({ "node_modules/merge2/index.js"(exports2, module2) {
		"use strict";
		var PassThrough = __require("stream").PassThrough;
		var slice = Array.prototype.slice;
		module2.exports = merge2;
		function merge2() {
			const streamsQueue = [];
			const args = slice.call(arguments);
			let merging = false;
			let options = args[args.length - 1];
			if (options && !Array.isArray(options) && options.pipe == null) args.pop();
			else options = {};
			const doEnd = options.end !== false;
			const doPipeError = options.pipeError === true;
			if (options.objectMode == null) options.objectMode = true;
			if (options.highWaterMark == null) options.highWaterMark = 64 * 1024;
			const mergedStream = PassThrough(options);
			function addStream() {
				for (let i = 0, len = arguments.length; i < len; i++) streamsQueue.push(pauseStreams(arguments[i], options));
				mergeStream();
				return this;
			}
			function mergeStream() {
				if (merging) return;
				merging = true;
				let streams = streamsQueue.shift();
				if (!streams) {
					process.nextTick(endStream2);
					return;
				}
				if (!Array.isArray(streams)) streams = [streams];
				let pipesCount = streams.length + 1;
				function next() {
					if (--pipesCount > 0) return;
					merging = false;
					mergeStream();
				}
				function pipe(stream) {
					function onend() {
						stream.removeListener("merge2UnpipeEnd", onend);
						stream.removeListener("end", onend);
						if (doPipeError) stream.removeListener("error", onerror);
						next();
					}
					function onerror(err) {
						mergedStream.emit("error", err);
					}
					if (stream._readableState.endEmitted) return next();
					stream.on("merge2UnpipeEnd", onend);
					stream.on("end", onend);
					if (doPipeError) stream.on("error", onerror);
					stream.pipe(mergedStream, { end: false });
					stream.resume();
				}
				for (let i = 0; i < streams.length; i++) pipe(streams[i]);
				next();
			}
			function endStream2() {
				merging = false;
				mergedStream.emit("queueDrain");
				if (doEnd) mergedStream.end();
			}
			mergedStream.setMaxListeners(0);
			mergedStream.add = addStream;
			mergedStream.on("unpipe", function(stream) {
				stream.emit("merge2UnpipeEnd");
			});
			if (args.length) addStream.apply(null, args);
			return mergedStream;
		}
		function pauseStreams(streams, options) {
			if (!Array.isArray(streams)) {
				if (!streams._readableState && streams.pipe) streams = streams.pipe(PassThrough(options));
				if (!streams._readableState || !streams.pause || !streams.pipe) throw new Error("Only readable stream can be merged.");
				streams.pause();
			} else for (let i = 0, len = streams.length; i < len; i++) streams[i] = pauseStreams(streams[i], options);
			return streams;
		}
	} });
	var require_stream = __commonJS({ "node_modules/fast-glob/out/utils/stream.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.merge = void 0;
		var merge2 = require_merge2();
		function merge3(streams) {
			const mergedStream = merge2(streams);
			streams.forEach((stream) => {
				stream.once("error", (error) => mergedStream.emit("error", error));
			});
			mergedStream.once("close", () => propagateCloseEventToSources(streams));
			mergedStream.once("end", () => propagateCloseEventToSources(streams));
			return mergedStream;
		}
		exports2.merge = merge3;
		function propagateCloseEventToSources(streams) {
			streams.forEach((stream) => stream.emit("close"));
		}
	} });
	var require_string = __commonJS({ "node_modules/fast-glob/out/utils/string.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.isEmpty = exports2.isString = void 0;
		function isString(input) {
			return typeof input === "string";
		}
		exports2.isString = isString;
		function isEmpty2(input) {
			return input === "";
		}
		exports2.isEmpty = isEmpty2;
	} });
	var require_utils3 = __commonJS({ "node_modules/fast-glob/out/utils/index.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.string = exports2.stream = exports2.pattern = exports2.path = exports2.fs = exports2.errno = exports2.array = void 0;
		exports2.array = require_array();
		exports2.errno = require_errno();
		exports2.fs = require_fs();
		exports2.path = require_path();
		exports2.pattern = require_pattern();
		exports2.stream = require_stream();
		exports2.string = require_string();
	} });
	var require_tasks = __commonJS({ "node_modules/fast-glob/out/managers/tasks.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.convertPatternGroupToTask = exports2.convertPatternGroupsToTasks = exports2.groupPatternsByBaseDirectory = exports2.getNegativePatternsAsPositive = exports2.getPositivePatterns = exports2.convertPatternsToTasks = exports2.generate = void 0;
		var utils = require_utils3();
		function generate(input, settings) {
			const patterns = processPatterns(input, settings);
			const ignore = processPatterns(settings.ignore, settings);
			const positivePatterns = getPositivePatterns(patterns);
			const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
			const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
			const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
			const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, false);
			const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, true);
			return staticTasks.concat(dynamicTasks);
		}
		exports2.generate = generate;
		function processPatterns(input, settings) {
			let patterns = input;
			if (settings.braceExpansion) patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns);
			if (settings.baseNameMatch) patterns = patterns.map((pattern) => pattern.includes("/") ? pattern : `**/${pattern}`);
			return patterns.map((pattern) => utils.pattern.removeDuplicateSlashes(pattern));
		}
		function convertPatternsToTasks(positive, negative, dynamic) {
			const tasks = [];
			const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
			const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
			const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
			const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
			tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
			if ("." in insideCurrentDirectoryGroup) tasks.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
			else tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
			return tasks;
		}
		exports2.convertPatternsToTasks = convertPatternsToTasks;
		function getPositivePatterns(patterns) {
			return utils.pattern.getPositivePatterns(patterns);
		}
		exports2.getPositivePatterns = getPositivePatterns;
		function getNegativePatternsAsPositive(patterns, ignore) {
			return utils.pattern.getNegativePatterns(patterns).concat(ignore).map(utils.pattern.convertToPositivePattern);
		}
		exports2.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
		function groupPatternsByBaseDirectory(patterns) {
			return patterns.reduce((collection, pattern) => {
				const base = utils.pattern.getBaseDirectory(pattern);
				if (base in collection) collection[base].push(pattern);
				else collection[base] = [pattern];
				return collection;
			}, {});
		}
		exports2.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
		function convertPatternGroupsToTasks(positive, negative, dynamic) {
			return Object.keys(positive).map((base) => {
				return convertPatternGroupToTask(base, positive[base], negative, dynamic);
			});
		}
		exports2.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
		function convertPatternGroupToTask(base, positive, negative, dynamic) {
			return {
				dynamic,
				positive,
				negative,
				base,
				patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
			};
		}
		exports2.convertPatternGroupToTask = convertPatternGroupToTask;
	} });
	var require_async = __commonJS({ "node_modules/@nodelib/fs.stat/out/providers/async.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.read = void 0;
		function read(path3, settings, callback) {
			settings.fs.lstat(path3, (lstatError, lstat) => {
				if (lstatError !== null) {
					callFailureCallback(callback, lstatError);
					return;
				}
				if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
					callSuccessCallback(callback, lstat);
					return;
				}
				settings.fs.stat(path3, (statError, stat) => {
					if (statError !== null) {
						if (settings.throwErrorOnBrokenSymbolicLink) {
							callFailureCallback(callback, statError);
							return;
						}
						callSuccessCallback(callback, lstat);
						return;
					}
					if (settings.markSymbolicLink) stat.isSymbolicLink = () => true;
					callSuccessCallback(callback, stat);
				});
			});
		}
		exports2.read = read;
		function callFailureCallback(callback, error) {
			callback(error);
		}
		function callSuccessCallback(callback, result) {
			callback(null, result);
		}
	} });
	var require_sync = __commonJS({ "node_modules/@nodelib/fs.stat/out/providers/sync.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.read = void 0;
		function read(path3, settings) {
			const lstat = settings.fs.lstatSync(path3);
			if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) return lstat;
			try {
				const stat = settings.fs.statSync(path3);
				if (settings.markSymbolicLink) stat.isSymbolicLink = () => true;
				return stat;
			} catch (error) {
				if (!settings.throwErrorOnBrokenSymbolicLink) return lstat;
				throw error;
			}
		}
		exports2.read = read;
	} });
	var require_fs2 = __commonJS({ "node_modules/@nodelib/fs.stat/out/adapters/fs.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
		var fs6 = __require("fs");
		exports2.FILE_SYSTEM_ADAPTER = {
			lstat: fs6.lstat,
			stat: fs6.stat,
			lstatSync: fs6.lstatSync,
			statSync: fs6.statSync
		};
		function createFileSystemAdapter(fsMethods) {
			if (fsMethods === void 0) return exports2.FILE_SYSTEM_ADAPTER;
			return Object.assign(Object.assign({}, exports2.FILE_SYSTEM_ADAPTER), fsMethods);
		}
		exports2.createFileSystemAdapter = createFileSystemAdapter;
	} });
	var require_settings = __commonJS({ "node_modules/@nodelib/fs.stat/out/settings.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var fs6 = require_fs2();
		var Settings = class {
			constructor(_options = {}) {
				this._options = _options;
				this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
				this.fs = fs6.createFileSystemAdapter(this._options.fs);
				this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
				this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
			}
			_getValue(option, value) {
				return option !== null && option !== void 0 ? option : value;
			}
		};
		exports2.default = Settings;
	} });
	var require_out = __commonJS({ "node_modules/@nodelib/fs.stat/out/index.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.statSync = exports2.stat = exports2.Settings = void 0;
		var async = require_async();
		var sync = require_sync();
		var settings_1 = require_settings();
		exports2.Settings = settings_1.default;
		function stat(path3, optionsOrSettingsOrCallback, callback) {
			if (typeof optionsOrSettingsOrCallback === "function") {
				async.read(path3, getSettings(), optionsOrSettingsOrCallback);
				return;
			}
			async.read(path3, getSettings(optionsOrSettingsOrCallback), callback);
		}
		exports2.stat = stat;
		function statSync(path3, optionsOrSettings) {
			const settings = getSettings(optionsOrSettings);
			return sync.read(path3, settings);
		}
		exports2.statSync = statSync;
		function getSettings(settingsOrOptions = {}) {
			if (settingsOrOptions instanceof settings_1.default) return settingsOrOptions;
			return new settings_1.default(settingsOrOptions);
		}
	} });
	var require_queue_microtask = __commonJS({ "node_modules/queue-microtask/index.js"(exports2, module2) {
		"use strict";
		var promise;
		module2.exports = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : global) : (cb) => (promise || (promise = Promise.resolve())).then(cb).catch((err) => setTimeout(() => {
			throw err;
		}, 0));
	} });
	var require_run_parallel = __commonJS({ "node_modules/run-parallel/index.js"(exports2, module2) {
		"use strict";
		module2.exports = runParallel;
		var queueMicrotask2 = require_queue_microtask();
		function runParallel(tasks, cb) {
			let results, pending, keys;
			let isSync = true;
			if (Array.isArray(tasks)) {
				results = [];
				pending = tasks.length;
			} else {
				keys = Object.keys(tasks);
				results = {};
				pending = keys.length;
			}
			function done(err) {
				function end() {
					if (cb) cb(err, results);
					cb = null;
				}
				if (isSync) queueMicrotask2(end);
				else end();
			}
			function each(i, err, result) {
				results[i] = result;
				if (--pending === 0 || err) done(err);
			}
			if (!pending) done(null);
			else if (keys) keys.forEach(function(key) {
				tasks[key](function(err, result) {
					each(key, err, result);
				});
			});
			else tasks.forEach(function(task, i) {
				task(function(err, result) {
					each(i, err, result);
				});
			});
			isSync = false;
		}
	} });
	var require_constants3 = __commonJS({ "node_modules/@nodelib/fs.scandir/out/constants.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
		var NODE_PROCESS_VERSION_PARTS = process.versions.node.split(".");
		if (NODE_PROCESS_VERSION_PARTS[0] === void 0 || NODE_PROCESS_VERSION_PARTS[1] === void 0) throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
		var MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
		var MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
		var SUPPORTED_MAJOR_VERSION = 10;
		exports2.IS_SUPPORT_READDIR_WITH_FILE_TYPES = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION || MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= 10;
	} });
	var require_fs3 = __commonJS({ "node_modules/@nodelib/fs.scandir/out/utils/fs.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.createDirentFromStats = void 0;
		var DirentFromStats = class {
			constructor(name, stats) {
				this.name = name;
				this.isBlockDevice = stats.isBlockDevice.bind(stats);
				this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
				this.isDirectory = stats.isDirectory.bind(stats);
				this.isFIFO = stats.isFIFO.bind(stats);
				this.isFile = stats.isFile.bind(stats);
				this.isSocket = stats.isSocket.bind(stats);
				this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
			}
		};
		function createDirentFromStats(name, stats) {
			return new DirentFromStats(name, stats);
		}
		exports2.createDirentFromStats = createDirentFromStats;
	} });
	var require_utils4 = __commonJS({ "node_modules/@nodelib/fs.scandir/out/utils/index.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.fs = void 0;
		exports2.fs = require_fs3();
	} });
	var require_common = __commonJS({ "node_modules/@nodelib/fs.scandir/out/providers/common.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.joinPathSegments = void 0;
		function joinPathSegments(a, b, separator) {
			if (a.endsWith(separator)) return a + b;
			return a + separator + b;
		}
		exports2.joinPathSegments = joinPathSegments;
	} });
	var require_async2 = __commonJS({ "node_modules/@nodelib/fs.scandir/out/providers/async.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.readdir = exports2.readdirWithFileTypes = exports2.read = void 0;
		var fsStat = require_out();
		var rpl = require_run_parallel();
		var constants_1 = require_constants3();
		var utils = require_utils4();
		var common = require_common();
		function read(directory, settings, callback) {
			if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
				readdirWithFileTypes(directory, settings, callback);
				return;
			}
			readdir(directory, settings, callback);
		}
		exports2.read = read;
		function readdirWithFileTypes(directory, settings, callback) {
			settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
				if (readdirError !== null) {
					callFailureCallback(callback, readdirError);
					return;
				}
				const entries = dirents.map((dirent) => ({
					dirent,
					name: dirent.name,
					path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
				}));
				if (!settings.followSymbolicLinks) {
					callSuccessCallback(callback, entries);
					return;
				}
				rpl(entries.map((entry) => makeRplTaskEntry(entry, settings)), (rplError, rplEntries) => {
					if (rplError !== null) {
						callFailureCallback(callback, rplError);
						return;
					}
					callSuccessCallback(callback, rplEntries);
				});
			});
		}
		exports2.readdirWithFileTypes = readdirWithFileTypes;
		function makeRplTaskEntry(entry, settings) {
			return (done) => {
				if (!entry.dirent.isSymbolicLink()) {
					done(null, entry);
					return;
				}
				settings.fs.stat(entry.path, (statError, stats) => {
					if (statError !== null) {
						if (settings.throwErrorOnBrokenSymbolicLink) {
							done(statError);
							return;
						}
						done(null, entry);
						return;
					}
					entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
					done(null, entry);
				});
			};
		}
		function readdir(directory, settings, callback) {
			settings.fs.readdir(directory, (readdirError, names) => {
				if (readdirError !== null) {
					callFailureCallback(callback, readdirError);
					return;
				}
				rpl(names.map((name) => {
					const path3 = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
					return (done) => {
						fsStat.stat(path3, settings.fsStatSettings, (error, stats) => {
							if (error !== null) {
								done(error);
								return;
							}
							const entry = {
								name,
								path: path3,
								dirent: utils.fs.createDirentFromStats(name, stats)
							};
							if (settings.stats) entry.stats = stats;
							done(null, entry);
						});
					};
				}), (rplError, entries) => {
					if (rplError !== null) {
						callFailureCallback(callback, rplError);
						return;
					}
					callSuccessCallback(callback, entries);
				});
			});
		}
		exports2.readdir = readdir;
		function callFailureCallback(callback, error) {
			callback(error);
		}
		function callSuccessCallback(callback, result) {
			callback(null, result);
		}
	} });
	var require_sync2 = __commonJS({ "node_modules/@nodelib/fs.scandir/out/providers/sync.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.readdir = exports2.readdirWithFileTypes = exports2.read = void 0;
		var fsStat = require_out();
		var constants_1 = require_constants3();
		var utils = require_utils4();
		var common = require_common();
		function read(directory, settings) {
			if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) return readdirWithFileTypes(directory, settings);
			return readdir(directory, settings);
		}
		exports2.read = read;
		function readdirWithFileTypes(directory, settings) {
			return settings.fs.readdirSync(directory, { withFileTypes: true }).map((dirent) => {
				const entry = {
					dirent,
					name: dirent.name,
					path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
				};
				if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) try {
					const stats = settings.fs.statSync(entry.path);
					entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
				} catch (error) {
					if (settings.throwErrorOnBrokenSymbolicLink) throw error;
				}
				return entry;
			});
		}
		exports2.readdirWithFileTypes = readdirWithFileTypes;
		function readdir(directory, settings) {
			return settings.fs.readdirSync(directory).map((name) => {
				const entryPath = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
				const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
				const entry = {
					name,
					path: entryPath,
					dirent: utils.fs.createDirentFromStats(name, stats)
				};
				if (settings.stats) entry.stats = stats;
				return entry;
			});
		}
		exports2.readdir = readdir;
	} });
	var require_fs4 = __commonJS({ "node_modules/@nodelib/fs.scandir/out/adapters/fs.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
		var fs6 = __require("fs");
		exports2.FILE_SYSTEM_ADAPTER = {
			lstat: fs6.lstat,
			stat: fs6.stat,
			lstatSync: fs6.lstatSync,
			statSync: fs6.statSync,
			readdir: fs6.readdir,
			readdirSync: fs6.readdirSync
		};
		function createFileSystemAdapter(fsMethods) {
			if (fsMethods === void 0) return exports2.FILE_SYSTEM_ADAPTER;
			return Object.assign(Object.assign({}, exports2.FILE_SYSTEM_ADAPTER), fsMethods);
		}
		exports2.createFileSystemAdapter = createFileSystemAdapter;
	} });
	var require_settings2 = __commonJS({ "node_modules/@nodelib/fs.scandir/out/settings.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var path3 = __require("path");
		var fsStat = require_out();
		var fs6 = require_fs4();
		var Settings = class {
			constructor(_options = {}) {
				this._options = _options;
				this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
				this.fs = fs6.createFileSystemAdapter(this._options.fs);
				this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path3.sep);
				this.stats = this._getValue(this._options.stats, false);
				this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
				this.fsStatSettings = new fsStat.Settings({
					followSymbolicLink: this.followSymbolicLinks,
					fs: this.fs,
					throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
				});
			}
			_getValue(option, value) {
				return option !== null && option !== void 0 ? option : value;
			}
		};
		exports2.default = Settings;
	} });
	var require_out2 = __commonJS({ "node_modules/@nodelib/fs.scandir/out/index.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.Settings = exports2.scandirSync = exports2.scandir = void 0;
		var async = require_async2();
		var sync = require_sync2();
		var settings_1 = require_settings2();
		exports2.Settings = settings_1.default;
		function scandir(path3, optionsOrSettingsOrCallback, callback) {
			if (typeof optionsOrSettingsOrCallback === "function") {
				async.read(path3, getSettings(), optionsOrSettingsOrCallback);
				return;
			}
			async.read(path3, getSettings(optionsOrSettingsOrCallback), callback);
		}
		exports2.scandir = scandir;
		function scandirSync(path3, optionsOrSettings) {
			const settings = getSettings(optionsOrSettings);
			return sync.read(path3, settings);
		}
		exports2.scandirSync = scandirSync;
		function getSettings(settingsOrOptions = {}) {
			if (settingsOrOptions instanceof settings_1.default) return settingsOrOptions;
			return new settings_1.default(settingsOrOptions);
		}
	} });
	var require_reusify = __commonJS({ "node_modules/reusify/reusify.js"(exports2, module2) {
		"use strict";
		function reusify(Constructor) {
			var head = new Constructor();
			var tail = head;
			function get() {
				var current = head;
				if (current.next) head = current.next;
				else {
					head = new Constructor();
					tail = head;
				}
				current.next = null;
				return current;
			}
			function release(obj) {
				tail.next = obj;
				tail = obj;
			}
			return {
				get,
				release
			};
		}
		module2.exports = reusify;
	} });
	var require_queue = __commonJS({ "node_modules/fastq/queue.js"(exports2, module2) {
		"use strict";
		var reusify = require_reusify();
		function fastqueue(context, worker, _concurrency) {
			if (typeof context === "function") {
				_concurrency = worker;
				worker = context;
				context = null;
			}
			if (!(_concurrency >= 1)) throw new Error("fastqueue concurrency must be equal to or greater than 1");
			var cache = reusify(Task);
			var queueHead = null;
			var queueTail = null;
			var _running = 0;
			var errorHandler = null;
			var self2 = {
				push,
				drain: noop2,
				saturated: noop2,
				pause,
				paused: false,
				get concurrency() {
					return _concurrency;
				},
				set concurrency(value) {
					if (!(value >= 1)) throw new Error("fastqueue concurrency must be equal to or greater than 1");
					_concurrency = value;
					if (self2.paused) return;
					for (; queueHead && _running < _concurrency;) {
						_running++;
						release();
					}
				},
				running,
				resume,
				idle,
				length,
				getQueue,
				unshift,
				empty: noop2,
				kill,
				killAndDrain,
				error
			};
			return self2;
			function running() {
				return _running;
			}
			function pause() {
				self2.paused = true;
			}
			function length() {
				var current = queueHead;
				var counter = 0;
				while (current) {
					current = current.next;
					counter++;
				}
				return counter;
			}
			function getQueue() {
				var current = queueHead;
				var tasks = [];
				while (current) {
					tasks.push(current.value);
					current = current.next;
				}
				return tasks;
			}
			function resume() {
				if (!self2.paused) return;
				self2.paused = false;
				if (queueHead === null) {
					_running++;
					release();
					return;
				}
				for (; queueHead && _running < _concurrency;) {
					_running++;
					release();
				}
			}
			function idle() {
				return _running === 0 && self2.length() === 0;
			}
			function push(value, done) {
				var current = cache.get();
				current.context = context;
				current.release = release;
				current.value = value;
				current.callback = done || noop2;
				current.errorHandler = errorHandler;
				if (_running >= _concurrency || self2.paused) if (queueTail) {
					queueTail.next = current;
					queueTail = current;
				} else {
					queueHead = current;
					queueTail = current;
					self2.saturated();
				}
				else {
					_running++;
					worker.call(context, current.value, current.worked);
				}
			}
			function unshift(value, done) {
				var current = cache.get();
				current.context = context;
				current.release = release;
				current.value = value;
				current.callback = done || noop2;
				current.errorHandler = errorHandler;
				if (_running >= _concurrency || self2.paused) if (queueHead) {
					current.next = queueHead;
					queueHead = current;
				} else {
					queueHead = current;
					queueTail = current;
					self2.saturated();
				}
				else {
					_running++;
					worker.call(context, current.value, current.worked);
				}
			}
			function release(holder) {
				if (holder) cache.release(holder);
				var next = queueHead;
				if (next && _running <= _concurrency) if (!self2.paused) {
					if (queueTail === queueHead) queueTail = null;
					queueHead = next.next;
					next.next = null;
					worker.call(context, next.value, next.worked);
					if (queueTail === null) self2.empty();
				} else _running--;
				else if (--_running === 0) self2.drain();
			}
			function kill() {
				queueHead = null;
				queueTail = null;
				self2.drain = noop2;
			}
			function killAndDrain() {
				queueHead = null;
				queueTail = null;
				self2.drain();
				self2.drain = noop2;
			}
			function error(handler) {
				errorHandler = handler;
			}
		}
		function noop2() {}
		function Task() {
			this.value = null;
			this.callback = noop2;
			this.next = null;
			this.release = noop2;
			this.context = null;
			this.errorHandler = null;
			var self2 = this;
			this.worked = function worked(err, result) {
				var callback = self2.callback;
				var errorHandler = self2.errorHandler;
				var val = self2.value;
				self2.value = null;
				self2.callback = noop2;
				if (self2.errorHandler) errorHandler(err, val);
				callback.call(self2.context, err, result);
				self2.release(self2);
			};
		}
		function queueAsPromised(context, worker, _concurrency) {
			if (typeof context === "function") {
				_concurrency = worker;
				worker = context;
				context = null;
			}
			function asyncWrapper(arg, cb) {
				worker.call(this, arg).then(function(res) {
					cb(null, res);
				}, cb);
			}
			var queue = fastqueue(context, asyncWrapper, _concurrency);
			var pushCb = queue.push;
			var unshiftCb = queue.unshift;
			queue.push = push;
			queue.unshift = unshift;
			queue.drained = drained;
			return queue;
			function push(value) {
				var p2 = new Promise(function(resolve, reject) {
					pushCb(value, function(err, result) {
						if (err) {
							reject(err);
							return;
						}
						resolve(result);
					});
				});
				p2.catch(noop2);
				return p2;
			}
			function unshift(value) {
				var p2 = new Promise(function(resolve, reject) {
					unshiftCb(value, function(err, result) {
						if (err) {
							reject(err);
							return;
						}
						resolve(result);
					});
				});
				p2.catch(noop2);
				return p2;
			}
			function drained() {
				return new Promise(function(resolve) {
					process.nextTick(function() {
						if (queue.idle()) resolve();
						else {
							var previousDrain = queue.drain;
							queue.drain = function() {
								if (typeof previousDrain === "function") previousDrain();
								resolve();
								queue.drain = previousDrain;
							};
						}
					});
				});
			}
		}
		module2.exports = fastqueue;
		module2.exports.promise = queueAsPromised;
	} });
	var require_common2 = __commonJS({ "node_modules/@nodelib/fs.walk/out/readers/common.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.joinPathSegments = exports2.replacePathSegmentSeparator = exports2.isAppliedFilter = exports2.isFatalError = void 0;
		function isFatalError(settings, error) {
			if (settings.errorFilter === null) return true;
			return !settings.errorFilter(error);
		}
		exports2.isFatalError = isFatalError;
		function isAppliedFilter(filter, value) {
			return filter === null || filter(value);
		}
		exports2.isAppliedFilter = isAppliedFilter;
		function replacePathSegmentSeparator(filepath, separator) {
			return filepath.split(/[/\\]/).join(separator);
		}
		exports2.replacePathSegmentSeparator = replacePathSegmentSeparator;
		function joinPathSegments(a, b, separator) {
			if (a === "") return b;
			if (a.endsWith(separator)) return a + b;
			return a + separator + b;
		}
		exports2.joinPathSegments = joinPathSegments;
	} });
	var require_reader = __commonJS({ "node_modules/@nodelib/fs.walk/out/readers/reader.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var common = require_common2();
		var Reader = class {
			constructor(_root, _settings) {
				this._root = _root;
				this._settings = _settings;
				this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
			}
		};
		exports2.default = Reader;
	} });
	var require_async3 = __commonJS({ "node_modules/@nodelib/fs.walk/out/readers/async.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var events_1 = __require("events");
		var fsScandir = require_out2();
		var fastq = require_queue();
		var common = require_common2();
		var reader_1 = require_reader();
		var AsyncReader = class extends reader_1.default {
			constructor(_root, _settings) {
				super(_root, _settings);
				this._settings = _settings;
				this._scandir = fsScandir.scandir;
				this._emitter = new events_1.EventEmitter();
				this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
				this._isFatalError = false;
				this._isDestroyed = false;
				this._queue.drain = () => {
					if (!this._isFatalError) this._emitter.emit("end");
				};
			}
			read() {
				this._isFatalError = false;
				this._isDestroyed = false;
				setImmediate(() => {
					this._pushToQueue(this._root, this._settings.basePath);
				});
				return this._emitter;
			}
			get isDestroyed() {
				return this._isDestroyed;
			}
			destroy() {
				if (this._isDestroyed) throw new Error("The reader is already destroyed");
				this._isDestroyed = true;
				this._queue.killAndDrain();
			}
			onEntry(callback) {
				this._emitter.on("entry", callback);
			}
			onError(callback) {
				this._emitter.once("error", callback);
			}
			onEnd(callback) {
				this._emitter.once("end", callback);
			}
			_pushToQueue(directory, base) {
				const queueItem = {
					directory,
					base
				};
				this._queue.push(queueItem, (error) => {
					if (error !== null) this._handleError(error);
				});
			}
			_worker(item, done) {
				this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
					if (error !== null) {
						done(error, void 0);
						return;
					}
					for (const entry of entries) this._handleEntry(entry, item.base);
					done(null, void 0);
				});
			}
			_handleError(error) {
				if (this._isDestroyed || !common.isFatalError(this._settings, error)) return;
				this._isFatalError = true;
				this._isDestroyed = true;
				this._emitter.emit("error", error);
			}
			_handleEntry(entry, base) {
				if (this._isDestroyed || this._isFatalError) return;
				const fullpath = entry.path;
				if (base !== void 0) entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
				if (common.isAppliedFilter(this._settings.entryFilter, entry)) this._emitEntry(entry);
				if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
			}
			_emitEntry(entry) {
				this._emitter.emit("entry", entry);
			}
		};
		exports2.default = AsyncReader;
	} });
	var require_async4 = __commonJS({ "node_modules/@nodelib/fs.walk/out/providers/async.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var async_1 = require_async3();
		var AsyncProvider = class {
			constructor(_root, _settings) {
				this._root = _root;
				this._settings = _settings;
				this._reader = new async_1.default(this._root, this._settings);
				this._storage = [];
			}
			read(callback) {
				this._reader.onError((error) => {
					callFailureCallback(callback, error);
				});
				this._reader.onEntry((entry) => {
					this._storage.push(entry);
				});
				this._reader.onEnd(() => {
					callSuccessCallback(callback, this._storage);
				});
				this._reader.read();
			}
		};
		exports2.default = AsyncProvider;
		function callFailureCallback(callback, error) {
			callback(error);
		}
		function callSuccessCallback(callback, entries) {
			callback(null, entries);
		}
	} });
	var require_stream2 = __commonJS({ "node_modules/@nodelib/fs.walk/out/providers/stream.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var stream_1 = __require("stream");
		var async_1 = require_async3();
		var StreamProvider = class {
			constructor(_root, _settings) {
				this._root = _root;
				this._settings = _settings;
				this._reader = new async_1.default(this._root, this._settings);
				this._stream = new stream_1.Readable({
					objectMode: true,
					read: () => {},
					destroy: () => {
						if (!this._reader.isDestroyed) this._reader.destroy();
					}
				});
			}
			read() {
				this._reader.onError((error) => {
					this._stream.emit("error", error);
				});
				this._reader.onEntry((entry) => {
					this._stream.push(entry);
				});
				this._reader.onEnd(() => {
					this._stream.push(null);
				});
				this._reader.read();
				return this._stream;
			}
		};
		exports2.default = StreamProvider;
	} });
	var require_sync3 = __commonJS({ "node_modules/@nodelib/fs.walk/out/readers/sync.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var fsScandir = require_out2();
		var common = require_common2();
		var reader_1 = require_reader();
		var SyncReader = class extends reader_1.default {
			constructor() {
				super(...arguments);
				this._scandir = fsScandir.scandirSync;
				this._storage = [];
				this._queue = /* @__PURE__ */ new Set();
			}
			read() {
				this._pushToQueue(this._root, this._settings.basePath);
				this._handleQueue();
				return this._storage;
			}
			_pushToQueue(directory, base) {
				this._queue.add({
					directory,
					base
				});
			}
			_handleQueue() {
				for (const item of this._queue.values()) this._handleDirectory(item.directory, item.base);
			}
			_handleDirectory(directory, base) {
				try {
					const entries = this._scandir(directory, this._settings.fsScandirSettings);
					for (const entry of entries) this._handleEntry(entry, base);
				} catch (error) {
					this._handleError(error);
				}
			}
			_handleError(error) {
				if (!common.isFatalError(this._settings, error)) return;
				throw error;
			}
			_handleEntry(entry, base) {
				const fullpath = entry.path;
				if (base !== void 0) entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
				if (common.isAppliedFilter(this._settings.entryFilter, entry)) this._pushToStorage(entry);
				if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
			}
			_pushToStorage(entry) {
				this._storage.push(entry);
			}
		};
		exports2.default = SyncReader;
	} });
	var require_sync4 = __commonJS({ "node_modules/@nodelib/fs.walk/out/providers/sync.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var sync_1 = require_sync3();
		var SyncProvider = class {
			constructor(_root, _settings) {
				this._root = _root;
				this._settings = _settings;
				this._reader = new sync_1.default(this._root, this._settings);
			}
			read() {
				return this._reader.read();
			}
		};
		exports2.default = SyncProvider;
	} });
	var require_settings3 = __commonJS({ "node_modules/@nodelib/fs.walk/out/settings.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var path3 = __require("path");
		var fsScandir = require_out2();
		var Settings = class {
			constructor(_options = {}) {
				this._options = _options;
				this.basePath = this._getValue(this._options.basePath, void 0);
				this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
				this.deepFilter = this._getValue(this._options.deepFilter, null);
				this.entryFilter = this._getValue(this._options.entryFilter, null);
				this.errorFilter = this._getValue(this._options.errorFilter, null);
				this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path3.sep);
				this.fsScandirSettings = new fsScandir.Settings({
					followSymbolicLinks: this._options.followSymbolicLinks,
					fs: this._options.fs,
					pathSegmentSeparator: this._options.pathSegmentSeparator,
					stats: this._options.stats,
					throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
				});
			}
			_getValue(option, value) {
				return option !== null && option !== void 0 ? option : value;
			}
		};
		exports2.default = Settings;
	} });
	var require_out3 = __commonJS({ "node_modules/@nodelib/fs.walk/out/index.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.Settings = exports2.walkStream = exports2.walkSync = exports2.walk = void 0;
		var async_1 = require_async4();
		var stream_1 = require_stream2();
		var sync_1 = require_sync4();
		var settings_1 = require_settings3();
		exports2.Settings = settings_1.default;
		function walk(directory, optionsOrSettingsOrCallback, callback) {
			if (typeof optionsOrSettingsOrCallback === "function") {
				new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
				return;
			}
			new async_1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
		}
		exports2.walk = walk;
		function walkSync(directory, optionsOrSettings) {
			const settings = getSettings(optionsOrSettings);
			return new sync_1.default(directory, settings).read();
		}
		exports2.walkSync = walkSync;
		function walkStream(directory, optionsOrSettings) {
			const settings = getSettings(optionsOrSettings);
			return new stream_1.default(directory, settings).read();
		}
		exports2.walkStream = walkStream;
		function getSettings(settingsOrOptions = {}) {
			if (settingsOrOptions instanceof settings_1.default) return settingsOrOptions;
			return new settings_1.default(settingsOrOptions);
		}
	} });
	var require_reader2 = __commonJS({ "node_modules/fast-glob/out/readers/reader.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var path3 = __require("path");
		var fsStat = require_out();
		var utils = require_utils3();
		var Reader = class {
			constructor(_settings) {
				this._settings = _settings;
				this._fsStatSettings = new fsStat.Settings({
					followSymbolicLink: this._settings.followSymbolicLinks,
					fs: this._settings.fs,
					throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
				});
			}
			_getFullEntryPath(filepath) {
				return path3.resolve(this._settings.cwd, filepath);
			}
			_makeEntry(stats, pattern) {
				const entry = {
					name: pattern,
					path: pattern,
					dirent: utils.fs.createDirentFromStats(pattern, stats)
				};
				if (this._settings.stats) entry.stats = stats;
				return entry;
			}
			_isFatalError(error) {
				return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
			}
		};
		exports2.default = Reader;
	} });
	var require_stream3 = __commonJS({ "node_modules/fast-glob/out/readers/stream.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var stream_1 = __require("stream");
		var fsStat = require_out();
		var fsWalk = require_out3();
		var reader_1 = require_reader2();
		var ReaderStream = class extends reader_1.default {
			constructor() {
				super(...arguments);
				this._walkStream = fsWalk.walkStream;
				this._stat = fsStat.stat;
			}
			dynamic(root, options) {
				return this._walkStream(root, options);
			}
			static(patterns, options) {
				const filepaths = patterns.map(this._getFullEntryPath, this);
				const stream = new stream_1.PassThrough({ objectMode: true });
				stream._write = (index, _enc, done) => {
					return this._getEntry(filepaths[index], patterns[index], options).then((entry) => {
						if (entry !== null && options.entryFilter(entry)) stream.push(entry);
						if (index === filepaths.length - 1) stream.end();
						done();
					}).catch(done);
				};
				for (let i = 0; i < filepaths.length; i++) stream.write(i);
				return stream;
			}
			_getEntry(filepath, pattern, options) {
				return this._getStat(filepath).then((stats) => this._makeEntry(stats, pattern)).catch((error) => {
					if (options.errorFilter(error)) return null;
					throw error;
				});
			}
			_getStat(filepath) {
				return new Promise((resolve, reject) => {
					this._stat(filepath, this._fsStatSettings, (error, stats) => {
						return error === null ? resolve(stats) : reject(error);
					});
				});
			}
		};
		exports2.default = ReaderStream;
	} });
	var require_async5 = __commonJS({ "node_modules/fast-glob/out/readers/async.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var fsWalk = require_out3();
		var reader_1 = require_reader2();
		var stream_1 = require_stream3();
		var ReaderAsync = class extends reader_1.default {
			constructor() {
				super(...arguments);
				this._walkAsync = fsWalk.walk;
				this._readerStream = new stream_1.default(this._settings);
			}
			dynamic(root, options) {
				return new Promise((resolve, reject) => {
					this._walkAsync(root, options, (error, entries) => {
						if (error === null) resolve(entries);
						else reject(error);
					});
				});
			}
			static(patterns, options) {
				return __async(this, null, function* () {
					const entries = [];
					const stream = this._readerStream.static(patterns, options);
					return new Promise((resolve, reject) => {
						stream.once("error", reject);
						stream.on("data", (entry) => entries.push(entry));
						stream.once("end", () => resolve(entries));
					});
				});
			}
		};
		exports2.default = ReaderAsync;
	} });
	var require_matcher = __commonJS({ "node_modules/fast-glob/out/providers/matchers/matcher.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var utils = require_utils3();
		var Matcher = class {
			constructor(_patterns, _settings, _micromatchOptions) {
				this._patterns = _patterns;
				this._settings = _settings;
				this._micromatchOptions = _micromatchOptions;
				this._storage = [];
				this._fillStorage();
			}
			_fillStorage() {
				for (const pattern of this._patterns) {
					const segments = this._getPatternSegments(pattern);
					const sections = this._splitSegmentsIntoSections(segments);
					this._storage.push({
						complete: sections.length <= 1,
						pattern,
						segments,
						sections
					});
				}
			}
			_getPatternSegments(pattern) {
				return utils.pattern.getPatternParts(pattern, this._micromatchOptions).map((part) => {
					if (!utils.pattern.isDynamicPattern(part, this._settings)) return {
						dynamic: false,
						pattern: part
					};
					return {
						dynamic: true,
						pattern: part,
						patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
					};
				});
			}
			_splitSegmentsIntoSections(segments) {
				return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
			}
		};
		exports2.default = Matcher;
	} });
	var require_partial = __commonJS({ "node_modules/fast-glob/out/providers/matchers/partial.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var matcher_1 = require_matcher();
		var PartialMatcher = class extends matcher_1.default {
			match(filepath) {
				const parts = filepath.split("/");
				const levels = parts.length;
				const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
				for (const pattern of patterns) {
					const section = pattern.sections[0];
					if (!pattern.complete && levels > section.length) return true;
					if (parts.every((part, index) => {
						const segment = pattern.segments[index];
						if (segment.dynamic && segment.patternRe.test(part)) return true;
						if (!segment.dynamic && segment.pattern === part) return true;
						return false;
					})) return true;
				}
				return false;
			}
		};
		exports2.default = PartialMatcher;
	} });
	var require_deep = __commonJS({ "node_modules/fast-glob/out/providers/filters/deep.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var utils = require_utils3();
		var partial_1 = require_partial();
		var DeepFilter = class {
			constructor(_settings, _micromatchOptions) {
				this._settings = _settings;
				this._micromatchOptions = _micromatchOptions;
			}
			getFilter(basePath, positive, negative) {
				const matcher = this._getMatcher(positive);
				const negativeRe = this._getNegativePatternsRe(negative);
				return (entry) => this._filter(basePath, entry, matcher, negativeRe);
			}
			_getMatcher(patterns) {
				return new partial_1.default(patterns, this._settings, this._micromatchOptions);
			}
			_getNegativePatternsRe(patterns) {
				const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
				return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
			}
			_filter(basePath, entry, matcher, negativeRe) {
				if (this._isSkippedByDeep(basePath, entry.path)) return false;
				if (this._isSkippedSymbolicLink(entry)) return false;
				const filepath = utils.path.removeLeadingDotSegment(entry.path);
				if (this._isSkippedByPositivePatterns(filepath, matcher)) return false;
				return this._isSkippedByNegativePatterns(filepath, negativeRe);
			}
			_isSkippedByDeep(basePath, entryPath) {
				if (this._settings.deep === Infinity) return false;
				return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
			}
			_getEntryLevel(basePath, entryPath) {
				const entryPathDepth = entryPath.split("/").length;
				if (basePath === "") return entryPathDepth;
				return entryPathDepth - basePath.split("/").length;
			}
			_isSkippedSymbolicLink(entry) {
				return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
			}
			_isSkippedByPositivePatterns(entryPath, matcher) {
				return !this._settings.baseNameMatch && !matcher.match(entryPath);
			}
			_isSkippedByNegativePatterns(entryPath, patternsRe) {
				return !utils.pattern.matchAny(entryPath, patternsRe);
			}
		};
		exports2.default = DeepFilter;
	} });
	var require_entry = __commonJS({ "node_modules/fast-glob/out/providers/filters/entry.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var utils = require_utils3();
		var EntryFilter = class {
			constructor(_settings, _micromatchOptions) {
				this._settings = _settings;
				this._micromatchOptions = _micromatchOptions;
				this.index = /* @__PURE__ */ new Map();
			}
			getFilter(positive, negative) {
				const [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative);
				const patterns = {
					positive: { all: utils.pattern.convertPatternsToRe(positive, this._micromatchOptions) },
					negative: {
						absolute: utils.pattern.convertPatternsToRe(absoluteNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true })),
						relative: utils.pattern.convertPatternsToRe(relativeNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }))
					}
				};
				return (entry) => this._filter(entry, patterns);
			}
			_filter(entry, patterns) {
				const filepath = utils.path.removeLeadingDotSegment(entry.path);
				if (this._settings.unique && this._isDuplicateEntry(filepath)) return false;
				if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) return false;
				const isMatched = this._isMatchToPatternsSet(filepath, patterns, entry.dirent.isDirectory());
				if (this._settings.unique && isMatched) this._createIndexRecord(filepath);
				return isMatched;
			}
			_isDuplicateEntry(filepath) {
				return this.index.has(filepath);
			}
			_createIndexRecord(filepath) {
				this.index.set(filepath, void 0);
			}
			_onlyFileFilter(entry) {
				return this._settings.onlyFiles && !entry.dirent.isFile();
			}
			_onlyDirectoryFilter(entry) {
				return this._settings.onlyDirectories && !entry.dirent.isDirectory();
			}
			_isMatchToPatternsSet(filepath, patterns, isDirectory2) {
				if (!this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory2)) return false;
				if (this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory2)) return false;
				if (this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory2)) return false;
				return true;
			}
			_isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory2) {
				if (patternsRe.length === 0) return false;
				const fullpath = utils.path.makeAbsolute(this._settings.cwd, filepath);
				return this._isMatchToPatterns(fullpath, patternsRe, isDirectory2);
			}
			_isMatchToPatterns(filepath, patternsRe, isDirectory2) {
				if (patternsRe.length === 0) return false;
				const isMatched = utils.pattern.matchAny(filepath, patternsRe);
				if (!isMatched && isDirectory2) return utils.pattern.matchAny(filepath + "/", patternsRe);
				return isMatched;
			}
		};
		exports2.default = EntryFilter;
	} });
	var require_error = __commonJS({ "node_modules/fast-glob/out/providers/filters/error.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var utils = require_utils3();
		var ErrorFilter = class {
			constructor(_settings) {
				this._settings = _settings;
			}
			getFilter() {
				return (error) => this._isNonFatalError(error);
			}
			_isNonFatalError(error) {
				return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
			}
		};
		exports2.default = ErrorFilter;
	} });
	var require_entry2 = __commonJS({ "node_modules/fast-glob/out/providers/transformers/entry.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var utils = require_utils3();
		var EntryTransformer = class {
			constructor(_settings) {
				this._settings = _settings;
			}
			getTransformer() {
				return (entry) => this._transform(entry);
			}
			_transform(entry) {
				let filepath = entry.path;
				if (this._settings.absolute) {
					filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
					filepath = utils.path.unixify(filepath);
				}
				if (this._settings.markDirectories && entry.dirent.isDirectory()) filepath += "/";
				if (!this._settings.objectMode) return filepath;
				return Object.assign(Object.assign({}, entry), { path: filepath });
			}
		};
		exports2.default = EntryTransformer;
	} });
	var require_provider = __commonJS({ "node_modules/fast-glob/out/providers/provider.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var path3 = __require("path");
		var deep_1 = require_deep();
		var entry_1 = require_entry();
		var error_1 = require_error();
		var entry_2 = require_entry2();
		var Provider = class {
			constructor(_settings) {
				this._settings = _settings;
				this.errorFilter = new error_1.default(this._settings);
				this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
				this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
				this.entryTransformer = new entry_2.default(this._settings);
			}
			_getRootDirectory(task) {
				return path3.resolve(this._settings.cwd, task.base);
			}
			_getReaderOptions(task) {
				const basePath = task.base === "." ? "" : task.base;
				return {
					basePath,
					pathSegmentSeparator: "/",
					concurrency: this._settings.concurrency,
					deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
					entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
					errorFilter: this.errorFilter.getFilter(),
					followSymbolicLinks: this._settings.followSymbolicLinks,
					fs: this._settings.fs,
					stats: this._settings.stats,
					throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
					transform: this.entryTransformer.getTransformer()
				};
			}
			_getMicromatchOptions() {
				return {
					dot: this._settings.dot,
					matchBase: this._settings.baseNameMatch,
					nobrace: !this._settings.braceExpansion,
					nocase: !this._settings.caseSensitiveMatch,
					noext: !this._settings.extglob,
					noglobstar: !this._settings.globstar,
					posix: true,
					strictSlashes: false
				};
			}
		};
		exports2.default = Provider;
	} });
	var require_async6 = __commonJS({ "node_modules/fast-glob/out/providers/async.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var async_1 = require_async5();
		var provider_1 = require_provider();
		var ProviderAsync = class extends provider_1.default {
			constructor() {
				super(...arguments);
				this._reader = new async_1.default(this._settings);
			}
			read(task) {
				return __async(this, null, function* () {
					const root = this._getRootDirectory(task);
					const options = this._getReaderOptions(task);
					return (yield this.api(root, task, options)).map((entry) => options.transform(entry));
				});
			}
			api(root, task, options) {
				if (task.dynamic) return this._reader.dynamic(root, options);
				return this._reader.static(task.patterns, options);
			}
		};
		exports2.default = ProviderAsync;
	} });
	var require_stream4 = __commonJS({ "node_modules/fast-glob/out/providers/stream.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var stream_1 = __require("stream");
		var stream_2 = require_stream3();
		var provider_1 = require_provider();
		var ProviderStream = class extends provider_1.default {
			constructor() {
				super(...arguments);
				this._reader = new stream_2.default(this._settings);
			}
			read(task) {
				const root = this._getRootDirectory(task);
				const options = this._getReaderOptions(task);
				const source = this.api(root, task, options);
				const destination = new stream_1.Readable({
					objectMode: true,
					read: () => {}
				});
				source.once("error", (error) => destination.emit("error", error)).on("data", (entry) => destination.emit("data", options.transform(entry))).once("end", () => destination.emit("end"));
				destination.once("close", () => source.destroy());
				return destination;
			}
			api(root, task, options) {
				if (task.dynamic) return this._reader.dynamic(root, options);
				return this._reader.static(task.patterns, options);
			}
		};
		exports2.default = ProviderStream;
	} });
	var require_sync5 = __commonJS({ "node_modules/fast-glob/out/readers/sync.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var fsStat = require_out();
		var fsWalk = require_out3();
		var reader_1 = require_reader2();
		var ReaderSync = class extends reader_1.default {
			constructor() {
				super(...arguments);
				this._walkSync = fsWalk.walkSync;
				this._statSync = fsStat.statSync;
			}
			dynamic(root, options) {
				return this._walkSync(root, options);
			}
			static(patterns, options) {
				const entries = [];
				for (const pattern of patterns) {
					const filepath = this._getFullEntryPath(pattern);
					const entry = this._getEntry(filepath, pattern, options);
					if (entry === null || !options.entryFilter(entry)) continue;
					entries.push(entry);
				}
				return entries;
			}
			_getEntry(filepath, pattern, options) {
				try {
					const stats = this._getStat(filepath);
					return this._makeEntry(stats, pattern);
				} catch (error) {
					if (options.errorFilter(error)) return null;
					throw error;
				}
			}
			_getStat(filepath) {
				return this._statSync(filepath, this._fsStatSettings);
			}
		};
		exports2.default = ReaderSync;
	} });
	var require_sync6 = __commonJS({ "node_modules/fast-glob/out/providers/sync.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		var sync_1 = require_sync5();
		var provider_1 = require_provider();
		var ProviderSync = class extends provider_1.default {
			constructor() {
				super(...arguments);
				this._reader = new sync_1.default(this._settings);
			}
			read(task) {
				const root = this._getRootDirectory(task);
				const options = this._getReaderOptions(task);
				return this.api(root, task, options).map(options.transform);
			}
			api(root, task, options) {
				if (task.dynamic) return this._reader.dynamic(root, options);
				return this._reader.static(task.patterns, options);
			}
		};
		exports2.default = ProviderSync;
	} });
	var require_settings4 = __commonJS({ "node_modules/fast-glob/out/settings.js"(exports2) {
		"use strict";
		Object.defineProperty(exports2, "__esModule", { value: true });
		exports2.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
		var fs6 = __require("fs");
		var os = __require("os");
		var CPU_COUNT = Math.max(os.cpus().length, 1);
		exports2.DEFAULT_FILE_SYSTEM_ADAPTER = {
			lstat: fs6.lstat,
			lstatSync: fs6.lstatSync,
			stat: fs6.stat,
			statSync: fs6.statSync,
			readdir: fs6.readdir,
			readdirSync: fs6.readdirSync
		};
		var Settings = class {
			constructor(_options = {}) {
				this._options = _options;
				this.absolute = this._getValue(this._options.absolute, false);
				this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
				this.braceExpansion = this._getValue(this._options.braceExpansion, true);
				this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
				this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
				this.cwd = this._getValue(this._options.cwd, process.cwd());
				this.deep = this._getValue(this._options.deep, Infinity);
				this.dot = this._getValue(this._options.dot, false);
				this.extglob = this._getValue(this._options.extglob, true);
				this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
				this.fs = this._getFileSystemMethods(this._options.fs);
				this.globstar = this._getValue(this._options.globstar, true);
				this.ignore = this._getValue(this._options.ignore, []);
				this.markDirectories = this._getValue(this._options.markDirectories, false);
				this.objectMode = this._getValue(this._options.objectMode, false);
				this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
				this.onlyFiles = this._getValue(this._options.onlyFiles, true);
				this.stats = this._getValue(this._options.stats, false);
				this.suppressErrors = this._getValue(this._options.suppressErrors, false);
				this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
				this.unique = this._getValue(this._options.unique, true);
				if (this.onlyDirectories) this.onlyFiles = false;
				if (this.stats) this.objectMode = true;
				this.ignore = [].concat(this.ignore);
			}
			_getValue(option, value) {
				return option === void 0 ? value : option;
			}
			_getFileSystemMethods(methods = {}) {
				return Object.assign(Object.assign({}, exports2.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
			}
		};
		exports2.default = Settings;
	} });
	var require_out4 = __commonJS({ "node_modules/fast-glob/out/index.js"(exports2, module2) {
		"use strict";
		var taskManager = require_tasks();
		var async_1 = require_async6();
		var stream_1 = require_stream4();
		var sync_1 = require_sync6();
		var settings_1 = require_settings4();
		var utils = require_utils3();
		function FastGlob(source, options) {
			return __async(this, null, function* () {
				assertPatternsInput2(source);
				const works = getWorks(source, async_1.default, options);
				const result = yield Promise.all(works);
				return utils.array.flatten(result);
			});
		}
		(function(FastGlob2) {
			FastGlob2.glob = FastGlob2;
			FastGlob2.globSync = sync;
			FastGlob2.globStream = stream;
			FastGlob2.async = FastGlob2;
			function sync(source, options) {
				assertPatternsInput2(source);
				const works = getWorks(source, sync_1.default, options);
				return utils.array.flatten(works);
			}
			FastGlob2.sync = sync;
			function stream(source, options) {
				assertPatternsInput2(source);
				const works = getWorks(source, stream_1.default, options);
				return utils.stream.merge(works);
			}
			FastGlob2.stream = stream;
			function generateTasks2(source, options) {
				assertPatternsInput2(source);
				const patterns = [].concat(source);
				const settings = new settings_1.default(options);
				return taskManager.generate(patterns, settings);
			}
			FastGlob2.generateTasks = generateTasks2;
			function isDynamicPattern2(source, options) {
				assertPatternsInput2(source);
				const settings = new settings_1.default(options);
				return utils.pattern.isDynamicPattern(source, settings);
			}
			FastGlob2.isDynamicPattern = isDynamicPattern2;
			function escapePath(source) {
				assertPatternsInput2(source);
				return utils.path.escape(source);
			}
			FastGlob2.escapePath = escapePath;
			function convertPathToPattern2(source) {
				assertPatternsInput2(source);
				return utils.path.convertPathToPattern(source);
			}
			FastGlob2.convertPathToPattern = convertPathToPattern2;
			(function(posix2) {
				function escapePath2(source) {
					assertPatternsInput2(source);
					return utils.path.escapePosixPath(source);
				}
				posix2.escapePath = escapePath2;
				function convertPathToPattern3(source) {
					assertPatternsInput2(source);
					return utils.path.convertPosixPathToPattern(source);
				}
				posix2.convertPathToPattern = convertPathToPattern3;
			})(FastGlob2.posix || (FastGlob2.posix = {}));
			(function(win322) {
				function escapePath2(source) {
					assertPatternsInput2(source);
					return utils.path.escapeWindowsPath(source);
				}
				win322.escapePath = escapePath2;
				function convertPathToPattern3(source) {
					assertPatternsInput2(source);
					return utils.path.convertWindowsPathToPattern(source);
				}
				win322.convertPathToPattern = convertPathToPattern3;
			})(FastGlob2.win32 || (FastGlob2.win32 = {}));
		})(FastGlob || (FastGlob = {}));
		function getWorks(source, _Provider, options) {
			const patterns = [].concat(source);
			const settings = new settings_1.default(options);
			const tasks = taskManager.generate(patterns, settings);
			const provider = new _Provider(settings);
			return tasks.map(provider.read, provider);
		}
		function assertPatternsInput2(input) {
			if (![].concat(input).every((item) => utils.string.isString(item) && !utils.string.isEmpty(item))) throw new TypeError("Patterns must be a string (non empty) or an array of strings");
		}
		module2.exports = FastGlob;
	} });
	var require_ignore = __commonJS({ "node_modules/ignore/index.js"(exports2, module2) {
		"use strict";
		function makeArray(subject) {
			return Array.isArray(subject) ? subject : [subject];
		}
		var UNDEFINED = void 0;
		var EMPTY = "";
		var SPACE = " ";
		var ESCAPE = "\\";
		var REGEX_TEST_BLANK_LINE = /^\s+$/;
		var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
		var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
		var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
		var REGEX_SPLITALL_CRLF = /\r?\n/g;
		var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
		var REGEX_TEST_TRAILING_SLASH = /\/$/;
		var SLASH = "/";
		var TMP_KEY_IGNORE = "node-ignore";
		if (typeof Symbol !== "undefined") TMP_KEY_IGNORE = Symbol.for("node-ignore");
		var KEY_IGNORE = TMP_KEY_IGNORE;
		var define = (object, key, value) => {
			Object.defineProperty(object, key, { value });
			return value;
		};
		var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
		var RETURN_FALSE = () => false;
		var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
		var cleanRangeBackSlash = (slashes) => {
			const { length } = slashes;
			return slashes.slice(0, length - length % 2);
		};
		var REPLACERS = [
			[/^\uFEFF/, () => EMPTY],
			[/((?:\\\\)*?)(\\?\s+)$/, (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)],
			[/(\\+?)\s/g, (_, m1) => {
				const { length } = m1;
				return m1.slice(0, length - length % 2) + SPACE;
			}],
			[/[\\$.|*+(){^]/g, (match) => `\\${match}`],
			[/(?!\\)\?/g, () => "[^/]"],
			[/^\//, () => "^"],
			[/\//g, () => "\\/"],
			[/^\^*\\\*\\\*\\\//, () => "^(?:.*\\/)?"],
			[/^(?=[^^])/, function startingReplacer() {
				return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
			}],
			[/\\\/\\\*\\\*(?=\\\/|$)/g, (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"],
			[/(^|[^\\]+)(\\\*)+(?=.+)/g, (_, p1, p2) => {
				return p1 + p2.replace(/\\\*/g, "[^\\/]*");
			}],
			[/\\\\\\(?=[$.|*+(){^])/g, () => ESCAPE],
			[/\\\\/g, () => ESCAPE],
			[/(\\)?\[([^\]/]*?)(\\*)($|\])/g, (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"],
			[/(?:[^*])$/, (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`]
		];
		var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
		var MODE_IGNORE = "regex";
		var MODE_CHECK_IGNORE = "checkRegex";
		var UNDERSCORE = "_";
		var TRAILING_WILD_CARD_REPLACERS = {
			[MODE_IGNORE](_, p1) {
				return `${p1 ? `${p1}[^/]+` : "[^/]*"}(?=$|\\/$)`;
			},
			[MODE_CHECK_IGNORE](_, p1) {
				return `${p1 ? `${p1}[^/]*` : "[^/]*"}(?=$|\\/$)`;
			}
		};
		var makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
		var isString = (subject) => typeof subject === "string";
		var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
		var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
		var IgnoreRule = class {
			constructor(pattern, mark, body, ignoreCase, negative, prefix) {
				this.pattern = pattern;
				this.mark = mark;
				this.negative = negative;
				define(this, "body", body);
				define(this, "ignoreCase", ignoreCase);
				define(this, "regexPrefix", prefix);
			}
			get regex() {
				const key = UNDERSCORE + MODE_IGNORE;
				if (this[key]) return this[key];
				return this._make(MODE_IGNORE, key);
			}
			get checkRegex() {
				const key = UNDERSCORE + MODE_CHECK_IGNORE;
				if (this[key]) return this[key];
				return this._make(MODE_CHECK_IGNORE, key);
			}
			_make(mode, key) {
				const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
				const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
				return define(this, key, regex);
			}
		};
		var createRule = ({ pattern, mark }, ignoreCase) => {
			let negative = false;
			let body = pattern;
			if (body.indexOf("!") === 0) {
				negative = true;
				body = body.substr(1);
			}
			body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
			const regexPrefix = makeRegexPrefix(body);
			return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
		};
		var RuleManager = class {
			constructor(ignoreCase) {
				this._ignoreCase = ignoreCase;
				this._rules = [];
			}
			_add(pattern) {
				if (pattern && pattern[KEY_IGNORE]) {
					this._rules = this._rules.concat(pattern._rules._rules);
					this._added = true;
					return;
				}
				if (isString(pattern)) pattern = { pattern };
				if (checkPattern(pattern.pattern)) {
					const rule = createRule(pattern, this._ignoreCase);
					this._added = true;
					this._rules.push(rule);
				}
			}
			add(pattern) {
				this._added = false;
				makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
				return this._added;
			}
			test(path3, checkUnignored, mode) {
				let ignored = false;
				let unignored = false;
				let matchedRule;
				this._rules.forEach((rule) => {
					const { negative } = rule;
					if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) return;
					if (!rule[mode].test(path3)) return;
					ignored = !negative;
					unignored = negative;
					matchedRule = negative ? UNDEFINED : rule;
				});
				const ret = {
					ignored,
					unignored
				};
				if (matchedRule) ret.rule = matchedRule;
				return ret;
			}
		};
		var throwError = (message, Ctor) => {
			throw new Ctor(message);
		};
		var checkPath = (path3, originalPath, doThrow) => {
			if (!isString(path3)) return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
			if (!path3) return doThrow(`path must not be empty`, TypeError);
			if (checkPath.isNotRelative(path3)) return doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError);
			return true;
		};
		var isNotRelative = (path3) => REGEX_TEST_INVALID_PATH.test(path3);
		checkPath.isNotRelative = isNotRelative;
		checkPath.convert = (p2) => p2;
		var Ignore = class {
			constructor({ ignorecase = true, ignoreCase = ignorecase, allowRelativePaths = false } = {}) {
				define(this, KEY_IGNORE, true);
				this._rules = new RuleManager(ignoreCase);
				this._strictPathCheck = !allowRelativePaths;
				this._initCache();
			}
			_initCache() {
				this._ignoreCache = /* @__PURE__ */ Object.create(null);
				this._testCache = /* @__PURE__ */ Object.create(null);
			}
			add(pattern) {
				if (this._rules.add(pattern)) this._initCache();
				return this;
			}
			addPattern(pattern) {
				return this.add(pattern);
			}
			_test(originalPath, cache, checkUnignored, slices) {
				const path3 = originalPath && checkPath.convert(originalPath);
				checkPath(path3, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
				return this._t(path3, cache, checkUnignored, slices);
			}
			checkIgnore(path3) {
				if (!REGEX_TEST_TRAILING_SLASH.test(path3)) return this.test(path3);
				const slices = path3.split(SLASH).filter(Boolean);
				slices.pop();
				if (slices.length) {
					const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
					if (parent.ignored) return parent;
				}
				return this._rules.test(path3, false, MODE_CHECK_IGNORE);
			}
			_t(path3, cache, checkUnignored, slices) {
				if (path3 in cache) return cache[path3];
				if (!slices) slices = path3.split(SLASH).filter(Boolean);
				slices.pop();
				if (!slices.length) return cache[path3] = this._rules.test(path3, checkUnignored, MODE_IGNORE);
				const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
				return cache[path3] = parent.ignored ? parent : this._rules.test(path3, checkUnignored, MODE_IGNORE);
			}
			ignores(path3) {
				return this._test(path3, this._ignoreCache, false).ignored;
			}
			createFilter() {
				return (path3) => !this.ignores(path3);
			}
			filter(paths) {
				return makeArray(paths).filter(this.createFilter());
			}
			test(path3) {
				return this._test(path3, this._testCache, true);
			}
		};
		var factory = (options) => new Ignore(options);
		var isPathValid = (path3) => checkPath(path3 && checkPath.convert(path3), path3, RETURN_FALSE);
		var setupWindows = () => {
			const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
			checkPath.convert = makePosix;
			const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
			checkPath.isNotRelative = (path3) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path3) || isNotRelative(path3);
		};
		if (typeof process !== "undefined" && process.platform === "win32") setupWindows();
		module2.exports = factory;
		factory.default = factory;
		module2.exports.isPathValid = isPathValid;
		define(module2.exports, Symbol.for("setupWindows"), setupWindows);
	} });
	var require_universalify = __commonJS({ "node_modules/universalify/index.js"(exports2) {
		"use strict";
		exports2.fromCallback = function(fn) {
			return Object.defineProperty(function(...args) {
				if (typeof args[args.length - 1] === "function") fn.apply(this, args);
				else return new Promise((resolve, reject) => {
					args.push((err, res) => err != null ? reject(err) : resolve(res));
					fn.apply(this, args);
				});
			}, "name", { value: fn.name });
		};
		exports2.fromPromise = function(fn) {
			return Object.defineProperty(function(...args) {
				const cb = args[args.length - 1];
				if (typeof cb !== "function") return fn.apply(this, args);
				else {
					args.pop();
					fn.apply(this, args).then((r2) => cb(null, r2), cb);
				}
			}, "name", { value: fn.name });
		};
	} });
	var require_polyfills = __commonJS({ "node_modules/graceful-fs/polyfills.js"(exports2, module2) {
		"use strict";
		var constants = __require("constants");
		var origCwd = process.cwd;
		var cwd = null;
		var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
		process.cwd = function() {
			if (!cwd) cwd = origCwd.call(process);
			return cwd;
		};
		try {
			process.cwd();
		} catch (er) {}
		if (typeof process.chdir === "function") {
			chdir = process.chdir;
			process.chdir = function(d) {
				cwd = null;
				chdir.call(process, d);
			};
			if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
		}
		var chdir;
		module2.exports = patch;
		function patch(fs6) {
			if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) patchLchmod(fs6);
			if (!fs6.lutimes) patchLutimes(fs6);
			fs6.chown = chownFix(fs6.chown);
			fs6.fchown = chownFix(fs6.fchown);
			fs6.lchown = chownFix(fs6.lchown);
			fs6.chmod = chmodFix(fs6.chmod);
			fs6.fchmod = chmodFix(fs6.fchmod);
			fs6.lchmod = chmodFix(fs6.lchmod);
			fs6.chownSync = chownFixSync(fs6.chownSync);
			fs6.fchownSync = chownFixSync(fs6.fchownSync);
			fs6.lchownSync = chownFixSync(fs6.lchownSync);
			fs6.chmodSync = chmodFixSync(fs6.chmodSync);
			fs6.fchmodSync = chmodFixSync(fs6.fchmodSync);
			fs6.lchmodSync = chmodFixSync(fs6.lchmodSync);
			fs6.stat = statFix(fs6.stat);
			fs6.fstat = statFix(fs6.fstat);
			fs6.lstat = statFix(fs6.lstat);
			fs6.statSync = statFixSync(fs6.statSync);
			fs6.fstatSync = statFixSync(fs6.fstatSync);
			fs6.lstatSync = statFixSync(fs6.lstatSync);
			if (fs6.chmod && !fs6.lchmod) {
				fs6.lchmod = function(path3, mode, cb) {
					if (cb) process.nextTick(cb);
				};
				fs6.lchmodSync = function() {};
			}
			if (fs6.chown && !fs6.lchown) {
				fs6.lchown = function(path3, uid, gid, cb) {
					if (cb) process.nextTick(cb);
				};
				fs6.lchownSync = function() {};
			}
			if (platform === "win32") fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : (function(fs$rename) {
				function rename(from, to, cb) {
					var start = Date.now();
					var backoff = 0;
					fs$rename(from, to, function CB(er) {
						if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
							setTimeout(function() {
								fs6.stat(to, function(stater, st2) {
									if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);
									else cb(er);
								});
							}, backoff);
							if (backoff < 100) backoff += 10;
							return;
						}
						if (cb) cb(er);
					});
				}
				if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
				return rename;
			})(fs6.rename);
			fs6.read = typeof fs6.read !== "function" ? fs6.read : (function(fs$read) {
				function read(fd, buffer, offset, length, position, callback_) {
					var callback;
					if (callback_ && typeof callback_ === "function") {
						var eagCounter = 0;
						callback = function(er, _, __) {
							if (er && er.code === "EAGAIN" && eagCounter < 10) {
								eagCounter++;
								return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
							}
							callback_.apply(this, arguments);
						};
					}
					return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
				}
				if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
				return read;
			})(fs6.read);
			fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : /* @__PURE__ */ (function(fs$readSync) {
				return function(fd, buffer, offset, length, position) {
					var eagCounter = 0;
					while (true) try {
						return fs$readSync.call(fs6, fd, buffer, offset, length, position);
					} catch (er) {
						if (er.code === "EAGAIN" && eagCounter < 10) {
							eagCounter++;
							continue;
						}
						throw er;
					}
				};
			})(fs6.readSync);
			function patchLchmod(fs7) {
				fs7.lchmod = function(path3, mode, callback) {
					fs7.open(path3, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
						if (err) {
							if (callback) callback(err);
							return;
						}
						fs7.fchmod(fd, mode, function(err2) {
							fs7.close(fd, function(err22) {
								if (callback) callback(err2 || err22);
							});
						});
					});
				};
				fs7.lchmodSync = function(path3, mode) {
					var fd = fs7.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
					var threw = true;
					var ret;
					try {
						ret = fs7.fchmodSync(fd, mode);
						threw = false;
					} finally {
						if (threw) try {
							fs7.closeSync(fd);
						} catch (er) {}
						else fs7.closeSync(fd);
					}
					return ret;
				};
			}
			function patchLutimes(fs7) {
				if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
					fs7.lutimes = function(path3, at, mt2, cb) {
						fs7.open(path3, constants.O_SYMLINK, function(er, fd) {
							if (er) {
								if (cb) cb(er);
								return;
							}
							fs7.futimes(fd, at, mt2, function(er2) {
								fs7.close(fd, function(er22) {
									if (cb) cb(er2 || er22);
								});
							});
						});
					};
					fs7.lutimesSync = function(path3, at, mt2) {
						var fd = fs7.openSync(path3, constants.O_SYMLINK);
						var ret;
						var threw = true;
						try {
							ret = fs7.futimesSync(fd, at, mt2);
							threw = false;
						} finally {
							if (threw) try {
								fs7.closeSync(fd);
							} catch (er) {}
							else fs7.closeSync(fd);
						}
						return ret;
					};
				} else if (fs7.futimes) {
					fs7.lutimes = function(_a2, _b2, _c, cb) {
						if (cb) process.nextTick(cb);
					};
					fs7.lutimesSync = function() {};
				}
			}
			function chmodFix(orig) {
				if (!orig) return orig;
				return function(target, mode, cb) {
					return orig.call(fs6, target, mode, function(er) {
						if (chownErOk(er)) er = null;
						if (cb) cb.apply(this, arguments);
					});
				};
			}
			function chmodFixSync(orig) {
				if (!orig) return orig;
				return function(target, mode) {
					try {
						return orig.call(fs6, target, mode);
					} catch (er) {
						if (!chownErOk(er)) throw er;
					}
				};
			}
			function chownFix(orig) {
				if (!orig) return orig;
				return function(target, uid, gid, cb) {
					return orig.call(fs6, target, uid, gid, function(er) {
						if (chownErOk(er)) er = null;
						if (cb) cb.apply(this, arguments);
					});
				};
			}
			function chownFixSync(orig) {
				if (!orig) return orig;
				return function(target, uid, gid) {
					try {
						return orig.call(fs6, target, uid, gid);
					} catch (er) {
						if (!chownErOk(er)) throw er;
					}
				};
			}
			function statFix(orig) {
				if (!orig) return orig;
				return function(target, options, cb) {
					if (typeof options === "function") {
						cb = options;
						options = null;
					}
					function callback(er, stats) {
						if (stats) {
							if (stats.uid < 0) stats.uid += 4294967296;
							if (stats.gid < 0) stats.gid += 4294967296;
						}
						if (cb) cb.apply(this, arguments);
					}
					return options ? orig.call(fs6, target, options, callback) : orig.call(fs6, target, callback);
				};
			}
			function statFixSync(orig) {
				if (!orig) return orig;
				return function(target, options) {
					var stats = options ? orig.call(fs6, target, options) : orig.call(fs6, target);
					if (stats) {
						if (stats.uid < 0) stats.uid += 4294967296;
						if (stats.gid < 0) stats.gid += 4294967296;
					}
					return stats;
				};
			}
			function chownErOk(er) {
				if (!er) return true;
				if (er.code === "ENOSYS") return true;
				if (!process.getuid || process.getuid() !== 0) {
					if (er.code === "EINVAL" || er.code === "EPERM") return true;
				}
				return false;
			}
		}
	} });
	var require_legacy_streams = __commonJS({ "node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
		"use strict";
		var Stream = __require("stream").Stream;
		module2.exports = legacy;
		function legacy(fs6) {
			return {
				ReadStream,
				WriteStream
			};
			function ReadStream(path3, options) {
				if (!(this instanceof ReadStream)) return new ReadStream(path3, options);
				Stream.call(this);
				var self2 = this;
				this.path = path3;
				this.fd = null;
				this.readable = true;
				this.paused = false;
				this.flags = "r";
				this.mode = 438;
				this.bufferSize = 64 * 1024;
				options = options || {};
				var keys = Object.keys(options);
				for (var index = 0, length = keys.length; index < length; index++) {
					var key = keys[index];
					this[key] = options[key];
				}
				if (this.encoding) this.setEncoding(this.encoding);
				if (this.start !== void 0) {
					if ("number" !== typeof this.start) throw TypeError("start must be a Number");
					if (this.end === void 0) this.end = Infinity;
					else if ("number" !== typeof this.end) throw TypeError("end must be a Number");
					if (this.start > this.end) throw new Error("start must be <= end");
					this.pos = this.start;
				}
				if (this.fd !== null) {
					process.nextTick(function() {
						self2._read();
					});
					return;
				}
				fs6.open(this.path, this.flags, this.mode, function(err, fd) {
					if (err) {
						self2.emit("error", err);
						self2.readable = false;
						return;
					}
					self2.fd = fd;
					self2.emit("open", fd);
					self2._read();
				});
			}
			function WriteStream(path3, options) {
				if (!(this instanceof WriteStream)) return new WriteStream(path3, options);
				Stream.call(this);
				this.path = path3;
				this.fd = null;
				this.writable = true;
				this.flags = "w";
				this.encoding = "binary";
				this.mode = 438;
				this.bytesWritten = 0;
				options = options || {};
				var keys = Object.keys(options);
				for (var index = 0, length = keys.length; index < length; index++) {
					var key = keys[index];
					this[key] = options[key];
				}
				if (this.start !== void 0) {
					if ("number" !== typeof this.start) throw TypeError("start must be a Number");
					if (this.start < 0) throw new Error("start must be >= zero");
					this.pos = this.start;
				}
				this.busy = false;
				this._queue = [];
				if (this.fd === null) {
					this._open = fs6.open;
					this._queue.push([
						this._open,
						this.path,
						this.flags,
						this.mode,
						void 0
					]);
					this.flush();
				}
			}
		}
	} });
	var require_clone = __commonJS({ "node_modules/graceful-fs/clone.js"(exports2, module2) {
		"use strict";
		module2.exports = clone;
		var getPrototypeOf = Object.getPrototypeOf || function(obj) {
			return obj.__proto__;
		};
		function clone(obj) {
			if (obj === null || typeof obj !== "object") return obj;
			if (obj instanceof Object) var copy = { __proto__: getPrototypeOf(obj) };
			else var copy = /* @__PURE__ */ Object.create(null);
			Object.getOwnPropertyNames(obj).forEach(function(key) {
				Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
			});
			return copy;
		}
	} });
	var require_graceful_fs = __commonJS({ "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
		"use strict";
		var fs6 = __require("fs");
		var polyfills = require_polyfills();
		var legacy = require_legacy_streams();
		var clone = require_clone();
		var util = __require("util");
		var gracefulQueue;
		var previousSymbol;
		if (typeof Symbol === "function" && typeof Symbol.for === "function") {
			gracefulQueue = Symbol.for("graceful-fs.queue");
			previousSymbol = Symbol.for("graceful-fs.previous");
		} else {
			gracefulQueue = "___graceful-fs.queue";
			previousSymbol = "___graceful-fs.previous";
		}
		function noop2() {}
		function publishQueue(context, queue2) {
			Object.defineProperty(context, gracefulQueue, { get: function() {
				return queue2;
			} });
		}
		var debug = noop2;
		if (util.debuglog) debug = util.debuglog("gfs4");
		else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) debug = function() {
			var m2 = util.format.apply(util, arguments);
			m2 = "GFS4: " + m2.split(/\n/).join("\nGFS4: ");
			console.error(m2);
		};
		if (!fs6[gracefulQueue]) {
			queue = global[gracefulQueue] || [];
			publishQueue(fs6, queue);
			fs6.close = (function(fs$close) {
				function close(fd, cb) {
					return fs$close.call(fs6, fd, function(err) {
						if (!err) resetQueue();
						if (typeof cb === "function") cb.apply(this, arguments);
					});
				}
				Object.defineProperty(close, previousSymbol, { value: fs$close });
				return close;
			})(fs6.close);
			fs6.closeSync = (function(fs$closeSync) {
				function closeSync(fd) {
					fs$closeSync.apply(fs6, arguments);
					resetQueue();
				}
				Object.defineProperty(closeSync, previousSymbol, { value: fs$closeSync });
				return closeSync;
			})(fs6.closeSync);
			if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) process.on("exit", function() {
				debug(fs6[gracefulQueue]);
				__require("assert").equal(fs6[gracefulQueue].length, 0);
			});
		}
		var queue;
		if (!global[gracefulQueue]) publishQueue(global, fs6[gracefulQueue]);
		module2.exports = patch(clone(fs6));
		if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs6.__patched) {
			module2.exports = patch(fs6);
			fs6.__patched = true;
		}
		function patch(fs7) {
			polyfills(fs7);
			fs7.gracefulify = patch;
			fs7.createReadStream = createReadStream;
			fs7.createWriteStream = createWriteStream;
			var fs$readFile = fs7.readFile;
			fs7.readFile = readFile;
			function readFile(path3, options, cb) {
				if (typeof options === "function") cb = options, options = null;
				return go$readFile(path3, options, cb);
				function go$readFile(path4, options2, cb2, startTime) {
					return fs$readFile(path4, options2, function(err) {
						if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
							go$readFile,
							[
								path4,
								options2,
								cb2
							],
							err,
							startTime || Date.now(),
							Date.now()
						]);
						else if (typeof cb2 === "function") cb2.apply(this, arguments);
					});
				}
			}
			var fs$writeFile = fs7.writeFile;
			fs7.writeFile = writeFile;
			function writeFile(path3, data, options, cb) {
				if (typeof options === "function") cb = options, options = null;
				return go$writeFile(path3, data, options, cb);
				function go$writeFile(path4, data2, options2, cb2, startTime) {
					return fs$writeFile(path4, data2, options2, function(err) {
						if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
							go$writeFile,
							[
								path4,
								data2,
								options2,
								cb2
							],
							err,
							startTime || Date.now(),
							Date.now()
						]);
						else if (typeof cb2 === "function") cb2.apply(this, arguments);
					});
				}
			}
			var fs$appendFile = fs7.appendFile;
			if (fs$appendFile) fs7.appendFile = appendFile;
			function appendFile(path3, data, options, cb) {
				if (typeof options === "function") cb = options, options = null;
				return go$appendFile(path3, data, options, cb);
				function go$appendFile(path4, data2, options2, cb2, startTime) {
					return fs$appendFile(path4, data2, options2, function(err) {
						if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
							go$appendFile,
							[
								path4,
								data2,
								options2,
								cb2
							],
							err,
							startTime || Date.now(),
							Date.now()
						]);
						else if (typeof cb2 === "function") cb2.apply(this, arguments);
					});
				}
			}
			var fs$copyFile = fs7.copyFile;
			if (fs$copyFile) fs7.copyFile = copyFile;
			function copyFile(src, dest, flags, cb) {
				if (typeof flags === "function") {
					cb = flags;
					flags = 0;
				}
				return go$copyFile(src, dest, flags, cb);
				function go$copyFile(src2, dest2, flags2, cb2, startTime) {
					return fs$copyFile(src2, dest2, flags2, function(err) {
						if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
							go$copyFile,
							[
								src2,
								dest2,
								flags2,
								cb2
							],
							err,
							startTime || Date.now(),
							Date.now()
						]);
						else if (typeof cb2 === "function") cb2.apply(this, arguments);
					});
				}
			}
			var fs$readdir = fs7.readdir;
			fs7.readdir = readdir;
			var noReaddirOptionVersions = /^v[0-5]\./;
			function readdir(path3, options, cb) {
				if (typeof options === "function") cb = options, options = null;
				var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path4, options2, cb2, startTime) {
					return fs$readdir(path4, fs$readdirCallback(path4, options2, cb2, startTime));
				} : function go$readdir2(path4, options2, cb2, startTime) {
					return fs$readdir(path4, options2, fs$readdirCallback(path4, options2, cb2, startTime));
				};
				return go$readdir(path3, options, cb);
				function fs$readdirCallback(path4, options2, cb2, startTime) {
					return function(err, files) {
						if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
							go$readdir,
							[
								path4,
								options2,
								cb2
							],
							err,
							startTime || Date.now(),
							Date.now()
						]);
						else {
							if (files && files.sort) files.sort();
							if (typeof cb2 === "function") cb2.call(this, err, files);
						}
					};
				}
			}
			if (process.version.substr(0, 4) === "v0.8") {
				var legStreams = legacy(fs7);
				ReadStream = legStreams.ReadStream;
				WriteStream = legStreams.WriteStream;
			}
			var fs$ReadStream = fs7.ReadStream;
			if (fs$ReadStream) {
				ReadStream.prototype = Object.create(fs$ReadStream.prototype);
				ReadStream.prototype.open = ReadStream$open;
			}
			var fs$WriteStream = fs7.WriteStream;
			if (fs$WriteStream) {
				WriteStream.prototype = Object.create(fs$WriteStream.prototype);
				WriteStream.prototype.open = WriteStream$open;
			}
			Object.defineProperty(fs7, "ReadStream", {
				get: function() {
					return ReadStream;
				},
				set: function(val) {
					ReadStream = val;
				},
				enumerable: true,
				configurable: true
			});
			Object.defineProperty(fs7, "WriteStream", {
				get: function() {
					return WriteStream;
				},
				set: function(val) {
					WriteStream = val;
				},
				enumerable: true,
				configurable: true
			});
			var FileReadStream = ReadStream;
			Object.defineProperty(fs7, "FileReadStream", {
				get: function() {
					return FileReadStream;
				},
				set: function(val) {
					FileReadStream = val;
				},
				enumerable: true,
				configurable: true
			});
			var FileWriteStream = WriteStream;
			Object.defineProperty(fs7, "FileWriteStream", {
				get: function() {
					return FileWriteStream;
				},
				set: function(val) {
					FileWriteStream = val;
				},
				enumerable: true,
				configurable: true
			});
			function ReadStream(path3, options) {
				if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;
				else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
			}
			function ReadStream$open() {
				var that = this;
				open(that.path, that.flags, that.mode, function(err, fd) {
					if (err) {
						if (that.autoClose) that.destroy();
						that.emit("error", err);
					} else {
						that.fd = fd;
						that.emit("open", fd);
						that.read();
					}
				});
			}
			function WriteStream(path3, options) {
				if (this instanceof WriteStream) return fs$WriteStream.apply(this, arguments), this;
				else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
			}
			function WriteStream$open() {
				var that = this;
				open(that.path, that.flags, that.mode, function(err, fd) {
					if (err) {
						that.destroy();
						that.emit("error", err);
					} else {
						that.fd = fd;
						that.emit("open", fd);
					}
				});
			}
			function createReadStream(path3, options) {
				return new fs7.ReadStream(path3, options);
			}
			function createWriteStream(path3, options) {
				return new fs7.WriteStream(path3, options);
			}
			var fs$open = fs7.open;
			fs7.open = open;
			function open(path3, flags, mode, cb) {
				if (typeof mode === "function") cb = mode, mode = null;
				return go$open(path3, flags, mode, cb);
				function go$open(path4, flags2, mode2, cb2, startTime) {
					return fs$open(path4, flags2, mode2, function(err, fd) {
						if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
							go$open,
							[
								path4,
								flags2,
								mode2,
								cb2
							],
							err,
							startTime || Date.now(),
							Date.now()
						]);
						else if (typeof cb2 === "function") cb2.apply(this, arguments);
					});
				}
			}
			return fs7;
		}
		function enqueue(elem) {
			debug("ENQUEUE", elem[0].name, elem[1]);
			fs6[gracefulQueue].push(elem);
			retry();
		}
		var retryTimer;
		function resetQueue() {
			var now = Date.now();
			for (var i = 0; i < fs6[gracefulQueue].length; ++i) if (fs6[gracefulQueue][i].length > 2) {
				fs6[gracefulQueue][i][3] = now;
				fs6[gracefulQueue][i][4] = now;
			}
			retry();
		}
		function retry() {
			clearTimeout(retryTimer);
			retryTimer = void 0;
			if (fs6[gracefulQueue].length === 0) return;
			var elem = fs6[gracefulQueue].shift();
			var fn = elem[0];
			var args = elem[1];
			var err = elem[2];
			var startTime = elem[3];
			var lastTime = elem[4];
			if (startTime === void 0) {
				debug("RETRY", fn.name, args);
				fn.apply(null, args);
			} else if (Date.now() - startTime >= 6e4) {
				debug("TIMEOUT", fn.name, args);
				var cb = args.pop();
				if (typeof cb === "function") cb.call(null, err);
			} else {
				var sinceAttempt = Date.now() - lastTime;
				var sinceStart = Math.max(lastTime - startTime, 1);
				if (sinceAttempt >= Math.min(sinceStart * 1.2, 100)) {
					debug("RETRY", fn.name, args);
					fn.apply(null, args.concat([startTime]));
				} else fs6[gracefulQueue].push(elem);
			}
			if (retryTimer === void 0) retryTimer = setTimeout(retry, 0);
		}
	} });
	var require_fs5 = __commonJS({ "node_modules/fs-extra/lib/fs/index.js"(exports2) {
		"use strict";
		var u = require_universalify().fromCallback;
		var fs6 = require_graceful_fs();
		var api = [
			"access",
			"appendFile",
			"chmod",
			"chown",
			"close",
			"copyFile",
			"cp",
			"fchmod",
			"fchown",
			"fdatasync",
			"fstat",
			"fsync",
			"ftruncate",
			"futimes",
			"glob",
			"lchmod",
			"lchown",
			"lutimes",
			"link",
			"lstat",
			"mkdir",
			"mkdtemp",
			"open",
			"opendir",
			"readdir",
			"readFile",
			"readlink",
			"realpath",
			"rename",
			"rm",
			"rmdir",
			"stat",
			"statfs",
			"symlink",
			"truncate",
			"unlink",
			"utimes",
			"writeFile"
		].filter((key) => {
			return typeof fs6[key] === "function";
		});
		Object.assign(exports2, fs6);
		api.forEach((method) => {
			exports2[method] = u(fs6[method]);
		});
		exports2.exists = function(filename, callback) {
			if (typeof callback === "function") return fs6.exists(filename, callback);
			return new Promise((resolve) => {
				return fs6.exists(filename, resolve);
			});
		};
		exports2.read = function(fd, buffer, offset, length, position, callback) {
			if (typeof callback === "function") return fs6.read(fd, buffer, offset, length, position, callback);
			return new Promise((resolve, reject) => {
				fs6.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
					if (err) return reject(err);
					resolve({
						bytesRead,
						buffer: buffer2
					});
				});
			});
		};
		exports2.write = function(fd, buffer, ...args) {
			if (typeof args[args.length - 1] === "function") return fs6.write(fd, buffer, ...args);
			return new Promise((resolve, reject) => {
				fs6.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
					if (err) return reject(err);
					resolve({
						bytesWritten,
						buffer: buffer2
					});
				});
			});
		};
		exports2.readv = function(fd, buffers, ...args) {
			if (typeof args[args.length - 1] === "function") return fs6.readv(fd, buffers, ...args);
			return new Promise((resolve, reject) => {
				fs6.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
					if (err) return reject(err);
					resolve({
						bytesRead,
						buffers: buffers2
					});
				});
			});
		};
		exports2.writev = function(fd, buffers, ...args) {
			if (typeof args[args.length - 1] === "function") return fs6.writev(fd, buffers, ...args);
			return new Promise((resolve, reject) => {
				fs6.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
					if (err) return reject(err);
					resolve({
						bytesWritten,
						buffers: buffers2
					});
				});
			});
		};
		if (typeof fs6.realpath.native === "function") exports2.realpath.native = u(fs6.realpath.native);
		else process.emitWarning("fs.realpath.native is not a function. Is fs being monkey-patched?", "Warning", "fs-extra-WARN0003");
	} });
	var require_utils5 = __commonJS({ "node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
		"use strict";
		var path3 = __require("path");
		module2.exports.checkPath = function checkPath(pth) {
			if (process.platform === "win32") {
				if (/[<>:"|?*]/.test(pth.replace(path3.parse(pth).root, ""))) {
					const error = /* @__PURE__ */ new Error(`Path contains invalid characters: ${pth}`);
					error.code = "EINVAL";
					throw error;
				}
			}
		};
	} });
	var require_make_dir = __commonJS({ "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
		"use strict";
		var fs6 = require_fs5();
		var { checkPath } = require_utils5();
		var getMode = (options) => {
			const defaults = { mode: 511 };
			if (typeof options === "number") return options;
			return __spreadValues(__spreadValues({}, defaults), options).mode;
		};
		module2.exports.makeDir = (dir, options) => __async(null, null, function* () {
			checkPath(dir);
			return fs6.mkdir(dir, {
				mode: getMode(options),
				recursive: true
			});
		});
		module2.exports.makeDirSync = (dir, options) => {
			checkPath(dir);
			return fs6.mkdirSync(dir, {
				mode: getMode(options),
				recursive: true
			});
		};
	} });
	var require_mkdirs = __commonJS({ "node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		var { makeDir: _makeDir, makeDirSync } = require_make_dir();
		var makeDir = u(_makeDir);
		module2.exports = {
			mkdirs: makeDir,
			mkdirsSync: makeDirSync,
			mkdirp: makeDir,
			mkdirpSync: makeDirSync,
			ensureDir: makeDir,
			ensureDirSync: makeDirSync
		};
	} });
	var require_path_exists = __commonJS({ "node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		var fs6 = require_fs5();
		function pathExists(path3) {
			return fs6.access(path3).then(() => true).catch(() => false);
		}
		module2.exports = {
			pathExists: u(pathExists),
			pathExistsSync: fs6.existsSync
		};
	} });
	var require_utimes = __commonJS({ "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
		"use strict";
		var fs6 = require_fs5();
		var u = require_universalify().fromPromise;
		function utimesMillis(path3, atime, mtime) {
			return __async(this, null, function* () {
				const fd = yield fs6.open(path3, "r+");
				let closeErr = null;
				try {
					yield fs6.futimes(fd, atime, mtime);
				} finally {
					try {
						yield fs6.close(fd);
					} catch (e) {
						closeErr = e;
					}
				}
				if (closeErr) throw closeErr;
			});
		}
		function utimesMillisSync(path3, atime, mtime) {
			const fd = fs6.openSync(path3, "r+");
			fs6.futimesSync(fd, atime, mtime);
			return fs6.closeSync(fd);
		}
		module2.exports = {
			utimesMillis: u(utimesMillis),
			utimesMillisSync
		};
	} });
	var require_stat = __commonJS({ "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
		"use strict";
		var fs6 = require_fs5();
		var path3 = __require("path");
		var u = require_universalify().fromPromise;
		function getStats(src, dest, opts) {
			const statFunc = opts.dereference ? (file) => fs6.stat(file, { bigint: true }) : (file) => fs6.lstat(file, { bigint: true });
			return Promise.all([statFunc(src), statFunc(dest).catch((err) => {
				if (err.code === "ENOENT") return null;
				throw err;
			})]).then(([srcStat, destStat]) => ({
				srcStat,
				destStat
			}));
		}
		function getStatsSync(src, dest, opts) {
			let destStat;
			const statFunc = opts.dereference ? (file) => fs6.statSync(file, { bigint: true }) : (file) => fs6.lstatSync(file, { bigint: true });
			const srcStat = statFunc(src);
			try {
				destStat = statFunc(dest);
			} catch (err) {
				if (err.code === "ENOENT") return {
					srcStat,
					destStat: null
				};
				throw err;
			}
			return {
				srcStat,
				destStat
			};
		}
		function checkPaths(src, dest, funcName, opts) {
			return __async(this, null, function* () {
				const { srcStat, destStat } = yield getStats(src, dest, opts);
				if (destStat) {
					if (areIdentical(srcStat, destStat)) {
						const srcBaseName = path3.basename(src);
						const destBaseName = path3.basename(dest);
						if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) return {
							srcStat,
							destStat,
							isChangingCase: true
						};
						throw new Error("Source and destination must not be the same.");
					}
					if (srcStat.isDirectory() && !destStat.isDirectory()) throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
					if (!srcStat.isDirectory() && destStat.isDirectory()) throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
				}
				if (srcStat.isDirectory() && isSrcSubdir(src, dest)) throw new Error(errMsg(src, dest, funcName));
				return {
					srcStat,
					destStat
				};
			});
		}
		function checkPathsSync(src, dest, funcName, opts) {
			const { srcStat, destStat } = getStatsSync(src, dest, opts);
			if (destStat) {
				if (areIdentical(srcStat, destStat)) {
					const srcBaseName = path3.basename(src);
					const destBaseName = path3.basename(dest);
					if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) return {
						srcStat,
						destStat,
						isChangingCase: true
					};
					throw new Error("Source and destination must not be the same.");
				}
				if (srcStat.isDirectory() && !destStat.isDirectory()) throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
				if (!srcStat.isDirectory() && destStat.isDirectory()) throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
			}
			if (srcStat.isDirectory() && isSrcSubdir(src, dest)) throw new Error(errMsg(src, dest, funcName));
			return {
				srcStat,
				destStat
			};
		}
		function checkParentPaths(src, srcStat, dest, funcName) {
			return __async(this, null, function* () {
				const srcParent = path3.resolve(path3.dirname(src));
				const destParent = path3.resolve(path3.dirname(dest));
				if (destParent === srcParent || destParent === path3.parse(destParent).root) return;
				let destStat;
				try {
					destStat = yield fs6.stat(destParent, { bigint: true });
				} catch (err) {
					if (err.code === "ENOENT") return;
					throw err;
				}
				if (areIdentical(srcStat, destStat)) throw new Error(errMsg(src, dest, funcName));
				return checkParentPaths(src, srcStat, destParent, funcName);
			});
		}
		function checkParentPathsSync(src, srcStat, dest, funcName) {
			const srcParent = path3.resolve(path3.dirname(src));
			const destParent = path3.resolve(path3.dirname(dest));
			if (destParent === srcParent || destParent === path3.parse(destParent).root) return;
			let destStat;
			try {
				destStat = fs6.statSync(destParent, { bigint: true });
			} catch (err) {
				if (err.code === "ENOENT") return;
				throw err;
			}
			if (areIdentical(srcStat, destStat)) throw new Error(errMsg(src, dest, funcName));
			return checkParentPathsSync(src, srcStat, destParent, funcName);
		}
		function areIdentical(srcStat, destStat) {
			return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
		}
		function isSrcSubdir(src, dest) {
			const srcArr = path3.resolve(src).split(path3.sep).filter((i) => i);
			const destArr = path3.resolve(dest).split(path3.sep).filter((i) => i);
			return srcArr.every((cur, i) => destArr[i] === cur);
		}
		function errMsg(src, dest, funcName) {
			return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
		}
		module2.exports = {
			checkPaths: u(checkPaths),
			checkPathsSync,
			checkParentPaths: u(checkParentPaths),
			checkParentPathsSync,
			isSrcSubdir,
			areIdentical
		};
	} });
	var require_async7 = __commonJS({ "node_modules/fs-extra/lib/util/async.js"(exports2, module2) {
		"use strict";
		function asyncIteratorConcurrentProcess(iterator, fn) {
			return __async(this, null, function* () {
				const promises = [];
				try {
					for (var iter = __forAwait(iterator), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
						const item = temp.value;
						promises.push(fn(item).then(() => null, (err) => err != null ? err : /* @__PURE__ */ new Error("unknown error")));
					}
				} catch (temp) {
					error = [temp];
				} finally {
					try {
						more && (temp = iter.return) && (yield temp.call(iter));
					} finally {
						if (error) throw error[0];
					}
				}
				yield Promise.all(promises.map((promise) => promise.then((possibleErr) => {
					if (possibleErr !== null) throw possibleErr;
				})));
			});
		}
		module2.exports = { asyncIteratorConcurrentProcess };
	} });
	var require_copy = __commonJS({ "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
		"use strict";
		var fs6 = require_fs5();
		var path3 = __require("path");
		var { mkdirs } = require_mkdirs();
		var { pathExists } = require_path_exists();
		var { utimesMillis } = require_utimes();
		var stat = require_stat();
		var { asyncIteratorConcurrentProcess } = require_async7();
		function copy(_0, _1) {
			return __async(this, arguments, function* (src, dest, opts = {}) {
				if (typeof opts === "function") opts = { filter: opts };
				opts.clobber = "clobber" in opts ? !!opts.clobber : true;
				opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
				if (opts.preserveTimestamps && process.arch === "ia32") process.emitWarning("Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0001");
				const { srcStat, destStat } = yield stat.checkPaths(src, dest, "copy", opts);
				yield stat.checkParentPaths(src, srcStat, dest, "copy");
				if (!(yield runFilter(src, dest, opts))) return;
				const destParent = path3.dirname(dest);
				if (!(yield pathExists(destParent))) yield mkdirs(destParent);
				yield getStatsAndPerformCopy(destStat, src, dest, opts);
			});
		}
		function runFilter(src, dest, opts) {
			return __async(this, null, function* () {
				if (!opts.filter) return true;
				return opts.filter(src, dest);
			});
		}
		function getStatsAndPerformCopy(destStat, src, dest, opts) {
			return __async(this, null, function* () {
				const srcStat = yield (opts.dereference ? fs6.stat : fs6.lstat)(src);
				if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
				if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
				if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
				if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
				if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
				throw new Error(`Unknown file: ${src}`);
			});
		}
		function onFile(srcStat, destStat, src, dest, opts) {
			return __async(this, null, function* () {
				if (!destStat) return copyFile(srcStat, src, dest, opts);
				if (opts.overwrite) {
					yield fs6.unlink(dest);
					return copyFile(srcStat, src, dest, opts);
				}
				if (opts.errorOnExist) throw new Error(`'${dest}' already exists`);
			});
		}
		function copyFile(srcStat, src, dest, opts) {
			return __async(this, null, function* () {
				yield fs6.copyFile(src, dest);
				if (opts.preserveTimestamps) {
					if (fileIsNotWritable(srcStat.mode)) yield makeFileWritable(dest, srcStat.mode);
					const updatedSrcStat = yield fs6.stat(src);
					yield utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
				}
				return fs6.chmod(dest, srcStat.mode);
			});
		}
		function fileIsNotWritable(srcMode) {
			return (srcMode & 128) === 0;
		}
		function makeFileWritable(dest, srcMode) {
			return fs6.chmod(dest, srcMode | 128);
		}
		function onDir(srcStat, destStat, src, dest, opts) {
			return __async(this, null, function* () {
				if (!destStat) yield fs6.mkdir(dest);
				yield asyncIteratorConcurrentProcess(yield fs6.opendir(src), (item) => __async(null, null, function* () {
					const srcItem = path3.join(src, item.name);
					const destItem = path3.join(dest, item.name);
					if (yield runFilter(srcItem, destItem, opts)) {
						const { destStat: destStat2 } = yield stat.checkPaths(srcItem, destItem, "copy", opts);
						yield getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
					}
				}));
				if (!destStat) yield fs6.chmod(dest, srcStat.mode);
			});
		}
		function onLink(destStat, src, dest, opts) {
			return __async(this, null, function* () {
				let resolvedSrc = yield fs6.readlink(src);
				if (opts.dereference) resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
				if (!destStat) return fs6.symlink(resolvedSrc, dest);
				let resolvedDest = null;
				try {
					resolvedDest = yield fs6.readlink(dest);
				} catch (e) {
					if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs6.symlink(resolvedSrc, dest);
					throw e;
				}
				if (opts.dereference) resolvedDest = path3.resolve(process.cwd(), resolvedDest);
				if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
				if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
				yield fs6.unlink(dest);
				return fs6.symlink(resolvedSrc, dest);
			});
		}
		module2.exports = copy;
	} });
	var require_copy_sync = __commonJS({ "node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
		"use strict";
		var fs6 = require_graceful_fs();
		var path3 = __require("path");
		var mkdirsSync = require_mkdirs().mkdirsSync;
		var utimesMillisSync = require_utimes().utimesMillisSync;
		var stat = require_stat();
		function copySync(src, dest, opts) {
			if (typeof opts === "function") opts = { filter: opts };
			opts = opts || {};
			opts.clobber = "clobber" in opts ? !!opts.clobber : true;
			opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
			if (opts.preserveTimestamps && process.arch === "ia32") process.emitWarning("Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0002");
			const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
			stat.checkParentPathsSync(src, srcStat, dest, "copy");
			if (opts.filter && !opts.filter(src, dest)) return;
			const destParent = path3.dirname(dest);
			if (!fs6.existsSync(destParent)) mkdirsSync(destParent);
			return getStats(destStat, src, dest, opts);
		}
		function getStats(destStat, src, dest, opts) {
			const srcStat = (opts.dereference ? fs6.statSync : fs6.lstatSync)(src);
			if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
			else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
			else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
			else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
			else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
			throw new Error(`Unknown file: ${src}`);
		}
		function onFile(srcStat, destStat, src, dest, opts) {
			if (!destStat) return copyFile(srcStat, src, dest, opts);
			return mayCopyFile(srcStat, src, dest, opts);
		}
		function mayCopyFile(srcStat, src, dest, opts) {
			if (opts.overwrite) {
				fs6.unlinkSync(dest);
				return copyFile(srcStat, src, dest, opts);
			} else if (opts.errorOnExist) throw new Error(`'${dest}' already exists`);
		}
		function copyFile(srcStat, src, dest, opts) {
			fs6.copyFileSync(src, dest);
			if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
			return setDestMode(dest, srcStat.mode);
		}
		function handleTimestamps(srcMode, src, dest) {
			if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
			return setDestTimestamps(src, dest);
		}
		function fileIsNotWritable(srcMode) {
			return (srcMode & 128) === 0;
		}
		function makeFileWritable(dest, srcMode) {
			return setDestMode(dest, srcMode | 128);
		}
		function setDestMode(dest, srcMode) {
			return fs6.chmodSync(dest, srcMode);
		}
		function setDestTimestamps(src, dest) {
			const updatedSrcStat = fs6.statSync(src);
			return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
		}
		function onDir(srcStat, destStat, src, dest, opts) {
			if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
			return copyDir(src, dest, opts);
		}
		function mkDirAndCopy(srcMode, src, dest, opts) {
			fs6.mkdirSync(dest);
			copyDir(src, dest, opts);
			return setDestMode(dest, srcMode);
		}
		function copyDir(src, dest, opts) {
			const dir = fs6.opendirSync(src);
			try {
				let dirent;
				while ((dirent = dir.readSync()) !== null) copyDirItem(dirent.name, src, dest, opts);
			} finally {
				dir.closeSync();
			}
		}
		function copyDirItem(item, src, dest, opts) {
			const srcItem = path3.join(src, item);
			const destItem = path3.join(dest, item);
			if (opts.filter && !opts.filter(srcItem, destItem)) return;
			const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
			return getStats(destStat, srcItem, destItem, opts);
		}
		function onLink(destStat, src, dest, opts) {
			let resolvedSrc = fs6.readlinkSync(src);
			if (opts.dereference) resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
			if (!destStat) return fs6.symlinkSync(resolvedSrc, dest);
			else {
				let resolvedDest;
				try {
					resolvedDest = fs6.readlinkSync(dest);
				} catch (err) {
					if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs6.symlinkSync(resolvedSrc, dest);
					throw err;
				}
				if (opts.dereference) resolvedDest = path3.resolve(process.cwd(), resolvedDest);
				if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
				if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
				return copyLink(resolvedSrc, dest);
			}
		}
		function copyLink(resolvedSrc, dest) {
			fs6.unlinkSync(dest);
			return fs6.symlinkSync(resolvedSrc, dest);
		}
		module2.exports = copySync;
	} });
	var require_copy2 = __commonJS({ "node_modules/fs-extra/lib/copy/index.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		module2.exports = {
			copy: u(require_copy()),
			copySync: require_copy_sync()
		};
	} });
	var require_remove = __commonJS({ "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
		"use strict";
		var fs6 = require_graceful_fs();
		var u = require_universalify().fromCallback;
		function remove(path3, callback) {
			fs6.rm(path3, {
				recursive: true,
				force: true
			}, callback);
		}
		function removeSync(path3) {
			fs6.rmSync(path3, {
				recursive: true,
				force: true
			});
		}
		module2.exports = {
			remove: u(remove),
			removeSync
		};
	} });
	var require_empty = __commonJS({ "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		var fs6 = require_fs5();
		var path3 = __require("path");
		var mkdir = require_mkdirs();
		var remove = require_remove();
		var emptyDir = u(function emptyDir2(dir) {
			return __async(this, null, function* () {
				let items;
				try {
					items = yield fs6.readdir(dir);
				} catch (e) {
					return mkdir.mkdirs(dir);
				}
				return Promise.all(items.map((item) => remove.remove(path3.join(dir, item))));
			});
		});
		function emptyDirSync(dir) {
			let items;
			try {
				items = fs6.readdirSync(dir);
			} catch (e) {
				return mkdir.mkdirsSync(dir);
			}
			items.forEach((item) => {
				item = path3.join(dir, item);
				remove.removeSync(item);
			});
		}
		module2.exports = {
			emptyDirSync,
			emptydirSync: emptyDirSync,
			emptyDir,
			emptydir: emptyDir
		};
	} });
	var require_file = __commonJS({ "node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		var path3 = __require("path");
		var fs6 = require_fs5();
		var mkdir = require_mkdirs();
		function createFile(file) {
			return __async(this, null, function* () {
				let stats;
				try {
					stats = yield fs6.stat(file);
				} catch (e) {}
				if (stats && stats.isFile()) return;
				const dir = path3.dirname(file);
				let dirStats = null;
				try {
					dirStats = yield fs6.stat(dir);
				} catch (err) {
					if (err.code === "ENOENT") {
						yield mkdir.mkdirs(dir);
						yield fs6.writeFile(file, "");
						return;
					} else throw err;
				}
				if (dirStats.isDirectory()) yield fs6.writeFile(file, "");
				else yield fs6.readdir(dir);
			});
		}
		function createFileSync(file) {
			let stats;
			try {
				stats = fs6.statSync(file);
			} catch (e) {}
			if (stats && stats.isFile()) return;
			const dir = path3.dirname(file);
			try {
				if (!fs6.statSync(dir).isDirectory()) fs6.readdirSync(dir);
			} catch (err) {
				if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
				else throw err;
			}
			fs6.writeFileSync(file, "");
		}
		module2.exports = {
			createFile: u(createFile),
			createFileSync
		};
	} });
	var require_link = __commonJS({ "node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		var path3 = __require("path");
		var fs6 = require_fs5();
		var mkdir = require_mkdirs();
		var { pathExists } = require_path_exists();
		var { areIdentical } = require_stat();
		function createLink(srcpath, dstpath) {
			return __async(this, null, function* () {
				let dstStat;
				try {
					dstStat = yield fs6.lstat(dstpath);
				} catch (e) {}
				let srcStat;
				try {
					srcStat = yield fs6.lstat(srcpath);
				} catch (err) {
					err.message = err.message.replace("lstat", "ensureLink");
					throw err;
				}
				if (dstStat && areIdentical(srcStat, dstStat)) return;
				const dir = path3.dirname(dstpath);
				if (!(yield pathExists(dir))) yield mkdir.mkdirs(dir);
				yield fs6.link(srcpath, dstpath);
			});
		}
		function createLinkSync(srcpath, dstpath) {
			let dstStat;
			try {
				dstStat = fs6.lstatSync(dstpath);
			} catch (e) {}
			try {
				const srcStat = fs6.lstatSync(srcpath);
				if (dstStat && areIdentical(srcStat, dstStat)) return;
			} catch (err) {
				err.message = err.message.replace("lstat", "ensureLink");
				throw err;
			}
			const dir = path3.dirname(dstpath);
			if (fs6.existsSync(dir)) return fs6.linkSync(srcpath, dstpath);
			mkdir.mkdirsSync(dir);
			return fs6.linkSync(srcpath, dstpath);
		}
		module2.exports = {
			createLink: u(createLink),
			createLinkSync
		};
	} });
	var require_symlink_paths = __commonJS({ "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
		"use strict";
		var path3 = __require("path");
		var fs6 = require_fs5();
		var { pathExists } = require_path_exists();
		var u = require_universalify().fromPromise;
		function symlinkPaths(srcpath, dstpath) {
			return __async(this, null, function* () {
				if (path3.isAbsolute(srcpath)) {
					try {
						yield fs6.lstat(srcpath);
					} catch (err) {
						err.message = err.message.replace("lstat", "ensureSymlink");
						throw err;
					}
					return {
						toCwd: srcpath,
						toDst: srcpath
					};
				}
				const dstdir = path3.dirname(dstpath);
				const relativeToDst = path3.join(dstdir, srcpath);
				if (yield pathExists(relativeToDst)) return {
					toCwd: relativeToDst,
					toDst: srcpath
				};
				try {
					yield fs6.lstat(srcpath);
				} catch (err) {
					err.message = err.message.replace("lstat", "ensureSymlink");
					throw err;
				}
				return {
					toCwd: srcpath,
					toDst: path3.relative(dstdir, srcpath)
				};
			});
		}
		function symlinkPathsSync(srcpath, dstpath) {
			if (path3.isAbsolute(srcpath)) {
				if (!fs6.existsSync(srcpath)) throw new Error("absolute srcpath does not exist");
				return {
					toCwd: srcpath,
					toDst: srcpath
				};
			}
			const dstdir = path3.dirname(dstpath);
			const relativeToDst = path3.join(dstdir, srcpath);
			if (fs6.existsSync(relativeToDst)) return {
				toCwd: relativeToDst,
				toDst: srcpath
			};
			if (!fs6.existsSync(srcpath)) throw new Error("relative srcpath does not exist");
			return {
				toCwd: srcpath,
				toDst: path3.relative(dstdir, srcpath)
			};
		}
		module2.exports = {
			symlinkPaths: u(symlinkPaths),
			symlinkPathsSync
		};
	} });
	var require_symlink_type = __commonJS({ "node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
		"use strict";
		var fs6 = require_fs5();
		var u = require_universalify().fromPromise;
		function symlinkType(srcpath, type) {
			return __async(this, null, function* () {
				if (type) return type;
				let stats;
				try {
					stats = yield fs6.lstat(srcpath);
				} catch (e) {
					return "file";
				}
				return stats && stats.isDirectory() ? "dir" : "file";
			});
		}
		function symlinkTypeSync(srcpath, type) {
			if (type) return type;
			let stats;
			try {
				stats = fs6.lstatSync(srcpath);
			} catch (e) {
				return "file";
			}
			return stats && stats.isDirectory() ? "dir" : "file";
		}
		module2.exports = {
			symlinkType: u(symlinkType),
			symlinkTypeSync
		};
	} });
	var require_symlink = __commonJS({ "node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		var path3 = __require("path");
		var fs6 = require_fs5();
		var { mkdirs, mkdirsSync } = require_mkdirs();
		var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
		var { symlinkType, symlinkTypeSync } = require_symlink_type();
		var { pathExists } = require_path_exists();
		var { areIdentical } = require_stat();
		function createSymlink(srcpath, dstpath, type) {
			return __async(this, null, function* () {
				let stats;
				try {
					stats = yield fs6.lstat(dstpath);
				} catch (e) {}
				if (stats && stats.isSymbolicLink()) {
					const [srcStat, dstStat] = yield Promise.all([fs6.stat(srcpath), fs6.stat(dstpath)]);
					if (areIdentical(srcStat, dstStat)) return;
				}
				const relative = yield symlinkPaths(srcpath, dstpath);
				srcpath = relative.toDst;
				const toType = yield symlinkType(relative.toCwd, type);
				const dir = path3.dirname(dstpath);
				if (!(yield pathExists(dir))) yield mkdirs(dir);
				return fs6.symlink(srcpath, dstpath, toType);
			});
		}
		function createSymlinkSync(srcpath, dstpath, type) {
			let stats;
			try {
				stats = fs6.lstatSync(dstpath);
			} catch (e) {}
			if (stats && stats.isSymbolicLink()) {
				if (areIdentical(fs6.statSync(srcpath), fs6.statSync(dstpath))) return;
			}
			const relative = symlinkPathsSync(srcpath, dstpath);
			srcpath = relative.toDst;
			type = symlinkTypeSync(relative.toCwd, type);
			const dir = path3.dirname(dstpath);
			if (fs6.existsSync(dir)) return fs6.symlinkSync(srcpath, dstpath, type);
			mkdirsSync(dir);
			return fs6.symlinkSync(srcpath, dstpath, type);
		}
		module2.exports = {
			createSymlink: u(createSymlink),
			createSymlinkSync
		};
	} });
	var require_ensure = __commonJS({ "node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) {
		"use strict";
		var { createFile, createFileSync } = require_file();
		var { createLink, createLinkSync } = require_link();
		var { createSymlink, createSymlinkSync } = require_symlink();
		module2.exports = {
			createFile,
			createFileSync,
			ensureFile: createFile,
			ensureFileSync: createFileSync,
			createLink,
			createLinkSync,
			ensureLink: createLink,
			ensureLinkSync: createLinkSync,
			createSymlink,
			createSymlinkSync,
			ensureSymlink: createSymlink,
			ensureSymlinkSync: createSymlinkSync
		};
	} });
	var require_utils6 = __commonJS({ "node_modules/jsonfile/utils.js"(exports2, module2) {
		"use strict";
		function stringify5(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
			const EOF = finalEOL ? EOL : "";
			return JSON.stringify(obj, replacer, spaces).replace(/\n/g, EOL) + EOF;
		}
		function stripBom(content) {
			if (Buffer.isBuffer(content)) content = content.toString("utf8");
			return content.replace(/^\uFEFF/, "");
		}
		module2.exports = {
			stringify: stringify5,
			stripBom
		};
	} });
	var require_jsonfile = __commonJS({ "node_modules/jsonfile/index.js"(exports2, module2) {
		"use strict";
		var _fs2;
		try {
			_fs2 = require_graceful_fs();
		} catch (_) {
			_fs2 = __require("fs");
		}
		var universalify = require_universalify();
		var { stringify: stringify5, stripBom } = require_utils6();
		function _readFile(_0) {
			return __async(this, arguments, function* (file, options = {}) {
				if (typeof options === "string") options = { encoding: options };
				const fs6 = options.fs || _fs2;
				const shouldThrow = "throws" in options ? options.throws : true;
				let data = yield universalify.fromCallback(fs6.readFile)(file, options);
				data = stripBom(data);
				let obj;
				try {
					obj = JSON.parse(data, options ? options.reviver : null);
				} catch (err) {
					if (shouldThrow) {
						err.message = `${file}: ${err.message}`;
						throw err;
					} else return null;
				}
				return obj;
			});
		}
		var readFile = universalify.fromPromise(_readFile);
		function readFileSync(file, options = {}) {
			if (typeof options === "string") options = { encoding: options };
			const fs6 = options.fs || _fs2;
			const shouldThrow = "throws" in options ? options.throws : true;
			try {
				let content = fs6.readFileSync(file, options);
				content = stripBom(content);
				return JSON.parse(content, options.reviver);
			} catch (err) {
				if (shouldThrow) {
					err.message = `${file}: ${err.message}`;
					throw err;
				} else return null;
			}
		}
		function _writeFile(_0, _1) {
			return __async(this, arguments, function* (file, obj, options = {}) {
				const fs6 = options.fs || _fs2;
				const str = stringify5(obj, options);
				yield universalify.fromCallback(fs6.writeFile)(file, str, options);
			});
		}
		var writeFile = universalify.fromPromise(_writeFile);
		function writeFileSync(file, obj, options = {}) {
			const fs6 = options.fs || _fs2;
			const str = stringify5(obj, options);
			return fs6.writeFileSync(file, str, options);
		}
		module2.exports = {
			readFile,
			readFileSync,
			writeFile,
			writeFileSync
		};
	} });
	var require_jsonfile2 = __commonJS({ "node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) {
		"use strict";
		var jsonFile = require_jsonfile();
		module2.exports = {
			readJson: jsonFile.readFile,
			readJsonSync: jsonFile.readFileSync,
			writeJson: jsonFile.writeFile,
			writeJsonSync: jsonFile.writeFileSync
		};
	} });
	var require_output_file = __commonJS({ "node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		var fs6 = require_fs5();
		var path3 = __require("path");
		var mkdir = require_mkdirs();
		var pathExists = require_path_exists().pathExists;
		function outputFile(file, data, encoding = "utf-8") {
			return __async(this, null, function* () {
				const dir = path3.dirname(file);
				if (!(yield pathExists(dir))) yield mkdir.mkdirs(dir);
				return fs6.writeFile(file, data, encoding);
			});
		}
		function outputFileSync(file, ...args) {
			const dir = path3.dirname(file);
			if (!fs6.existsSync(dir)) mkdir.mkdirsSync(dir);
			fs6.writeFileSync(file, ...args);
		}
		module2.exports = {
			outputFile: u(outputFile),
			outputFileSync
		};
	} });
	var require_output_json = __commonJS({ "node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) {
		"use strict";
		var { stringify: stringify5 } = require_utils6();
		var { outputFile } = require_output_file();
		function outputJson(_0, _1) {
			return __async(this, arguments, function* (file, data, options = {}) {
				yield outputFile(file, stringify5(data, options), options);
			});
		}
		module2.exports = outputJson;
	} });
	var require_output_json_sync = __commonJS({ "node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) {
		"use strict";
		var { stringify: stringify5 } = require_utils6();
		var { outputFileSync } = require_output_file();
		function outputJsonSync(file, data, options) {
			outputFileSync(file, stringify5(data, options), options);
		}
		module2.exports = outputJsonSync;
	} });
	var require_json = __commonJS({ "node_modules/fs-extra/lib/json/index.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		var jsonFile = require_jsonfile2();
		jsonFile.outputJson = u(require_output_json());
		jsonFile.outputJsonSync = require_output_json_sync();
		jsonFile.outputJSON = jsonFile.outputJson;
		jsonFile.outputJSONSync = jsonFile.outputJsonSync;
		jsonFile.writeJSON = jsonFile.writeJson;
		jsonFile.writeJSONSync = jsonFile.writeJsonSync;
		jsonFile.readJSON = jsonFile.readJson;
		jsonFile.readJSONSync = jsonFile.readJsonSync;
		module2.exports = jsonFile;
	} });
	var require_move = __commonJS({ "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
		"use strict";
		var fs6 = require_fs5();
		var path3 = __require("path");
		var { copy } = require_copy2();
		var { remove } = require_remove();
		var { mkdirp } = require_mkdirs();
		var { pathExists } = require_path_exists();
		var stat = require_stat();
		function move(_0, _1) {
			return __async(this, arguments, function* (src, dest, opts = {}) {
				const overwrite = opts.overwrite || opts.clobber || false;
				const { srcStat, isChangingCase = false } = yield stat.checkPaths(src, dest, "move", opts);
				yield stat.checkParentPaths(src, srcStat, dest, "move");
				const destParent = path3.dirname(dest);
				if (path3.parse(destParent).root !== destParent) yield mkdirp(destParent);
				return doRename(src, dest, overwrite, isChangingCase);
			});
		}
		function doRename(src, dest, overwrite, isChangingCase) {
			return __async(this, null, function* () {
				if (!isChangingCase) {
					if (overwrite) yield remove(dest);
					else if (yield pathExists(dest)) throw new Error("dest already exists.");
				}
				try {
					yield fs6.rename(src, dest);
				} catch (err) {
					if (err.code !== "EXDEV") throw err;
					yield moveAcrossDevice(src, dest, overwrite);
				}
			});
		}
		function moveAcrossDevice(src, dest, overwrite) {
			return __async(this, null, function* () {
				yield copy(src, dest, {
					overwrite,
					errorOnExist: true,
					preserveTimestamps: true
				});
				return remove(src);
			});
		}
		module2.exports = move;
	} });
	var require_move_sync = __commonJS({ "node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
		"use strict";
		var fs6 = require_graceful_fs();
		var path3 = __require("path");
		var copySync = require_copy2().copySync;
		var removeSync = require_remove().removeSync;
		var mkdirpSync = require_mkdirs().mkdirpSync;
		var stat = require_stat();
		function moveSync(src, dest, opts) {
			opts = opts || {};
			const overwrite = opts.overwrite || opts.clobber || false;
			const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
			stat.checkParentPathsSync(src, srcStat, dest, "move");
			if (!isParentRoot(dest)) mkdirpSync(path3.dirname(dest));
			return doRename(src, dest, overwrite, isChangingCase);
		}
		function isParentRoot(dest) {
			const parent = path3.dirname(dest);
			return path3.parse(parent).root === parent;
		}
		function doRename(src, dest, overwrite, isChangingCase) {
			if (isChangingCase) return rename(src, dest, overwrite);
			if (overwrite) {
				removeSync(dest);
				return rename(src, dest, overwrite);
			}
			if (fs6.existsSync(dest)) throw new Error("dest already exists.");
			return rename(src, dest, overwrite);
		}
		function rename(src, dest, overwrite) {
			try {
				fs6.renameSync(src, dest);
			} catch (err) {
				if (err.code !== "EXDEV") throw err;
				return moveAcrossDevice(src, dest, overwrite);
			}
		}
		function moveAcrossDevice(src, dest, overwrite) {
			copySync(src, dest, {
				overwrite,
				errorOnExist: true,
				preserveTimestamps: true
			});
			return removeSync(src);
		}
		module2.exports = moveSync;
	} });
	var require_move2 = __commonJS({ "node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
		"use strict";
		var u = require_universalify().fromPromise;
		module2.exports = {
			move: u(require_move()),
			moveSync: require_move_sync()
		};
	} });
	var require_lib = __commonJS({ "node_modules/fs-extra/lib/index.js"(exports2, module2) {
		"use strict";
		module2.exports = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, require_fs5()), require_copy2()), require_empty()), require_ensure()), require_json()), require_mkdirs()), require_move2()), require_output_file()), require_path_exists()), require_remove());
	} });
	var require_create_require = __commonJS({ "node_modules/create-require/create-require.js"(exports2, module2) {
		"use strict";
		var nativeModule = __require("module");
		var path3 = __require("path");
		var fs6 = __require("fs");
		function createRequire2(filename) {
			if (!filename) filename = process.cwd();
			if (isDir(filename)) filename = path3.join(filename, "index.js");
			if (nativeModule.createRequire) return nativeModule.createRequire(filename);
			if (nativeModule.createRequireFromPath) return nativeModule.createRequireFromPath(filename);
			return _createRequire2(filename);
		}
		function _createRequire2(filename) {
			const mod = new nativeModule.Module(filename, null);
			mod.filename = filename;
			mod.paths = nativeModule.Module._nodeModulePaths(path3.dirname(filename));
			mod._compile("module.exports = require;", filename);
			return mod.exports;
		}
		function isDir(path4) {
			try {
				return fs6.lstatSync(path4).isDirectory();
			} catch (e) {
				return false;
			}
		}
		module2.exports = createRequire2;
	} });
	function f(e) {
		return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
	}
	var t, o, n;
	var init_node_fetch_native_DfbY2q_x = __esm({ "node_modules/node-fetch-native/dist/shared/node-fetch-native.DfbY2q-x.mjs"() {
		"use strict";
		t = Object.defineProperty;
		o = (e, l) => t(e, "name", {
			value: l,
			configurable: true
		});
		n = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
		o(f, "getDefaultExportFromCjs");
	} });
	var multipart_parser_exports = {};
	__export(multipart_parser_exports, { toFormData: () => Z });
	function v(u) {
		const a = u.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i);
		if (!a) return;
		const n4 = a[2] || a[3] || "";
		let r2 = n4.slice(n4.lastIndexOf("\\") + 1);
		return r2 = r2.replace(/%22/g, "\""), r2 = r2.replace(/&#(\d{4});/g, (d, l) => String.fromCharCode(l)), r2;
	}
	function Z(u, a) {
		return __async(this, null, function* () {
			if (!/multipart/i.test(a)) throw new TypeError("Failed to fetch");
			const n4 = a.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
			if (!n4) throw new TypeError("no or bad content-type header, no multipart boundary");
			const r2 = new k(n4[1] || n4[2]);
			let d, l, c2, p2, e, i;
			const A = [], H2 = new br(), O2 = E((s) => {
				c2 += f2.decode(s, { stream: true });
			}, "onPartData"), y = E((s) => {
				A.push(s);
			}, "appendToFile"), o3 = E(() => {
				const s = new qn(A, i, { type: e });
				H2.append(p2, s);
			}, "appendFileToFormData"), L = E(() => {
				H2.append(p2, c2);
			}, "appendEntryToFormData"), f2 = new TextDecoder("utf-8");
			f2.decode(), r2.onPartBegin = function() {
				r2.onPartData = O2, r2.onPartEnd = L, d = "", l = "", c2 = "", p2 = "", e = "", i = null, A.length = 0;
			}, r2.onHeaderField = function(s) {
				d += f2.decode(s, { stream: true });
			}, r2.onHeaderValue = function(s) {
				l += f2.decode(s, { stream: true });
			}, r2.onHeaderEnd = function() {
				if (l += f2.decode(), d = d.toLowerCase(), d === "content-disposition") {
					const s = l.match(/\bname=("([^"]*)"|([^()<>@,;:\\"/[\]?={}\s\t]+))/i);
					s && (p2 = s[2] || s[3] || ""), i = v(l), i && (r2.onPartData = y, r2.onPartEnd = o3);
				} else d === "content-type" && (e = l);
				l = "", d = "";
			};
			try {
				for (var iter = __forAwait(u), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
					const s = temp.value;
					r2.write(s);
				}
			} catch (temp) {
				error = [temp];
			} finally {
				try {
					more && (temp = iter.return) && (yield temp.call(iter));
				} finally {
					if (error) throw error[0];
				}
			}
			return r2.end(), H2;
		});
	}
	var B, E, D, t2, w, R, g, N, x, P, C, I, M, $, m, F, k;
	var init_multipart_parser = __esm({ "node_modules/node-fetch-native/dist/chunks/multipart-parser.mjs"() {
		"use strict";
		init_node();
		init_node_fetch_native_DfbY2q_x();
		B = Object.defineProperty;
		E = (u, a) => B(u, "name", {
			value: a,
			configurable: true
		});
		D = 0;
		t2 = {
			START_BOUNDARY: D++,
			HEADER_FIELD_START: D++,
			HEADER_FIELD: D++,
			HEADER_VALUE_START: D++,
			HEADER_VALUE: D++,
			HEADER_VALUE_ALMOST_DONE: D++,
			HEADERS_ALMOST_DONE: D++,
			PART_DATA_START: D++,
			PART_DATA: D++,
			END: D++
		};
		w = 1;
		R = {
			PART_BOUNDARY: w,
			LAST_BOUNDARY: w *= 2
		};
		g = 10;
		N = 13;
		x = 32;
		P = 45;
		C = 58;
		I = 97;
		M = 122;
		$ = E((u) => u | 32, "lower");
		m = E(() => {}, "noop");
		F = class F2 {
			constructor(a) {
				this.index = 0, this.flags = 0, this.onHeaderEnd = m, this.onHeaderField = m, this.onHeadersEnd = m, this.onHeaderValue = m, this.onPartBegin = m, this.onPartData = m, this.onPartEnd = m, this.boundaryChars = {}, a = `\r
--` + a;
				const n4 = new Uint8Array(a.length);
				for (let r2 = 0; r2 < a.length; r2++) n4[r2] = a.charCodeAt(r2), this.boundaryChars[n4[r2]] = true;
				this.boundary = n4, this.lookbehind = new Uint8Array(this.boundary.length + 8), this.state = t2.START_BOUNDARY;
			}
			write(a) {
				let n4 = 0;
				const r2 = a.length;
				let d = this.index, { lookbehind: l, boundary: c2, boundaryChars: p2, index: e, state: i, flags: A } = this;
				const H2 = this.boundary.length, O2 = H2 - 1, y = a.length;
				let o3, L;
				const f2 = E((h2) => {
					this[h2 + "Mark"] = n4;
				}, "mark"), s = E((h2) => {
					delete this[h2 + "Mark"];
				}, "clear"), T2 = E((h2, S, _, U) => {
					(S === void 0 || S !== _) && this[h2](U && U.subarray(S, _));
				}, "callback"), b = E((h2, S) => {
					const _ = h2 + "Mark";
					_ in this && (S ? (T2(h2, this[_], n4, a), delete this[_]) : (T2(h2, this[_], a.length, a), this[_] = 0));
				}, "dataCallback");
				for (n4 = 0; n4 < r2; n4++) switch (o3 = a[n4], i) {
					case t2.START_BOUNDARY:
						if (e === c2.length - 2) {
							if (o3 === P) A |= R.LAST_BOUNDARY;
							else if (o3 !== N) return;
							e++;
							break;
						} else if (e - 1 === c2.length - 2) {
							if (A & R.LAST_BOUNDARY && o3 === P) i = t2.END, A = 0;
							else if (!(A & R.LAST_BOUNDARY) && o3 === g) e = 0, T2("onPartBegin"), i = t2.HEADER_FIELD_START;
							else return;
							break;
						}
						o3 !== c2[e + 2] && (e = -2), o3 === c2[e + 2] && e++;
						break;
					case t2.HEADER_FIELD_START: i = t2.HEADER_FIELD, f2("onHeaderField"), e = 0;
					case t2.HEADER_FIELD:
						if (o3 === N) {
							s("onHeaderField"), i = t2.HEADERS_ALMOST_DONE;
							break;
						}
						if (e++, o3 === P) break;
						if (o3 === C) {
							if (e === 1) return;
							b("onHeaderField", true), i = t2.HEADER_VALUE_START;
							break;
						}
						if (L = $(o3), L < I || L > M) return;
						break;
					case t2.HEADER_VALUE_START:
						if (o3 === x) break;
						f2("onHeaderValue"), i = t2.HEADER_VALUE;
					case t2.HEADER_VALUE:
						o3 === N && (b("onHeaderValue", true), T2("onHeaderEnd"), i = t2.HEADER_VALUE_ALMOST_DONE);
						break;
					case t2.HEADER_VALUE_ALMOST_DONE:
						if (o3 !== g) return;
						i = t2.HEADER_FIELD_START;
						break;
					case t2.HEADERS_ALMOST_DONE:
						if (o3 !== g) return;
						T2("onHeadersEnd"), i = t2.PART_DATA_START;
						break;
					case t2.PART_DATA_START: i = t2.PART_DATA, f2("onPartData");
					case t2.PART_DATA:
						if (d = e, e === 0) {
							for (n4 += O2; n4 < y && !(a[n4] in p2);) n4 += H2;
							n4 -= O2, o3 = a[n4];
						}
						if (e < c2.length) c2[e] === o3 ? (e === 0 && b("onPartData", true), e++) : e = 0;
						else if (e === c2.length) e++, o3 === N ? A |= R.PART_BOUNDARY : o3 === P ? A |= R.LAST_BOUNDARY : e = 0;
						else if (e - 1 === c2.length) if (A & R.PART_BOUNDARY) {
							if (e = 0, o3 === g) {
								A &= ~R.PART_BOUNDARY, T2("onPartEnd"), T2("onPartBegin"), i = t2.HEADER_FIELD_START;
								break;
							}
						} else A & R.LAST_BOUNDARY && o3 === P ? (T2("onPartEnd"), i = t2.END, A = 0) : e = 0;
						if (e > 0) l[e - 1] = o3;
						else if (d > 0) {
							const h2 = new Uint8Array(l.buffer, l.byteOffset, l.byteLength);
							T2("onPartData", 0, d, h2), d = 0, f2("onPartData"), n4--;
						}
						break;
					case t2.END: break;
					default: throw new Error(`Unexpected state entered: ${i}`);
				}
				b("onHeaderField"), b("onHeaderValue"), b("onPartData"), this.index = e, this.state = i, this.flags = A;
			}
			end() {
				if (this.state === t2.HEADER_FIELD_START && this.index === 0 || this.state === t2.PART_DATA && this.index === this.boundary.length) this.onPartEnd();
				else if (this.state !== t2.END) throw new Error("MultipartParser.end(): stream ended unexpectedly");
			}
		};
		E(F, "MultipartParser");
		k = F;
		E(v, "_fileName");
		E(Z, "toFormData");
	} });
	function Us(i) {
		if (!/^data:/i.test(i)) throw new TypeError("`uri` does not appear to be a Data URI (must begin with \"data:\")");
		i = i.replace(/\r?\n/g, "");
		const o3 = i.indexOf(",");
		if (o3 === -1 || o3 <= 4) throw new TypeError("malformed data: URI");
		const a = i.substring(5, o3).split(";");
		let f2 = "", l = false;
		const p2 = a[0] || "text/plain";
		let h2 = p2;
		for (let A = 1; A < a.length; A++) a[A] === "base64" ? l = true : a[A] && (h2 += `;${a[A]}`, a[A].indexOf("charset=") === 0 && (f2 = a[A].substring(8)));
		!a[0] && !f2.length && (h2 += ";charset=US-ASCII", f2 = "US-ASCII");
		const S = l ? "base64" : "ascii", v2 = unescape(i.substring(o3 + 1)), w2 = Buffer.from(v2, S);
		return w2.type = p2, w2.typeFull = h2, w2.charset = f2, w2;
	}
	function Ns() {
		return bi || (bi = 1, (function(i, o3) {
			(function(a, f2) {
				f2(o3);
			})(xs, function(a) {
				function f2() {}
				n2(f2, "noop");
				function l(e) {
					return typeof e == "object" && e !== null || typeof e == "function";
				}
				n2(l, "typeIsObject");
				const p2 = f2;
				function h2(e, t3) {
					try {
						Object.defineProperty(e, "name", {
							value: t3,
							configurable: true
						});
					} catch (e2) {}
				}
				n2(h2, "setFunctionName");
				const S = Promise, v2 = Promise.prototype.then, w2 = Promise.reject.bind(S);
				function A(e) {
					return new S(e);
				}
				n2(A, "newPromise");
				function T2(e) {
					return A((t3) => t3(e));
				}
				n2(T2, "promiseResolvedWith");
				function b(e) {
					return w2(e);
				}
				n2(b, "promiseRejectedWith");
				function q(e, t3, r2) {
					return v2.call(e, t3, r2);
				}
				n2(q, "PerformPromiseThen");
				function g2(e, t3, r2) {
					q(q(e, t3, r2), void 0, p2);
				}
				n2(g2, "uponPromise");
				function V(e, t3) {
					g2(e, t3);
				}
				n2(V, "uponFulfillment");
				function I2(e, t3) {
					g2(e, void 0, t3);
				}
				n2(I2, "uponRejection");
				function F4(e, t3, r2) {
					return q(e, t3, r2);
				}
				n2(F4, "transformPromiseWith");
				function Q(e) {
					q(e, void 0, p2);
				}
				n2(Q, "setPromiseIsHandledToTrue");
				let ge = n2((e) => {
					if (typeof queueMicrotask == "function") ge = queueMicrotask;
					else {
						const t3 = T2(void 0);
						ge = n2((r2) => q(t3, r2), "_queueMicrotask");
					}
					return ge(e);
				}, "_queueMicrotask");
				function z(e, t3, r2) {
					if (typeof e != "function") throw new TypeError("Argument is not a function");
					return Function.prototype.apply.call(e, t3, r2);
				}
				n2(z, "reflectCall");
				function j(e, t3, r2) {
					try {
						return T2(z(e, t3, r2));
					} catch (s) {
						return b(s);
					}
				}
				n2(j, "promiseCall");
				const U = 16384, bn = class bn {
					constructor() {
						this._cursor = 0, this._size = 0, this._front = {
							_elements: [],
							_next: void 0
						}, this._back = this._front, this._cursor = 0, this._size = 0;
					}
					get length() {
						return this._size;
					}
					push(t3) {
						const r2 = this._back;
						let s = r2;
						r2._elements.length === U - 1 && (s = {
							_elements: [],
							_next: void 0
						}), r2._elements.push(t3), s !== r2 && (this._back = s, r2._next = s), ++this._size;
					}
					shift() {
						const t3 = this._front;
						let r2 = t3;
						const s = this._cursor;
						let u = s + 1;
						const c2 = t3._elements, d = c2[s];
						return u === U && (r2 = t3._next, u = 0), --this._size, this._cursor = u, t3 !== r2 && (this._front = r2), c2[s] = void 0, d;
					}
					forEach(t3) {
						let r2 = this._cursor, s = this._front, u = s._elements;
						for (; (r2 !== u.length || s._next !== void 0) && !(r2 === u.length && (s = s._next, u = s._elements, r2 = 0, u.length === 0));) t3(u[r2]), ++r2;
					}
					peek() {
						const t3 = this._front, r2 = this._cursor;
						return t3._elements[r2];
					}
				};
				n2(bn, "SimpleQueue");
				let D2 = bn;
				const jt = Symbol("[[AbortSteps]]"), Qn = Symbol("[[ErrorSteps]]"), Ar = Symbol("[[CancelSteps]]"), Br = Symbol("[[PullSteps]]"), kr = Symbol("[[ReleaseSteps]]");
				function Yn(e, t3) {
					e._ownerReadableStream = t3, t3._reader = e, t3._state === "readable" ? qr(e) : t3._state === "closed" ? xi(e) : Gn(e, t3._storedError);
				}
				n2(Yn, "ReadableStreamReaderGenericInitialize");
				function Wr(e, t3) {
					const r2 = e._ownerReadableStream;
					return ie(r2, t3);
				}
				n2(Wr, "ReadableStreamReaderGenericCancel");
				function _e(e) {
					const t3 = e._ownerReadableStream;
					t3._state === "readable" ? Or(e, /* @__PURE__ */ new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : Ni(e, /* @__PURE__ */ new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), t3._readableStreamController[kr](), t3._reader = void 0, e._ownerReadableStream = void 0;
				}
				n2(_e, "ReadableStreamReaderGenericRelease");
				function Lt(e) {
					return /* @__PURE__ */ new TypeError("Cannot " + e + " a stream using a released reader");
				}
				n2(Lt, "readerLockException");
				function qr(e) {
					e._closedPromise = A((t3, r2) => {
						e._closedPromise_resolve = t3, e._closedPromise_reject = r2;
					});
				}
				n2(qr, "defaultReaderClosedPromiseInitialize");
				function Gn(e, t3) {
					qr(e), Or(e, t3);
				}
				n2(Gn, "defaultReaderClosedPromiseInitializeAsRejected");
				function xi(e) {
					qr(e), Zn(e);
				}
				n2(xi, "defaultReaderClosedPromiseInitializeAsResolved");
				function Or(e, t3) {
					e._closedPromise_reject !== void 0 && (Q(e._closedPromise), e._closedPromise_reject(t3), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
				}
				n2(Or, "defaultReaderClosedPromiseReject");
				function Ni(e, t3) {
					Gn(e, t3);
				}
				n2(Ni, "defaultReaderClosedPromiseResetToRejected");
				function Zn(e) {
					e._closedPromise_resolve !== void 0 && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
				}
				n2(Zn, "defaultReaderClosedPromiseResolve");
				const Kn = Number.isFinite || function(e) {
					return typeof e == "number" && isFinite(e);
				}, Hi = Math.trunc || function(e) {
					return e < 0 ? Math.ceil(e) : Math.floor(e);
				};
				function Vi(e) {
					return typeof e == "object" || typeof e == "function";
				}
				n2(Vi, "isDictionary");
				function ue(e, t3) {
					if (e !== void 0 && !Vi(e)) throw new TypeError(`${t3} is not an object.`);
				}
				n2(ue, "assertDictionary");
				function Z2(e, t3) {
					if (typeof e != "function") throw new TypeError(`${t3} is not a function.`);
				}
				n2(Z2, "assertFunction");
				function Qi(e) {
					return typeof e == "object" && e !== null || typeof e == "function";
				}
				n2(Qi, "isObject");
				function Jn(e, t3) {
					if (!Qi(e)) throw new TypeError(`${t3} is not an object.`);
				}
				n2(Jn, "assertObject");
				function Se(e, t3, r2) {
					if (e === void 0) throw new TypeError(`Parameter ${t3} is required in '${r2}'.`);
				}
				n2(Se, "assertRequiredArgument");
				function zr(e, t3, r2) {
					if (e === void 0) throw new TypeError(`${t3} is required in '${r2}'.`);
				}
				n2(zr, "assertRequiredField");
				function Ir(e) {
					return Number(e);
				}
				n2(Ir, "convertUnrestrictedDouble");
				function Xn(e) {
					return e === 0 ? 0 : e;
				}
				n2(Xn, "censorNegativeZero");
				function Yi(e) {
					return Xn(Hi(e));
				}
				n2(Yi, "integerPart");
				function Fr(e, t3) {
					const s = Number.MAX_SAFE_INTEGER;
					let u = Number(e);
					if (u = Xn(u), !Kn(u)) throw new TypeError(`${t3} is not a finite number`);
					if (u = Yi(u), u < 0 || u > s) throw new TypeError(`${t3} is outside the accepted range of 0 to ${s}, inclusive`);
					return !Kn(u) || u === 0 ? 0 : u;
				}
				n2(Fr, "convertUnsignedLongLongWithEnforceRange");
				function jr(e, t3) {
					if (!We(e)) throw new TypeError(`${t3} is not a ReadableStream.`);
				}
				n2(jr, "assertReadableStream");
				function Qe(e) {
					return new fe(e);
				}
				n2(Qe, "AcquireReadableStreamDefaultReader");
				function eo(e, t3) {
					e._reader._readRequests.push(t3);
				}
				n2(eo, "ReadableStreamAddReadRequest");
				function Lr(e, t3, r2) {
					const u = e._reader._readRequests.shift();
					r2 ? u._closeSteps() : u._chunkSteps(t3);
				}
				n2(Lr, "ReadableStreamFulfillReadRequest");
				function $t(e) {
					return e._reader._readRequests.length;
				}
				n2($t, "ReadableStreamGetNumReadRequests");
				function to(e) {
					const t3 = e._reader;
					return !(t3 === void 0 || !Ee(t3));
				}
				n2(to, "ReadableStreamHasDefaultReader");
				const mn = class mn {
					constructor(t3) {
						if (Se(t3, 1, "ReadableStreamDefaultReader"), jr(t3, "First parameter"), qe(t3)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
						Yn(this, t3), this._readRequests = new D2();
					}
					get closed() {
						return Ee(this) ? this._closedPromise : b(Dt("closed"));
					}
					cancel(t3 = void 0) {
						return Ee(this) ? this._ownerReadableStream === void 0 ? b(Lt("cancel")) : Wr(this, t3) : b(Dt("cancel"));
					}
					read() {
						if (!Ee(this)) return b(Dt("read"));
						if (this._ownerReadableStream === void 0) return b(Lt("read from"));
						let t3, r2;
						const s = A((c2, d) => {
							t3 = c2, r2 = d;
						});
						return _t(this, {
							_chunkSteps: n2((c2) => t3({
								value: c2,
								done: false
							}), "_chunkSteps"),
							_closeSteps: n2(() => t3({
								value: void 0,
								done: true
							}), "_closeSteps"),
							_errorSteps: n2((c2) => r2(c2), "_errorSteps")
						}), s;
					}
					releaseLock() {
						if (!Ee(this)) throw Dt("releaseLock");
						this._ownerReadableStream !== void 0 && Gi(this);
					}
				};
				n2(mn, "ReadableStreamDefaultReader");
				let fe = mn;
				Object.defineProperties(fe.prototype, {
					cancel: { enumerable: true },
					read: { enumerable: true },
					releaseLock: { enumerable: true },
					closed: { enumerable: true }
				}), h2(fe.prototype.cancel, "cancel"), h2(fe.prototype.read, "read"), h2(fe.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(fe.prototype, Symbol.toStringTag, {
					value: "ReadableStreamDefaultReader",
					configurable: true
				});
				function Ee(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readRequests") ? false : e instanceof fe;
				}
				n2(Ee, "IsReadableStreamDefaultReader");
				function _t(e, t3) {
					const r2 = e._ownerReadableStream;
					r2._disturbed = true, r2._state === "closed" ? t3._closeSteps() : r2._state === "errored" ? t3._errorSteps(r2._storedError) : r2._readableStreamController[Br](t3);
				}
				n2(_t, "ReadableStreamDefaultReaderRead");
				function Gi(e) {
					_e(e);
					ro(e, /* @__PURE__ */ new TypeError("Reader was released"));
				}
				n2(Gi, "ReadableStreamDefaultReaderRelease");
				function ro(e, t3) {
					const r2 = e._readRequests;
					e._readRequests = new D2(), r2.forEach((s) => {
						s._errorSteps(t3);
					});
				}
				n2(ro, "ReadableStreamDefaultReaderErrorReadRequests");
				function Dt(e) {
					return /* @__PURE__ */ new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`);
				}
				n2(Dt, "defaultReaderBrandCheckException");
				const Zi = Object.getPrototypeOf(Object.getPrototypeOf(function() {
					return __asyncGenerator(this, null, function* () {});
				}).prototype || {}), yn = class yn {
					constructor(t3, r2) {
						this._ongoingPromise = void 0, this._isFinished = false, this._reader = t3, this._preventCancel = r2;
					}
					next() {
						const t3 = n2(() => this._nextSteps(), "nextSteps");
						return this._ongoingPromise = this._ongoingPromise ? F4(this._ongoingPromise, t3, t3) : t3(), this._ongoingPromise;
					}
					return(t3) {
						const r2 = n2(() => this._returnSteps(t3), "returnSteps");
						return this._ongoingPromise ? F4(this._ongoingPromise, r2, r2) : r2();
					}
					_nextSteps() {
						if (this._isFinished) return Promise.resolve({
							value: void 0,
							done: true
						});
						const t3 = this._reader;
						let r2, s;
						const u = A((d, m2) => {
							r2 = d, s = m2;
						});
						return _t(t3, {
							_chunkSteps: n2((d) => {
								this._ongoingPromise = void 0, ge(() => r2({
									value: d,
									done: false
								}));
							}, "_chunkSteps"),
							_closeSteps: n2(() => {
								this._ongoingPromise = void 0, this._isFinished = true, _e(t3), r2({
									value: void 0,
									done: true
								});
							}, "_closeSteps"),
							_errorSteps: n2((d) => {
								this._ongoingPromise = void 0, this._isFinished = true, _e(t3), s(d);
							}, "_errorSteps")
						}), u;
					}
					_returnSteps(t3) {
						if (this._isFinished) return Promise.resolve({
							value: t3,
							done: true
						});
						this._isFinished = true;
						const r2 = this._reader;
						if (!this._preventCancel) {
							const s = Wr(r2, t3);
							return _e(r2), F4(s, () => ({
								value: t3,
								done: true
							}));
						}
						return _e(r2), T2({
							value: t3,
							done: true
						});
					}
				};
				n2(yn, "ReadableStreamAsyncIteratorImpl");
				let Mt = yn;
				const no = {
					next() {
						return oo(this) ? this._asyncIteratorImpl.next() : b(io("next"));
					},
					return(e) {
						return oo(this) ? this._asyncIteratorImpl.return(e) : b(io("return"));
					}
				};
				Object.setPrototypeOf(no, Zi);
				function Ki(e, t3) {
					const s = new Mt(Qe(e), t3), u = Object.create(no);
					return u._asyncIteratorImpl = s, u;
				}
				n2(Ki, "AcquireReadableStreamAsyncIterator");
				function oo(e) {
					if (!l(e) || !Object.prototype.hasOwnProperty.call(e, "_asyncIteratorImpl")) return false;
					try {
						return e._asyncIteratorImpl instanceof Mt;
					} catch (e2) {
						return false;
					}
				}
				n2(oo, "IsReadableStreamAsyncIterator");
				function io(e) {
					return /* @__PURE__ */ new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`);
				}
				n2(io, "streamAsyncIteratorBrandCheckException");
				const ao = Number.isNaN || function(e) {
					return e !== e;
				};
				var $r, Dr, Mr;
				function St(e) {
					return e.slice();
				}
				n2(St, "CreateArrayFromList");
				function so(e, t3, r2, s, u) {
					new Uint8Array(e).set(new Uint8Array(r2, s, u), t3);
				}
				n2(so, "CopyDataBlockBytes");
				let we = n2((e) => (typeof e.transfer == "function" ? we = n2((t3) => t3.transfer(), "TransferArrayBuffer") : typeof structuredClone == "function" ? we = n2((t3) => structuredClone(t3, { transfer: [t3] }), "TransferArrayBuffer") : we = n2((t3) => t3, "TransferArrayBuffer"), we(e)), "TransferArrayBuffer"), Ae = n2((e) => (typeof e.detached == "boolean" ? Ae = n2((t3) => t3.detached, "IsDetachedBuffer") : Ae = n2((t3) => t3.byteLength === 0, "IsDetachedBuffer"), Ae(e)), "IsDetachedBuffer");
				function lo(e, t3, r2) {
					if (e.slice) return e.slice(t3, r2);
					const s = r2 - t3, u = new ArrayBuffer(s);
					return so(u, 0, e, t3, s), u;
				}
				n2(lo, "ArrayBufferSlice");
				function Ut(e, t3) {
					const r2 = e[t3];
					if (r2 != null) {
						if (typeof r2 != "function") throw new TypeError(`${String(t3)} is not a function`);
						return r2;
					}
				}
				n2(Ut, "GetMethod");
				function Ji(e) {
					const t3 = { [Symbol.iterator]: () => e.iterator }, r2 = (function() {
						return __asyncGenerator(this, null, function* () {
							return yield* __yieldStar(t3);
						});
					})();
					return {
						iterator: r2,
						nextMethod: r2.next,
						done: false
					};
				}
				n2(Ji, "CreateAsyncFromSyncIterator");
				const Ur = (Mr = ($r = Symbol.asyncIterator) !== null && $r !== void 0 ? $r : (Dr = Symbol.for) === null || Dr === void 0 ? void 0 : Dr.call(Symbol, "Symbol.asyncIterator")) !== null && Mr !== void 0 ? Mr : "@@asyncIterator";
				function uo(e, t3 = "sync", r2) {
					if (r2 === void 0) if (t3 === "async") {
						if (r2 = Ut(e, Ur), r2 === void 0) return Ji(uo(e, "sync", Ut(e, Symbol.iterator)));
					} else r2 = Ut(e, Symbol.iterator);
					if (r2 === void 0) throw new TypeError("The object is not iterable");
					const s = z(r2, e, []);
					if (!l(s)) throw new TypeError("The iterator method must return an object");
					return {
						iterator: s,
						nextMethod: s.next,
						done: false
					};
				}
				n2(uo, "GetIterator");
				function Xi(e) {
					const t3 = z(e.nextMethod, e.iterator, []);
					if (!l(t3)) throw new TypeError("The iterator.next() method must return an object");
					return t3;
				}
				n2(Xi, "IteratorNext");
				function ea(e) {
					return !!e.done;
				}
				n2(ea, "IteratorComplete");
				function ta(e) {
					return e.value;
				}
				n2(ta, "IteratorValue");
				function ra(e) {
					return !(typeof e != "number" || ao(e) || e < 0);
				}
				n2(ra, "IsNonNegativeNumber");
				function fo(e) {
					const t3 = lo(e.buffer, e.byteOffset, e.byteOffset + e.byteLength);
					return new Uint8Array(t3);
				}
				n2(fo, "CloneAsUint8Array");
				function xr(e) {
					const t3 = e._queue.shift();
					return e._queueTotalSize -= t3.size, e._queueTotalSize < 0 && (e._queueTotalSize = 0), t3.value;
				}
				n2(xr, "DequeueValue");
				function Nr(e, t3, r2) {
					if (!ra(r2) || r2 === Infinity) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
					e._queue.push({
						value: t3,
						size: r2
					}), e._queueTotalSize += r2;
				}
				n2(Nr, "EnqueueValueWithSize");
				function na(e) {
					return e._queue.peek().value;
				}
				n2(na, "PeekQueueValue");
				function Be(e) {
					e._queue = new D2(), e._queueTotalSize = 0;
				}
				n2(Be, "ResetQueue");
				function co(e) {
					return e === DataView;
				}
				n2(co, "isDataViewConstructor");
				function oa(e) {
					return co(e.constructor);
				}
				n2(oa, "isDataView");
				function ia(e) {
					return co(e) ? 1 : e.BYTES_PER_ELEMENT;
				}
				n2(ia, "arrayBufferViewElementSize");
				const gn = class gn {
					constructor() {
						throw new TypeError("Illegal constructor");
					}
					get view() {
						if (!Hr(this)) throw Zr("view");
						return this._view;
					}
					respond(t3) {
						if (!Hr(this)) throw Zr("respond");
						if (Se(t3, 1, "respond"), t3 = Fr(t3, "First parameter"), this._associatedReadableByteStreamController === void 0) throw new TypeError("This BYOB request has been invalidated");
						if (Ae(this._view.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
						Vt(this._associatedReadableByteStreamController, t3);
					}
					respondWithNewView(t3) {
						if (!Hr(this)) throw Zr("respondWithNewView");
						if (Se(t3, 1, "respondWithNewView"), !ArrayBuffer.isView(t3)) throw new TypeError("You can only respond with array buffer views");
						if (this._associatedReadableByteStreamController === void 0) throw new TypeError("This BYOB request has been invalidated");
						if (Ae(t3.buffer)) throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
						Qt(this._associatedReadableByteStreamController, t3);
					}
				};
				n2(gn, "ReadableStreamBYOBRequest");
				let Re = gn;
				Object.defineProperties(Re.prototype, {
					respond: { enumerable: true },
					respondWithNewView: { enumerable: true },
					view: { enumerable: true }
				}), h2(Re.prototype.respond, "respond"), h2(Re.prototype.respondWithNewView, "respondWithNewView"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Re.prototype, Symbol.toStringTag, {
					value: "ReadableStreamBYOBRequest",
					configurable: true
				});
				const _n = class _n {
					constructor() {
						throw new TypeError("Illegal constructor");
					}
					get byobRequest() {
						if (!Ie(this)) throw Rt("byobRequest");
						return Gr(this);
					}
					get desiredSize() {
						if (!Ie(this)) throw Rt("desiredSize");
						return Ro(this);
					}
					close() {
						if (!Ie(this)) throw Rt("close");
						if (this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");
						const t3 = this._controlledReadableByteStream._state;
						if (t3 !== "readable") throw new TypeError(`The stream (in ${t3} state) is not in the readable state and cannot be closed`);
						wt(this);
					}
					enqueue(t3) {
						if (!Ie(this)) throw Rt("enqueue");
						if (Se(t3, 1, "enqueue"), !ArrayBuffer.isView(t3)) throw new TypeError("chunk must be an array buffer view");
						if (t3.byteLength === 0) throw new TypeError("chunk must have non-zero byteLength");
						if (t3.buffer.byteLength === 0) throw new TypeError("chunk's buffer must have non-zero byteLength");
						if (this._closeRequested) throw new TypeError("stream is closed or draining");
						const r2 = this._controlledReadableByteStream._state;
						if (r2 !== "readable") throw new TypeError(`The stream (in ${r2} state) is not in the readable state and cannot be enqueued to`);
						Ht(this, t3);
					}
					error(t3 = void 0) {
						if (!Ie(this)) throw Rt("error");
						K(this, t3);
					}
					[Ar](t3) {
						ho(this), Be(this);
						const r2 = this._cancelAlgorithm(t3);
						return Nt(this), r2;
					}
					[Br](t3) {
						const r2 = this._controlledReadableByteStream;
						if (this._queueTotalSize > 0) {
							wo(this, t3);
							return;
						}
						const s = this._autoAllocateChunkSize;
						if (s !== void 0) {
							let u;
							try {
								u = new ArrayBuffer(s);
							} catch (d) {
								t3._errorSteps(d);
								return;
							}
							const c2 = {
								buffer: u,
								bufferByteLength: s,
								byteOffset: 0,
								byteLength: s,
								bytesFilled: 0,
								minimumFill: 1,
								elementSize: 1,
								viewConstructor: Uint8Array,
								readerType: "default"
							};
							this._pendingPullIntos.push(c2);
						}
						eo(r2, t3), Fe(this);
					}
					[kr]() {
						if (this._pendingPullIntos.length > 0) {
							const t3 = this._pendingPullIntos.peek();
							t3.readerType = "none", this._pendingPullIntos = new D2(), this._pendingPullIntos.push(t3);
						}
					}
				};
				n2(_n, "ReadableByteStreamController");
				let te = _n;
				Object.defineProperties(te.prototype, {
					close: { enumerable: true },
					enqueue: { enumerable: true },
					error: { enumerable: true },
					byobRequest: { enumerable: true },
					desiredSize: { enumerable: true }
				}), h2(te.prototype.close, "close"), h2(te.prototype.enqueue, "enqueue"), h2(te.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(te.prototype, Symbol.toStringTag, {
					value: "ReadableByteStreamController",
					configurable: true
				});
				function Ie(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledReadableByteStream") ? false : e instanceof te;
				}
				n2(Ie, "IsReadableByteStreamController");
				function Hr(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_associatedReadableByteStreamController") ? false : e instanceof Re;
				}
				n2(Hr, "IsReadableStreamBYOBRequest");
				function Fe(e) {
					if (!fa(e)) return;
					if (e._pulling) {
						e._pullAgain = true;
						return;
					}
					e._pulling = true;
					g2(e._pullAlgorithm(), () => (e._pulling = false, e._pullAgain && (e._pullAgain = false, Fe(e)), null), (s) => (K(e, s), null));
				}
				n2(Fe, "ReadableByteStreamControllerCallPullIfNeeded");
				function ho(e) {
					Qr(e), e._pendingPullIntos = new D2();
				}
				n2(ho, "ReadableByteStreamControllerClearPendingPullIntos");
				function Vr(e, t3) {
					let r2 = false;
					e._state === "closed" && (r2 = true);
					const s = po(t3);
					t3.readerType === "default" ? Lr(e, s, r2) : ma(e, s, r2);
				}
				n2(Vr, "ReadableByteStreamControllerCommitPullIntoDescriptor");
				function po(e) {
					const t3 = e.bytesFilled, r2 = e.elementSize;
					return new e.viewConstructor(e.buffer, e.byteOffset, t3 / r2);
				}
				n2(po, "ReadableByteStreamControllerConvertPullIntoDescriptor");
				function xt(e, t3, r2, s) {
					e._queue.push({
						buffer: t3,
						byteOffset: r2,
						byteLength: s
					}), e._queueTotalSize += s;
				}
				n2(xt, "ReadableByteStreamControllerEnqueueChunkToQueue");
				function bo(e, t3, r2, s) {
					let u;
					try {
						u = lo(t3, r2, r2 + s);
					} catch (c2) {
						throw K(e, c2), c2;
					}
					xt(e, u, 0, s);
				}
				n2(bo, "ReadableByteStreamControllerEnqueueClonedChunkToQueue");
				function mo(e, t3) {
					t3.bytesFilled > 0 && bo(e, t3.buffer, t3.byteOffset, t3.bytesFilled), Ye(e);
				}
				n2(mo, "ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue");
				function yo(e, t3) {
					const r2 = Math.min(e._queueTotalSize, t3.byteLength - t3.bytesFilled), s = t3.bytesFilled + r2;
					let u = r2, c2 = false;
					const m2 = s - s % t3.elementSize;
					m2 >= t3.minimumFill && (u = m2 - t3.bytesFilled, c2 = true);
					const R3 = e._queue;
					for (; u > 0;) {
						const y = R3.peek(), C2 = Math.min(u, y.byteLength), P2 = t3.byteOffset + t3.bytesFilled;
						so(t3.buffer, P2, y.buffer, y.byteOffset, C2), y.byteLength === C2 ? R3.shift() : (y.byteOffset += C2, y.byteLength -= C2), e._queueTotalSize -= C2, go(e, C2, t3), u -= C2;
					}
					return c2;
				}
				n2(yo, "ReadableByteStreamControllerFillPullIntoDescriptorFromQueue");
				function go(e, t3, r2) {
					r2.bytesFilled += t3;
				}
				n2(go, "ReadableByteStreamControllerFillHeadPullIntoDescriptor");
				function _o(e) {
					e._queueTotalSize === 0 && e._closeRequested ? (Nt(e), At(e._controlledReadableByteStream)) : Fe(e);
				}
				n2(_o, "ReadableByteStreamControllerHandleQueueDrain");
				function Qr(e) {
					e._byobRequest !== null && (e._byobRequest._associatedReadableByteStreamController = void 0, e._byobRequest._view = null, e._byobRequest = null);
				}
				n2(Qr, "ReadableByteStreamControllerInvalidateBYOBRequest");
				function Yr(e) {
					for (; e._pendingPullIntos.length > 0;) {
						if (e._queueTotalSize === 0) return;
						const t3 = e._pendingPullIntos.peek();
						yo(e, t3) && (Ye(e), Vr(e._controlledReadableByteStream, t3));
					}
				}
				n2(Yr, "ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue");
				function aa(e) {
					const t3 = e._controlledReadableByteStream._reader;
					for (; t3._readRequests.length > 0;) {
						if (e._queueTotalSize === 0) return;
						wo(e, t3._readRequests.shift());
					}
				}
				n2(aa, "ReadableByteStreamControllerProcessReadRequestsUsingQueue");
				function sa(e, t3, r2, s) {
					const u = e._controlledReadableByteStream, c2 = t3.constructor, d = ia(c2), { byteOffset: m2, byteLength: R3 } = t3, y = r2 * d;
					let C2;
					try {
						C2 = we(t3.buffer);
					} catch (B2) {
						s._errorSteps(B2);
						return;
					}
					const P2 = {
						buffer: C2,
						bufferByteLength: C2.byteLength,
						byteOffset: m2,
						byteLength: R3,
						bytesFilled: 0,
						minimumFill: y,
						elementSize: d,
						viewConstructor: c2,
						readerType: "byob"
					};
					if (e._pendingPullIntos.length > 0) {
						e._pendingPullIntos.push(P2), Po(u, s);
						return;
					}
					if (u._state === "closed") {
						const B2 = new c2(P2.buffer, P2.byteOffset, 0);
						s._closeSteps(B2);
						return;
					}
					if (e._queueTotalSize > 0) {
						if (yo(e, P2)) {
							const B2 = po(P2);
							_o(e), s._chunkSteps(B2);
							return;
						}
						if (e._closeRequested) {
							const B2 = /* @__PURE__ */ new TypeError("Insufficient bytes to fill elements in the given buffer");
							K(e, B2), s._errorSteps(B2);
							return;
						}
					}
					e._pendingPullIntos.push(P2), Po(u, s), Fe(e);
				}
				n2(sa, "ReadableByteStreamControllerPullInto");
				function la(e, t3) {
					t3.readerType === "none" && Ye(e);
					const r2 = e._controlledReadableByteStream;
					if (Kr(r2)) for (; vo(r2) > 0;) Vr(r2, Ye(e));
				}
				n2(la, "ReadableByteStreamControllerRespondInClosedState");
				function ua(e, t3, r2) {
					if (go(e, t3, r2), r2.readerType === "none") {
						mo(e, r2), Yr(e);
						return;
					}
					if (r2.bytesFilled < r2.minimumFill) return;
					Ye(e);
					const s = r2.bytesFilled % r2.elementSize;
					if (s > 0) {
						const u = r2.byteOffset + r2.bytesFilled;
						bo(e, r2.buffer, u - s, s);
					}
					r2.bytesFilled -= s, Vr(e._controlledReadableByteStream, r2), Yr(e);
				}
				n2(ua, "ReadableByteStreamControllerRespondInReadableState");
				function So(e, t3) {
					const r2 = e._pendingPullIntos.peek();
					Qr(e), e._controlledReadableByteStream._state === "closed" ? la(e, r2) : ua(e, t3, r2), Fe(e);
				}
				n2(So, "ReadableByteStreamControllerRespondInternal");
				function Ye(e) {
					return e._pendingPullIntos.shift();
				}
				n2(Ye, "ReadableByteStreamControllerShiftPendingPullInto");
				function fa(e) {
					const t3 = e._controlledReadableByteStream;
					return t3._state !== "readable" || e._closeRequested || !e._started ? false : !!(to(t3) && $t(t3) > 0 || Kr(t3) && vo(t3) > 0 || Ro(e) > 0);
				}
				n2(fa, "ReadableByteStreamControllerShouldCallPull");
				function Nt(e) {
					e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0;
				}
				n2(Nt, "ReadableByteStreamControllerClearAlgorithms");
				function wt(e) {
					const t3 = e._controlledReadableByteStream;
					if (!(e._closeRequested || t3._state !== "readable")) {
						if (e._queueTotalSize > 0) {
							e._closeRequested = true;
							return;
						}
						if (e._pendingPullIntos.length > 0) {
							const r2 = e._pendingPullIntos.peek();
							if (r2.bytesFilled % r2.elementSize !== 0) {
								const s = /* @__PURE__ */ new TypeError("Insufficient bytes to fill elements in the given buffer");
								throw K(e, s), s;
							}
						}
						Nt(e), At(t3);
					}
				}
				n2(wt, "ReadableByteStreamControllerClose");
				function Ht(e, t3) {
					const r2 = e._controlledReadableByteStream;
					if (e._closeRequested || r2._state !== "readable") return;
					const { buffer: s, byteOffset: u, byteLength: c2 } = t3;
					if (Ae(s)) throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
					const d = we(s);
					if (e._pendingPullIntos.length > 0) {
						const m2 = e._pendingPullIntos.peek();
						if (Ae(m2.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
						Qr(e), m2.buffer = we(m2.buffer), m2.readerType === "none" && mo(e, m2);
					}
					if (to(r2)) if (aa(e), $t(r2) === 0) xt(e, d, u, c2);
					else {
						e._pendingPullIntos.length > 0 && Ye(e);
						Lr(r2, new Uint8Array(d, u, c2), false);
					}
					else Kr(r2) ? (xt(e, d, u, c2), Yr(e)) : xt(e, d, u, c2);
					Fe(e);
				}
				n2(Ht, "ReadableByteStreamControllerEnqueue");
				function K(e, t3) {
					const r2 = e._controlledReadableByteStream;
					r2._state === "readable" && (ho(e), Be(e), Nt(e), Zo(r2, t3));
				}
				n2(K, "ReadableByteStreamControllerError");
				function wo(e, t3) {
					const r2 = e._queue.shift();
					e._queueTotalSize -= r2.byteLength, _o(e);
					const s = new Uint8Array(r2.buffer, r2.byteOffset, r2.byteLength);
					t3._chunkSteps(s);
				}
				n2(wo, "ReadableByteStreamControllerFillReadRequestFromQueue");
				function Gr(e) {
					if (e._byobRequest === null && e._pendingPullIntos.length > 0) {
						const t3 = e._pendingPullIntos.peek(), r2 = new Uint8Array(t3.buffer, t3.byteOffset + t3.bytesFilled, t3.byteLength - t3.bytesFilled), s = Object.create(Re.prototype);
						da(s, e, r2), e._byobRequest = s;
					}
					return e._byobRequest;
				}
				n2(Gr, "ReadableByteStreamControllerGetBYOBRequest");
				function Ro(e) {
					const t3 = e._controlledReadableByteStream._state;
					return t3 === "errored" ? null : t3 === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
				}
				n2(Ro, "ReadableByteStreamControllerGetDesiredSize");
				function Vt(e, t3) {
					const r2 = e._pendingPullIntos.peek();
					if (e._controlledReadableByteStream._state === "closed") {
						if (t3 !== 0) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
					} else {
						if (t3 === 0) throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
						if (r2.bytesFilled + t3 > r2.byteLength) throw new RangeError("bytesWritten out of range");
					}
					r2.buffer = we(r2.buffer), So(e, t3);
				}
				n2(Vt, "ReadableByteStreamControllerRespond");
				function Qt(e, t3) {
					const r2 = e._pendingPullIntos.peek();
					if (e._controlledReadableByteStream._state === "closed") {
						if (t3.byteLength !== 0) throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
					} else if (t3.byteLength === 0) throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
					if (r2.byteOffset + r2.bytesFilled !== t3.byteOffset) throw new RangeError("The region specified by view does not match byobRequest");
					if (r2.bufferByteLength !== t3.buffer.byteLength) throw new RangeError("The buffer of view has different capacity than byobRequest");
					if (r2.bytesFilled + t3.byteLength > r2.byteLength) throw new RangeError("The region specified by view is larger than byobRequest");
					const u = t3.byteLength;
					r2.buffer = we(t3.buffer), So(e, u);
				}
				n2(Qt, "ReadableByteStreamControllerRespondWithNewView");
				function To(e, t3, r2, s, u, c2, d) {
					t3._controlledReadableByteStream = e, t3._pullAgain = false, t3._pulling = false, t3._byobRequest = null, t3._queue = t3._queueTotalSize = void 0, Be(t3), t3._closeRequested = false, t3._started = false, t3._strategyHWM = c2, t3._pullAlgorithm = s, t3._cancelAlgorithm = u, t3._autoAllocateChunkSize = d, t3._pendingPullIntos = new D2(), e._readableStreamController = t3;
					g2(T2(r2()), () => (t3._started = true, Fe(t3), null), (R3) => (K(t3, R3), null));
				}
				n2(To, "SetUpReadableByteStreamController");
				function ca(e, t3, r2) {
					const s = Object.create(te.prototype);
					let u, c2, d;
					t3.start !== void 0 ? u = n2(() => t3.start(s), "startAlgorithm") : u = n2(() => {}, "startAlgorithm"), t3.pull !== void 0 ? c2 = n2(() => t3.pull(s), "pullAlgorithm") : c2 = n2(() => T2(void 0), "pullAlgorithm"), t3.cancel !== void 0 ? d = n2((R3) => t3.cancel(R3), "cancelAlgorithm") : d = n2(() => T2(void 0), "cancelAlgorithm");
					const m2 = t3.autoAllocateChunkSize;
					if (m2 === 0) throw new TypeError("autoAllocateChunkSize must be greater than 0");
					To(e, s, u, c2, d, r2, m2);
				}
				n2(ca, "SetUpReadableByteStreamControllerFromUnderlyingSource");
				function da(e, t3, r2) {
					e._associatedReadableByteStreamController = t3, e._view = r2;
				}
				n2(da, "SetUpReadableStreamBYOBRequest");
				function Zr(e) {
					return /* @__PURE__ */ new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`);
				}
				n2(Zr, "byobRequestBrandCheckException");
				function Rt(e) {
					return /* @__PURE__ */ new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`);
				}
				n2(Rt, "byteStreamControllerBrandCheckException");
				function ha(e, t3) {
					ue(e, t3);
					const r2 = e == null ? void 0 : e.mode;
					return { mode: r2 === void 0 ? void 0 : pa(r2, `${t3} has member 'mode' that`) };
				}
				n2(ha, "convertReaderOptions");
				function pa(e, t3) {
					if (e = `${e}`, e !== "byob") throw new TypeError(`${t3} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);
					return e;
				}
				n2(pa, "convertReadableStreamReaderMode");
				function ba(e, t3) {
					var r2;
					ue(e, t3);
					return { min: Fr((r2 = e == null ? void 0 : e.min) !== null && r2 !== void 0 ? r2 : 1, `${t3} has member 'min' that`) };
				}
				n2(ba, "convertByobReadOptions");
				function Co(e) {
					return new ce(e);
				}
				n2(Co, "AcquireReadableStreamBYOBReader");
				function Po(e, t3) {
					e._reader._readIntoRequests.push(t3);
				}
				n2(Po, "ReadableStreamAddReadIntoRequest");
				function ma(e, t3, r2) {
					const u = e._reader._readIntoRequests.shift();
					r2 ? u._closeSteps(t3) : u._chunkSteps(t3);
				}
				n2(ma, "ReadableStreamFulfillReadIntoRequest");
				function vo(e) {
					return e._reader._readIntoRequests.length;
				}
				n2(vo, "ReadableStreamGetNumReadIntoRequests");
				function Kr(e) {
					const t3 = e._reader;
					return !(t3 === void 0 || !je(t3));
				}
				n2(Kr, "ReadableStreamHasBYOBReader");
				const Sn = class Sn {
					constructor(t3) {
						if (Se(t3, 1, "ReadableStreamBYOBReader"), jr(t3, "First parameter"), qe(t3)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
						if (!Ie(t3._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
						Yn(this, t3), this._readIntoRequests = new D2();
					}
					get closed() {
						return je(this) ? this._closedPromise : b(Yt("closed"));
					}
					cancel(t3 = void 0) {
						return je(this) ? this._ownerReadableStream === void 0 ? b(Lt("cancel")) : Wr(this, t3) : b(Yt("cancel"));
					}
					read(t3, r2 = {}) {
						if (!je(this)) return b(Yt("read"));
						if (!ArrayBuffer.isView(t3)) return b(/* @__PURE__ */ new TypeError("view must be an array buffer view"));
						if (t3.byteLength === 0) return b(/* @__PURE__ */ new TypeError("view must have non-zero byteLength"));
						if (t3.buffer.byteLength === 0) return b(/* @__PURE__ */ new TypeError("view's buffer must have non-zero byteLength"));
						if (Ae(t3.buffer)) return b(/* @__PURE__ */ new TypeError("view's buffer has been detached"));
						let s;
						try {
							s = ba(r2, "options");
						} catch (y) {
							return b(y);
						}
						const u = s.min;
						if (u === 0) return b(/* @__PURE__ */ new TypeError("options.min must be greater than 0"));
						if (oa(t3)) {
							if (u > t3.byteLength) return b(/* @__PURE__ */ new RangeError("options.min must be less than or equal to view's byteLength"));
						} else if (u > t3.length) return b(/* @__PURE__ */ new RangeError("options.min must be less than or equal to view's length"));
						if (this._ownerReadableStream === void 0) return b(Lt("read from"));
						let c2, d;
						const m2 = A((y, C2) => {
							c2 = y, d = C2;
						});
						return Eo(this, t3, u, {
							_chunkSteps: n2((y) => c2({
								value: y,
								done: false
							}), "_chunkSteps"),
							_closeSteps: n2((y) => c2({
								value: y,
								done: true
							}), "_closeSteps"),
							_errorSteps: n2((y) => d(y), "_errorSteps")
						}), m2;
					}
					releaseLock() {
						if (!je(this)) throw Yt("releaseLock");
						this._ownerReadableStream !== void 0 && ya(this);
					}
				};
				n2(Sn, "ReadableStreamBYOBReader");
				let ce = Sn;
				Object.defineProperties(ce.prototype, {
					cancel: { enumerable: true },
					read: { enumerable: true },
					releaseLock: { enumerable: true },
					closed: { enumerable: true }
				}), h2(ce.prototype.cancel, "cancel"), h2(ce.prototype.read, "read"), h2(ce.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ce.prototype, Symbol.toStringTag, {
					value: "ReadableStreamBYOBReader",
					configurable: true
				});
				function je(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readIntoRequests") ? false : e instanceof ce;
				}
				n2(je, "IsReadableStreamBYOBReader");
				function Eo(e, t3, r2, s) {
					const u = e._ownerReadableStream;
					u._disturbed = true, u._state === "errored" ? s._errorSteps(u._storedError) : sa(u._readableStreamController, t3, r2, s);
				}
				n2(Eo, "ReadableStreamBYOBReaderRead");
				function ya(e) {
					_e(e);
					Ao(e, /* @__PURE__ */ new TypeError("Reader was released"));
				}
				n2(ya, "ReadableStreamBYOBReaderRelease");
				function Ao(e, t3) {
					const r2 = e._readIntoRequests;
					e._readIntoRequests = new D2(), r2.forEach((s) => {
						s._errorSteps(t3);
					});
				}
				n2(Ao, "ReadableStreamBYOBReaderErrorReadIntoRequests");
				function Yt(e) {
					return /* @__PURE__ */ new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`);
				}
				n2(Yt, "byobReaderBrandCheckException");
				function Tt(e, t3) {
					const { highWaterMark: r2 } = e;
					if (r2 === void 0) return t3;
					if (ao(r2) || r2 < 0) throw new RangeError("Invalid highWaterMark");
					return r2;
				}
				n2(Tt, "ExtractHighWaterMark");
				function Gt(e) {
					const { size: t3 } = e;
					return t3 || (() => 1);
				}
				n2(Gt, "ExtractSizeAlgorithm");
				function Zt(e, t3) {
					ue(e, t3);
					const r2 = e == null ? void 0 : e.highWaterMark, s = e == null ? void 0 : e.size;
					return {
						highWaterMark: r2 === void 0 ? void 0 : Ir(r2),
						size: s === void 0 ? void 0 : ga(s, `${t3} has member 'size' that`)
					};
				}
				n2(Zt, "convertQueuingStrategy");
				function ga(e, t3) {
					return Z2(e, t3), (r2) => Ir(e(r2));
				}
				n2(ga, "convertQueuingStrategySize");
				function _a2(e, t3) {
					ue(e, t3);
					const r2 = e == null ? void 0 : e.abort, s = e == null ? void 0 : e.close, u = e == null ? void 0 : e.start, c2 = e == null ? void 0 : e.type, d = e == null ? void 0 : e.write;
					return {
						abort: r2 === void 0 ? void 0 : Sa(r2, e, `${t3} has member 'abort' that`),
						close: s === void 0 ? void 0 : wa(s, e, `${t3} has member 'close' that`),
						start: u === void 0 ? void 0 : Ra(u, e, `${t3} has member 'start' that`),
						write: d === void 0 ? void 0 : Ta(d, e, `${t3} has member 'write' that`),
						type: c2
					};
				}
				n2(_a2, "convertUnderlyingSink");
				function Sa(e, t3, r2) {
					return Z2(e, r2), (s) => j(e, t3, [s]);
				}
				n2(Sa, "convertUnderlyingSinkAbortCallback");
				function wa(e, t3, r2) {
					return Z2(e, r2), () => j(e, t3, []);
				}
				n2(wa, "convertUnderlyingSinkCloseCallback");
				function Ra(e, t3, r2) {
					return Z2(e, r2), (s) => z(e, t3, [s]);
				}
				n2(Ra, "convertUnderlyingSinkStartCallback");
				function Ta(e, t3, r2) {
					return Z2(e, r2), (s, u) => j(e, t3, [s, u]);
				}
				n2(Ta, "convertUnderlyingSinkWriteCallback");
				function Bo(e, t3) {
					if (!Ge(e)) throw new TypeError(`${t3} is not a WritableStream.`);
				}
				n2(Bo, "assertWritableStream");
				function Ca(e) {
					if (typeof e != "object" || e === null) return false;
					try {
						return typeof e.aborted == "boolean";
					} catch (e2) {
						return false;
					}
				}
				n2(Ca, "isAbortSignal");
				const Pa = typeof AbortController == "function";
				function va() {
					if (Pa) return new AbortController();
				}
				n2(va, "createAbortController");
				const wn = class wn {
					constructor(t3 = {}, r2 = {}) {
						t3 === void 0 ? t3 = null : Jn(t3, "First parameter");
						const s = Zt(r2, "Second parameter"), u = _a2(t3, "First parameter");
						if (Wo(this), u.type !== void 0) throw new RangeError("Invalid type is specified");
						const d = Gt(s), m2 = Tt(s, 1);
						Da(this, u, m2, d);
					}
					get locked() {
						if (!Ge(this)) throw tr("locked");
						return Ze(this);
					}
					abort(t3 = void 0) {
						return Ge(this) ? Ze(this) ? b(/* @__PURE__ */ new TypeError("Cannot abort a stream that already has a writer")) : Kt(this, t3) : b(tr("abort"));
					}
					close() {
						return Ge(this) ? Ze(this) ? b(/* @__PURE__ */ new TypeError("Cannot close a stream that already has a writer")) : he(this) ? b(/* @__PURE__ */ new TypeError("Cannot close an already-closing stream")) : qo(this) : b(tr("close"));
					}
					getWriter() {
						if (!Ge(this)) throw tr("getWriter");
						return ko(this);
					}
				};
				n2(wn, "WritableStream");
				let de = wn;
				Object.defineProperties(de.prototype, {
					abort: { enumerable: true },
					close: { enumerable: true },
					getWriter: { enumerable: true },
					locked: { enumerable: true }
				}), h2(de.prototype.abort, "abort"), h2(de.prototype.close, "close"), h2(de.prototype.getWriter, "getWriter"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(de.prototype, Symbol.toStringTag, {
					value: "WritableStream",
					configurable: true
				});
				function ko(e) {
					return new re(e);
				}
				n2(ko, "AcquireWritableStreamDefaultWriter");
				function Ea(e, t3, r2, s, u = 1, c2 = () => 1) {
					const d = Object.create(de.prototype);
					Wo(d);
					return Lo(d, Object.create(ke.prototype), e, t3, r2, s, u, c2), d;
				}
				n2(Ea, "CreateWritableStream");
				function Wo(e) {
					e._state = "writable", e._storedError = void 0, e._writer = void 0, e._writableStreamController = void 0, e._writeRequests = new D2(), e._inFlightWriteRequest = void 0, e._closeRequest = void 0, e._inFlightCloseRequest = void 0, e._pendingAbortRequest = void 0, e._backpressure = false;
				}
				n2(Wo, "InitializeWritableStream");
				function Ge(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_writableStreamController") ? false : e instanceof de;
				}
				n2(Ge, "IsWritableStream");
				function Ze(e) {
					return e._writer !== void 0;
				}
				n2(Ze, "IsWritableStreamLocked");
				function Kt(e, t3) {
					var r2;
					if (e._state === "closed" || e._state === "errored") return T2(void 0);
					e._writableStreamController._abortReason = t3, (r2 = e._writableStreamController._abortController) === null || r2 === void 0 || r2.abort(t3);
					const s = e._state;
					if (s === "closed" || s === "errored") return T2(void 0);
					if (e._pendingAbortRequest !== void 0) return e._pendingAbortRequest._promise;
					let u = false;
					s === "erroring" && (u = true, t3 = void 0);
					const c2 = A((d, m2) => {
						e._pendingAbortRequest = {
							_promise: void 0,
							_resolve: d,
							_reject: m2,
							_reason: t3,
							_wasAlreadyErroring: u
						};
					});
					return e._pendingAbortRequest._promise = c2, u || Xr(e, t3), c2;
				}
				n2(Kt, "WritableStreamAbort");
				function qo(e) {
					const t3 = e._state;
					if (t3 === "closed" || t3 === "errored") return b(/* @__PURE__ */ new TypeError(`The stream (in ${t3} state) is not in the writable state and cannot be closed`));
					const r2 = A((u, c2) => {
						e._closeRequest = {
							_resolve: u,
							_reject: c2
						};
					}), s = e._writer;
					return s !== void 0 && e._backpressure && t3 === "writable" && ln(s), Ma(e._writableStreamController), r2;
				}
				n2(qo, "WritableStreamClose");
				function Aa(e) {
					return A((r2, s) => {
						const u = {
							_resolve: r2,
							_reject: s
						};
						e._writeRequests.push(u);
					});
				}
				n2(Aa, "WritableStreamAddWriteRequest");
				function Jr(e, t3) {
					if (e._state === "writable") {
						Xr(e, t3);
						return;
					}
					en(e);
				}
				n2(Jr, "WritableStreamDealWithRejection");
				function Xr(e, t3) {
					const r2 = e._writableStreamController;
					e._state = "erroring", e._storedError = t3;
					const s = e._writer;
					s !== void 0 && zo(s, t3), !Oa(e) && r2._started && en(e);
				}
				n2(Xr, "WritableStreamStartErroring");
				function en(e) {
					e._state = "errored", e._writableStreamController[Qn]();
					const t3 = e._storedError;
					if (e._writeRequests.forEach((u) => {
						u._reject(t3);
					}), e._writeRequests = new D2(), e._pendingAbortRequest === void 0) {
						Jt(e);
						return;
					}
					const r2 = e._pendingAbortRequest;
					if (e._pendingAbortRequest = void 0, r2._wasAlreadyErroring) {
						r2._reject(t3), Jt(e);
						return;
					}
					g2(e._writableStreamController[jt](r2._reason), () => (r2._resolve(), Jt(e), null), (u) => (r2._reject(u), Jt(e), null));
				}
				n2(en, "WritableStreamFinishErroring");
				function Ba(e) {
					e._inFlightWriteRequest._resolve(void 0), e._inFlightWriteRequest = void 0;
				}
				n2(Ba, "WritableStreamFinishInFlightWrite");
				function ka(e, t3) {
					e._inFlightWriteRequest._reject(t3), e._inFlightWriteRequest = void 0, Jr(e, t3);
				}
				n2(ka, "WritableStreamFinishInFlightWriteWithError");
				function Wa(e) {
					e._inFlightCloseRequest._resolve(void 0), e._inFlightCloseRequest = void 0, e._state === "erroring" && (e._storedError = void 0, e._pendingAbortRequest !== void 0 && (e._pendingAbortRequest._resolve(), e._pendingAbortRequest = void 0)), e._state = "closed";
					const r2 = e._writer;
					r2 !== void 0 && Uo(r2);
				}
				n2(Wa, "WritableStreamFinishInFlightClose");
				function qa(e, t3) {
					e._inFlightCloseRequest._reject(t3), e._inFlightCloseRequest = void 0, e._pendingAbortRequest !== void 0 && (e._pendingAbortRequest._reject(t3), e._pendingAbortRequest = void 0), Jr(e, t3);
				}
				n2(qa, "WritableStreamFinishInFlightCloseWithError");
				function he(e) {
					return !(e._closeRequest === void 0 && e._inFlightCloseRequest === void 0);
				}
				n2(he, "WritableStreamCloseQueuedOrInFlight");
				function Oa(e) {
					return !(e._inFlightWriteRequest === void 0 && e._inFlightCloseRequest === void 0);
				}
				n2(Oa, "WritableStreamHasOperationMarkedInFlight");
				function za(e) {
					e._inFlightCloseRequest = e._closeRequest, e._closeRequest = void 0;
				}
				n2(za, "WritableStreamMarkCloseRequestInFlight");
				function Ia(e) {
					e._inFlightWriteRequest = e._writeRequests.shift();
				}
				n2(Ia, "WritableStreamMarkFirstWriteRequestInFlight");
				function Jt(e) {
					e._closeRequest !== void 0 && (e._closeRequest._reject(e._storedError), e._closeRequest = void 0);
					const t3 = e._writer;
					t3 !== void 0 && an(t3, e._storedError);
				}
				n2(Jt, "WritableStreamRejectCloseAndClosedPromiseIfNeeded");
				function tn(e, t3) {
					const r2 = e._writer;
					r2 !== void 0 && t3 !== e._backpressure && (t3 ? Ya(r2) : ln(r2)), e._backpressure = t3;
				}
				n2(tn, "WritableStreamUpdateBackpressure");
				const Rn = class Rn {
					constructor(t3) {
						if (Se(t3, 1, "WritableStreamDefaultWriter"), Bo(t3, "First parameter"), Ze(t3)) throw new TypeError("This stream has already been locked for exclusive writing by another writer");
						this._ownerWritableStream = t3, t3._writer = this;
						const r2 = t3._state;
						if (r2 === "writable") !he(t3) && t3._backpressure ? nr(this) : xo(this), rr(this);
						else if (r2 === "erroring") sn(this, t3._storedError), rr(this);
						else if (r2 === "closed") xo(this), Va(this);
						else {
							const s = t3._storedError;
							sn(this, s), Mo(this, s);
						}
					}
					get closed() {
						return Le(this) ? this._closedPromise : b($e("closed"));
					}
					get desiredSize() {
						if (!Le(this)) throw $e("desiredSize");
						if (this._ownerWritableStream === void 0) throw Pt("desiredSize");
						return $a(this);
					}
					get ready() {
						return Le(this) ? this._readyPromise : b($e("ready"));
					}
					abort(t3 = void 0) {
						return Le(this) ? this._ownerWritableStream === void 0 ? b(Pt("abort")) : Fa(this, t3) : b($e("abort"));
					}
					close() {
						if (!Le(this)) return b($e("close"));
						const t3 = this._ownerWritableStream;
						return t3 === void 0 ? b(Pt("close")) : he(t3) ? b(/* @__PURE__ */ new TypeError("Cannot close an already-closing stream")) : Oo(this);
					}
					releaseLock() {
						if (!Le(this)) throw $e("releaseLock");
						this._ownerWritableStream !== void 0 && Io(this);
					}
					write(t3 = void 0) {
						return Le(this) ? this._ownerWritableStream === void 0 ? b(Pt("write to")) : Fo(this, t3) : b($e("write"));
					}
				};
				n2(Rn, "WritableStreamDefaultWriter");
				let re = Rn;
				Object.defineProperties(re.prototype, {
					abort: { enumerable: true },
					close: { enumerable: true },
					releaseLock: { enumerable: true },
					write: { enumerable: true },
					closed: { enumerable: true },
					desiredSize: { enumerable: true },
					ready: { enumerable: true }
				}), h2(re.prototype.abort, "abort"), h2(re.prototype.close, "close"), h2(re.prototype.releaseLock, "releaseLock"), h2(re.prototype.write, "write"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(re.prototype, Symbol.toStringTag, {
					value: "WritableStreamDefaultWriter",
					configurable: true
				});
				function Le(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_ownerWritableStream") ? false : e instanceof re;
				}
				n2(Le, "IsWritableStreamDefaultWriter");
				function Fa(e, t3) {
					const r2 = e._ownerWritableStream;
					return Kt(r2, t3);
				}
				n2(Fa, "WritableStreamDefaultWriterAbort");
				function Oo(e) {
					const t3 = e._ownerWritableStream;
					return qo(t3);
				}
				n2(Oo, "WritableStreamDefaultWriterClose");
				function ja(e) {
					const t3 = e._ownerWritableStream, r2 = t3._state;
					return he(t3) || r2 === "closed" ? T2(void 0) : r2 === "errored" ? b(t3._storedError) : Oo(e);
				}
				n2(ja, "WritableStreamDefaultWriterCloseWithErrorPropagation");
				function La(e, t3) {
					e._closedPromiseState === "pending" ? an(e, t3) : Qa(e, t3);
				}
				n2(La, "WritableStreamDefaultWriterEnsureClosedPromiseRejected");
				function zo(e, t3) {
					e._readyPromiseState === "pending" ? No(e, t3) : Ga(e, t3);
				}
				n2(zo, "WritableStreamDefaultWriterEnsureReadyPromiseRejected");
				function $a(e) {
					const t3 = e._ownerWritableStream, r2 = t3._state;
					return r2 === "errored" || r2 === "erroring" ? null : r2 === "closed" ? 0 : $o(t3._writableStreamController);
				}
				n2($a, "WritableStreamDefaultWriterGetDesiredSize");
				function Io(e) {
					const t3 = e._ownerWritableStream, r2 = /* @__PURE__ */ new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
					zo(e, r2), La(e, r2), t3._writer = void 0, e._ownerWritableStream = void 0;
				}
				n2(Io, "WritableStreamDefaultWriterRelease");
				function Fo(e, t3) {
					const r2 = e._ownerWritableStream, s = r2._writableStreamController, u = Ua(s, t3);
					if (r2 !== e._ownerWritableStream) return b(Pt("write to"));
					const c2 = r2._state;
					if (c2 === "errored") return b(r2._storedError);
					if (he(r2) || c2 === "closed") return b(/* @__PURE__ */ new TypeError("The stream is closing or closed and cannot be written to"));
					if (c2 === "erroring") return b(r2._storedError);
					const d = Aa(r2);
					return xa(s, t3, u), d;
				}
				n2(Fo, "WritableStreamDefaultWriterWrite");
				const jo = {}, Tn = class Tn {
					constructor() {
						throw new TypeError("Illegal constructor");
					}
					get abortReason() {
						if (!rn(this)) throw on2("abortReason");
						return this._abortReason;
					}
					get signal() {
						if (!rn(this)) throw on2("signal");
						if (this._abortController === void 0) throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
						return this._abortController.signal;
					}
					error(t3 = void 0) {
						if (!rn(this)) throw on2("error");
						this._controlledWritableStream._state === "writable" && Do(this, t3);
					}
					[jt](t3) {
						const r2 = this._abortAlgorithm(t3);
						return Xt(this), r2;
					}
					[Qn]() {
						Be(this);
					}
				};
				n2(Tn, "WritableStreamDefaultController");
				let ke = Tn;
				Object.defineProperties(ke.prototype, {
					abortReason: { enumerable: true },
					signal: { enumerable: true },
					error: { enumerable: true }
				}), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ke.prototype, Symbol.toStringTag, {
					value: "WritableStreamDefaultController",
					configurable: true
				});
				function rn(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledWritableStream") ? false : e instanceof ke;
				}
				n2(rn, "IsWritableStreamDefaultController");
				function Lo(e, t3, r2, s, u, c2, d, m2) {
					t3._controlledWritableStream = e, e._writableStreamController = t3, t3._queue = void 0, t3._queueTotalSize = void 0, Be(t3), t3._abortReason = void 0, t3._abortController = va(), t3._started = false, t3._strategySizeAlgorithm = m2, t3._strategyHWM = d, t3._writeAlgorithm = s, t3._closeAlgorithm = u, t3._abortAlgorithm = c2;
					tn(e, nn(t3));
					g2(T2(r2()), () => (t3._started = true, er(t3), null), (P2) => (t3._started = true, Jr(e, P2), null));
				}
				n2(Lo, "SetUpWritableStreamDefaultController");
				function Da(e, t3, r2, s) {
					const u = Object.create(ke.prototype);
					let c2, d, m2, R3;
					t3.start !== void 0 ? c2 = n2(() => t3.start(u), "startAlgorithm") : c2 = n2(() => {}, "startAlgorithm"), t3.write !== void 0 ? d = n2((y) => t3.write(y, u), "writeAlgorithm") : d = n2(() => T2(void 0), "writeAlgorithm"), t3.close !== void 0 ? m2 = n2(() => t3.close(), "closeAlgorithm") : m2 = n2(() => T2(void 0), "closeAlgorithm"), t3.abort !== void 0 ? R3 = n2((y) => t3.abort(y), "abortAlgorithm") : R3 = n2(() => T2(void 0), "abortAlgorithm"), Lo(e, u, c2, d, m2, R3, r2, s);
				}
				n2(Da, "SetUpWritableStreamDefaultControllerFromUnderlyingSink");
				function Xt(e) {
					e._writeAlgorithm = void 0, e._closeAlgorithm = void 0, e._abortAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
				}
				n2(Xt, "WritableStreamDefaultControllerClearAlgorithms");
				function Ma(e) {
					Nr(e, jo, 0), er(e);
				}
				n2(Ma, "WritableStreamDefaultControllerClose");
				function Ua(e, t3) {
					try {
						return e._strategySizeAlgorithm(t3);
					} catch (r2) {
						return Ct(e, r2), 1;
					}
				}
				n2(Ua, "WritableStreamDefaultControllerGetChunkSize");
				function $o(e) {
					return e._strategyHWM - e._queueTotalSize;
				}
				n2($o, "WritableStreamDefaultControllerGetDesiredSize");
				function xa(e, t3, r2) {
					try {
						Nr(e, t3, r2);
					} catch (u) {
						Ct(e, u);
						return;
					}
					const s = e._controlledWritableStream;
					if (!he(s) && s._state === "writable") tn(s, nn(e));
					er(e);
				}
				n2(xa, "WritableStreamDefaultControllerWrite");
				function er(e) {
					const t3 = e._controlledWritableStream;
					if (!e._started || t3._inFlightWriteRequest !== void 0) return;
					if (t3._state === "erroring") {
						en(t3);
						return;
					}
					if (e._queue.length === 0) return;
					const s = na(e);
					s === jo ? Na(e) : Ha(e, s);
				}
				n2(er, "WritableStreamDefaultControllerAdvanceQueueIfNeeded");
				function Ct(e, t3) {
					e._controlledWritableStream._state === "writable" && Do(e, t3);
				}
				n2(Ct, "WritableStreamDefaultControllerErrorIfNeeded");
				function Na(e) {
					const t3 = e._controlledWritableStream;
					za(t3), xr(e);
					const r2 = e._closeAlgorithm();
					Xt(e), g2(r2, () => (Wa(t3), null), (s) => (qa(t3, s), null));
				}
				n2(Na, "WritableStreamDefaultControllerProcessClose");
				function Ha(e, t3) {
					const r2 = e._controlledWritableStream;
					Ia(r2);
					g2(e._writeAlgorithm(t3), () => {
						Ba(r2);
						const u = r2._state;
						if (xr(e), !he(r2) && u === "writable") tn(r2, nn(e));
						return er(e), null;
					}, (u) => (r2._state === "writable" && Xt(e), ka(r2, u), null));
				}
				n2(Ha, "WritableStreamDefaultControllerProcessWrite");
				function nn(e) {
					return $o(e) <= 0;
				}
				n2(nn, "WritableStreamDefaultControllerGetBackpressure");
				function Do(e, t3) {
					const r2 = e._controlledWritableStream;
					Xt(e), Xr(r2, t3);
				}
				n2(Do, "WritableStreamDefaultControllerError");
				function tr(e) {
					return /* @__PURE__ */ new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`);
				}
				n2(tr, "streamBrandCheckException$2");
				function on2(e) {
					return /* @__PURE__ */ new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`);
				}
				n2(on2, "defaultControllerBrandCheckException$2");
				function $e(e) {
					return /* @__PURE__ */ new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`);
				}
				n2($e, "defaultWriterBrandCheckException");
				function Pt(e) {
					return /* @__PURE__ */ new TypeError("Cannot " + e + " a stream using a released writer");
				}
				n2(Pt, "defaultWriterLockException");
				function rr(e) {
					e._closedPromise = A((t3, r2) => {
						e._closedPromise_resolve = t3, e._closedPromise_reject = r2, e._closedPromiseState = "pending";
					});
				}
				n2(rr, "defaultWriterClosedPromiseInitialize");
				function Mo(e, t3) {
					rr(e), an(e, t3);
				}
				n2(Mo, "defaultWriterClosedPromiseInitializeAsRejected");
				function Va(e) {
					rr(e), Uo(e);
				}
				n2(Va, "defaultWriterClosedPromiseInitializeAsResolved");
				function an(e, t3) {
					e._closedPromise_reject !== void 0 && (Q(e._closedPromise), e._closedPromise_reject(t3), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "rejected");
				}
				n2(an, "defaultWriterClosedPromiseReject");
				function Qa(e, t3) {
					Mo(e, t3);
				}
				n2(Qa, "defaultWriterClosedPromiseResetToRejected");
				function Uo(e) {
					e._closedPromise_resolve !== void 0 && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "resolved");
				}
				n2(Uo, "defaultWriterClosedPromiseResolve");
				function nr(e) {
					e._readyPromise = A((t3, r2) => {
						e._readyPromise_resolve = t3, e._readyPromise_reject = r2;
					}), e._readyPromiseState = "pending";
				}
				n2(nr, "defaultWriterReadyPromiseInitialize");
				function sn(e, t3) {
					nr(e), No(e, t3);
				}
				n2(sn, "defaultWriterReadyPromiseInitializeAsRejected");
				function xo(e) {
					nr(e), ln(e);
				}
				n2(xo, "defaultWriterReadyPromiseInitializeAsResolved");
				function No(e, t3) {
					e._readyPromise_reject !== void 0 && (Q(e._readyPromise), e._readyPromise_reject(t3), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "rejected");
				}
				n2(No, "defaultWriterReadyPromiseReject");
				function Ya(e) {
					nr(e);
				}
				n2(Ya, "defaultWriterReadyPromiseReset");
				function Ga(e, t3) {
					sn(e, t3);
				}
				n2(Ga, "defaultWriterReadyPromiseResetToRejected");
				function ln(e) {
					e._readyPromise_resolve !== void 0 && (e._readyPromise_resolve(void 0), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "fulfilled");
				}
				n2(ln, "defaultWriterReadyPromiseResolve");
				function Za() {
					if (typeof globalThis < "u") return globalThis;
					if (typeof self < "u") return self;
					if (typeof n < "u") return n;
				}
				n2(Za, "getGlobals");
				const un = Za();
				function Ka(e) {
					if (!(typeof e == "function" || typeof e == "object") || e.name !== "DOMException") return false;
					try {
						return new e(), true;
					} catch (e2) {
						return false;
					}
				}
				n2(Ka, "isDOMExceptionConstructor");
				function Ja() {
					const e = un == null ? void 0 : un.DOMException;
					return Ka(e) ? e : void 0;
				}
				n2(Ja, "getFromGlobal");
				function Xa() {
					const e = n2(function(r2, s) {
						this.message = r2 || "", this.name = s || "Error", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
					}, "DOMException");
					return h2(e, "DOMException"), e.prototype = Object.create(Error.prototype), Object.defineProperty(e.prototype, "constructor", {
						value: e,
						writable: true,
						configurable: true
					}), e;
				}
				n2(Xa, "createPolyfill");
				const es = Ja() || Xa();
				function Ho(e, t3, r2, s, u, c2) {
					const d = Qe(e), m2 = ko(t3);
					e._disturbed = true;
					let R3 = false, y = T2(void 0);
					return A((C2, P2) => {
						let B2;
						if (c2 !== void 0) {
							if (B2 = n2(() => {
								const _ = c2.reason !== void 0 ? c2.reason : new es("Aborted", "AbortError"), E2 = [];
								s || E2.push(() => t3._state === "writable" ? Kt(t3, _) : T2(void 0)), u || E2.push(() => e._state === "readable" ? ie(e, _) : T2(void 0)), N2(() => Promise.all(E2.map((k2) => k2())), true, _);
							}, "abortAlgorithm"), c2.aborted) {
								B2();
								return;
							}
							c2.addEventListener("abort", B2);
						}
						function ae() {
							return A((_, E2) => {
								function k2(Y) {
									Y ? _() : q(nt(), k2, E2);
								}
								n2(k2, "next"), k2(false);
							});
						}
						n2(ae, "pipeLoop");
						function nt() {
							return R3 ? T2(true) : q(m2._readyPromise, () => A((_, E2) => {
								_t(d, {
									_chunkSteps: n2((k2) => {
										y = q(Fo(m2, k2), void 0, f2), _(false);
									}, "_chunkSteps"),
									_closeSteps: n2(() => _(true), "_closeSteps"),
									_errorSteps: E2
								});
							}));
						}
						if (n2(nt, "pipeStep"), Te(e, d._closedPromise, (_) => (s ? J(true, _) : N2(() => Kt(t3, _), true, _), null)), Te(t3, m2._closedPromise, (_) => (u ? J(true, _) : N2(() => ie(e, _), true, _), null)), x2(e, d._closedPromise, () => (r2 ? J() : N2(() => ja(m2)), null)), he(t3) || t3._state === "closed") {
							const _ = /* @__PURE__ */ new TypeError("the destination writable stream closed before all data could be piped to it");
							u ? J(true, _) : N2(() => ie(e, _), true, _);
						}
						Q(ae());
						function Oe() {
							const _ = y;
							return q(y, () => _ !== y ? Oe() : void 0);
						}
						n2(Oe, "waitForWritesToFinish");
						function Te(_, E2, k2) {
							_._state === "errored" ? k2(_._storedError) : I2(E2, k2);
						}
						n2(Te, "isOrBecomesErrored");
						function x2(_, E2, k2) {
							_._state === "closed" ? k2() : V(E2, k2);
						}
						n2(x2, "isOrBecomesClosed");
						function N2(_, E2, k2) {
							if (R3) return;
							R3 = true, t3._state === "writable" && !he(t3) ? V(Oe(), Y) : Y();
							function Y() {
								return g2(_(), () => Ce(E2, k2), (ot) => Ce(true, ot)), null;
							}
							n2(Y, "doTheRest");
						}
						n2(N2, "shutdownWithAction");
						function J(_, E2) {
							R3 || (R3 = true, t3._state === "writable" && !he(t3) ? V(Oe(), () => Ce(_, E2)) : Ce(_, E2));
						}
						n2(J, "shutdown");
						function Ce(_, E2) {
							return Io(m2), _e(d), c2 !== void 0 && c2.removeEventListener("abort", B2), _ ? P2(E2) : C2(void 0), null;
						}
						n2(Ce, "finalize");
					});
				}
				n2(Ho, "ReadableStreamPipeTo");
				const Cn = class Cn {
					constructor() {
						throw new TypeError("Illegal constructor");
					}
					get desiredSize() {
						if (!or(this)) throw ar("desiredSize");
						return fn(this);
					}
					close() {
						if (!or(this)) throw ar("close");
						if (!Je(this)) throw new TypeError("The stream is not in a state that permits close");
						De(this);
					}
					enqueue(t3 = void 0) {
						if (!or(this)) throw ar("enqueue");
						if (!Je(this)) throw new TypeError("The stream is not in a state that permits enqueue");
						return Ke(this, t3);
					}
					error(t3 = void 0) {
						if (!or(this)) throw ar("error");
						oe(this, t3);
					}
					[Ar](t3) {
						Be(this);
						const r2 = this._cancelAlgorithm(t3);
						return ir(this), r2;
					}
					[Br](t3) {
						const r2 = this._controlledReadableStream;
						if (this._queue.length > 0) {
							const s = xr(this);
							this._closeRequested && this._queue.length === 0 ? (ir(this), At(r2)) : vt(this), t3._chunkSteps(s);
						} else eo(r2, t3), vt(this);
					}
					[kr]() {}
				};
				n2(Cn, "ReadableStreamDefaultController");
				let ne = Cn;
				Object.defineProperties(ne.prototype, {
					close: { enumerable: true },
					enqueue: { enumerable: true },
					error: { enumerable: true },
					desiredSize: { enumerable: true }
				}), h2(ne.prototype.close, "close"), h2(ne.prototype.enqueue, "enqueue"), h2(ne.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ne.prototype, Symbol.toStringTag, {
					value: "ReadableStreamDefaultController",
					configurable: true
				});
				function or(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledReadableStream") ? false : e instanceof ne;
				}
				n2(or, "IsReadableStreamDefaultController");
				function vt(e) {
					if (!Vo(e)) return;
					if (e._pulling) {
						e._pullAgain = true;
						return;
					}
					e._pulling = true;
					g2(e._pullAlgorithm(), () => (e._pulling = false, e._pullAgain && (e._pullAgain = false, vt(e)), null), (s) => (oe(e, s), null));
				}
				n2(vt, "ReadableStreamDefaultControllerCallPullIfNeeded");
				function Vo(e) {
					const t3 = e._controlledReadableStream;
					return !Je(e) || !e._started ? false : !!(qe(t3) && $t(t3) > 0 || fn(e) > 0);
				}
				n2(Vo, "ReadableStreamDefaultControllerShouldCallPull");
				function ir(e) {
					e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
				}
				n2(ir, "ReadableStreamDefaultControllerClearAlgorithms");
				function De(e) {
					if (!Je(e)) return;
					const t3 = e._controlledReadableStream;
					e._closeRequested = true, e._queue.length === 0 && (ir(e), At(t3));
				}
				n2(De, "ReadableStreamDefaultControllerClose");
				function Ke(e, t3) {
					if (!Je(e)) return;
					const r2 = e._controlledReadableStream;
					if (qe(r2) && $t(r2) > 0) Lr(r2, t3, false);
					else {
						let s;
						try {
							s = e._strategySizeAlgorithm(t3);
						} catch (u) {
							throw oe(e, u), u;
						}
						try {
							Nr(e, t3, s);
						} catch (u) {
							throw oe(e, u), u;
						}
					}
					vt(e);
				}
				n2(Ke, "ReadableStreamDefaultControllerEnqueue");
				function oe(e, t3) {
					const r2 = e._controlledReadableStream;
					r2._state === "readable" && (Be(e), ir(e), Zo(r2, t3));
				}
				n2(oe, "ReadableStreamDefaultControllerError");
				function fn(e) {
					const t3 = e._controlledReadableStream._state;
					return t3 === "errored" ? null : t3 === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
				}
				n2(fn, "ReadableStreamDefaultControllerGetDesiredSize");
				function ts(e) {
					return !Vo(e);
				}
				n2(ts, "ReadableStreamDefaultControllerHasBackpressure");
				function Je(e) {
					const t3 = e._controlledReadableStream._state;
					return !e._closeRequested && t3 === "readable";
				}
				n2(Je, "ReadableStreamDefaultControllerCanCloseOrEnqueue");
				function Qo(e, t3, r2, s, u, c2, d) {
					t3._controlledReadableStream = e, t3._queue = void 0, t3._queueTotalSize = void 0, Be(t3), t3._started = false, t3._closeRequested = false, t3._pullAgain = false, t3._pulling = false, t3._strategySizeAlgorithm = d, t3._strategyHWM = c2, t3._pullAlgorithm = s, t3._cancelAlgorithm = u, e._readableStreamController = t3;
					g2(T2(r2()), () => (t3._started = true, vt(t3), null), (R3) => (oe(t3, R3), null));
				}
				n2(Qo, "SetUpReadableStreamDefaultController");
				function rs(e, t3, r2, s) {
					const u = Object.create(ne.prototype);
					let c2, d, m2;
					t3.start !== void 0 ? c2 = n2(() => t3.start(u), "startAlgorithm") : c2 = n2(() => {}, "startAlgorithm"), t3.pull !== void 0 ? d = n2(() => t3.pull(u), "pullAlgorithm") : d = n2(() => T2(void 0), "pullAlgorithm"), t3.cancel !== void 0 ? m2 = n2((R3) => t3.cancel(R3), "cancelAlgorithm") : m2 = n2(() => T2(void 0), "cancelAlgorithm"), Qo(e, u, c2, d, m2, r2, s);
				}
				n2(rs, "SetUpReadableStreamDefaultControllerFromUnderlyingSource");
				function ar(e) {
					return /* @__PURE__ */ new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`);
				}
				n2(ar, "defaultControllerBrandCheckException$1");
				function ns(e, t3) {
					return Ie(e._readableStreamController) ? is(e) : os(e);
				}
				n2(ns, "ReadableStreamTee");
				function os(e, t3) {
					const r2 = Qe(e);
					let s = false, u = false, c2 = false, d = false, m2, R3, y, C2, P2;
					const B2 = A((x2) => {
						P2 = x2;
					});
					function ae() {
						return s ? (u = true, T2(void 0)) : (s = true, _t(r2, {
							_chunkSteps: n2((N2) => {
								ge(() => {
									u = false;
									const J = N2, Ce = N2;
									c2 || Ke(y._readableStreamController, J), d || Ke(C2._readableStreamController, Ce), s = false, u && ae();
								});
							}, "_chunkSteps"),
							_closeSteps: n2(() => {
								s = false, c2 || De(y._readableStreamController), d || De(C2._readableStreamController), (!c2 || !d) && P2(void 0);
							}, "_closeSteps"),
							_errorSteps: n2(() => {
								s = false;
							}, "_errorSteps")
						}), T2(void 0));
					}
					n2(ae, "pullAlgorithm");
					function nt(x2) {
						if (c2 = true, m2 = x2, d) {
							const J = ie(e, St([m2, R3]));
							P2(J);
						}
						return B2;
					}
					n2(nt, "cancel1Algorithm");
					function Oe(x2) {
						if (d = true, R3 = x2, c2) {
							const J = ie(e, St([m2, R3]));
							P2(J);
						}
						return B2;
					}
					n2(Oe, "cancel2Algorithm");
					function Te() {}
					return n2(Te, "startAlgorithm"), y = Et(Te, ae, nt), C2 = Et(Te, ae, Oe), I2(r2._closedPromise, (x2) => (oe(y._readableStreamController, x2), oe(C2._readableStreamController, x2), (!c2 || !d) && P2(void 0), null)), [y, C2];
				}
				n2(os, "ReadableStreamDefaultTee");
				function is(e) {
					let t3 = Qe(e), r2 = false, s = false, u = false, c2 = false, d = false, m2, R3, y, C2, P2;
					const B2 = A((_) => {
						P2 = _;
					});
					function ae(_) {
						I2(_._closedPromise, (E2) => (_ !== t3 || (K(y._readableStreamController, E2), K(C2._readableStreamController, E2), (!c2 || !d) && P2(void 0)), null));
					}
					n2(ae, "forwardReaderError");
					function nt() {
						je(t3) && (_e(t3), t3 = Qe(e), ae(t3)), _t(t3, {
							_chunkSteps: n2((E2) => {
								ge(() => {
									s = false, u = false;
									const k2 = E2;
									let Y = E2;
									if (!c2 && !d) try {
										Y = fo(E2);
									} catch (ot) {
										K(y._readableStreamController, ot), K(C2._readableStreamController, ot), P2(ie(e, ot));
										return;
									}
									c2 || Ht(y._readableStreamController, k2), d || Ht(C2._readableStreamController, Y), r2 = false, s ? Te() : u && x2();
								});
							}, "_chunkSteps"),
							_closeSteps: n2(() => {
								r2 = false, c2 || wt(y._readableStreamController), d || wt(C2._readableStreamController), y._readableStreamController._pendingPullIntos.length > 0 && Vt(y._readableStreamController, 0), C2._readableStreamController._pendingPullIntos.length > 0 && Vt(C2._readableStreamController, 0), (!c2 || !d) && P2(void 0);
							}, "_closeSteps"),
							_errorSteps: n2(() => {
								r2 = false;
							}, "_errorSteps")
						});
					}
					n2(nt, "pullWithDefaultReader");
					function Oe(_, E2) {
						Ee(t3) && (_e(t3), t3 = Co(e), ae(t3));
						const k2 = E2 ? C2 : y, Y = E2 ? y : C2;
						Eo(t3, _, 1, {
							_chunkSteps: n2((it) => {
								ge(() => {
									s = false, u = false;
									const at = E2 ? d : c2;
									if (E2 ? c2 : d) at || Qt(k2._readableStreamController, it);
									else {
										let ui;
										try {
											ui = fo(it);
										} catch (kn) {
											K(k2._readableStreamController, kn), K(Y._readableStreamController, kn), P2(ie(e, kn));
											return;
										}
										at || Qt(k2._readableStreamController, it), Ht(Y._readableStreamController, ui);
									}
									r2 = false, s ? Te() : u && x2();
								});
							}, "_chunkSteps"),
							_closeSteps: n2((it) => {
								r2 = false;
								const at = E2 ? d : c2, cr = E2 ? c2 : d;
								at || wt(k2._readableStreamController), cr || wt(Y._readableStreamController), it !== void 0 && (at || Qt(k2._readableStreamController, it), !cr && Y._readableStreamController._pendingPullIntos.length > 0 && Vt(Y._readableStreamController, 0)), (!at || !cr) && P2(void 0);
							}, "_closeSteps"),
							_errorSteps: n2(() => {
								r2 = false;
							}, "_errorSteps")
						});
					}
					n2(Oe, "pullWithBYOBReader");
					function Te() {
						if (r2) return s = true, T2(void 0);
						r2 = true;
						const _ = Gr(y._readableStreamController);
						return _ === null ? nt() : Oe(_._view, false), T2(void 0);
					}
					n2(Te, "pull1Algorithm");
					function x2() {
						if (r2) return u = true, T2(void 0);
						r2 = true;
						const _ = Gr(C2._readableStreamController);
						return _ === null ? nt() : Oe(_._view, true), T2(void 0);
					}
					n2(x2, "pull2Algorithm");
					function N2(_) {
						if (c2 = true, m2 = _, d) {
							const k2 = ie(e, St([m2, R3]));
							P2(k2);
						}
						return B2;
					}
					n2(N2, "cancel1Algorithm");
					function J(_) {
						if (d = true, R3 = _, c2) {
							const k2 = ie(e, St([m2, R3]));
							P2(k2);
						}
						return B2;
					}
					n2(J, "cancel2Algorithm");
					function Ce() {}
					return n2(Ce, "startAlgorithm"), y = Go(Ce, Te, N2), C2 = Go(Ce, x2, J), ae(t3), [y, C2];
				}
				n2(is, "ReadableByteStreamTee");
				function as(e) {
					return l(e) && typeof e.getReader < "u";
				}
				n2(as, "isReadableStreamLike");
				function ss(e) {
					return as(e) ? us(e.getReader()) : ls(e);
				}
				n2(ss, "ReadableStreamFrom");
				function ls(e) {
					let t3;
					const r2 = uo(e, "async"), s = f2;
					function u() {
						let d;
						try {
							d = Xi(r2);
						} catch (R3) {
							return b(R3);
						}
						return F4(T2(d), (R3) => {
							if (!l(R3)) throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
							if (ea(R3)) De(t3._readableStreamController);
							else {
								const C2 = ta(R3);
								Ke(t3._readableStreamController, C2);
							}
						});
					}
					n2(u, "pullAlgorithm");
					function c2(d) {
						const m2 = r2.iterator;
						let R3;
						try {
							R3 = Ut(m2, "return");
						} catch (P2) {
							return b(P2);
						}
						if (R3 === void 0) return T2(void 0);
						let y;
						try {
							y = z(R3, m2, [d]);
						} catch (P2) {
							return b(P2);
						}
						return F4(T2(y), (P2) => {
							if (!l(P2)) throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
						});
					}
					return n2(c2, "cancelAlgorithm"), t3 = Et(s, u, c2, 0), t3;
				}
				n2(ls, "ReadableStreamFromIterable");
				function us(e) {
					let t3;
					const r2 = f2;
					function s() {
						let c2;
						try {
							c2 = e.read();
						} catch (d) {
							return b(d);
						}
						return F4(c2, (d) => {
							if (!l(d)) throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
							if (d.done) De(t3._readableStreamController);
							else {
								const m2 = d.value;
								Ke(t3._readableStreamController, m2);
							}
						});
					}
					n2(s, "pullAlgorithm");
					function u(c2) {
						try {
							return T2(e.cancel(c2));
						} catch (d) {
							return b(d);
						}
					}
					return n2(u, "cancelAlgorithm"), t3 = Et(r2, s, u, 0), t3;
				}
				n2(us, "ReadableStreamFromDefaultReader");
				function fs6(e, t3) {
					ue(e, t3);
					const r2 = e, s = r2 == null ? void 0 : r2.autoAllocateChunkSize, u = r2 == null ? void 0 : r2.cancel, c2 = r2 == null ? void 0 : r2.pull, d = r2 == null ? void 0 : r2.start, m2 = r2 == null ? void 0 : r2.type;
					return {
						autoAllocateChunkSize: s === void 0 ? void 0 : Fr(s, `${t3} has member 'autoAllocateChunkSize' that`),
						cancel: u === void 0 ? void 0 : cs(u, r2, `${t3} has member 'cancel' that`),
						pull: c2 === void 0 ? void 0 : ds(c2, r2, `${t3} has member 'pull' that`),
						start: d === void 0 ? void 0 : hs(d, r2, `${t3} has member 'start' that`),
						type: m2 === void 0 ? void 0 : ps(m2, `${t3} has member 'type' that`)
					};
				}
				n2(fs6, "convertUnderlyingDefaultOrByteSource");
				function cs(e, t3, r2) {
					return Z2(e, r2), (s) => j(e, t3, [s]);
				}
				n2(cs, "convertUnderlyingSourceCancelCallback");
				function ds(e, t3, r2) {
					return Z2(e, r2), (s) => j(e, t3, [s]);
				}
				n2(ds, "convertUnderlyingSourcePullCallback");
				function hs(e, t3, r2) {
					return Z2(e, r2), (s) => z(e, t3, [s]);
				}
				n2(hs, "convertUnderlyingSourceStartCallback");
				function ps(e, t3) {
					if (e = `${e}`, e !== "bytes") throw new TypeError(`${t3} '${e}' is not a valid enumeration value for ReadableStreamType`);
					return e;
				}
				n2(ps, "convertReadableStreamType");
				function bs(e, t3) {
					return ue(e, t3), { preventCancel: !!(e == null ? void 0 : e.preventCancel) };
				}
				n2(bs, "convertIteratorOptions");
				function Yo(e, t3) {
					ue(e, t3);
					const r2 = e == null ? void 0 : e.preventAbort, s = e == null ? void 0 : e.preventCancel, u = e == null ? void 0 : e.preventClose, c2 = e == null ? void 0 : e.signal;
					return c2 !== void 0 && ms(c2, `${t3} has member 'signal' that`), {
						preventAbort: !!r2,
						preventCancel: !!s,
						preventClose: !!u,
						signal: c2
					};
				}
				n2(Yo, "convertPipeOptions");
				function ms(e, t3) {
					if (!Ca(e)) throw new TypeError(`${t3} is not an AbortSignal.`);
				}
				n2(ms, "assertAbortSignal");
				function ys(e, t3) {
					ue(e, t3);
					const r2 = e == null ? void 0 : e.readable;
					zr(r2, "readable", "ReadableWritablePair"), jr(r2, `${t3} has member 'readable' that`);
					const s = e == null ? void 0 : e.writable;
					return zr(s, "writable", "ReadableWritablePair"), Bo(s, `${t3} has member 'writable' that`), {
						readable: r2,
						writable: s
					};
				}
				n2(ys, "convertReadableWritablePair");
				const Pn = class Pn {
					constructor(t3 = {}, r2 = {}) {
						t3 === void 0 ? t3 = null : Jn(t3, "First parameter");
						const s = Zt(r2, "Second parameter"), u = fs6(t3, "First parameter");
						if (cn(this), u.type === "bytes") {
							if (s.size !== void 0) throw new RangeError("The strategy for a byte stream cannot have a size function");
							const c2 = Tt(s, 0);
							ca(this, u, c2);
						} else {
							const c2 = Gt(s), d = Tt(s, 1);
							rs(this, u, d, c2);
						}
					}
					get locked() {
						if (!We(this)) throw Me("locked");
						return qe(this);
					}
					cancel(t3 = void 0) {
						return We(this) ? qe(this) ? b(/* @__PURE__ */ new TypeError("Cannot cancel a stream that already has a reader")) : ie(this, t3) : b(Me("cancel"));
					}
					getReader(t3 = void 0) {
						if (!We(this)) throw Me("getReader");
						return ha(t3, "First parameter").mode === void 0 ? Qe(this) : Co(this);
					}
					pipeThrough(t3, r2 = {}) {
						if (!We(this)) throw Me("pipeThrough");
						Se(t3, 1, "pipeThrough");
						const s = ys(t3, "First parameter"), u = Yo(r2, "Second parameter");
						if (qe(this)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
						if (Ze(s.writable)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
						return Q(Ho(this, s.writable, u.preventClose, u.preventAbort, u.preventCancel, u.signal)), s.readable;
					}
					pipeTo(t3, r2 = {}) {
						if (!We(this)) return b(Me("pipeTo"));
						if (t3 === void 0) return b("Parameter 1 is required in 'pipeTo'.");
						if (!Ge(t3)) return b(/* @__PURE__ */ new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
						let s;
						try {
							s = Yo(r2, "Second parameter");
						} catch (u) {
							return b(u);
						}
						return qe(this) ? b(/* @__PURE__ */ new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : Ze(t3) ? b(/* @__PURE__ */ new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : Ho(this, t3, s.preventClose, s.preventAbort, s.preventCancel, s.signal);
					}
					tee() {
						if (!We(this)) throw Me("tee");
						return St(ns(this));
					}
					values(t3 = void 0) {
						if (!We(this)) throw Me("values");
						const r2 = bs(t3, "First parameter");
						return Ki(this, r2.preventCancel);
					}
					[Ur](t3) {
						return this.values(t3);
					}
					static from(t3) {
						return ss(t3);
					}
				};
				n2(Pn, "ReadableStream");
				let L = Pn;
				Object.defineProperties(L, { from: { enumerable: true } }), Object.defineProperties(L.prototype, {
					cancel: { enumerable: true },
					getReader: { enumerable: true },
					pipeThrough: { enumerable: true },
					pipeTo: { enumerable: true },
					tee: { enumerable: true },
					values: { enumerable: true },
					locked: { enumerable: true }
				}), h2(L.from, "from"), h2(L.prototype.cancel, "cancel"), h2(L.prototype.getReader, "getReader"), h2(L.prototype.pipeThrough, "pipeThrough"), h2(L.prototype.pipeTo, "pipeTo"), h2(L.prototype.tee, "tee"), h2(L.prototype.values, "values"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(L.prototype, Symbol.toStringTag, {
					value: "ReadableStream",
					configurable: true
				}), Object.defineProperty(L.prototype, Ur, {
					value: L.prototype.values,
					writable: true,
					configurable: true
				});
				function Et(e, t3, r2, s = 1, u = () => 1) {
					const c2 = Object.create(L.prototype);
					cn(c2);
					return Qo(c2, Object.create(ne.prototype), e, t3, r2, s, u), c2;
				}
				n2(Et, "CreateReadableStream");
				function Go(e, t3, r2) {
					const s = Object.create(L.prototype);
					cn(s);
					return To(s, Object.create(te.prototype), e, t3, r2, 0, void 0), s;
				}
				n2(Go, "CreateReadableByteStream");
				function cn(e) {
					e._state = "readable", e._reader = void 0, e._storedError = void 0, e._disturbed = false;
				}
				n2(cn, "InitializeReadableStream");
				function We(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readableStreamController") ? false : e instanceof L;
				}
				n2(We, "IsReadableStream");
				function qe(e) {
					return e._reader !== void 0;
				}
				n2(qe, "IsReadableStreamLocked");
				function ie(e, t3) {
					if (e._disturbed = true, e._state === "closed") return T2(void 0);
					if (e._state === "errored") return b(e._storedError);
					At(e);
					const r2 = e._reader;
					if (r2 !== void 0 && je(r2)) {
						const u = r2._readIntoRequests;
						r2._readIntoRequests = new D2(), u.forEach((c2) => {
							c2._closeSteps(void 0);
						});
					}
					return F4(e._readableStreamController[Ar](t3), f2);
				}
				n2(ie, "ReadableStreamCancel");
				function At(e) {
					e._state = "closed";
					const t3 = e._reader;
					if (t3 !== void 0 && (Zn(t3), Ee(t3))) {
						const r2 = t3._readRequests;
						t3._readRequests = new D2(), r2.forEach((s) => {
							s._closeSteps();
						});
					}
				}
				n2(At, "ReadableStreamClose");
				function Zo(e, t3) {
					e._state = "errored", e._storedError = t3;
					const r2 = e._reader;
					r2 !== void 0 && (Or(r2, t3), Ee(r2) ? ro(r2, t3) : Ao(r2, t3));
				}
				n2(Zo, "ReadableStreamError");
				function Me(e) {
					return /* @__PURE__ */ new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`);
				}
				n2(Me, "streamBrandCheckException$1");
				function Ko(e, t3) {
					ue(e, t3);
					const r2 = e == null ? void 0 : e.highWaterMark;
					return zr(r2, "highWaterMark", "QueuingStrategyInit"), { highWaterMark: Ir(r2) };
				}
				n2(Ko, "convertQueuingStrategyInit");
				const Jo = n2((e) => e.byteLength, "byteLengthSizeFunction");
				h2(Jo, "size");
				const vn = class vn {
					constructor(t3) {
						Se(t3, 1, "ByteLengthQueuingStrategy"), t3 = Ko(t3, "First parameter"), this._byteLengthQueuingStrategyHighWaterMark = t3.highWaterMark;
					}
					get highWaterMark() {
						if (!ei(this)) throw Xo("highWaterMark");
						return this._byteLengthQueuingStrategyHighWaterMark;
					}
					get size() {
						if (!ei(this)) throw Xo("size");
						return Jo;
					}
				};
				n2(vn, "ByteLengthQueuingStrategy");
				let Xe = vn;
				Object.defineProperties(Xe.prototype, {
					highWaterMark: { enumerable: true },
					size: { enumerable: true }
				}), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Xe.prototype, Symbol.toStringTag, {
					value: "ByteLengthQueuingStrategy",
					configurable: true
				});
				function Xo(e) {
					return /* @__PURE__ */ new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`);
				}
				n2(Xo, "byteLengthBrandCheckException");
				function ei(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_byteLengthQueuingStrategyHighWaterMark") ? false : e instanceof Xe;
				}
				n2(ei, "IsByteLengthQueuingStrategy");
				const ti = n2(() => 1, "countSizeFunction");
				h2(ti, "size");
				const En = class En {
					constructor(t3) {
						Se(t3, 1, "CountQueuingStrategy"), t3 = Ko(t3, "First parameter"), this._countQueuingStrategyHighWaterMark = t3.highWaterMark;
					}
					get highWaterMark() {
						if (!ni(this)) throw ri("highWaterMark");
						return this._countQueuingStrategyHighWaterMark;
					}
					get size() {
						if (!ni(this)) throw ri("size");
						return ti;
					}
				};
				n2(En, "CountQueuingStrategy");
				let et = En;
				Object.defineProperties(et.prototype, {
					highWaterMark: { enumerable: true },
					size: { enumerable: true }
				}), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(et.prototype, Symbol.toStringTag, {
					value: "CountQueuingStrategy",
					configurable: true
				});
				function ri(e) {
					return /* @__PURE__ */ new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`);
				}
				n2(ri, "countBrandCheckException");
				function ni(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_countQueuingStrategyHighWaterMark") ? false : e instanceof et;
				}
				n2(ni, "IsCountQueuingStrategy");
				function gs(e, t3) {
					ue(e, t3);
					const r2 = e == null ? void 0 : e.cancel, s = e == null ? void 0 : e.flush, u = e == null ? void 0 : e.readableType, c2 = e == null ? void 0 : e.start, d = e == null ? void 0 : e.transform, m2 = e == null ? void 0 : e.writableType;
					return {
						cancel: r2 === void 0 ? void 0 : Rs(r2, e, `${t3} has member 'cancel' that`),
						flush: s === void 0 ? void 0 : _s(s, e, `${t3} has member 'flush' that`),
						readableType: u,
						start: c2 === void 0 ? void 0 : Ss(c2, e, `${t3} has member 'start' that`),
						transform: d === void 0 ? void 0 : ws(d, e, `${t3} has member 'transform' that`),
						writableType: m2
					};
				}
				n2(gs, "convertTransformer");
				function _s(e, t3, r2) {
					return Z2(e, r2), (s) => j(e, t3, [s]);
				}
				n2(_s, "convertTransformerFlushCallback");
				function Ss(e, t3, r2) {
					return Z2(e, r2), (s) => z(e, t3, [s]);
				}
				n2(Ss, "convertTransformerStartCallback");
				function ws(e, t3, r2) {
					return Z2(e, r2), (s, u) => j(e, t3, [s, u]);
				}
				n2(ws, "convertTransformerTransformCallback");
				function Rs(e, t3, r2) {
					return Z2(e, r2), (s) => j(e, t3, [s]);
				}
				n2(Rs, "convertTransformerCancelCallback");
				const An = class An {
					constructor(t3 = {}, r2 = {}, s = {}) {
						t3 === void 0 && (t3 = null);
						const u = Zt(r2, "Second parameter"), c2 = Zt(s, "Third parameter"), d = gs(t3, "First parameter");
						if (d.readableType !== void 0) throw new RangeError("Invalid readableType specified");
						if (d.writableType !== void 0) throw new RangeError("Invalid writableType specified");
						const m2 = Tt(c2, 0), R3 = Gt(c2), y = Tt(u, 1), C2 = Gt(u);
						let P2;
						const B2 = A((ae) => {
							P2 = ae;
						});
						Ts(this, B2, y, C2, m2, R3), Ps(this, d), d.start !== void 0 ? P2(d.start(this._transformStreamController)) : P2(void 0);
					}
					get readable() {
						if (!oi(this)) throw li("readable");
						return this._readable;
					}
					get writable() {
						if (!oi(this)) throw li("writable");
						return this._writable;
					}
				};
				n2(An, "TransformStream");
				let tt = An;
				Object.defineProperties(tt.prototype, {
					readable: { enumerable: true },
					writable: { enumerable: true }
				}), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(tt.prototype, Symbol.toStringTag, {
					value: "TransformStream",
					configurable: true
				});
				function Ts(e, t3, r2, s, u, c2) {
					function d() {
						return t3;
					}
					n2(d, "startAlgorithm");
					function m2(B2) {
						return As(e, B2);
					}
					n2(m2, "writeAlgorithm");
					function R3(B2) {
						return Bs(e, B2);
					}
					n2(R3, "abortAlgorithm");
					function y() {
						return ks(e);
					}
					n2(y, "closeAlgorithm"), e._writable = Ea(d, m2, y, R3, r2, s);
					function C2() {
						return Ws(e);
					}
					n2(C2, "pullAlgorithm");
					function P2(B2) {
						return qs(e, B2);
					}
					n2(P2, "cancelAlgorithm"), e._readable = Et(d, C2, P2, u, c2), e._backpressure = void 0, e._backpressureChangePromise = void 0, e._backpressureChangePromise_resolve = void 0, sr(e, true), e._transformStreamController = void 0;
				}
				n2(Ts, "InitializeTransformStream");
				function oi(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_transformStreamController") ? false : e instanceof tt;
				}
				n2(oi, "IsTransformStream");
				function ii(e, t3) {
					oe(e._readable._readableStreamController, t3), dn(e, t3);
				}
				n2(ii, "TransformStreamError");
				function dn(e, t3) {
					ur(e._transformStreamController), Ct(e._writable._writableStreamController, t3), hn(e);
				}
				n2(dn, "TransformStreamErrorWritableAndUnblockWrite");
				function hn(e) {
					e._backpressure && sr(e, false);
				}
				n2(hn, "TransformStreamUnblockWrite");
				function sr(e, t3) {
					e._backpressureChangePromise !== void 0 && e._backpressureChangePromise_resolve(), e._backpressureChangePromise = A((r2) => {
						e._backpressureChangePromise_resolve = r2;
					}), e._backpressure = t3;
				}
				n2(sr, "TransformStreamSetBackpressure");
				const Bn = class Bn {
					constructor() {
						throw new TypeError("Illegal constructor");
					}
					get desiredSize() {
						if (!lr(this)) throw fr("desiredSize");
						const t3 = this._controlledTransformStream._readable._readableStreamController;
						return fn(t3);
					}
					enqueue(t3 = void 0) {
						if (!lr(this)) throw fr("enqueue");
						ai(this, t3);
					}
					error(t3 = void 0) {
						if (!lr(this)) throw fr("error");
						vs(this, t3);
					}
					terminate() {
						if (!lr(this)) throw fr("terminate");
						Es(this);
					}
				};
				n2(Bn, "TransformStreamDefaultController");
				let pe = Bn;
				Object.defineProperties(pe.prototype, {
					enqueue: { enumerable: true },
					error: { enumerable: true },
					terminate: { enumerable: true },
					desiredSize: { enumerable: true }
				}), h2(pe.prototype.enqueue, "enqueue"), h2(pe.prototype.error, "error"), h2(pe.prototype.terminate, "terminate"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(pe.prototype, Symbol.toStringTag, {
					value: "TransformStreamDefaultController",
					configurable: true
				});
				function lr(e) {
					return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledTransformStream") ? false : e instanceof pe;
				}
				n2(lr, "IsTransformStreamDefaultController");
				function Cs(e, t3, r2, s, u) {
					t3._controlledTransformStream = e, e._transformStreamController = t3, t3._transformAlgorithm = r2, t3._flushAlgorithm = s, t3._cancelAlgorithm = u, t3._finishPromise = void 0, t3._finishPromise_resolve = void 0, t3._finishPromise_reject = void 0;
				}
				n2(Cs, "SetUpTransformStreamDefaultController");
				function Ps(e, t3) {
					const r2 = Object.create(pe.prototype);
					let s, u, c2;
					t3.transform !== void 0 ? s = n2((d) => t3.transform(d, r2), "transformAlgorithm") : s = n2((d) => {
						try {
							return ai(r2, d), T2(void 0);
						} catch (m2) {
							return b(m2);
						}
					}, "transformAlgorithm"), t3.flush !== void 0 ? u = n2(() => t3.flush(r2), "flushAlgorithm") : u = n2(() => T2(void 0), "flushAlgorithm"), t3.cancel !== void 0 ? c2 = n2((d) => t3.cancel(d), "cancelAlgorithm") : c2 = n2(() => T2(void 0), "cancelAlgorithm"), Cs(e, r2, s, u, c2);
				}
				n2(Ps, "SetUpTransformStreamDefaultControllerFromTransformer");
				function ur(e) {
					e._transformAlgorithm = void 0, e._flushAlgorithm = void 0, e._cancelAlgorithm = void 0;
				}
				n2(ur, "TransformStreamDefaultControllerClearAlgorithms");
				function ai(e, t3) {
					const r2 = e._controlledTransformStream, s = r2._readable._readableStreamController;
					if (!Je(s)) throw new TypeError("Readable side is not in a state that permits enqueue");
					try {
						Ke(s, t3);
					} catch (c2) {
						throw dn(r2, c2), r2._readable._storedError;
					}
					ts(s) !== r2._backpressure && sr(r2, true);
				}
				n2(ai, "TransformStreamDefaultControllerEnqueue");
				function vs(e, t3) {
					ii(e._controlledTransformStream, t3);
				}
				n2(vs, "TransformStreamDefaultControllerError");
				function si(e, t3) {
					return F4(e._transformAlgorithm(t3), void 0, (s) => {
						throw ii(e._controlledTransformStream, s), s;
					});
				}
				n2(si, "TransformStreamDefaultControllerPerformTransform");
				function Es(e) {
					const t3 = e._controlledTransformStream, r2 = t3._readable._readableStreamController;
					De(r2);
					dn(t3, /* @__PURE__ */ new TypeError("TransformStream terminated"));
				}
				n2(Es, "TransformStreamDefaultControllerTerminate");
				function As(e, t3) {
					const r2 = e._transformStreamController;
					if (e._backpressure) {
						const s = e._backpressureChangePromise;
						return F4(s, () => {
							const u = e._writable;
							if (u._state === "erroring") throw u._storedError;
							return si(r2, t3);
						});
					}
					return si(r2, t3);
				}
				n2(As, "TransformStreamDefaultSinkWriteAlgorithm");
				function Bs(e, t3) {
					const r2 = e._transformStreamController;
					if (r2._finishPromise !== void 0) return r2._finishPromise;
					const s = e._readable;
					r2._finishPromise = A((c2, d) => {
						r2._finishPromise_resolve = c2, r2._finishPromise_reject = d;
					});
					const u = r2._cancelAlgorithm(t3);
					return ur(r2), g2(u, () => (s._state === "errored" ? rt(r2, s._storedError) : (oe(s._readableStreamController, t3), pn(r2)), null), (c2) => (oe(s._readableStreamController, c2), rt(r2, c2), null)), r2._finishPromise;
				}
				n2(Bs, "TransformStreamDefaultSinkAbortAlgorithm");
				function ks(e) {
					const t3 = e._transformStreamController;
					if (t3._finishPromise !== void 0) return t3._finishPromise;
					const r2 = e._readable;
					t3._finishPromise = A((u, c2) => {
						t3._finishPromise_resolve = u, t3._finishPromise_reject = c2;
					});
					const s = t3._flushAlgorithm();
					return ur(t3), g2(s, () => (r2._state === "errored" ? rt(t3, r2._storedError) : (De(r2._readableStreamController), pn(t3)), null), (u) => (oe(r2._readableStreamController, u), rt(t3, u), null)), t3._finishPromise;
				}
				n2(ks, "TransformStreamDefaultSinkCloseAlgorithm");
				function Ws(e) {
					return sr(e, false), e._backpressureChangePromise;
				}
				n2(Ws, "TransformStreamDefaultSourcePullAlgorithm");
				function qs(e, t3) {
					const r2 = e._transformStreamController;
					if (r2._finishPromise !== void 0) return r2._finishPromise;
					const s = e._writable;
					r2._finishPromise = A((c2, d) => {
						r2._finishPromise_resolve = c2, r2._finishPromise_reject = d;
					});
					const u = r2._cancelAlgorithm(t3);
					return ur(r2), g2(u, () => (s._state === "errored" ? rt(r2, s._storedError) : (Ct(s._writableStreamController, t3), hn(e), pn(r2)), null), (c2) => (Ct(s._writableStreamController, c2), hn(e), rt(r2, c2), null)), r2._finishPromise;
				}
				n2(qs, "TransformStreamDefaultSourceCancelAlgorithm");
				function fr(e) {
					return /* @__PURE__ */ new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`);
				}
				n2(fr, "defaultControllerBrandCheckException");
				function pn(e) {
					e._finishPromise_resolve !== void 0 && (e._finishPromise_resolve(), e._finishPromise_resolve = void 0, e._finishPromise_reject = void 0);
				}
				n2(pn, "defaultControllerFinishPromiseResolve");
				function rt(e, t3) {
					e._finishPromise_reject !== void 0 && (Q(e._finishPromise), e._finishPromise_reject(t3), e._finishPromise_resolve = void 0, e._finishPromise_reject = void 0);
				}
				n2(rt, "defaultControllerFinishPromiseReject");
				function li(e) {
					return /* @__PURE__ */ new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`);
				}
				n2(li, "streamBrandCheckException"), a.ByteLengthQueuingStrategy = Xe, a.CountQueuingStrategy = et, a.ReadableByteStreamController = te, a.ReadableStream = L, a.ReadableStreamBYOBReader = ce, a.ReadableStreamBYOBRequest = Re, a.ReadableStreamDefaultController = ne, a.ReadableStreamDefaultReader = fe, a.TransformStream = tt, a.TransformStreamDefaultController = pe, a.WritableStream = de, a.WritableStreamDefaultController = ke, a.WritableStreamDefaultWriter = re;
			});
		})(kt, kt.exports)), kt.exports;
	}
	function Hs() {
		if (mi) return pi;
		mi = 1;
		const i = 65536;
		if (!globalThis.ReadableStream) try {
			const o3 = __require("process"), { emitWarning: a } = o3;
			try {
				o3.emitWarning = () => {}, Object.assign(globalThis, __require("stream/web")), o3.emitWarning = a;
			} catch (f2) {
				throw o3.emitWarning = a, f2;
			}
		} catch (e) {
			Object.assign(globalThis, Ns());
		}
		try {
			const { Blob: o3 } = __require("buffer");
			o3 && !o3.prototype.stream && (o3.prototype.stream = n2(function(f2) {
				let l = 0;
				const p2 = this;
				return new ReadableStream({
					type: "bytes",
					pull(h2) {
						return __async(this, null, function* () {
							const v2 = yield p2.slice(l, Math.min(p2.size, l + i)).arrayBuffer();
							l += v2.byteLength, h2.enqueue(new Uint8Array(v2)), l === p2.size && h2.close();
						});
					}
				});
			}, "name"));
		} catch (e) {}
		return pi;
	}
	function Wn(i, o3 = true) {
		return __asyncGenerator(this, null, function* () {
			for (const a of i) if ("stream" in a) yield* __yieldStar(a.stream());
			else if (ArrayBuffer.isView(a)) if (o3) {
				let f2 = a.byteOffset;
				const l = a.byteOffset + a.byteLength;
				for (; f2 !== l;) {
					const p2 = Math.min(l - f2, yi), h2 = a.buffer.slice(f2, f2 + p2);
					f2 += h2.byteLength, yield new Uint8Array(h2);
				}
			} else yield a;
			else {
				let f2 = 0, l = a;
				for (; f2 !== l.size;) {
					const h2 = yield new __await(l.slice(f2, Math.min(l.size, f2 + yi)).arrayBuffer());
					f2 += h2.byteLength, yield new Uint8Array(h2);
				}
			}
		});
	}
	function Zs(i, o3 = ut) {
		var a = `${_i()}${_i()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), f2 = [], l = `--${a}\r
Content-Disposition: form-data; name="`;
		return i.forEach((p2, h2) => typeof p2 == "string" ? f2.push(l + On(h2) + `"\r
\r
${p2.replace(/* @__PURE__ */ new RegExp("\\r(?!\\n)|(?<!\\r)\\n", "g"), `\r
`)}\r
`) : f2.push(l + On(h2) + `"; filename="${On(p2.name, 1)}"\r
Content-Type: ${p2.type || "application/octet-stream"}\r
\r
`, p2, `\r
`)), f2.push(`--${a}--`), new o3(f2, { type: "multipart/form-data; boundary=" + a });
	}
	function zn(i) {
		return __async(this, null, function* () {
			if (i[H].disturbed) throw new TypeError(`body used already for: ${i.url}`);
			if (i[H].disturbed = true, i[H].error) throw i[H].error;
			const { body: o3 } = i;
			if (o3 === null) return import_node_buffer.Buffer.alloc(0);
			if (!(o3 instanceof import_node_stream3.default)) return import_node_buffer.Buffer.alloc(0);
			const a = [];
			let f2 = 0;
			try {
				try {
					for (var iter = __forAwait(o3), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
						const l = temp.value;
						if (i.size > 0 && f2 + l.length > i.size) {
							const p2 = new G(`content size at ${i.url} over limit: ${i.size}`, "max-size");
							throw o3.destroy(p2), p2;
						}
						f2 += l.length, a.push(l);
					}
				} catch (temp) {
					error = [temp];
				} finally {
					try {
						more && (temp = iter.return) && (yield temp.call(iter));
					} finally {
						if (error) throw error[0];
					}
				}
			} catch (l) {
				throw l instanceof ft ? l : new G(`Invalid response body while trying to fetch ${i.url}: ${l.message}`, "system", l);
			}
			if (o3.readableEnded === true || o3._readableState.ended === true) try {
				return a.every((l) => typeof l == "string") ? import_node_buffer.Buffer.from(a.join("")) : import_node_buffer.Buffer.concat(a, f2);
			} catch (l) {
				throw new G(`Could not create Buffer from response body for ${i.url}: ${l.message}`, "system", l);
			}
			else throw new G(`Premature close of server response while trying to fetch ${i.url}`);
		});
	}
	function ol(i = []) {
		return new ye(i.reduce((o3, a, f2, l) => (f2 % 2 === 0 && o3.push(l.slice(f2, f2 + 2)), o3), []).filter(([o3, a]) => {
			try {
				return gr(o3), Fn(o3, String(a)), true;
			} catch (e) {
				return false;
			}
		}));
	}
	function Ti(i, o3 = false) {
		return i == null || (i = new URL(i), /^(about|blob|data):$/.test(i.protocol)) ? "no-referrer" : (i.username = "", i.password = "", i.hash = "", o3 && (i.pathname = "", i.search = ""), i);
	}
	function ll(i) {
		if (!Ci.has(i)) throw new TypeError(`Invalid referrerPolicy: ${i}`);
		return i;
	}
	function ul(i) {
		if (/^(http|ws)s:$/.test(i.protocol)) return true;
		const o3 = i.host.replace(/(^\[)|(]$)/g, ""), a = (0, import_node_net.isIP)(o3);
		return a === 4 && /^127\./.test(o3) || a === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(o3) ? true : i.host === "localhost" || i.host.endsWith(".localhost") ? false : i.protocol === "file:";
	}
	function ct(i) {
		return /^about:(blank|srcdoc)$/.test(i) || i.protocol === "data:" || /^(blob|filesystem):$/.test(i.protocol) ? true : ul(i);
	}
	function fl(i, { referrerURLCallback: o3, referrerOriginCallback: a } = {}) {
		if (i.referrer === "no-referrer" || i.referrerPolicy === "") return null;
		const f2 = i.referrerPolicy;
		if (i.referrer === "about:client") return "no-referrer";
		const l = i.referrer;
		let p2 = Ti(l), h2 = Ti(l, true);
		p2.toString().length > 4096 && (p2 = h2), o3 && (p2 = o3(p2)), a && (h2 = a(h2));
		const S = new URL(i.url);
		switch (f2) {
			case "no-referrer": return "no-referrer";
			case "origin": return h2;
			case "unsafe-url": return p2;
			case "strict-origin": return ct(p2) && !ct(S) ? "no-referrer" : h2.toString();
			case "strict-origin-when-cross-origin": return p2.origin === S.origin ? p2 : ct(p2) && !ct(S) ? "no-referrer" : h2;
			case "same-origin": return p2.origin === S.origin ? p2 : "no-referrer";
			case "origin-when-cross-origin": return p2.origin === S.origin ? p2 : h2;
			case "no-referrer-when-downgrade": return ct(p2) && !ct(S) ? "no-referrer" : p2;
			default: throw new TypeError(`Invalid referrerPolicy: ${f2}`);
		}
	}
	function cl(i) {
		const o3 = (i.get("referrer-policy") || "").split(/[,\s]+/);
		let a = "";
		for (const f2 of o3) f2 && Ci.has(f2) && (a = f2);
		return a;
	}
	function pl() {
		if (Pi) return Ln;
		if (Pi = 1, !globalThis.DOMException) try {
			const { MessageChannel: i } = __require("worker_threads"), o3 = new i().port1, a = /* @__PURE__ */ new ArrayBuffer();
			o3.postMessage(a, [a, a]);
		} catch (i) {
			i.constructor.name === "DOMException" && (globalThis.DOMException = i.constructor);
		}
		return Ln = globalThis.DOMException, Ln;
	}
	function Ai(i, o3) {
		return __async(this, null, function* () {
			return new Promise((a, f2) => {
				const l = new dt(i, o3), { parsedURL: p2, options: h2 } = hl(l);
				if (!wl.has(p2.protocol)) throw new TypeError(`node-fetch cannot load ${i}. URL scheme "${p2.protocol.replace(/:$/, "")}" is not supported.`);
				if (p2.protocol === "data:") {
					const g2 = Us(l.url);
					a(new le(g2, { headers: { "Content-Type": g2.typeFull } }));
					return;
				}
				const S = (p2.protocol === "https:" ? import_node_https.default : import_node_http.default).request, { signal: v2 } = l;
				let w2 = null;
				const A = n2(() => {
					const g2 = new _r("The operation was aborted.");
					f2(g2), l.body && l.body instanceof import_node_stream3.default.Readable && l.body.destroy(g2), !(!w2 || !w2.body) && w2.body.emit("error", g2);
				}, "abort");
				if (v2 && v2.aborted) {
					A();
					return;
				}
				const T2 = n2(() => {
					A(), q();
				}, "abortAndFinalize"), b = S(p2.toString(), h2);
				v2 && v2.addEventListener("abort", T2);
				const q = n2(() => {
					b.abort(), v2 && v2.removeEventListener("abort", T2);
				}, "finalize");
				b.on("error", (g2) => {
					f2(new G(`request to ${l.url} failed, reason: ${g2.message}`, "system", g2)), q();
				}), Rl(b, (g2) => {
					w2 && w2.body && w2.body.destroy(g2);
				}), process.version < "v14" && b.on("socket", (g2) => {
					let V;
					g2.prependListener("end", () => {
						V = g2._eventsCount;
					}), g2.prependListener("close", (I2) => {
						if (w2 && V < g2._eventsCount && !I2) {
							const F4 = /* @__PURE__ */ new Error("Premature close");
							F4.code = "ERR_STREAM_PREMATURE_CLOSE", w2.body.emit("error", F4);
						}
					});
				}), b.on("response", (g2) => {
					b.setTimeout(0);
					const V = ol(g2.rawHeaders);
					if (jn(g2.statusCode)) {
						const z = V.get("Location");
						let j = null;
						try {
							j = z === null ? null : new URL(z, l.url);
						} catch (e) {
							if (l.redirect !== "manual") {
								f2(new G(`uri requested responds with an invalid redirect URL: ${z}`, "invalid-redirect")), q();
								return;
							}
						}
						switch (l.redirect) {
							case "error":
								f2(new G(`uri requested responds with a redirect, redirect mode is set to error: ${l.url}`, "no-redirect")), q();
								return;
							case "manual": break;
							case "follow": {
								if (j === null) break;
								if (l.counter >= l.follow) {
									f2(new G(`maximum redirect reached at: ${l.url}`, "max-redirect")), q();
									return;
								}
								const U = {
									headers: new ye(l.headers),
									follow: l.follow,
									counter: l.counter + 1,
									agent: l.agent,
									compress: l.compress,
									method: l.method,
									body: In(l),
									signal: l.signal,
									size: l.size,
									referrer: l.referrer,
									referrerPolicy: l.referrerPolicy
								};
								if (!Js(l.url, j) || !Xs(l.url, j)) for (const jt of [
									"authorization",
									"www-authenticate",
									"cookie",
									"cookie2"
								]) U.headers.delete(jt);
								if (g2.statusCode !== 303 && l.body && o3.body instanceof import_node_stream3.default.Readable) {
									f2(new G("Cannot follow redirect with body being a readable stream", "unsupported-redirect")), q();
									return;
								}
								(g2.statusCode === 303 || (g2.statusCode === 301 || g2.statusCode === 302) && l.method === "POST") && (U.method = "GET", U.body = void 0, U.headers.delete("content-length"));
								const D2 = cl(V);
								D2 && (U.referrerPolicy = D2), a(Ai(new dt(j, U))), q();
								return;
							}
							default: return f2(/* @__PURE__ */ new TypeError(`Redirect option '${l.redirect}' is not a valid value of RequestRedirect`));
						}
					}
					v2 && g2.once("end", () => {
						v2.removeEventListener("abort", T2);
					});
					let I2 = (0, import_node_stream3.pipeline)(g2, new import_node_stream3.PassThrough(), (z) => {
						z && f2(z);
					});
					process.version < "v12.10" && g2.on("aborted", T2);
					const F4 = {
						url: l.url,
						status: g2.statusCode,
						statusText: g2.statusMessage,
						headers: V,
						size: l.size,
						counter: l.counter,
						highWaterMark: l.highWaterMark
					}, Q = V.get("Content-Encoding");
					if (!l.compress || l.method === "HEAD" || Q === null || g2.statusCode === 204 || g2.statusCode === 304) {
						w2 = new le(I2, F4), a(w2);
						return;
					}
					const ge = {
						flush: import_node_zlib.default.Z_SYNC_FLUSH,
						finishFlush: import_node_zlib.default.Z_SYNC_FLUSH
					};
					if (Q === "gzip" || Q === "x-gzip") {
						I2 = (0, import_node_stream3.pipeline)(I2, import_node_zlib.default.createGunzip(ge), (z) => {
							z && f2(z);
						}), w2 = new le(I2, F4), a(w2);
						return;
					}
					if (Q === "deflate" || Q === "x-deflate") {
						const z = (0, import_node_stream3.pipeline)(g2, new import_node_stream3.PassThrough(), (j) => {
							j && f2(j);
						});
						z.once("data", (j) => {
							(j[0] & 15) === 8 ? I2 = (0, import_node_stream3.pipeline)(I2, import_node_zlib.default.createInflate(), (U) => {
								U && f2(U);
							}) : I2 = (0, import_node_stream3.pipeline)(I2, import_node_zlib.default.createInflateRaw(), (U) => {
								U && f2(U);
							}), w2 = new le(I2, F4), a(w2);
						}), z.once("end", () => {
							w2 || (w2 = new le(I2, F4), a(w2));
						});
						return;
					}
					if (Q === "br") {
						I2 = (0, import_node_stream3.pipeline)(I2, import_node_zlib.default.createBrotliDecompress(), (z) => {
							z && f2(z);
						}), w2 = new le(I2, F4), a(w2);
						return;
					}
					w2 = new le(I2, F4), a(w2);
				}), nl(b, l).catch(f2);
			});
		});
	}
	function Rl(i, o3) {
		const a = import_node_buffer.Buffer.from(`0\r
\r
`);
		let f2 = false, l = false, p2;
		i.on("response", (h2) => {
			const { headers: S } = h2;
			f2 = S["transfer-encoding"] === "chunked" && !S["content-length"];
		}), i.on("socket", (h2) => {
			const S = n2(() => {
				if (f2 && !l) {
					const w2 = /* @__PURE__ */ new Error("Premature close");
					w2.code = "ERR_STREAM_PREMATURE_CLOSE", o3(w2);
				}
			}, "onSocketClose"), v2 = n2((w2) => {
				l = import_node_buffer.Buffer.compare(w2.slice(-5), a) === 0, !l && p2 && (l = import_node_buffer.Buffer.compare(p2.slice(-3), a.slice(0, 3)) === 0 && import_node_buffer.Buffer.compare(w2.slice(-2), a.slice(3)) === 0), p2 = w2;
			}, "onData");
			h2.prependListener("close", S), h2.on("data", v2), i.on("close", () => {
				h2.removeListener("close", S), h2.removeListener("data", v2);
			});
		});
	}
	function W(i) {
		const o3 = Bi.get(i);
		return console.assert(o3 != null, "'this' is expected an Event object, but got", i), o3;
	}
	function ki(i) {
		if (i.passiveListener != null) {
			typeof console < "u" && typeof console.error == "function" && console.error("Unable to preventDefault inside passive event listener invocation.", i.passiveListener);
			return;
		}
		i.event.cancelable && (i.canceled = true, typeof i.event.preventDefault == "function" && i.event.preventDefault());
	}
	function ht(i, o3) {
		Bi.set(this, {
			eventTarget: i,
			event: o3,
			eventPhase: 2,
			currentTarget: i,
			canceled: false,
			stopped: false,
			immediateStopped: false,
			passiveListener: null,
			timeStamp: o3.timeStamp || Date.now()
		}), Object.defineProperty(this, "isTrusted", {
			value: false,
			enumerable: true
		});
		const a = Object.keys(o3);
		for (let f2 = 0; f2 < a.length; ++f2) {
			const l = a[f2];
			l in this || Object.defineProperty(this, l, Wi(l));
		}
	}
	function Wi(i) {
		return {
			get() {
				return W(this).event[i];
			},
			set(o3) {
				W(this).event[i] = o3;
			},
			configurable: true,
			enumerable: true
		};
	}
	function Tl(i) {
		return {
			value() {
				const o3 = W(this).event;
				return o3[i].apply(o3, arguments);
			},
			configurable: true,
			enumerable: true
		};
	}
	function Cl(i, o3) {
		const a = Object.keys(o3);
		if (a.length === 0) return i;
		function f2(l, p2) {
			i.call(this, l, p2);
		}
		n2(f2, "CustomEvent"), f2.prototype = Object.create(i.prototype, { constructor: {
			value: f2,
			configurable: true,
			writable: true
		} });
		for (let l = 0; l < a.length; ++l) {
			const p2 = a[l];
			if (!(p2 in i.prototype)) {
				const S = typeof Object.getOwnPropertyDescriptor(o3, p2).value == "function";
				Object.defineProperty(f2.prototype, p2, S ? Tl(p2) : Wi(p2));
			}
		}
		return f2;
	}
	function qi(i) {
		if (i == null || i === Object.prototype) return ht;
		let o3 = Dn.get(i);
		return o3 ?? (o3 = Cl(qi(Object.getPrototypeOf(i)), i), Dn.set(i, o3)), o3;
	}
	function Pl(i, o3) {
		return new (qi(Object.getPrototypeOf(o3)))(i, o3);
	}
	function vl(i) {
		return W(i).immediateStopped;
	}
	function El(i, o3) {
		W(i).eventPhase = o3;
	}
	function Al(i, o3) {
		W(i).currentTarget = o3;
	}
	function Oi(i, o3) {
		W(i).passiveListener = o3;
	}
	function Rr(i) {
		return i !== null && typeof i == "object";
	}
	function Ot(i) {
		const o3 = zi.get(i);
		if (o3 == null) throw new TypeError("'this' is expected an EventTarget object, but got another value.");
		return o3;
	}
	function Bl(i) {
		return {
			get() {
				let a = Ot(this).get(i);
				for (; a != null;) {
					if (a.listenerType === wr) return a.listener;
					a = a.next;
				}
				return null;
			},
			set(o3) {
				typeof o3 != "function" && !Rr(o3) && (o3 = null);
				const a = Ot(this);
				let f2 = null, l = a.get(i);
				for (; l != null;) l.listenerType === wr ? f2 !== null ? f2.next = l.next : l.next !== null ? a.set(i, l.next) : a.delete(i) : f2 = l, l = l.next;
				if (o3 !== null) {
					const p2 = {
						listener: o3,
						listenerType: wr,
						passive: false,
						once: false,
						next: null
					};
					f2 === null ? a.set(i, p2) : f2.next = p2;
				}
			},
			configurable: true,
			enumerable: true
		};
	}
	function ji(i, o3) {
		Object.defineProperty(i, `on${o3}`, Bl(o3));
	}
	function Li(i) {
		function o3() {
			Pe.call(this);
		}
		n2(o3, "CustomEventTarget"), o3.prototype = Object.create(Pe.prototype, { constructor: {
			value: o3,
			configurable: true,
			writable: true
		} });
		for (let a = 0; a < i.length; ++a) ji(o3.prototype, i[a]);
		return o3;
	}
	function Pe() {
		if (this instanceof Pe) {
			zi.set(this, /* @__PURE__ */ new Map());
			return;
		}
		if (arguments.length === 1 && Array.isArray(arguments[0])) return Li(arguments[0]);
		if (arguments.length > 0) {
			const i = new Array(arguments.length);
			for (let o3 = 0; o3 < arguments.length; ++o3) i[o3] = arguments[o3];
			return Li(i);
		}
		throw new TypeError("Cannot call a class as a function");
	}
	function kl() {
		const i = Object.create(pt.prototype);
		return Pe.call(i), Tr.set(i, false), i;
	}
	function Wl(i) {
		Tr.get(i) === false && (Tr.set(i, true), i.dispatchEvent({ type: "abort" }));
	}
	function Di(i) {
		const o3 = $i.get(i);
		if (o3 == null) throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${i === null ? "null" : typeof i}`);
		return o3;
	}
	function Ui() {
		var _a2, _b2, _c, _d;
		!((_b2 = (_a2 = globalThis.process) == null ? void 0 : _a2.versions) == null ? void 0 : _b2.node) && !((_d = (_c = globalThis.process) == null ? void 0 : _c.env) == null ? void 0 : _d.DISABLE_NODE_FETCH_NATIVE_WARN || true) && console.warn("[node-fetch-native] Node.js compatible build of `node-fetch-native` is being used in a non-Node.js environment. Please make sure you are using proper export conditions or report this issue to https://github.com/unjs/node-fetch-native. You can set `process.env.DISABLE_NODE_FETCH_NATIVE_WARN` to disable this warning.");
	}
	var import_node_http, import_node_https, import_node_zlib, import_node_stream3, import_node_buffer, import_node_util2, import_node_url2, import_node_net, import_node_fs4, import_node_path3, Os, fi, n2, ci, O, be, X, ve, zt, bt, Cr, ze, It, Ft, mt, ee, yt, He, Ve, gt, pi, kt, xs, bi, mi, yi, gi, ut, Vs, qn, Wt, Qs, Ys, _i, Gs, Si, On, Ue, br, Un, ft, xn, G, mr, wi, yr, Ks, Js, Xs, el, H, Nn, xe, In, tl, Ri, rl, nl, gr, Fn, Pr, ye, il, jn, se, Ne, le, al, Ci, sl, $2, qt, dl, vr, dt, hl, Hn, _r, Ln, Pi, bl, ml, $n, vi, Ei, Er, Sr, wl, Bi, Dn, zi, Ii, Fi, wr, Vn, pt, Tr, Mn, $i, ql, Ol, Mi;
	var init_node = __esm({ "node_modules/node-fetch-native/dist/node.mjs"() {
		"use strict";
		import_node_http = __toESM(__require("http"), 1);
		import_node_https = __toESM(__require("https"), 1);
		import_node_zlib = __toESM(__require("zlib"), 1);
		import_node_stream3 = __toESM(__require("stream"), 1);
		import_node_buffer = __require("buffer");
		import_node_util2 = __require("util");
		init_node_fetch_native_DfbY2q_x();
		import_node_url2 = __require("url");
		import_node_net = __require("net");
		import_node_fs4 = __require("fs");
		import_node_path3 = __require("path");
		Os = Object.defineProperty;
		fi = (i) => {
			throw TypeError(i);
		};
		n2 = (i, o3) => Os(i, "name", {
			value: o3,
			configurable: true
		});
		ci = (i, o3, a) => o3.has(i) || fi("Cannot " + a);
		O = (i, o3, a) => (ci(i, o3, "read from private field"), a ? a.call(i) : o3.get(i));
		be = (i, o3, a) => o3.has(i) ? fi("Cannot add the same private member more than once") : o3 instanceof WeakSet ? o3.add(i) : o3.set(i, a);
		X = (i, o3, a, f2) => (ci(i, o3, "write to private field"), f2 ? f2.call(i, a) : o3.set(i, a), a);
		n2(Us, "dataUriToBuffer");
		pi = {};
		kt = { exports: {} };
		xs = kt.exports;
		n2(Ns, "requirePonyfill_es2018");
		n2(Hs, "requireStreams"), Hs();
		yi = 65536;
		n2(Wn, "toIterator");
		gi = (ze = class {
			constructor(o3 = [], a = {}) {
				be(this, ve, []);
				be(this, zt, "");
				be(this, bt, 0);
				be(this, Cr, "transparent");
				if (typeof o3 != "object" || o3 === null) throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence.");
				if (typeof o3[Symbol.iterator] != "function") throw new TypeError("Failed to construct 'Blob': The object must have a callable @@iterator property.");
				if (typeof a != "object" && typeof a != "function") throw new TypeError("Failed to construct 'Blob': parameter 2 cannot convert to dictionary.");
				a === null && (a = {});
				const f2 = new TextEncoder();
				for (const p2 of o3) {
					let h2;
					ArrayBuffer.isView(p2) ? h2 = new Uint8Array(p2.buffer.slice(p2.byteOffset, p2.byteOffset + p2.byteLength)) : p2 instanceof ArrayBuffer ? h2 = new Uint8Array(p2.slice(0)) : p2 instanceof ze ? h2 = p2 : h2 = f2.encode(`${p2}`), X(this, bt, O(this, bt) + (ArrayBuffer.isView(h2) ? h2.byteLength : h2.size)), O(this, ve).push(h2);
				}
				X(this, Cr, `${a.endings === void 0 ? "transparent" : a.endings}`);
				const l = a.type === void 0 ? "" : String(a.type);
				X(this, zt, /^[\x20-\x7E]*$/.test(l) ? l : "");
			}
			get size() {
				return O(this, bt);
			}
			get type() {
				return O(this, zt);
			}
			text() {
				return __async(this, null, function* () {
					const o3 = new TextDecoder();
					let a = "";
					try {
						for (var iter = __forAwait(Wn(O(this, ve), false)), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
							const f2 = temp.value;
							a += o3.decode(f2, { stream: true });
						}
					} catch (temp) {
						error = [temp];
					} finally {
						try {
							more && (temp = iter.return) && (yield temp.call(iter));
						} finally {
							if (error) throw error[0];
						}
					}
					return a += o3.decode(), a;
				});
			}
			arrayBuffer() {
				return __async(this, null, function* () {
					const o3 = new Uint8Array(this.size);
					let a = 0;
					try {
						for (var iter = __forAwait(Wn(O(this, ve), false)), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
							const f2 = temp.value;
							o3.set(f2, a), a += f2.length;
						}
					} catch (temp) {
						error = [temp];
					} finally {
						try {
							more && (temp = iter.return) && (yield temp.call(iter));
						} finally {
							if (error) throw error[0];
						}
					}
					return o3.buffer;
				});
			}
			stream() {
				const o3 = Wn(O(this, ve), true);
				return new globalThis.ReadableStream({
					type: "bytes",
					pull(a) {
						return __async(this, null, function* () {
							const f2 = yield o3.next();
							f2.done ? a.close() : a.enqueue(f2.value);
						});
					},
					cancel() {
						return __async(this, null, function* () {
							yield o3.return();
						});
					}
				});
			}
			slice(o3 = 0, a = this.size, f2 = "") {
				const { size: l } = this;
				let p2 = o3 < 0 ? Math.max(l + o3, 0) : Math.min(o3, l), h2 = a < 0 ? Math.max(l + a, 0) : Math.min(a, l);
				const S = Math.max(h2 - p2, 0), v2 = O(this, ve), w2 = [];
				let A = 0;
				for (const b of v2) {
					if (A >= S) break;
					const q = ArrayBuffer.isView(b) ? b.byteLength : b.size;
					if (p2 && q <= p2) p2 -= q, h2 -= q;
					else {
						let g2;
						ArrayBuffer.isView(b) ? (g2 = b.subarray(p2, Math.min(q, h2)), A += g2.byteLength) : (g2 = b.slice(p2, Math.min(q, h2)), A += g2.size), h2 -= q, w2.push(g2), p2 = 0;
					}
				}
				const T2 = new ze([], { type: String(f2).toLowerCase() });
				return X(T2, bt, S), X(T2, ve, w2), T2;
			}
			get [Symbol.toStringTag]() {
				return "Blob";
			}
			static [Symbol.hasInstance](o3) {
				return o3 && typeof o3 == "object" && typeof o3.constructor == "function" && (typeof o3.stream == "function" || typeof o3.arrayBuffer == "function") && /^(Blob|File)$/.test(o3[Symbol.toStringTag]);
			}
		}, ve = /* @__PURE__ */ new WeakMap(), zt = /* @__PURE__ */ new WeakMap(), bt = /* @__PURE__ */ new WeakMap(), Cr = /* @__PURE__ */ new WeakMap(), n2(ze, "Blob"), ze);
		Object.defineProperties(gi.prototype, {
			size: { enumerable: true },
			type: { enumerable: true },
			slice: { enumerable: true }
		});
		ut = gi;
		Vs = (mt = class extends ut {
			constructor(a, f2, l = {}) {
				if (arguments.length < 2) throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);
				super(a, l);
				be(this, It, 0);
				be(this, Ft, "");
				l === null && (l = {});
				const p2 = l.lastModified === void 0 ? Date.now() : Number(l.lastModified);
				Number.isNaN(p2) || X(this, It, p2), X(this, Ft, String(f2));
			}
			get name() {
				return O(this, Ft);
			}
			get lastModified() {
				return O(this, It);
			}
			get [Symbol.toStringTag]() {
				return "File";
			}
			static [Symbol.hasInstance](a) {
				return !!a && a instanceof ut && /^(File)$/.test(a[Symbol.toStringTag]);
			}
		}, It = /* @__PURE__ */ new WeakMap(), Ft = /* @__PURE__ */ new WeakMap(), n2(mt, "File"), mt);
		qn = Vs;
		({toStringTag: Wt, iterator: Qs, hasInstance: Ys} = Symbol);
		_i = Math.random;
		Gs = "append,set,get,getAll,delete,keys,values,entries,forEach,constructor".split(",");
		Si = n2((i, o3, a) => (i += "", /^(Blob|File)$/.test(o3 && o3[Wt]) ? [(a = a !== void 0 ? a + "" : o3[Wt] == "File" ? o3.name : "blob", i), o3.name !== a || o3[Wt] == "blob" ? new qn([o3], a, o3) : o3] : [i, o3 + ""]), "f");
		On = n2((i, o3) => (o3 ? i : i.replace(/\r?\n|\r/g, `\r
`)).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), "e$1");
		Ue = n2((i, o3, a) => {
			if (o3.length < a) throw new TypeError(`Failed to execute '${i}' on 'FormData': ${a} arguments required, but only ${o3.length} present.`);
		}, "x");
		br = (yt = class {
			constructor(...o3) {
				be(this, ee, []);
				if (o3.length) throw new TypeError("Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.");
			}
			get [Wt]() {
				return "FormData";
			}
			[Qs]() {
				return this.entries();
			}
			static [Ys](o3) {
				return o3 && typeof o3 == "object" && o3[Wt] === "FormData" && !Gs.some((a) => typeof o3[a] != "function");
			}
			append(...o3) {
				Ue("append", arguments, 2), O(this, ee).push(Si(...o3));
			}
			delete(o3) {
				Ue("delete", arguments, 1), o3 += "", X(this, ee, O(this, ee).filter(([a]) => a !== o3));
			}
			get(o3) {
				Ue("get", arguments, 1), o3 += "";
				for (var a = O(this, ee), f2 = a.length, l = 0; l < f2; l++) if (a[l][0] === o3) return a[l][1];
				return null;
			}
			getAll(o3, a) {
				return Ue("getAll", arguments, 1), a = [], o3 += "", O(this, ee).forEach((f2) => f2[0] === o3 && a.push(f2[1])), a;
			}
			has(o3) {
				return Ue("has", arguments, 1), o3 += "", O(this, ee).some((a) => a[0] === o3);
			}
			forEach(o3, a) {
				Ue("forEach", arguments, 1);
				for (var [f2, l] of this) o3.call(a, l, f2, this);
			}
			set(...o3) {
				Ue("set", arguments, 2);
				var a = [], f2 = true;
				o3 = Si(...o3), O(this, ee).forEach((l) => {
					l[0] === o3[0] ? f2 && (f2 = !a.push(o3)) : a.push(l);
				}), f2 && a.push(o3), X(this, ee, a);
			}
			*entries() {
				yield* __yieldStar(O(this, ee));
			}
			*keys() {
				for (var [o3] of this) yield o3;
			}
			*values() {
				for (var [, o3] of this) yield o3;
			}
		}, ee = /* @__PURE__ */ new WeakMap(), n2(yt, "FormData"), yt);
		n2(Zs, "formDataToBlob");
		Un = class Un2 extends Error {
			constructor(o3, a) {
				super(o3), Error.captureStackTrace(this, this.constructor), this.type = a;
			}
			get name() {
				return this.constructor.name;
			}
			get [Symbol.toStringTag]() {
				return this.constructor.name;
			}
		};
		n2(Un, "FetchBaseError");
		ft = Un;
		xn = class xn2 extends ft {
			constructor(o3, a, f2) {
				super(o3, a), f2 && (this.code = this.errno = f2.code, this.erroredSysCall = f2.syscall);
			}
		};
		n2(xn, "FetchError");
		G = xn;
		mr = Symbol.toStringTag;
		wi = n2((i) => typeof i == "object" && typeof i.append == "function" && typeof i.delete == "function" && typeof i.get == "function" && typeof i.getAll == "function" && typeof i.has == "function" && typeof i.set == "function" && typeof i.sort == "function" && i[mr] === "URLSearchParams", "isURLSearchParameters");
		yr = n2((i) => i && typeof i == "object" && typeof i.arrayBuffer == "function" && typeof i.type == "string" && typeof i.stream == "function" && typeof i.constructor == "function" && /^(Blob|File)$/.test(i[mr]), "isBlob");
		Ks = n2((i) => typeof i == "object" && (i[mr] === "AbortSignal" || i[mr] === "EventTarget"), "isAbortSignal");
		Js = n2((i, o3) => {
			const a = new URL(o3).hostname, f2 = new URL(i).hostname;
			return a === f2 || a.endsWith(`.${f2}`);
		}, "isDomainOrSubdomain");
		Xs = n2((i, o3) => {
			return new URL(o3).protocol === new URL(i).protocol;
		}, "isSameProtocol");
		el = (0, import_node_util2.promisify)(import_node_stream3.default.pipeline);
		H = Symbol("Body internals");
		Nn = class Nn2 {
			constructor(o3, { size: a = 0 } = {}) {
				let f2 = null;
				o3 === null ? o3 = null : wi(o3) ? o3 = import_node_buffer.Buffer.from(o3.toString()) : yr(o3) || import_node_buffer.Buffer.isBuffer(o3) || (import_node_util2.types.isAnyArrayBuffer(o3) ? o3 = import_node_buffer.Buffer.from(o3) : ArrayBuffer.isView(o3) ? o3 = import_node_buffer.Buffer.from(o3.buffer, o3.byteOffset, o3.byteLength) : o3 instanceof import_node_stream3.default || (o3 instanceof br ? (o3 = Zs(o3), f2 = o3.type.split("=")[1]) : o3 = import_node_buffer.Buffer.from(String(o3))));
				let l = o3;
				import_node_buffer.Buffer.isBuffer(o3) ? l = import_node_stream3.default.Readable.from(o3) : yr(o3) && (l = import_node_stream3.default.Readable.from(o3.stream())), this[H] = {
					body: o3,
					stream: l,
					boundary: f2,
					disturbed: false,
					error: null
				}, this.size = a, o3 instanceof import_node_stream3.default && o3.on("error", (p2) => {
					const h2 = p2 instanceof ft ? p2 : new G(`Invalid response body while trying to fetch ${this.url}: ${p2.message}`, "system", p2);
					this[H].error = h2;
				});
			}
			get body() {
				return this[H].stream;
			}
			get bodyUsed() {
				return this[H].disturbed;
			}
			arrayBuffer() {
				return __async(this, null, function* () {
					const { buffer: o3, byteOffset: a, byteLength: f2 } = yield zn(this);
					return o3.slice(a, a + f2);
				});
			}
			formData() {
				return __async(this, null, function* () {
					const o3 = this.headers.get("content-type");
					if (o3.startsWith("application/x-www-form-urlencoded")) {
						const f2 = new br(), l = new URLSearchParams(yield this.text());
						for (const [p2, h2] of l) f2.append(p2, h2);
						return f2;
					}
					const { toFormData: a } = yield Promise.resolve().then(() => (init_multipart_parser(), multipart_parser_exports));
					return a(this.body, o3);
				});
			}
			blob() {
				return __async(this, null, function* () {
					const o3 = this.headers && this.headers.get("content-type") || this[H].body && this[H].body.type || "", a = yield this.arrayBuffer();
					return new ut([a], { type: o3 });
				});
			}
			json() {
				return __async(this, null, function* () {
					const o3 = yield this.text();
					return JSON.parse(o3);
				});
			}
			text() {
				return __async(this, null, function* () {
					const o3 = yield zn(this);
					return new TextDecoder().decode(o3);
				});
			}
			buffer() {
				return zn(this);
			}
		};
		n2(Nn, "Body");
		xe = Nn;
		xe.prototype.buffer = (0, import_node_util2.deprecate)(xe.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer"), Object.defineProperties(xe.prototype, {
			body: { enumerable: true },
			bodyUsed: { enumerable: true },
			arrayBuffer: { enumerable: true },
			blob: { enumerable: true },
			json: { enumerable: true },
			text: { enumerable: true },
			data: { get: (0, import_node_util2.deprecate)(() => {}, "data doesn't exist, use json(), text(), arrayBuffer(), or body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (response)") }
		});
		n2(zn, "consumeBody");
		In = n2((i, o3) => {
			let a, f2, { body: l } = i[H];
			if (i.bodyUsed) throw new Error("cannot clone body after it is used");
			return l instanceof import_node_stream3.default && typeof l.getBoundary != "function" && (a = new import_node_stream3.PassThrough({ highWaterMark: o3 }), f2 = new import_node_stream3.PassThrough({ highWaterMark: o3 }), l.pipe(a), l.pipe(f2), i[H].stream = a, l = f2), l;
		}, "clone");
		tl = (0, import_node_util2.deprecate)((i) => i.getBoundary(), "form-data doesn't follow the spec and requires special treatment. Use alternative package", "https://github.com/node-fetch/node-fetch/issues/1167");
		Ri = n2((i, o3) => i === null ? null : typeof i == "string" ? "text/plain;charset=UTF-8" : wi(i) ? "application/x-www-form-urlencoded;charset=UTF-8" : yr(i) ? i.type || null : import_node_buffer.Buffer.isBuffer(i) || import_node_util2.types.isAnyArrayBuffer(i) || ArrayBuffer.isView(i) ? null : i instanceof br ? `multipart/form-data; boundary=${o3[H].boundary}` : i && typeof i.getBoundary == "function" ? `multipart/form-data;boundary=${tl(i)}` : i instanceof import_node_stream3.default ? null : "text/plain;charset=UTF-8", "extractContentType");
		rl = n2((i) => {
			const { body: o3 } = i[H];
			return o3 === null ? 0 : yr(o3) ? o3.size : import_node_buffer.Buffer.isBuffer(o3) ? o3.length : o3 && typeof o3.getLengthSync == "function" && o3.hasKnownLength && o3.hasKnownLength() ? o3.getLengthSync() : null;
		}, "getTotalBytes");
		nl = n2((_0, _1) => __async(null, [_0, _1], function* (i, { body: o3 }) {
			o3 === null ? i.end() : yield el(o3, i);
		}), "writeToStream");
		gr = typeof import_node_http.default.validateHeaderName == "function" ? import_node_http.default.validateHeaderName : (i) => {
			if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(i)) {
				const o3 = /* @__PURE__ */ new TypeError(`Header name must be a valid HTTP token [${i}]`);
				throw Object.defineProperty(o3, "code", { value: "ERR_INVALID_HTTP_TOKEN" }), o3;
			}
		};
		Fn = typeof import_node_http.default.validateHeaderValue == "function" ? import_node_http.default.validateHeaderValue : (i, o3) => {
			if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(o3)) {
				const a = /* @__PURE__ */ new TypeError(`Invalid character in header content ["${i}"]`);
				throw Object.defineProperty(a, "code", { value: "ERR_INVALID_CHAR" }), a;
			}
		};
		Pr = class Pr2 extends URLSearchParams {
			constructor(o3) {
				let a = [];
				if (o3 instanceof Pr2) {
					const f2 = o3.raw();
					for (const [l, p2] of Object.entries(f2)) a.push(...p2.map((h2) => [l, h2]));
				} else if (o3 != null) if (typeof o3 == "object" && !import_node_util2.types.isBoxedPrimitive(o3)) {
					const f2 = o3[Symbol.iterator];
					if (f2 == null) a.push(...Object.entries(o3));
					else {
						if (typeof f2 != "function") throw new TypeError("Header pairs must be iterable");
						a = [...o3].map((l) => {
							if (typeof l != "object" || import_node_util2.types.isBoxedPrimitive(l)) throw new TypeError("Each header pair must be an iterable object");
							return [...l];
						}).map((l) => {
							if (l.length !== 2) throw new TypeError("Each header pair must be a name/value tuple");
							return [...l];
						});
					}
				} else throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)");
				return a = a.length > 0 ? a.map(([f2, l]) => (gr(f2), Fn(f2, String(l)), [String(f2).toLowerCase(), String(l)])) : void 0, super(a), new Proxy(this, { get(f2, l, p2) {
					switch (l) {
						case "append":
						case "set": return (h2, S) => (gr(h2), Fn(h2, String(S)), URLSearchParams.prototype[l].call(f2, String(h2).toLowerCase(), String(S)));
						case "delete":
						case "has":
						case "getAll": return (h2) => (gr(h2), URLSearchParams.prototype[l].call(f2, String(h2).toLowerCase()));
						case "keys": return () => (f2.sort(), new Set(URLSearchParams.prototype.keys.call(f2)).keys());
						default: return Reflect.get(f2, l, p2);
					}
				} });
			}
			get [Symbol.toStringTag]() {
				return this.constructor.name;
			}
			toString() {
				return Object.prototype.toString.call(this);
			}
			get(o3) {
				const a = this.getAll(o3);
				if (a.length === 0) return null;
				let f2 = a.join(", ");
				return /^content-encoding$/i.test(o3) && (f2 = f2.toLowerCase()), f2;
			}
			forEach(o3, a = void 0) {
				for (const f2 of this.keys()) Reflect.apply(o3, a, [
					this.get(f2),
					f2,
					this
				]);
			}
			*values() {
				for (const o3 of this.keys()) yield this.get(o3);
			}
			*entries() {
				for (const o3 of this.keys()) yield [o3, this.get(o3)];
			}
			[Symbol.iterator]() {
				return this.entries();
			}
			raw() {
				return [...this.keys()].reduce((o3, a) => (o3[a] = this.getAll(a), o3), {});
			}
			[Symbol.for("nodejs.util.inspect.custom")]() {
				return [...this.keys()].reduce((o3, a) => {
					const f2 = this.getAll(a);
					return a === "host" ? o3[a] = f2[0] : o3[a] = f2.length > 1 ? f2 : f2[0], o3;
				}, {});
			}
		};
		n2(Pr, "Headers");
		ye = Pr;
		Object.defineProperties(ye.prototype, [
			"get",
			"entries",
			"forEach",
			"values"
		].reduce((i, o3) => (i[o3] = { enumerable: true }, i), {}));
		n2(ol, "fromRawHeaders");
		il = /* @__PURE__ */ new Set([
			301,
			302,
			303,
			307,
			308
		]);
		jn = n2((i) => il.has(i), "isRedirect");
		se = Symbol("Response internals");
		Ne = class Ne2 extends xe {
			constructor(o3 = null, a = {}) {
				super(o3, a);
				const f2 = a.status != null ? a.status : 200, l = new ye(a.headers);
				if (o3 !== null && !l.has("Content-Type")) {
					const p2 = Ri(o3, this);
					p2 && l.append("Content-Type", p2);
				}
				this[se] = {
					type: "default",
					url: a.url,
					status: f2,
					statusText: a.statusText || "",
					headers: l,
					counter: a.counter,
					highWaterMark: a.highWaterMark
				};
			}
			get type() {
				return this[se].type;
			}
			get url() {
				return this[se].url || "";
			}
			get status() {
				return this[se].status;
			}
			get ok() {
				return this[se].status >= 200 && this[se].status < 300;
			}
			get redirected() {
				return this[se].counter > 0;
			}
			get statusText() {
				return this[se].statusText;
			}
			get headers() {
				return this[se].headers;
			}
			get highWaterMark() {
				return this[se].highWaterMark;
			}
			clone() {
				return new Ne2(In(this, this.highWaterMark), {
					type: this.type,
					url: this.url,
					status: this.status,
					statusText: this.statusText,
					headers: this.headers,
					ok: this.ok,
					redirected: this.redirected,
					size: this.size,
					highWaterMark: this.highWaterMark
				});
			}
			static redirect(o3, a = 302) {
				if (!jn(a)) throw new RangeError("Failed to execute \"redirect\" on \"response\": Invalid status code");
				return new Ne2(null, {
					headers: { location: new URL(o3).toString() },
					status: a
				});
			}
			static error() {
				const o3 = new Ne2(null, {
					status: 0,
					statusText: ""
				});
				return o3[se].type = "error", o3;
			}
			static json(o3 = void 0, a = {}) {
				const f2 = JSON.stringify(o3);
				if (f2 === void 0) throw new TypeError("data is not JSON serializable");
				const l = new ye(a && a.headers);
				return l.has("content-type") || l.set("content-type", "application/json"), new Ne2(f2, __spreadProps(__spreadValues({}, a), { headers: l }));
			}
			get [Symbol.toStringTag]() {
				return "Response";
			}
		};
		n2(Ne, "Response");
		le = Ne;
		Object.defineProperties(le.prototype, {
			type: { enumerable: true },
			url: { enumerable: true },
			status: { enumerable: true },
			ok: { enumerable: true },
			redirected: { enumerable: true },
			statusText: { enumerable: true },
			headers: { enumerable: true },
			clone: { enumerable: true }
		});
		al = n2((i) => {
			if (i.search) return i.search;
			const o3 = i.href.length - 1, a = i.hash || (i.href[o3] === "#" ? "#" : "");
			return i.href[o3 - a.length] === "?" ? "?" : "";
		}, "getSearch");
		n2(Ti, "stripURLForUseAsAReferrer");
		Ci = /* @__PURE__ */ new Set([
			"",
			"no-referrer",
			"no-referrer-when-downgrade",
			"same-origin",
			"origin",
			"strict-origin",
			"origin-when-cross-origin",
			"strict-origin-when-cross-origin",
			"unsafe-url"
		]);
		sl = "strict-origin-when-cross-origin";
		n2(ll, "validateReferrerPolicy");
		n2(ul, "isOriginPotentiallyTrustworthy");
		n2(ct, "isUrlPotentiallyTrustworthy");
		n2(fl, "determineRequestsReferrer");
		n2(cl, "parseReferrerPolicyFromHeader");
		$2 = Symbol("Request internals");
		qt = n2((i) => typeof i == "object" && typeof i[$2] == "object", "isRequest");
		dl = (0, import_node_util2.deprecate)(() => {}, ".data is not a valid RequestInit property, use .body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (request)");
		vr = class vr2 extends xe {
			constructor(o3, a = {}) {
				let f2;
				if (qt(o3) ? f2 = new URL(o3.url) : (f2 = new URL(o3), o3 = {}), f2.username !== "" || f2.password !== "") throw new TypeError(`${f2} is an url with embedded credentials.`);
				let l = a.method || o3.method || "GET";
				if (/^(delete|get|head|options|post|put)$/i.test(l) && (l = l.toUpperCase()), !qt(a) && "data" in a && dl(), (a.body != null || qt(o3) && o3.body !== null) && (l === "GET" || l === "HEAD")) throw new TypeError("Request with GET/HEAD method cannot have body");
				const p2 = a.body ? a.body : qt(o3) && o3.body !== null ? In(o3) : null;
				super(p2, { size: a.size || o3.size || 0 });
				const h2 = new ye(a.headers || o3.headers || {});
				if (p2 !== null && !h2.has("Content-Type")) {
					const w2 = Ri(p2, this);
					w2 && h2.set("Content-Type", w2);
				}
				let S = qt(o3) ? o3.signal : null;
				if ("signal" in a && (S = a.signal), S != null && !Ks(S)) throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
				let v2 = a.referrer == null ? o3.referrer : a.referrer;
				if (v2 === "") v2 = "no-referrer";
				else if (v2) {
					const w2 = new URL(v2);
					v2 = /^about:(\/\/)?client$/.test(w2) ? "client" : w2;
				} else v2 = void 0;
				this[$2] = {
					method: l,
					redirect: a.redirect || o3.redirect || "follow",
					headers: h2,
					parsedURL: f2,
					signal: S,
					referrer: v2
				}, this.follow = a.follow === void 0 ? o3.follow === void 0 ? 20 : o3.follow : a.follow, this.compress = a.compress === void 0 ? o3.compress === void 0 ? true : o3.compress : a.compress, this.counter = a.counter || o3.counter || 0, this.agent = a.agent || o3.agent, this.highWaterMark = a.highWaterMark || o3.highWaterMark || 16384, this.insecureHTTPParser = a.insecureHTTPParser || o3.insecureHTTPParser || false, this.referrerPolicy = a.referrerPolicy || o3.referrerPolicy || "";
			}
			get method() {
				return this[$2].method;
			}
			get url() {
				return (0, import_node_url2.format)(this[$2].parsedURL);
			}
			get headers() {
				return this[$2].headers;
			}
			get redirect() {
				return this[$2].redirect;
			}
			get signal() {
				return this[$2].signal;
			}
			get referrer() {
				if (this[$2].referrer === "no-referrer") return "";
				if (this[$2].referrer === "client") return "about:client";
				if (this[$2].referrer) return this[$2].referrer.toString();
			}
			get referrerPolicy() {
				return this[$2].referrerPolicy;
			}
			set referrerPolicy(o3) {
				this[$2].referrerPolicy = ll(o3);
			}
			clone() {
				return new vr2(this);
			}
			get [Symbol.toStringTag]() {
				return "Request";
			}
		};
		n2(vr, "Request");
		dt = vr;
		Object.defineProperties(dt.prototype, {
			method: { enumerable: true },
			url: { enumerable: true },
			headers: { enumerable: true },
			redirect: { enumerable: true },
			clone: { enumerable: true },
			signal: { enumerable: true },
			referrer: { enumerable: true },
			referrerPolicy: { enumerable: true }
		});
		hl = n2((i) => {
			const { parsedURL: o3 } = i[$2], a = new ye(i[$2].headers);
			a.has("Accept") || a.set("Accept", "*/*");
			let f2 = null;
			if (i.body === null && /^(post|put)$/i.test(i.method) && (f2 = "0"), i.body !== null) {
				const S = rl(i);
				typeof S == "number" && !Number.isNaN(S) && (f2 = String(S));
			}
			f2 && a.set("Content-Length", f2), i.referrerPolicy === "" && (i.referrerPolicy = sl), i.referrer && i.referrer !== "no-referrer" ? i[$2].referrer = fl(i) : i[$2].referrer = "no-referrer", i[$2].referrer instanceof URL && a.set("Referer", i.referrer), a.has("User-Agent") || a.set("User-Agent", "node-fetch"), i.compress && !a.has("Accept-Encoding") && a.set("Accept-Encoding", "gzip, deflate, br");
			let { agent: l } = i;
			typeof l == "function" && (l = l(o3));
			const p2 = al(o3);
			return {
				parsedURL: o3,
				options: {
					path: o3.pathname + p2,
					method: i.method,
					headers: a[Symbol.for("nodejs.util.inspect.custom")](),
					insecureHTTPParser: i.insecureHTTPParser,
					agent: l
				}
			};
		}, "getNodeRequestOptions");
		Hn = class Hn2 extends ft {
			constructor(o3, a = "aborted") {
				super(o3, a);
			}
		};
		n2(Hn, "AbortError");
		_r = Hn;
		n2(pl, "requireNodeDomexception");
		bl = pl();
		ml = f(bl);
		({stat: $n} = import_node_fs4.promises);
		n2((i, o3) => vi((0, import_node_fs4.statSync)(i), i, o3), "blobFromSync");
		n2((i, o3) => $n(i).then((a) => vi(a, i, o3)), "blobFrom");
		n2((i, o3) => $n(i).then((a) => Ei(a, i, o3)), "fileFrom");
		n2((i, o3) => Ei((0, import_node_fs4.statSync)(i), i, o3), "fileFromSync");
		vi = n2((i, o3, a = "") => new ut([new Sr({
			path: o3,
			size: i.size,
			lastModified: i.mtimeMs,
			start: 0
		})], { type: a }), "fromBlob");
		Ei = n2((i, o3, a = "") => new qn([new Sr({
			path: o3,
			size: i.size,
			lastModified: i.mtimeMs,
			start: 0
		})], (0, import_node_path3.basename)(o3), {
			type: a,
			lastModified: i.mtimeMs
		}), "fromFile");
		Er = class Er2 {
			constructor(o3) {
				be(this, He);
				be(this, Ve);
				X(this, He, o3.path), X(this, Ve, o3.start), this.size = o3.size, this.lastModified = o3.lastModified;
			}
			slice(o3, a) {
				return new Er2({
					path: O(this, He),
					lastModified: this.lastModified,
					size: a - o3,
					start: O(this, Ve) + o3
				});
			}
			stream() {
				return __asyncGenerator(this, null, function* () {
					const { mtimeMs: o3 } = yield new __await($n(O(this, He)));
					if (o3 > this.lastModified) throw new ml("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.", "NotReadableError");
					yield* __yieldStar((0, import_node_fs4.createReadStream)(O(this, He), {
						start: O(this, Ve),
						end: O(this, Ve) + this.size - 1
					}));
				});
			}
			get [Symbol.toStringTag]() {
				return "Blob";
			}
		};
		He = /* @__PURE__ */ new WeakMap(), Ve = /* @__PURE__ */ new WeakMap(), n2(Er, "BlobDataItem");
		Sr = Er;
		wl = /* @__PURE__ */ new Set([
			"data:",
			"http:",
			"https:"
		]);
		n2(Ai, "fetch$1");
		n2(Rl, "fixResponseChunkedTransferBadEnding");
		Bi = /* @__PURE__ */ new WeakMap();
		Dn = /* @__PURE__ */ new WeakMap();
		n2(W, "pd");
		n2(ki, "setCancelFlag");
		n2(ht, "Event"), ht.prototype = {
			get type() {
				return W(this).event.type;
			},
			get target() {
				return W(this).eventTarget;
			},
			get currentTarget() {
				return W(this).currentTarget;
			},
			composedPath() {
				const i = W(this).currentTarget;
				return i == null ? [] : [i];
			},
			get NONE() {
				return 0;
			},
			get CAPTURING_PHASE() {
				return 1;
			},
			get AT_TARGET() {
				return 2;
			},
			get BUBBLING_PHASE() {
				return 3;
			},
			get eventPhase() {
				return W(this).eventPhase;
			},
			stopPropagation() {
				const i = W(this);
				i.stopped = true, typeof i.event.stopPropagation == "function" && i.event.stopPropagation();
			},
			stopImmediatePropagation() {
				const i = W(this);
				i.stopped = true, i.immediateStopped = true, typeof i.event.stopImmediatePropagation == "function" && i.event.stopImmediatePropagation();
			},
			get bubbles() {
				return !!W(this).event.bubbles;
			},
			get cancelable() {
				return !!W(this).event.cancelable;
			},
			preventDefault() {
				ki(W(this));
			},
			get defaultPrevented() {
				return W(this).canceled;
			},
			get composed() {
				return !!W(this).event.composed;
			},
			get timeStamp() {
				return W(this).timeStamp;
			},
			get srcElement() {
				return W(this).eventTarget;
			},
			get cancelBubble() {
				return W(this).stopped;
			},
			set cancelBubble(i) {
				if (!i) return;
				const o3 = W(this);
				o3.stopped = true, typeof o3.event.cancelBubble == "boolean" && (o3.event.cancelBubble = true);
			},
			get returnValue() {
				return !W(this).canceled;
			},
			set returnValue(i) {
				i || ki(W(this));
			},
			initEvent() {}
		}, Object.defineProperty(ht.prototype, "constructor", {
			value: ht,
			configurable: true,
			writable: true
		}), typeof window < "u" && typeof window.Event < "u" && (Object.setPrototypeOf(ht.prototype, window.Event.prototype), Dn.set(window.Event.prototype, ht));
		n2(Wi, "defineRedirectDescriptor");
		n2(Tl, "defineCallDescriptor");
		n2(Cl, "defineWrapper");
		n2(qi, "getWrapper");
		n2(Pl, "wrapEvent");
		n2(vl, "isStopped");
		n2(El, "setEventPhase");
		n2(Al, "setCurrentTarget");
		n2(Oi, "setPassiveListener");
		zi = /* @__PURE__ */ new WeakMap();
		Ii = 1;
		Fi = 2;
		wr = 3;
		n2(Rr, "isObject");
		n2(Ot, "getListeners");
		n2(Bl, "defineEventAttributeDescriptor");
		n2(ji, "defineEventAttribute");
		n2(Li, "defineCustomEventTarget");
		n2(Pe, "EventTarget"), Pe.prototype = {
			addEventListener(i, o3, a) {
				if (o3 == null) return;
				if (typeof o3 != "function" && !Rr(o3)) throw new TypeError("'listener' should be a function or an object.");
				const f2 = Ot(this), l = Rr(a), h2 = (l ? !!a.capture : !!a) ? Ii : Fi, S = {
					listener: o3,
					listenerType: h2,
					passive: l && !!a.passive,
					once: l && !!a.once,
					next: null
				};
				let v2 = f2.get(i);
				if (v2 === void 0) {
					f2.set(i, S);
					return;
				}
				let w2 = null;
				for (; v2 != null;) {
					if (v2.listener === o3 && v2.listenerType === h2) return;
					w2 = v2, v2 = v2.next;
				}
				w2.next = S;
			},
			removeEventListener(i, o3, a) {
				if (o3 == null) return;
				const f2 = Ot(this), p2 = (Rr(a) ? !!a.capture : !!a) ? Ii : Fi;
				let h2 = null, S = f2.get(i);
				for (; S != null;) {
					if (S.listener === o3 && S.listenerType === p2) {
						h2 !== null ? h2.next = S.next : S.next !== null ? f2.set(i, S.next) : f2.delete(i);
						return;
					}
					h2 = S, S = S.next;
				}
			},
			dispatchEvent(i) {
				if (i == null || typeof i.type != "string") throw new TypeError("\"event.type\" should be a string.");
				const o3 = Ot(this), a = i.type;
				let f2 = o3.get(a);
				if (f2 == null) return true;
				const l = Pl(this, i);
				let p2 = null;
				for (; f2 != null;) {
					if (f2.once ? p2 !== null ? p2.next = f2.next : f2.next !== null ? o3.set(a, f2.next) : o3.delete(a) : p2 = f2, Oi(l, f2.passive ? f2.listener : null), typeof f2.listener == "function") try {
						f2.listener.call(this, l);
					} catch (h2) {
						typeof console < "u" && typeof console.error == "function" && console.error(h2);
					}
					else f2.listenerType !== wr && typeof f2.listener.handleEvent == "function" && f2.listener.handleEvent(l);
					if (vl(l)) break;
					f2 = f2.next;
				}
				return Oi(l, null), El(l, 0), Al(l, null), !l.defaultPrevented;
			}
		}, Object.defineProperty(Pe.prototype, "constructor", {
			value: Pe,
			configurable: true,
			writable: true
		}), typeof window < "u" && typeof window.EventTarget < "u" && Object.setPrototypeOf(Pe.prototype, window.EventTarget.prototype);
		Vn = class Vn2 extends Pe {
			constructor() {
				throw super(), /* @__PURE__ */ new TypeError("AbortSignal cannot be constructed directly");
			}
			get aborted() {
				const o3 = Tr.get(this);
				if (typeof o3 != "boolean") throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
				return o3;
			}
		};
		n2(Vn, "AbortSignal");
		pt = Vn;
		ji(pt.prototype, "abort");
		n2(kl, "createAbortSignal");
		n2(Wl, "abortSignal");
		Tr = /* @__PURE__ */ new WeakMap();
		Object.defineProperties(pt.prototype, { aborted: { enumerable: true } }), typeof Symbol == "function" && typeof Symbol.toStringTag == "symbol" && Object.defineProperty(pt.prototype, Symbol.toStringTag, {
			configurable: true,
			value: "AbortSignal"
		});
		Mn = (gt = class {
			constructor() {
				$i.set(this, kl());
			}
			get signal() {
				return Di(this);
			}
			abort() {
				Wl(Di(this));
			}
		}, n2(gt, "AbortController"), gt);
		$i = /* @__PURE__ */ new WeakMap();
		n2(Di, "getSignal"), Object.defineProperties(Mn.prototype, {
			signal: { enumerable: true },
			abort: { enumerable: true }
		}), typeof Symbol == "function" && typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Mn.prototype, Symbol.toStringTag, {
			configurable: true,
			value: "AbortController"
		});
		ql = Object.defineProperty;
		Ol = n2((i, o3) => ql(i, "name", {
			value: o3,
			configurable: true
		}), "e");
		Mi = Ai;
		Ui();
		n2(Ui, "s"), Ol(Ui, "checkNodeEnvironment");
	} });
	var require_minimist = __commonJS({ "node_modules/minimist/index.js"(exports2, module2) {
		"use strict";
		function hasKey(obj, keys) {
			var o3 = obj;
			keys.slice(0, -1).forEach(function(key2) {
				o3 = o3[key2] || {};
			});
			return keys[keys.length - 1] in o3;
		}
		function isNumber(x2) {
			if (typeof x2 === "number") return true;
			if (/^0x[0-9a-f]+$/i.test(x2)) return true;
			return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x2);
		}
		function isConstructorOrProto(obj, key) {
			return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
		}
		module2.exports = function(args, opts) {
			if (!opts) opts = {};
			var flags = {
				bools: {},
				strings: {},
				unknownFn: null
			};
			if (typeof opts.unknown === "function") flags.unknownFn = opts.unknown;
			if (typeof opts.boolean === "boolean" && opts.boolean) flags.allBools = true;
			else [].concat(opts.boolean).filter(Boolean).forEach(function(key2) {
				flags.bools[key2] = true;
			});
			var aliases = {};
			function aliasIsBoolean(key2) {
				return aliases[key2].some(function(x2) {
					return flags.bools[x2];
				});
			}
			Object.keys(opts.alias || {}).forEach(function(key2) {
				aliases[key2] = [].concat(opts.alias[key2]);
				aliases[key2].forEach(function(x2) {
					aliases[x2] = [key2].concat(aliases[key2].filter(function(y) {
						return x2 !== y;
					}));
				});
			});
			[].concat(opts.string).filter(Boolean).forEach(function(key2) {
				flags.strings[key2] = true;
				if (aliases[key2]) [].concat(aliases[key2]).forEach(function(k2) {
					flags.strings[k2] = true;
				});
			});
			var defaults = opts.default || {};
			var argv = { _: [] };
			function argDefined(key2, arg2) {
				return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
			}
			function setKey(obj, keys, value2) {
				var o3 = obj;
				for (var i2 = 0; i2 < keys.length - 1; i2++) {
					var key2 = keys[i2];
					if (isConstructorOrProto(o3, key2)) return;
					if (o3[key2] === void 0) o3[key2] = {};
					if (o3[key2] === Object.prototype || o3[key2] === Number.prototype || o3[key2] === String.prototype) o3[key2] = {};
					if (o3[key2] === Array.prototype) o3[key2] = [];
					o3 = o3[key2];
				}
				var lastKey = keys[keys.length - 1];
				if (isConstructorOrProto(o3, lastKey)) return;
				if (o3 === Object.prototype || o3 === Number.prototype || o3 === String.prototype) o3 = {};
				if (o3 === Array.prototype) o3 = [];
				if (o3[lastKey] === void 0 || flags.bools[lastKey] || typeof o3[lastKey] === "boolean") o3[lastKey] = value2;
				else if (Array.isArray(o3[lastKey])) o3[lastKey].push(value2);
				else o3[lastKey] = [o3[lastKey], value2];
			}
			function setArg(key2, val, arg2) {
				if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
					if (flags.unknownFn(arg2) === false) return;
				}
				var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
				setKey(argv, key2.split("."), value2);
				(aliases[key2] || []).forEach(function(x2) {
					setKey(argv, x2.split("."), value2);
				});
			}
			Object.keys(flags.bools).forEach(function(key2) {
				setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
			});
			var notFlags = [];
			if (args.indexOf("--") !== -1) {
				notFlags = args.slice(args.indexOf("--") + 1);
				args = args.slice(0, args.indexOf("--"));
			}
			for (var i = 0; i < args.length; i++) {
				var arg = args[i];
				var key;
				var next;
				if (/^--.+=/.test(arg)) {
					var m2 = arg.match(/^--([^=]+)=([\s\S]*)$/);
					key = m2[1];
					var value = m2[2];
					if (flags.bools[key]) value = value !== "false";
					setArg(key, value, arg);
				} else if (/^--no-.+/.test(arg)) {
					key = arg.match(/^--no-(.+)/)[1];
					setArg(key, false, arg);
				} else if (/^--.+/.test(arg)) {
					key = arg.match(/^--(.+)/)[1];
					next = args[i + 1];
					if (next !== void 0 && !/^(-|--)[^-]/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
						setArg(key, next, arg);
						i += 1;
					} else if (/^(true|false)$/.test(next)) {
						setArg(key, next === "true", arg);
						i += 1;
					} else setArg(key, flags.strings[key] ? "" : true, arg);
				} else if (/^-[^-]+/.test(arg)) {
					var letters = arg.slice(1, -1).split("");
					var broken = false;
					for (var j = 0; j < letters.length; j++) {
						next = arg.slice(j + 2);
						if (next === "-") {
							setArg(letters[j], next, arg);
							continue;
						}
						if (/[A-Za-z]/.test(letters[j]) && next[0] === "=") {
							setArg(letters[j], next.slice(1), arg);
							broken = true;
							break;
						}
						if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
							setArg(letters[j], next, arg);
							broken = true;
							break;
						}
						if (letters[j + 1] && letters[j + 1].match(/\W/)) {
							setArg(letters[j], arg.slice(j + 2), arg);
							broken = true;
							break;
						} else setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
					}
					key = arg.slice(-1)[0];
					if (!broken && key !== "-") if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
						setArg(key, args[i + 1], arg);
						i += 1;
					} else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
						setArg(key, args[i + 1] === "true", arg);
						i += 1;
					} else setArg(key, flags.strings[key] ? "" : true, arg);
				} else {
					if (!flags.unknownFn || flags.unknownFn(arg) !== false) argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
					if (opts.stopEarly) {
						argv._.push.apply(argv._, args.slice(i + 1));
						break;
					}
				}
			}
			Object.keys(defaults).forEach(function(k2) {
				if (!hasKey(argv, k2.split("."))) {
					setKey(argv, k2.split("."), defaults[k2]);
					(aliases[k2] || []).forEach(function(x2) {
						setKey(argv, x2.split("."), defaults[k2]);
					});
				}
			});
			if (opts["--"]) argv["--"] = notFlags.slice();
			else notFlags.forEach(function(k2) {
				argv._.push(k2);
			});
			return argv;
		};
	} });
	var vendor_extra_exports = {};
	__export(vendor_extra_exports, {
		YAML: () => YAML,
		createRequire: () => createRequire,
		depseek: () => depseek,
		dotenv: () => dotenv,
		fs: () => fs5,
		glob: () => glob,
		minimist: () => minimist,
		nodeFetch: () => nodeFetch
	});
	module.exports = __toCommonJS(vendor_extra_exports);
	var import_node_process2 = __toESM(__require("process"), 1);
	var import_node_fs3 = __toESM(__require("fs"), 1);
	var import_node_path2 = __toESM(__require("path"), 1);
	var import_node_stream2 = __require("stream");
	var import_node_events = __require("events");
	var import_node_stream$1 = __require("stream");
	var import_promises = __require("stream").promises;
	function mergeStreams(streams) {
		if (!Array.isArray(streams)) throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
		for (const stream of streams) validateStream(stream);
		const objectMode = streams.some(({ readableObjectMode }) => readableObjectMode);
		const highWaterMark = getHighWaterMark(streams, objectMode);
		const passThroughStream = new MergedStream({
			objectMode,
			writableHighWaterMark: highWaterMark,
			readableHighWaterMark: highWaterMark
		});
		for (const stream of streams) passThroughStream.add(stream);
		return passThroughStream;
	}
	var getHighWaterMark = (streams, objectMode) => {
		if (streams.length === 0) return (0, import_node_stream$1.getDefaultHighWaterMark)(objectMode);
		const highWaterMarks = streams.filter(({ readableObjectMode }) => readableObjectMode === objectMode).map(({ readableHighWaterMark }) => readableHighWaterMark);
		return Math.max(...highWaterMarks);
	};
	var _streams, _ended, _aborted, _onFinished, _unpipeEvent, _streamPromises;
	var MergedStream = class extends import_node_stream$1.PassThrough {
		constructor() {
			super(...arguments);
			__privateAdd(this, _streams, /* @__PURE__ */ new Set([]));
			__privateAdd(this, _ended, /* @__PURE__ */ new Set([]));
			__privateAdd(this, _aborted, /* @__PURE__ */ new Set([]));
			__privateAdd(this, _onFinished);
			__privateAdd(this, _unpipeEvent, Symbol("unpipe"));
			__privateAdd(this, _streamPromises, /* @__PURE__ */ new WeakMap());
		}
		add(stream) {
			validateStream(stream);
			if (__privateGet(this, _streams).has(stream)) return;
			__privateGet(this, _streams).add(stream);
			__privateGet(this, _onFinished) ?? __privateSet(this, _onFinished, onMergedStreamFinished(this, __privateGet(this, _streams), __privateGet(this, _unpipeEvent)));
			const streamPromise = endWhenStreamsDone({
				passThroughStream: this,
				stream,
				streams: __privateGet(this, _streams),
				ended: __privateGet(this, _ended),
				aborted: __privateGet(this, _aborted),
				onFinished: __privateGet(this, _onFinished),
				unpipeEvent: __privateGet(this, _unpipeEvent)
			});
			__privateGet(this, _streamPromises).set(stream, streamPromise);
			stream.pipe(this, { end: false });
		}
		remove(stream) {
			return __async(this, null, function* () {
				validateStream(stream);
				if (!__privateGet(this, _streams).has(stream)) return false;
				const streamPromise = __privateGet(this, _streamPromises).get(stream);
				if (streamPromise === void 0) return false;
				__privateGet(this, _streamPromises).delete(stream);
				stream.unpipe(this);
				yield streamPromise;
				return true;
			});
		}
	};
	_streams = /* @__PURE__ */ new WeakMap();
	_ended = /* @__PURE__ */ new WeakMap();
	_aborted = /* @__PURE__ */ new WeakMap();
	_onFinished = /* @__PURE__ */ new WeakMap();
	_unpipeEvent = /* @__PURE__ */ new WeakMap();
	_streamPromises = /* @__PURE__ */ new WeakMap();
	var onMergedStreamFinished = (passThroughStream, streams, unpipeEvent) => __async(null, null, function* () {
		updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
		const controller = new AbortController();
		try {
			yield Promise.race([onMergedStreamEnd(passThroughStream, controller), onInputStreamsUnpipe(passThroughStream, streams, unpipeEvent, controller)]);
		} finally {
			controller.abort();
			updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_COUNT);
		}
	});
	var onMergedStreamEnd = (_0, _1) => __async(null, [_0, _1], function* (passThroughStream, { signal }) {
		try {
			yield (0, import_promises.finished)(passThroughStream, {
				signal,
				cleanup: true
			});
		} catch (error) {
			errorOrAbortStream(passThroughStream, error);
			throw error;
		}
	});
	var onInputStreamsUnpipe = (_0, _1, _2, _3) => __async(null, [
		_0,
		_1,
		_2,
		_3
	], function* (passThroughStream, streams, unpipeEvent, { signal }) {
		try {
			for (var iter = __forAwait((0, import_node_events.on)(passThroughStream, "unpipe", { signal })), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
				const [unpipedStream] = temp.value;
				if (streams.has(unpipedStream)) unpipedStream.emit(unpipeEvent);
			}
		} catch (temp) {
			error = [temp];
		} finally {
			try {
				more && (temp = iter.return) && (yield temp.call(iter));
			} finally {
				if (error) throw error[0];
			}
		}
	});
	var validateStream = (stream) => {
		if (typeof (stream == null ? void 0 : stream.pipe) !== "function") throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
	};
	var endWhenStreamsDone = (_0) => __async(null, [_0], function* ({ passThroughStream, stream, streams, ended, aborted, onFinished, unpipeEvent }) {
		updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
		const controller = new AbortController();
		try {
			yield Promise.race([
				afterMergedStreamFinished(onFinished, stream, controller),
				onInputStreamEnd({
					passThroughStream,
					stream,
					streams,
					ended,
					aborted,
					controller
				}),
				onInputStreamUnpipe({
					stream,
					streams,
					ended,
					aborted,
					unpipeEvent,
					controller
				})
			]);
		} finally {
			controller.abort();
			updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
		}
		if (streams.size > 0 && streams.size === ended.size + aborted.size) if (ended.size === 0 && aborted.size > 0) abortStream(passThroughStream);
		else endStream(passThroughStream);
	});
	var afterMergedStreamFinished = (_0, _1, _2) => __async(null, [
		_0,
		_1,
		_2
	], function* (onFinished, stream, { signal }) {
		try {
			yield onFinished;
			if (!signal.aborted) abortStream(stream);
		} catch (error) {
			if (!signal.aborted) errorOrAbortStream(stream, error);
		}
	});
	var onInputStreamEnd = (_0) => __async(null, [_0], function* ({ passThroughStream, stream, streams, ended, aborted, controller: { signal } }) {
		try {
			yield (0, import_promises.finished)(stream, {
				signal,
				cleanup: true,
				readable: true,
				writable: false
			});
			if (streams.has(stream)) ended.add(stream);
		} catch (error) {
			if (signal.aborted || !streams.has(stream)) return;
			if (isAbortError(error)) aborted.add(stream);
			else errorStream(passThroughStream, error);
		}
	});
	var onInputStreamUnpipe = (_0) => __async(null, [_0], function* ({ stream, streams, ended, aborted, unpipeEvent, controller: { signal } }) {
		yield (0, import_node_events.once)(stream, unpipeEvent, { signal });
		if (!stream.readable) return (0, import_node_events.once)(signal, "abort", { signal });
		streams.delete(stream);
		ended.delete(stream);
		aborted.delete(stream);
	});
	var endStream = (stream) => {
		if (stream.writable) stream.end();
	};
	var errorOrAbortStream = (stream, error) => {
		if (isAbortError(error)) abortStream(stream);
		else errorStream(stream, error);
	};
	var isAbortError = (error) => (error == null ? void 0 : error.code) === "ERR_STREAM_PREMATURE_CLOSE";
	var abortStream = (stream) => {
		if (stream.readable || stream.writable) stream.destroy();
	};
	var errorStream = (stream, error) => {
		if (!stream.destroyed) {
			stream.once("error", noop);
			stream.destroy(error);
		}
	};
	var noop = () => {};
	var updateMaxListeners = (passThroughStream, increment) => {
		const maxListeners = passThroughStream.getMaxListeners();
		if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) passThroughStream.setMaxListeners(maxListeners + increment);
	};
	var PASSTHROUGH_LISTENERS_COUNT = 2;
	var PASSTHROUGH_LISTENERS_PER_STREAM = 1;
	var import_fast_glob2 = __toESM(require_out4(), 1);
	var import_node_fs = __toESM(__require("fs"), 1);
	var import_promises2 = __toESM(__require("fs").promises, 1);
	function isType(fsStatType, statsMethodName, filePath) {
		return __async(this, null, function* () {
			if (typeof filePath !== "string") throw new TypeError(`Expected a string, got ${typeof filePath}`);
			try {
				return (yield import_promises2.default[fsStatType](filePath))[statsMethodName]();
			} catch (error) {
				if (error.code === "ENOENT") return false;
				throw error;
			}
		});
	}
	function isTypeSync(fsStatType, statsMethodName, filePath) {
		if (typeof filePath !== "string") throw new TypeError(`Expected a string, got ${typeof filePath}`);
		try {
			return import_node_fs.default[fsStatType](filePath)[statsMethodName]();
		} catch (error) {
			if (error.code === "ENOENT") return false;
			throw error;
		}
	}
	isType.bind(void 0, "stat", "isFile");
	var isDirectory = isType.bind(void 0, "stat", "isDirectory");
	isType.bind(void 0, "lstat", "isSymbolicLink");
	isTypeSync.bind(void 0, "statSync", "isFile");
	var isDirectorySync = isTypeSync.bind(void 0, "statSync", "isDirectory");
	isTypeSync.bind(void 0, "lstatSync", "isSymbolicLink");
	var import_node_util = __require("util");
	var import_node_child_process = __require("child_process");
	var import_node_url = __require("url");
	(0, import_node_util.promisify)(import_node_child_process.execFile);
	function toPath(urlOrPath) {
		return urlOrPath instanceof URL ? (0, import_node_url.fileURLToPath)(urlOrPath) : urlOrPath;
	}
	var import_node_process$1 = __toESM(__require("process"), 1);
	var import_node_fs2 = __toESM(__require("fs"), 1);
	var import_promises3 = __toESM(__require("fs").promises, 1);
	var import_node_path = __toESM(__require("path"), 1);
	var import_fast_glob = __toESM(require_out4(), 1);
	var import_ignore = __toESM(require_ignore(), 1);
	function slash(path3) {
		if (path3.startsWith("\\\\?\\")) return path3;
		return path3.replace(/\\/g, "/");
	}
	var isNegativePattern = (pattern) => pattern[0] === "!";
	var defaultIgnoredDirectories = [
		"**/node_modules",
		"**/flow-typed",
		"**/coverage",
		"**/.git"
	];
	var ignoreFilesGlobOptions = {
		absolute: true,
		dot: true
	};
	var GITIGNORE_FILES_PATTERN = "**/.gitignore";
	var applyBaseToPattern = (pattern, base) => {
		if (!base) return pattern;
		const isNegative = isNegativePattern(pattern);
		const cleanPattern = isNegative ? pattern.slice(1) : pattern;
		const slashIndex = cleanPattern.indexOf("/");
		const hasNonTrailingSlash = slashIndex !== -1 && slashIndex !== cleanPattern.length - 1;
		let result;
		if (!hasNonTrailingSlash) result = import_node_path.default.posix.join(base, "**", cleanPattern);
		else if (cleanPattern.startsWith("/")) result = import_node_path.default.posix.join(base, cleanPattern.slice(1));
		else result = import_node_path.default.posix.join(base, cleanPattern);
		return isNegative ? "!" + result : result;
	};
	var parseIgnoreFile = (file, cwd) => {
		const base = slash(import_node_path.default.relative(cwd, import_node_path.default.dirname(file.filePath)));
		return file.content.split(/\r?\n/).filter((line) => line && !line.startsWith("#")).map((pattern) => applyBaseToPattern(pattern, base));
	};
	var toRelativePath = (fileOrDirectory, cwd) => {
		cwd = slash(cwd);
		if (import_node_path.default.isAbsolute(fileOrDirectory)) {
			if (slash(fileOrDirectory).startsWith(cwd)) return import_node_path.default.relative(cwd, fileOrDirectory);
			throw new Error(`Path ${fileOrDirectory} is not in cwd ${cwd}`);
		}
		if (fileOrDirectory.startsWith("./")) return fileOrDirectory.slice(2);
		if (fileOrDirectory.startsWith("../")) return;
		return fileOrDirectory;
	};
	var getIsIgnoredPredicate = (files, cwd) => {
		const patterns = files.flatMap((file) => parseIgnoreFile(file, cwd));
		const ignores = (0, import_ignore.default)().add(patterns);
		return (fileOrDirectory) => {
			fileOrDirectory = toPath(fileOrDirectory);
			fileOrDirectory = toRelativePath(fileOrDirectory, cwd);
			if (fileOrDirectory === void 0) return false;
			return fileOrDirectory ? ignores.ignores(slash(fileOrDirectory)) : false;
		};
	};
	var normalizeOptions = (options = {}) => {
		var _a2, _b2;
		return {
			cwd: (_a2 = toPath(options.cwd)) != null ? _a2 : import_node_process$1.default.cwd(),
			suppressErrors: Boolean(options.suppressErrors),
			deep: typeof options.deep === "number" ? options.deep : Number.POSITIVE_INFINITY,
			ignore: [...(_b2 = options.ignore) != null ? _b2 : [], ...defaultIgnoredDirectories]
		};
	};
	var isIgnoredByIgnoreFiles = (patterns, options) => __async(null, null, function* () {
		const { cwd, suppressErrors, deep, ignore } = normalizeOptions(options);
		const paths = yield (0, import_fast_glob.default)(patterns, __spreadValues({
			cwd,
			suppressErrors,
			deep,
			ignore
		}, ignoreFilesGlobOptions));
		return getIsIgnoredPredicate(yield Promise.all(paths.map((filePath) => __async(null, null, function* () {
			return {
				filePath,
				content: yield import_promises3.default.readFile(filePath, "utf8")
			};
		}))), cwd);
	});
	var isIgnoredByIgnoreFilesSync = (patterns, options) => {
		const { cwd, suppressErrors, deep, ignore } = normalizeOptions(options);
		return getIsIgnoredPredicate(import_fast_glob.default.sync(patterns, __spreadValues({
			cwd,
			suppressErrors,
			deep,
			ignore
		}, ignoreFilesGlobOptions)).map((filePath) => ({
			filePath,
			content: import_node_fs2.default.readFileSync(filePath, "utf8")
		})), cwd);
	};
	var isGitIgnored = (options) => isIgnoredByIgnoreFiles(GITIGNORE_FILES_PATTERN, options);
	var isGitIgnoredSync = (options) => isIgnoredByIgnoreFilesSync(GITIGNORE_FILES_PATTERN, options);
	var assertPatternsInput = (patterns) => {
		if (patterns.some((pattern) => typeof pattern !== "string")) throw new TypeError("Patterns must be a string or an array of strings");
	};
	var normalizePathForDirectoryGlob = (filePath, cwd) => {
		const path3 = isNegativePattern(filePath) ? filePath.slice(1) : filePath;
		return import_node_path2.default.isAbsolute(path3) ? path3 : import_node_path2.default.join(cwd, path3);
	};
	var shouldExpandGlobstarDirectory = (pattern) => {
		const match = pattern == null ? void 0 : pattern.match(/\*\*\/([^/]+)$/);
		if (!match) return false;
		const dirname = match[1];
		const hasWildcards = /[*?[\]{}]/.test(dirname);
		const hasExtension = import_node_path2.default.extname(dirname) && !dirname.startsWith(".");
		return !hasWildcards && !hasExtension;
	};
	var getDirectoryGlob = ({ directoryPath, files, extensions }) => {
		const extensionGlob = (extensions == null ? void 0 : extensions.length) > 0 ? `.${extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0]}` : "";
		return files ? files.map((file) => import_node_path2.default.posix.join(directoryPath, `**/${import_node_path2.default.extname(file) ? file : `${file}${extensionGlob}`}`)) : [import_node_path2.default.posix.join(directoryPath, `**${extensionGlob ? `/*${extensionGlob}` : ""}`)];
	};
	var directoryToGlob = (_0, ..._1) => __async(null, [_0, ..._1], function* (directoryPaths, { cwd = import_node_process2.default.cwd(), files, extensions } = {}) {
		return (yield Promise.all(directoryPaths.map((directoryPath) => __async(null, null, function* () {
			if (shouldExpandGlobstarDirectory(isNegativePattern(directoryPath) ? directoryPath.slice(1) : directoryPath)) return getDirectoryGlob({
				directoryPath,
				files,
				extensions
			});
			return (yield isDirectory(normalizePathForDirectoryGlob(directoryPath, cwd))) ? getDirectoryGlob({
				directoryPath,
				files,
				extensions
			}) : directoryPath;
		})))).flat();
	});
	var directoryToGlobSync = (directoryPaths, { cwd = import_node_process2.default.cwd(), files, extensions } = {}) => directoryPaths.flatMap((directoryPath) => {
		if (shouldExpandGlobstarDirectory(isNegativePattern(directoryPath) ? directoryPath.slice(1) : directoryPath)) return getDirectoryGlob({
			directoryPath,
			files,
			extensions
		});
		return isDirectorySync(normalizePathForDirectoryGlob(directoryPath, cwd)) ? getDirectoryGlob({
			directoryPath,
			files,
			extensions
		}) : directoryPath;
	});
	var toPatternsArray = (patterns) => {
		patterns = [...new Set([patterns].flat())];
		assertPatternsInput(patterns);
		return patterns;
	};
	var checkCwdOption = (cwd) => {
		if (!cwd) return;
		let stat;
		try {
			stat = import_node_fs3.default.statSync(cwd);
		} catch (e) {
			return;
		}
		if (!stat.isDirectory()) throw new Error("The `cwd` option must be a path to a directory");
	};
	var normalizeOptions2 = (options = {}) => {
		var _a2, _b2;
		options = __spreadProps(__spreadValues({}, options), {
			ignore: (_a2 = options.ignore) != null ? _a2 : [],
			expandDirectories: (_b2 = options.expandDirectories) != null ? _b2 : true,
			cwd: toPath(options.cwd)
		});
		checkCwdOption(options.cwd);
		return options;
	};
	var normalizeArguments = (function_) => (patterns, options) => __async(null, null, function* () {
		return function_(toPatternsArray(patterns), normalizeOptions2(options));
	});
	var normalizeArgumentsSync = (function_) => (patterns, options) => function_(toPatternsArray(patterns), normalizeOptions2(options));
	var getIgnoreFilesPatterns = (options) => {
		const { ignoreFiles, gitignore } = options;
		const patterns = ignoreFiles ? toPatternsArray(ignoreFiles) : [];
		if (gitignore) patterns.push(GITIGNORE_FILES_PATTERN);
		return patterns;
	};
	var getFilter = (options) => __async(null, null, function* () {
		const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
		return createFilterFunction(ignoreFilesPatterns.length > 0 && (yield isIgnoredByIgnoreFiles(ignoreFilesPatterns, options)));
	});
	var getFilterSync = (options) => {
		const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
		return createFilterFunction(ignoreFilesPatterns.length > 0 && isIgnoredByIgnoreFilesSync(ignoreFilesPatterns, options));
	};
	var createFilterFunction = (isIgnored) => {
		const seen = /* @__PURE__ */ new Set();
		return (fastGlobResult) => {
			var _a2;
			const pathKey = import_node_path2.default.normalize((_a2 = fastGlobResult.path) != null ? _a2 : fastGlobResult);
			if (seen.has(pathKey) || isIgnored && isIgnored(pathKey)) return false;
			seen.add(pathKey);
			return true;
		};
	};
	var unionFastGlobResults = (results, filter) => results.flat().filter((fastGlobResult) => filter(fastGlobResult));
	var convertNegativePatterns = (patterns, options) => {
		const tasks = [];
		while (patterns.length > 0) {
			const index = patterns.findIndex((pattern) => isNegativePattern(pattern));
			if (index === -1) {
				tasks.push({
					patterns,
					options
				});
				break;
			}
			const ignorePattern = patterns[index].slice(1);
			for (const task of tasks) task.options.ignore.push(ignorePattern);
			if (index !== 0) tasks.push({
				patterns: patterns.slice(0, index),
				options: __spreadProps(__spreadValues({}, options), { ignore: [...options.ignore, ignorePattern] })
			});
			patterns = patterns.slice(index + 1);
		}
		return tasks;
	};
	var normalizeExpandDirectoriesOption = (options, cwd) => __spreadValues(__spreadValues({}, cwd ? { cwd } : {}), Array.isArray(options) ? { files: options } : options);
	var generateTasks = (patterns, options) => __async(null, null, function* () {
		const globTasks = convertNegativePatterns(patterns, options);
		const { cwd, expandDirectories } = options;
		if (!expandDirectories) return globTasks;
		const directoryToGlobOptions = normalizeExpandDirectoriesOption(expandDirectories, cwd);
		return Promise.all(globTasks.map((task) => __async(null, null, function* () {
			let { patterns: patterns2, options: options2 } = task;
			[patterns2, options2.ignore] = yield Promise.all([directoryToGlob(patterns2, directoryToGlobOptions), directoryToGlob(options2.ignore, { cwd })]);
			return {
				patterns: patterns2,
				options: options2
			};
		})));
	});
	var generateTasksSync = (patterns, options) => {
		const globTasks = convertNegativePatterns(patterns, options);
		const { cwd, expandDirectories } = options;
		if (!expandDirectories) return globTasks;
		const directoryToGlobSyncOptions = normalizeExpandDirectoriesOption(expandDirectories, cwd);
		return globTasks.map((task) => {
			let { patterns: patterns2, options: options2 } = task;
			patterns2 = directoryToGlobSync(patterns2, directoryToGlobSyncOptions);
			options2.ignore = directoryToGlobSync(options2.ignore, { cwd });
			return {
				patterns: patterns2,
				options: options2
			};
		});
	};
	var globby = normalizeArguments((patterns, options) => __async(null, null, function* () {
		const [tasks, filter] = yield Promise.all([generateTasks(patterns, options), getFilter(options)]);
		return unionFastGlobResults(yield Promise.all(tasks.map((task) => (0, import_fast_glob2.default)(task.patterns, task.options))), filter);
	}));
	var globbySync = normalizeArgumentsSync((patterns, options) => {
		const tasks = generateTasksSync(patterns, options);
		const filter = getFilterSync(options);
		return unionFastGlobResults(tasks.map((task) => import_fast_glob2.default.sync(task.patterns, task.options)), filter);
	});
	var globbyStream = normalizeArgumentsSync((patterns, options) => {
		const tasks = generateTasksSync(patterns, options);
		const filter = getFilterSync(options);
		const streams = tasks.map((task) => import_fast_glob2.default.stream(task.patterns, task.options));
		if (streams.length === 0) return import_node_stream2.Readable.from([]);
		return mergeStreams(streams).filter((fastGlobResult) => filter(fastGlobResult));
	});
	var isDynamicPattern = normalizeArgumentsSync((patterns, options) => patterns.some((pattern) => import_fast_glob2.default.isDynamicPattern(pattern, options)));
	var generateGlobTasks = normalizeArguments(generateTasks);
	var generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync);
	var { convertPathToPattern } = import_fast_glob2.default;
	var browser_exports = {};
	__export(browser_exports, {
		Alias: () => Alias,
		CST: () => cst_exports,
		Composer: () => Composer,
		Document: () => Document,
		Lexer: () => Lexer,
		LineCounter: () => LineCounter,
		Pair: () => Pair,
		Parser: () => Parser,
		Scalar: () => Scalar,
		Schema: () => Schema,
		YAMLError: () => YAMLError,
		YAMLMap: () => YAMLMap,
		YAMLParseError: () => YAMLParseError,
		YAMLSeq: () => YAMLSeq,
		YAMLWarning: () => YAMLWarning,
		default: () => browser_default,
		isAlias: () => isAlias,
		isCollection: () => isCollection,
		isDocument: () => isDocument,
		isMap: () => isMap,
		isNode: () => isNode,
		isPair: () => isPair,
		isScalar: () => isScalar,
		isSeq: () => isSeq,
		parse: () => parse,
		parseAllDocuments: () => parseAllDocuments,
		parseDocument: () => parseDocument,
		stringify: () => stringify3,
		visit: () => visit,
		visitAsync: () => visitAsync
	});
	var dist_exports = {};
	__export(dist_exports, {
		Alias: () => Alias,
		CST: () => cst_exports,
		Composer: () => Composer,
		Document: () => Document,
		Lexer: () => Lexer,
		LineCounter: () => LineCounter,
		Pair: () => Pair,
		Parser: () => Parser,
		Scalar: () => Scalar,
		Schema: () => Schema,
		YAMLError: () => YAMLError,
		YAMLMap: () => YAMLMap,
		YAMLParseError: () => YAMLParseError,
		YAMLSeq: () => YAMLSeq,
		YAMLWarning: () => YAMLWarning,
		isAlias: () => isAlias,
		isCollection: () => isCollection,
		isDocument: () => isDocument,
		isMap: () => isMap,
		isNode: () => isNode,
		isPair: () => isPair,
		isScalar: () => isScalar,
		isSeq: () => isSeq,
		parse: () => parse,
		parseAllDocuments: () => parseAllDocuments,
		parseDocument: () => parseDocument,
		stringify: () => stringify3,
		visit: () => visit,
		visitAsync: () => visitAsync
	});
	var ALIAS = Symbol.for("yaml.alias");
	var DOC = Symbol.for("yaml.document");
	var MAP = Symbol.for("yaml.map");
	var PAIR = Symbol.for("yaml.pair");
	var SCALAR = Symbol.for("yaml.scalar");
	var SEQ = Symbol.for("yaml.seq");
	var NODE_TYPE = Symbol.for("yaml.node.type");
	var isAlias = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === ALIAS;
	var isDocument = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === DOC;
	var isMap = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP;
	var isPair = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === PAIR;
	var isScalar = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SCALAR;
	var isSeq = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SEQ;
	function isCollection(node) {
		if (node && typeof node === "object") switch (node[NODE_TYPE]) {
			case MAP:
			case SEQ: return true;
		}
		return false;
	}
	function isNode(node) {
		if (node && typeof node === "object") switch (node[NODE_TYPE]) {
			case ALIAS:
			case MAP:
			case SCALAR:
			case SEQ: return true;
		}
		return false;
	}
	var hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;
	var BREAK = Symbol("break visit");
	var SKIP = Symbol("skip children");
	var REMOVE = Symbol("remove node");
	function visit(node, visitor) {
		const visitor_ = initVisitor(visitor);
		if (isDocument(node)) {
			if (visit_(null, node.contents, visitor_, Object.freeze([node])) === REMOVE) node.contents = null;
		} else visit_(null, node, visitor_, Object.freeze([]));
	}
	visit.BREAK = BREAK;
	visit.SKIP = SKIP;
	visit.REMOVE = REMOVE;
	function visit_(key, node, visitor, path3) {
		const ctrl = callVisitor(key, node, visitor, path3);
		if (isNode(ctrl) || isPair(ctrl)) {
			replaceNode(key, path3, ctrl);
			return visit_(key, ctrl, visitor, path3);
		}
		if (typeof ctrl !== "symbol") {
			if (isCollection(node)) {
				path3 = Object.freeze(path3.concat(node));
				for (let i = 0; i < node.items.length; ++i) {
					const ci2 = visit_(i, node.items[i], visitor, path3);
					if (typeof ci2 === "number") i = ci2 - 1;
					else if (ci2 === BREAK) return BREAK;
					else if (ci2 === REMOVE) {
						node.items.splice(i, 1);
						i -= 1;
					}
				}
			} else if (isPair(node)) {
				path3 = Object.freeze(path3.concat(node));
				const ck = visit_("key", node.key, visitor, path3);
				if (ck === BREAK) return BREAK;
				else if (ck === REMOVE) node.key = null;
				const cv = visit_("value", node.value, visitor, path3);
				if (cv === BREAK) return BREAK;
				else if (cv === REMOVE) node.value = null;
			}
		}
		return ctrl;
	}
	function visitAsync(node, visitor) {
		return __async(this, null, function* () {
			const visitor_ = initVisitor(visitor);
			if (isDocument(node)) {
				if ((yield visitAsync_(null, node.contents, visitor_, Object.freeze([node]))) === REMOVE) node.contents = null;
			} else yield visitAsync_(null, node, visitor_, Object.freeze([]));
		});
	}
	visitAsync.BREAK = BREAK;
	visitAsync.SKIP = SKIP;
	visitAsync.REMOVE = REMOVE;
	function visitAsync_(key, node, visitor, path3) {
		return __async(this, null, function* () {
			const ctrl = yield callVisitor(key, node, visitor, path3);
			if (isNode(ctrl) || isPair(ctrl)) {
				replaceNode(key, path3, ctrl);
				return visitAsync_(key, ctrl, visitor, path3);
			}
			if (typeof ctrl !== "symbol") {
				if (isCollection(node)) {
					path3 = Object.freeze(path3.concat(node));
					for (let i = 0; i < node.items.length; ++i) {
						const ci2 = yield visitAsync_(i, node.items[i], visitor, path3);
						if (typeof ci2 === "number") i = ci2 - 1;
						else if (ci2 === BREAK) return BREAK;
						else if (ci2 === REMOVE) {
							node.items.splice(i, 1);
							i -= 1;
						}
					}
				} else if (isPair(node)) {
					path3 = Object.freeze(path3.concat(node));
					const ck = yield visitAsync_("key", node.key, visitor, path3);
					if (ck === BREAK) return BREAK;
					else if (ck === REMOVE) node.key = null;
					const cv = yield visitAsync_("value", node.value, visitor, path3);
					if (cv === BREAK) return BREAK;
					else if (cv === REMOVE) node.value = null;
				}
			}
			return ctrl;
		});
	}
	function initVisitor(visitor) {
		if (typeof visitor === "object" && (visitor.Collection || visitor.Node || visitor.Value)) return Object.assign({
			Alias: visitor.Node,
			Map: visitor.Node,
			Scalar: visitor.Node,
			Seq: visitor.Node
		}, visitor.Value && {
			Map: visitor.Value,
			Scalar: visitor.Value,
			Seq: visitor.Value
		}, visitor.Collection && {
			Map: visitor.Collection,
			Seq: visitor.Collection
		}, visitor);
		return visitor;
	}
	function callVisitor(key, node, visitor, path3) {
		var _a2, _b2, _c, _d, _e;
		if (typeof visitor === "function") return visitor(key, node, path3);
		if (isMap(node)) return (_a2 = visitor.Map) == null ? void 0 : _a2.call(visitor, key, node, path3);
		if (isSeq(node)) return (_b2 = visitor.Seq) == null ? void 0 : _b2.call(visitor, key, node, path3);
		if (isPair(node)) return (_c = visitor.Pair) == null ? void 0 : _c.call(visitor, key, node, path3);
		if (isScalar(node)) return (_d = visitor.Scalar) == null ? void 0 : _d.call(visitor, key, node, path3);
		if (isAlias(node)) return (_e = visitor.Alias) == null ? void 0 : _e.call(visitor, key, node, path3);
	}
	function replaceNode(key, path3, node) {
		const parent = path3[path3.length - 1];
		if (isCollection(parent)) parent.items[key] = node;
		else if (isPair(parent)) if (key === "key") parent.key = node;
		else parent.value = node;
		else if (isDocument(parent)) parent.contents = node;
		else {
			const pt2 = isAlias(parent) ? "alias" : "scalar";
			throw new Error(`Cannot replace node with ${pt2} parent`);
		}
	}
	var escapeChars = {
		"!": "%21",
		",": "%2C",
		"[": "%5B",
		"]": "%5D",
		"{": "%7B",
		"}": "%7D"
	};
	var escapeTagName = (tn) => tn.replace(/[!,[\]{}]/g, (ch) => escapeChars[ch]);
	var Directives = class _Directives {
		constructor(yaml, tags) {
			this.docStart = null;
			this.docEnd = false;
			this.yaml = Object.assign({}, _Directives.defaultYaml, yaml);
			this.tags = Object.assign({}, _Directives.defaultTags, tags);
		}
		clone() {
			const copy = new _Directives(this.yaml, this.tags);
			copy.docStart = this.docStart;
			return copy;
		}
		/**
		* During parsing, get a Directives instance for the current document and
		* update the stream state according to the current version's spec.
		*/
		atDocument() {
			const res = new _Directives(this.yaml, this.tags);
			switch (this.yaml.version) {
				case "1.1":
					this.atNextDocument = true;
					break;
				case "1.2":
					this.atNextDocument = false;
					this.yaml = {
						explicit: _Directives.defaultYaml.explicit,
						version: "1.2"
					};
					this.tags = Object.assign({}, _Directives.defaultTags);
					break;
			}
			return res;
		}
		/**
		* @param onError - May be called even if the action was successful
		* @returns `true` on success
		*/
		add(line, onError) {
			if (this.atNextDocument) {
				this.yaml = {
					explicit: _Directives.defaultYaml.explicit,
					version: "1.1"
				};
				this.tags = Object.assign({}, _Directives.defaultTags);
				this.atNextDocument = false;
			}
			const parts = line.trim().split(/[ \t]+/);
			const name = parts.shift();
			switch (name) {
				case "%TAG": {
					if (parts.length !== 2) {
						onError(0, "%TAG directive should contain exactly two parts");
						if (parts.length < 2) return false;
					}
					const [handle, prefix] = parts;
					this.tags[handle] = prefix;
					return true;
				}
				case "%YAML": {
					this.yaml.explicit = true;
					if (parts.length !== 1) {
						onError(0, "%YAML directive should contain exactly one part");
						return false;
					}
					const [version] = parts;
					if (version === "1.1" || version === "1.2") {
						this.yaml.version = version;
						return true;
					} else {
						const isValid = /^\d+\.\d+$/.test(version);
						onError(6, `Unsupported YAML version ${version}`, isValid);
						return false;
					}
				}
				default:
					onError(0, `Unknown directive ${name}`, true);
					return false;
			}
		}
		/**
		* Resolves a tag, matching handles to those defined in %TAG directives.
		*
		* @returns Resolved tag, which may also be the non-specific tag `'!'` or a
		*   `'!local'` tag, or `null` if unresolvable.
		*/
		tagName(source, onError) {
			if (source === "!") return "!";
			if (source[0] !== "!") {
				onError(`Not a valid tag: ${source}`);
				return null;
			}
			if (source[1] === "<") {
				const verbatim = source.slice(2, -1);
				if (verbatim === "!" || verbatim === "!!") {
					onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);
					return null;
				}
				if (source[source.length - 1] !== ">") onError("Verbatim tags must end with a >");
				return verbatim;
			}
			const [, handle, suffix] = source.match(/* @__PURE__ */ new RegExp("^(.*!)([^!]*)$", "s"));
			if (!suffix) onError(`The ${source} tag has no suffix`);
			const prefix = this.tags[handle];
			if (prefix) try {
				return prefix + decodeURIComponent(suffix);
			} catch (error) {
				onError(String(error));
				return null;
			}
			if (handle === "!") return source;
			onError(`Could not resolve tag: ${source}`);
			return null;
		}
		/**
		* Given a fully resolved tag, returns its printable string form,
		* taking into account current tag prefixes and defaults.
		*/
		tagString(tag) {
			for (const [handle, prefix] of Object.entries(this.tags)) if (tag.startsWith(prefix)) return handle + escapeTagName(tag.substring(prefix.length));
			return tag[0] === "!" ? tag : `!<${tag}>`;
		}
		toString(doc) {
			const lines = this.yaml.explicit ? [`%YAML ${this.yaml.version || "1.2"}`] : [];
			const tagEntries = Object.entries(this.tags);
			let tagNames;
			if (doc && tagEntries.length > 0 && isNode(doc.contents)) {
				const tags = {};
				visit(doc.contents, (_key, node) => {
					if (isNode(node) && node.tag) tags[node.tag] = true;
				});
				tagNames = Object.keys(tags);
			} else tagNames = [];
			for (const [handle, prefix] of tagEntries) {
				if (handle === "!!" && prefix === "tag:yaml.org,2002:") continue;
				if (!doc || tagNames.some((tn) => tn.startsWith(prefix))) lines.push(`%TAG ${handle} ${prefix}`);
			}
			return lines.join("\n");
		}
	};
	Directives.defaultYaml = {
		explicit: false,
		version: "1.2"
	};
	Directives.defaultTags = { "!!": "tag:yaml.org,2002:" };
	function anchorIsValid(anchor) {
		if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
			const msg = `Anchor must not contain whitespace or control characters: ${JSON.stringify(anchor)}`;
			throw new Error(msg);
		}
		return true;
	}
	function anchorNames(root) {
		const anchors = /* @__PURE__ */ new Set();
		visit(root, { Value(_key, node) {
			if (node.anchor) anchors.add(node.anchor);
		} });
		return anchors;
	}
	function findNewAnchor(prefix, exclude) {
		for (let i = 1;; ++i) {
			const name = `${prefix}${i}`;
			if (!exclude.has(name)) return name;
		}
	}
	function createNodeAnchors(doc, prefix) {
		const aliasObjects = [];
		const sourceObjects = /* @__PURE__ */ new Map();
		let prevAnchors = null;
		return {
			onAnchor: (source) => {
				aliasObjects.push(source);
				prevAnchors ??= anchorNames(doc);
				const anchor = findNewAnchor(prefix, prevAnchors);
				prevAnchors.add(anchor);
				return anchor;
			},
			setAnchors: () => {
				for (const source of aliasObjects) {
					const ref = sourceObjects.get(source);
					if (typeof ref === "object" && ref.anchor && (isScalar(ref.node) || isCollection(ref.node))) ref.node.anchor = ref.anchor;
					else {
						const error = /* @__PURE__ */ new Error("Failed to resolve repeated object (this should not happen)");
						error.source = source;
						throw error;
					}
				}
			},
			sourceObjects
		};
	}
	function applyReviver(reviver, obj, key, val) {
		if (val && typeof val === "object") if (Array.isArray(val)) for (let i = 0, len = val.length; i < len; ++i) {
			const v0 = val[i];
			const v1 = applyReviver(reviver, val, String(i), v0);
			if (v1 === void 0) delete val[i];
			else if (v1 !== v0) val[i] = v1;
		}
		else if (val instanceof Map) for (const k2 of Array.from(val.keys())) {
			const v0 = val.get(k2);
			const v1 = applyReviver(reviver, val, k2, v0);
			if (v1 === void 0) val.delete(k2);
			else if (v1 !== v0) val.set(k2, v1);
		}
		else if (val instanceof Set) for (const v0 of Array.from(val)) {
			const v1 = applyReviver(reviver, val, v0, v0);
			if (v1 === void 0) val.delete(v0);
			else if (v1 !== v0) {
				val.delete(v0);
				val.add(v1);
			}
		}
		else for (const [k2, v0] of Object.entries(val)) {
			const v1 = applyReviver(reviver, val, k2, v0);
			if (v1 === void 0) delete val[k2];
			else if (v1 !== v0) val[k2] = v1;
		}
		return reviver.call(obj, key, val);
	}
	function toJS(value, arg, ctx) {
		if (Array.isArray(value)) return value.map((v2, i) => toJS(v2, String(i), ctx));
		if (value && typeof value.toJSON === "function") {
			if (!ctx || !hasAnchor(value)) return value.toJSON(arg, ctx);
			const data = {
				aliasCount: 0,
				count: 1,
				res: void 0
			};
			ctx.anchors.set(value, data);
			ctx.onCreate = (res2) => {
				data.res = res2;
				delete ctx.onCreate;
			};
			const res = value.toJSON(arg, ctx);
			if (ctx.onCreate) ctx.onCreate(res);
			return res;
		}
		if (typeof value === "bigint" && !(ctx == null ? void 0 : ctx.keep)) return Number(value);
		return value;
	}
	var NodeBase = class {
		constructor(type) {
			Object.defineProperty(this, NODE_TYPE, { value: type });
		}
		/** Create a copy of this node.  */
		clone() {
			const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
			if (this.range) copy.range = this.range.slice();
			return copy;
		}
		/** A plain JavaScript representation of this node. */
		toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
			if (!isDocument(doc)) throw new TypeError("A document argument is required");
			const ctx = {
				anchors: /* @__PURE__ */ new Map(),
				doc,
				keep: true,
				mapAsMap: mapAsMap === true,
				mapKeyWarned: false,
				maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100
			};
			const res = toJS(this, "", ctx);
			if (typeof onAnchor === "function") for (const { count, res: res2 } of ctx.anchors.values()) onAnchor(res2, count);
			return typeof reviver === "function" ? applyReviver(reviver, { "": res }, "", res) : res;
		}
	};
	var Alias = class extends NodeBase {
		constructor(source) {
			super(ALIAS);
			this.source = source;
			Object.defineProperty(this, "tag", { set() {
				throw new Error("Alias nodes cannot have tags");
			} });
		}
		/**
		* Resolve the value of this alias within `doc`, finding the last
		* instance of the `source` anchor before this node.
		*/
		resolve(doc, ctx) {
			let nodes;
			if (ctx == null ? void 0 : ctx.aliasResolveCache) nodes = ctx.aliasResolveCache;
			else {
				nodes = [];
				visit(doc, { Node: (_key, node) => {
					if (isAlias(node) || hasAnchor(node)) nodes.push(node);
				} });
				if (ctx) ctx.aliasResolveCache = nodes;
			}
			let found = void 0;
			for (const node of nodes) {
				if (node === this) break;
				if (node.anchor === this.source) found = node;
			}
			return found;
		}
		toJSON(_arg, ctx) {
			if (!ctx) return { source: this.source };
			const { anchors, doc, maxAliasCount } = ctx;
			const source = this.resolve(doc, ctx);
			if (!source) {
				const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
				throw new ReferenceError(msg);
			}
			let data = anchors.get(source);
			if (!data) {
				toJS(source, null, ctx);
				data = anchors.get(source);
			}
			if (!data || data.res === void 0) throw new ReferenceError("This should not happen: Alias anchor was not resolved?");
			if (maxAliasCount >= 0) {
				data.count += 1;
				if (data.aliasCount === 0) data.aliasCount = getAliasCount(doc, source, anchors);
				if (data.count * data.aliasCount > maxAliasCount) throw new ReferenceError("Excessive alias count indicates a resource exhaustion attack");
			}
			return data.res;
		}
		toString(ctx, _onComment, _onChompKeep) {
			const src = `*${this.source}`;
			if (ctx) {
				anchorIsValid(this.source);
				if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
					const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
					throw new Error(msg);
				}
				if (ctx.implicitKey) return `${src} `;
			}
			return src;
		}
	};
	function getAliasCount(doc, node, anchors) {
		if (isAlias(node)) {
			const source = node.resolve(doc);
			const anchor = anchors && source && anchors.get(source);
			return anchor ? anchor.count * anchor.aliasCount : 0;
		} else if (isCollection(node)) {
			let count = 0;
			for (const item of node.items) {
				const c2 = getAliasCount(doc, item, anchors);
				if (c2 > count) count = c2;
			}
			return count;
		} else if (isPair(node)) {
			const kc = getAliasCount(doc, node.key, anchors);
			const vc = getAliasCount(doc, node.value, anchors);
			return Math.max(kc, vc);
		}
		return 1;
	}
	var isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object";
	var Scalar = class extends NodeBase {
		constructor(value) {
			super(SCALAR);
			this.value = value;
		}
		toJSON(arg, ctx) {
			return (ctx == null ? void 0 : ctx.keep) ? this.value : toJS(this.value, arg, ctx);
		}
		toString() {
			return String(this.value);
		}
	};
	Scalar.BLOCK_FOLDED = "BLOCK_FOLDED";
	Scalar.BLOCK_LITERAL = "BLOCK_LITERAL";
	Scalar.PLAIN = "PLAIN";
	Scalar.QUOTE_DOUBLE = "QUOTE_DOUBLE";
	Scalar.QUOTE_SINGLE = "QUOTE_SINGLE";
	var defaultTagPrefix = "tag:yaml.org,2002:";
	function findTagObject(value, tagName, tags) {
		var _a2;
		if (tagName) {
			const match = tags.filter((t3) => t3.tag === tagName);
			const tagObj = (_a2 = match.find((t3) => !t3.format)) != null ? _a2 : match[0];
			if (!tagObj) throw new Error(`Tag ${tagName} not found`);
			return tagObj;
		}
		return tags.find((t3) => {
			var _a3;
			return ((_a3 = t3.identify) == null ? void 0 : _a3.call(t3, value)) && !t3.format;
		});
	}
	function createNode(value, tagName, ctx) {
		var _a2, _b2, _d;
		if (isDocument(value)) value = value.contents;
		if (isNode(value)) return value;
		if (isPair(value)) {
			const map2 = (_b2 = (_a2 = ctx.schema[MAP]).createNode) == null ? void 0 : _b2.call(_a2, ctx.schema, null, ctx);
			map2.items.push(value);
			return map2;
		}
		if (value instanceof String || value instanceof Number || value instanceof Boolean || typeof BigInt !== "undefined" && value instanceof BigInt) value = value.valueOf();
		const { aliasDuplicateObjects, onAnchor, onTagObj, schema: schema4, sourceObjects } = ctx;
		let ref = void 0;
		if (aliasDuplicateObjects && value && typeof value === "object") {
			ref = sourceObjects.get(value);
			if (ref) {
				ref.anchor ?? (ref.anchor = onAnchor(value));
				return new Alias(ref.anchor);
			} else {
				ref = {
					anchor: null,
					node: null
				};
				sourceObjects.set(value, ref);
			}
		}
		if (tagName == null ? void 0 : tagName.startsWith("!!")) tagName = defaultTagPrefix + tagName.slice(2);
		let tagObj = findTagObject(value, tagName, schema4.tags);
		if (!tagObj) {
			if (value && typeof value.toJSON === "function") value = value.toJSON();
			if (!value || typeof value !== "object") {
				const node2 = new Scalar(value);
				if (ref) ref.node = node2;
				return node2;
			}
			tagObj = value instanceof Map ? schema4[MAP] : Symbol.iterator in Object(value) ? schema4[SEQ] : schema4[MAP];
		}
		if (onTagObj) {
			onTagObj(tagObj);
			delete ctx.onTagObj;
		}
		const node = (tagObj == null ? void 0 : tagObj.createNode) ? tagObj.createNode(ctx.schema, value, ctx) : typeof ((_d = tagObj == null ? void 0 : tagObj.nodeClass) == null ? void 0 : _d.from) === "function" ? tagObj.nodeClass.from(ctx.schema, value, ctx) : new Scalar(value);
		if (tagName) node.tag = tagName;
		else if (!tagObj.default) node.tag = tagObj.tag;
		if (ref) ref.node = node;
		return node;
	}
	function collectionFromPath(schema4, path3, value) {
		let v2 = value;
		for (let i = path3.length - 1; i >= 0; --i) {
			const k2 = path3[i];
			if (typeof k2 === "number" && Number.isInteger(k2) && k2 >= 0) {
				const a = [];
				a[k2] = v2;
				v2 = a;
			} else v2 = /* @__PURE__ */ new Map([[k2, v2]]);
		}
		return createNode(v2, void 0, {
			aliasDuplicateObjects: false,
			keepUndefined: false,
			onAnchor: () => {
				throw new Error("This should not happen, please report a bug.");
			},
			schema: schema4,
			sourceObjects: /* @__PURE__ */ new Map()
		});
	}
	var isEmptyPath = (path3) => path3 == null || typeof path3 === "object" && !!path3[Symbol.iterator]().next().done;
	var Collection = class extends NodeBase {
		constructor(type, schema4) {
			super(type);
			Object.defineProperty(this, "schema", {
				value: schema4,
				configurable: true,
				enumerable: false,
				writable: true
			});
		}
		/**
		* Create a copy of this collection.
		*
		* @param schema - If defined, overwrites the original's schema
		*/
		clone(schema4) {
			const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
			if (schema4) copy.schema = schema4;
			copy.items = copy.items.map((it) => isNode(it) || isPair(it) ? it.clone(schema4) : it);
			if (this.range) copy.range = this.range.slice();
			return copy;
		}
		/**
		* Adds a value to the collection. For `!!map` and `!!omap` the value must
		* be a Pair instance or a `{ key, value }` object, which may not have a key
		* that already exists in the map.
		*/
		addIn(path3, value) {
			if (isEmptyPath(path3)) this.add(value);
			else {
				const [key, ...rest] = path3;
				const node = this.get(key, true);
				if (isCollection(node)) node.addIn(rest, value);
				else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));
				else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
			}
		}
		/**
		* Removes a value from the collection.
		* @returns `true` if the item was found and removed.
		*/
		deleteIn(path3) {
			const [key, ...rest] = path3;
			if (rest.length === 0) return this.delete(key);
			const node = this.get(key, true);
			if (isCollection(node)) return node.deleteIn(rest);
			else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
		}
		/**
		* Returns item at `key`, or `undefined` if not found. By default unwraps
		* scalar values from their surrounding node; to disable set `keepScalar` to
		* `true` (collections are always returned intact).
		*/
		getIn(path3, keepScalar) {
			const [key, ...rest] = path3;
			const node = this.get(key, true);
			if (rest.length === 0) return !keepScalar && isScalar(node) ? node.value : node;
			else return isCollection(node) ? node.getIn(rest, keepScalar) : void 0;
		}
		hasAllNullValues(allowScalar) {
			return this.items.every((node) => {
				if (!isPair(node)) return false;
				const n4 = node.value;
				return n4 == null || allowScalar && isScalar(n4) && n4.value == null && !n4.commentBefore && !n4.comment && !n4.tag;
			});
		}
		/**
		* Checks if the collection includes a value with the key `key`.
		*/
		hasIn(path3) {
			const [key, ...rest] = path3;
			if (rest.length === 0) return this.has(key);
			const node = this.get(key, true);
			return isCollection(node) ? node.hasIn(rest) : false;
		}
		/**
		* Sets a value in this collection. For `!!set`, `value` needs to be a
		* boolean to add/remove the item from the set.
		*/
		setIn(path3, value) {
			const [key, ...rest] = path3;
			if (rest.length === 0) this.set(key, value);
			else {
				const node = this.get(key, true);
				if (isCollection(node)) node.setIn(rest, value);
				else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));
				else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
			}
		}
	};
	var stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, "#");
	function indentComment(comment, indent) {
		if (/^\n+$/.test(comment)) return comment.substring(1);
		return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
	}
	var lineComment = (str, indent, comment) => str.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str.endsWith(" ") ? "" : " ") + comment;
	var FOLD_FLOW = "flow";
	var FOLD_BLOCK = "block";
	var FOLD_QUOTED = "quoted";
	function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
		if (!lineWidth || lineWidth < 0) return text;
		if (lineWidth < minContentWidth) minContentWidth = 0;
		const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
		if (text.length <= endStep) return text;
		const folds = [];
		const escapedFolds = {};
		let end = lineWidth - indent.length;
		if (typeof indentAtStart === "number") if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0);
		else end = lineWidth - indentAtStart;
		let split = void 0;
		let prev = void 0;
		let overflow = false;
		let i = -1;
		let escStart = -1;
		let escEnd = -1;
		if (mode === FOLD_BLOCK) {
			i = consumeMoreIndentedLines(text, i, indent.length);
			if (i !== -1) end = i + endStep;
		}
		for (let ch; ch = text[i += 1];) {
			if (mode === FOLD_QUOTED && ch === "\\") {
				escStart = i;
				switch (text[i + 1]) {
					case "x":
						i += 3;
						break;
					case "u":
						i += 5;
						break;
					case "U":
						i += 9;
						break;
					default: i += 1;
				}
				escEnd = i;
			}
			if (ch === "\n") {
				if (mode === FOLD_BLOCK) i = consumeMoreIndentedLines(text, i, indent.length);
				end = i + indent.length + endStep;
				split = void 0;
			} else {
				if (ch === " " && prev && prev !== " " && prev !== "\n" && prev !== "	") {
					const next = text[i + 1];
					if (next && next !== " " && next !== "\n" && next !== "	") split = i;
				}
				if (i >= end) if (split) {
					folds.push(split);
					end = split + endStep;
					split = void 0;
				} else if (mode === FOLD_QUOTED) {
					while (prev === " " || prev === "	") {
						prev = ch;
						ch = text[i += 1];
						overflow = true;
					}
					const j = i > escEnd + 1 ? i - 2 : escStart - 1;
					if (escapedFolds[j]) return text;
					folds.push(j);
					escapedFolds[j] = true;
					end = j + endStep;
					split = void 0;
				} else overflow = true;
			}
			prev = ch;
		}
		if (overflow && onOverflow) onOverflow();
		if (folds.length === 0) return text;
		if (onFold) onFold();
		let res = text.slice(0, folds[0]);
		for (let i2 = 0; i2 < folds.length; ++i2) {
			const fold = folds[i2];
			const end2 = folds[i2 + 1] || text.length;
			if (fold === 0) res = `
${indent}${text.slice(0, end2)}`;
			else {
				if (mode === FOLD_QUOTED && escapedFolds[fold]) res += `${text[fold]}\\`;
				res += `
${indent}${text.slice(fold + 1, end2)}`;
			}
		}
		return res;
	}
	function consumeMoreIndentedLines(text, i, indent) {
		let end = i;
		let start = i + 1;
		let ch = text[start];
		while (ch === " " || ch === "	") if (i < start + indent) ch = text[++i];
		else {
			do
				ch = text[++i];
			while (ch && ch !== "\n");
			end = i;
			start = i + 1;
			ch = text[start];
		}
		return end;
	}
	var getFoldOptions = (ctx, isBlock2) => ({
		indentAtStart: isBlock2 ? ctx.indent.length : ctx.indentAtStart,
		lineWidth: ctx.options.lineWidth,
		minContentWidth: ctx.options.minContentWidth
	});
	var containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str);
	function lineLengthOverLimit(str, lineWidth, indentLength) {
		if (!lineWidth || lineWidth < 0) return false;
		const limit = lineWidth - indentLength;
		const strLen = str.length;
		if (strLen <= limit) return false;
		for (let i = 0, start = 0; i < strLen; ++i) if (str[i] === "\n") {
			if (i - start > limit) return true;
			start = i + 1;
			if (strLen - start <= limit) return false;
		}
		return true;
	}
	function doubleQuotedString(value, ctx) {
		const json = JSON.stringify(value);
		if (ctx.options.doubleQuotedAsJSON) return json;
		const { implicitKey } = ctx;
		const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
		const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
		let str = "";
		let start = 0;
		for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
			if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") {
				str += json.slice(start, i) + "\\ ";
				i += 1;
				start = i;
				ch = "\\";
			}
			if (ch === "\\") switch (json[i + 1]) {
				case "u":
					{
						str += json.slice(start, i);
						const code = json.substr(i + 2, 4);
						switch (code) {
							case "0000":
								str += "\\0";
								break;
							case "0007":
								str += "\\a";
								break;
							case "000b":
								str += "\\v";
								break;
							case "001b":
								str += "\\e";
								break;
							case "0085":
								str += "\\N";
								break;
							case "00a0":
								str += "\\_";
								break;
							case "2028":
								str += "\\L";
								break;
							case "2029":
								str += "\\P";
								break;
							default: if (code.substr(0, 2) === "00") str += "\\x" + code.substr(2);
							else str += json.substr(i, 6);
						}
						i += 5;
						start = i + 1;
					}
					break;
				case "n":
					if (implicitKey || json[i + 2] === "\"" || json.length < minMultiLineLength) i += 1;
					else {
						str += json.slice(start, i) + "\n\n";
						while (json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== "\"") {
							str += "\n";
							i += 2;
						}
						str += indent;
						if (json[i + 2] === " ") str += "\\";
						i += 1;
						start = i + 1;
					}
					break;
				default: i += 1;
			}
		}
		str = start ? str + json.slice(start) : json;
		return implicitKey ? str : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));
	}
	function singleQuotedString(value, ctx) {
		if (ctx.options.singleQuote === false || ctx.implicitKey && value.includes("\n") || /[ \t]\n|\n[ \t]/.test(value)) return doubleQuotedString(value, ctx);
		const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
		const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&
${indent}`) + "'";
		return ctx.implicitKey ? res : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));
	}
	function quotedString(value, ctx) {
		const { singleQuote } = ctx.options;
		let qs;
		if (singleQuote === false) qs = doubleQuotedString;
		else {
			const hasDouble = value.includes("\"");
			const hasSingle = value.includes("'");
			if (hasDouble && !hasSingle) qs = singleQuotedString;
			else if (hasSingle && !hasDouble) qs = doubleQuotedString;
			else qs = singleQuote ? singleQuotedString : doubleQuotedString;
		}
		return qs(value, ctx);
	}
	var blockEndNewlines;
	try {
		blockEndNewlines = /* @__PURE__ */ new RegExp("(^|(?<!\n))\n+(?!\n|$)", "g");
	} catch (e) {
		blockEndNewlines = /\n+(?!\n|$)/g;
	}
	function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
		const { blockQuote, commentString, lineWidth } = ctx.options;
		if (!blockQuote || /\n[\t ]+$/.test(value)) return quotedString(value, ctx);
		const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? "  " : "");
		const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.BLOCK_FOLDED ? false : type === Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, lineWidth, indent.length);
		if (!value) return literal ? "|\n" : ">\n";
		let chomp;
		let endStart;
		for (endStart = value.length; endStart > 0; --endStart) {
			const ch = value[endStart - 1];
			if (ch !== "\n" && ch !== "	" && ch !== " ") break;
		}
		let end = value.substring(endStart);
		const endNlPos = end.indexOf("\n");
		if (endNlPos === -1) chomp = "-";
		else if (value === end || endNlPos !== end.length - 1) {
			chomp = "+";
			if (onChompKeep) onChompKeep();
		} else chomp = "";
		if (end) {
			value = value.slice(0, -end.length);
			if (end[end.length - 1] === "\n") end = end.slice(0, -1);
			end = end.replace(blockEndNewlines, `$&${indent}`);
		}
		let startWithSpace = false;
		let startEnd;
		let startNlPos = -1;
		for (startEnd = 0; startEnd < value.length; ++startEnd) {
			const ch = value[startEnd];
			if (ch === " ") startWithSpace = true;
			else if (ch === "\n") startNlPos = startEnd;
			else break;
		}
		let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
		if (start) {
			value = value.substring(start.length);
			start = start.replace(/\n+/g, `$&${indent}`);
		}
		let header = (startWithSpace ? indent ? "2" : "1" : "") + chomp;
		if (comment) {
			header += " " + commentString(comment.replace(/ ?[\r\n]+/g, " "));
			if (onComment) onComment();
		}
		if (!literal) {
			const foldedValue = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`);
			let literalFallback = false;
			const foldOptions = getFoldOptions(ctx, true);
			if (blockQuote !== "folded" && type !== Scalar.BLOCK_FOLDED) foldOptions.onOverflow = () => {
				literalFallback = true;
			};
			const body = foldFlowLines(`${start}${foldedValue}${end}`, indent, FOLD_BLOCK, foldOptions);
			if (!literalFallback) return `>${header}
${indent}${body}`;
		}
		value = value.replace(/\n+/g, `$&${indent}`);
		return `|${header}
${indent}${start}${value}${end}`;
	}
	function plainString(item, ctx, onComment, onChompKeep) {
		const { type, value } = item;
		const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;
		if (implicitKey && value.includes("\n") || inFlow && /[[\]{},]/.test(value)) return quotedString(value, ctx);
		if (/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) return implicitKey || inFlow || !value.includes("\n") ? quotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
		if (!implicitKey && !inFlow && type !== Scalar.PLAIN && value.includes("\n")) return blockString(item, ctx, onComment, onChompKeep);
		if (containsDocumentMarker(value)) {
			if (indent === "") {
				ctx.forceBlockIndent = true;
				return blockString(item, ctx, onComment, onChompKeep);
			} else if (implicitKey && indent === indentStep) return quotedString(value, ctx);
		}
		const str = value.replace(/\n+/g, `$&
${indent}`);
		if (actualString) {
			const test = (tag) => {
				var _a2;
				return tag.default && tag.tag !== "tag:yaml.org,2002:str" && ((_a2 = tag.test) == null ? void 0 : _a2.test(str));
			};
			const { compat, tags } = ctx.doc.schema;
			if (tags.some(test) || (compat == null ? void 0 : compat.some(test))) return quotedString(value, ctx);
		}
		return implicitKey ? str : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));
	}
	function stringifyString(item, ctx, onComment, onChompKeep) {
		const { implicitKey, inFlow } = ctx;
		const ss = typeof item.value === "string" ? item : Object.assign({}, item, { value: String(item.value) });
		let { type } = item;
		if (type !== Scalar.QUOTE_DOUBLE) {
			if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value)) type = Scalar.QUOTE_DOUBLE;
		}
		const _stringify = (_type) => {
			switch (_type) {
				case Scalar.BLOCK_FOLDED:
				case Scalar.BLOCK_LITERAL: return implicitKey || inFlow ? quotedString(ss.value, ctx) : blockString(ss, ctx, onComment, onChompKeep);
				case Scalar.QUOTE_DOUBLE: return doubleQuotedString(ss.value, ctx);
				case Scalar.QUOTE_SINGLE: return singleQuotedString(ss.value, ctx);
				case Scalar.PLAIN: return plainString(ss, ctx, onComment, onChompKeep);
				default: return null;
			}
		};
		let res = _stringify(type);
		if (res === null) {
			const { defaultKeyType, defaultStringType } = ctx.options;
			const t3 = implicitKey && defaultKeyType || defaultStringType;
			res = _stringify(t3);
			if (res === null) throw new Error(`Unsupported default string type ${t3}`);
		}
		return res;
	}
	function createStringifyContext(doc, options) {
		const opt = Object.assign({
			blockQuote: true,
			commentString: stringifyComment,
			defaultKeyType: null,
			defaultStringType: "PLAIN",
			directives: null,
			doubleQuotedAsJSON: false,
			doubleQuotedMinMultiLineLength: 40,
			falseStr: "false",
			flowCollectionPadding: true,
			indentSeq: true,
			lineWidth: 80,
			minContentWidth: 20,
			nullStr: "null",
			simpleKeys: false,
			singleQuote: null,
			trueStr: "true",
			verifyAliasOrder: true
		}, doc.schema.toStringOptions, options);
		let inFlow;
		switch (opt.collectionStyle) {
			case "block":
				inFlow = false;
				break;
			case "flow":
				inFlow = true;
				break;
			default: inFlow = null;
		}
		return {
			anchors: /* @__PURE__ */ new Set(),
			doc,
			flowCollectionPadding: opt.flowCollectionPadding ? " " : "",
			indent: "",
			indentStep: typeof opt.indent === "number" ? " ".repeat(opt.indent) : "  ",
			inFlow,
			options: opt
		};
	}
	function getTagObject(tags, item) {
		var _a2, _b2, _c, _d;
		if (item.tag) {
			const match = tags.filter((t3) => t3.tag === item.tag);
			if (match.length > 0) return (_a2 = match.find((t3) => t3.format === item.format)) != null ? _a2 : match[0];
		}
		let tagObj = void 0;
		let obj;
		if (isScalar(item)) {
			obj = item.value;
			let match = tags.filter((t3) => {
				var _a3;
				return (_a3 = t3.identify) == null ? void 0 : _a3.call(t3, obj);
			});
			if (match.length > 1) {
				const testMatch = match.filter((t3) => t3.test);
				if (testMatch.length > 0) match = testMatch;
			}
			tagObj = (_b2 = match.find((t3) => t3.format === item.format)) != null ? _b2 : match.find((t3) => !t3.format);
		} else {
			obj = item;
			tagObj = tags.find((t3) => t3.nodeClass && obj instanceof t3.nodeClass);
		}
		if (!tagObj) {
			const name = (_d = (_c = obj == null ? void 0 : obj.constructor) == null ? void 0 : _c.name) != null ? _d : obj === null ? "null" : typeof obj;
			throw new Error(`Tag not resolved for ${name} value`);
		}
		return tagObj;
	}
	function stringifyProps(node, tagObj, { anchors, doc }) {
		var _a2;
		if (!doc.directives) return "";
		const props = [];
		const anchor = (isScalar(node) || isCollection(node)) && node.anchor;
		if (anchor && anchorIsValid(anchor)) {
			anchors.add(anchor);
			props.push(`&${anchor}`);
		}
		const tag = (_a2 = node.tag) != null ? _a2 : tagObj.default ? null : tagObj.tag;
		if (tag) props.push(doc.directives.tagString(tag));
		return props.join(" ");
	}
	function stringify(item, ctx, onComment, onChompKeep) {
		var _a2, _b2;
		if (isPair(item)) return item.toString(ctx, onComment, onChompKeep);
		if (isAlias(item)) {
			if (ctx.doc.directives) return item.toString(ctx);
			if ((_a2 = ctx.resolvedAliases) == null ? void 0 : _a2.has(item)) throw new TypeError(`Cannot stringify circular structure without alias nodes`);
			else {
				if (ctx.resolvedAliases) ctx.resolvedAliases.add(item);
				else ctx.resolvedAliases = /* @__PURE__ */ new Set([item]);
				item = item.resolve(ctx.doc);
			}
		}
		let tagObj = void 0;
		const node = isNode(item) ? item : ctx.doc.createNode(item, { onTagObj: (o3) => tagObj = o3 });
		tagObj ??= getTagObject(ctx.doc.schema.tags, node);
		const props = stringifyProps(node, tagObj, ctx);
		if (props.length > 0) ctx.indentAtStart = ((_b2 = ctx.indentAtStart) != null ? _b2 : 0) + props.length + 1;
		const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : isScalar(node) ? stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
		if (!props) return str;
		return isScalar(node) || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props}
${ctx.indent}${str}`;
	}
	function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
		var _a2, _b2;
		const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
		let keyComment = isNode(key) && key.comment || null;
		if (simpleKeys) {
			if (keyComment) throw new Error("With simple keys, key nodes cannot have comments");
			if (isCollection(key) || !isNode(key) && typeof key === "object") throw new Error("With simple keys, collection cannot be used as a key value");
		}
		let explicitKey = !simpleKeys && (!key || keyComment && value == null && !ctx.inFlow || isCollection(key) || (isScalar(key) ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL : typeof key === "object"));
		ctx = Object.assign({}, ctx, {
			allNullValues: false,
			implicitKey: !explicitKey && (simpleKeys || !allNullValues),
			indent: indent + indentStep
		});
		let keyCommentDone = false;
		let chompKeep = false;
		let str = stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
		if (!explicitKey && !ctx.inFlow && str.length > 1024) {
			if (simpleKeys) throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
			explicitKey = true;
		}
		if (ctx.inFlow) {
			if (allNullValues || value == null) {
				if (keyCommentDone && onComment) onComment();
				return str === "" ? "?" : explicitKey ? `? ${str}` : str;
			}
		} else if (allNullValues && !simpleKeys || value == null && explicitKey) {
			str = `? ${str}`;
			if (keyComment && !keyCommentDone) str += lineComment(str, ctx.indent, commentString(keyComment));
			else if (chompKeep && onChompKeep) onChompKeep();
			return str;
		}
		if (keyCommentDone) keyComment = null;
		if (explicitKey) {
			if (keyComment) str += lineComment(str, ctx.indent, commentString(keyComment));
			str = `? ${str}
${indent}:`;
		} else {
			str = `${str}:`;
			if (keyComment) str += lineComment(str, ctx.indent, commentString(keyComment));
		}
		let vsb, vcb, valueComment;
		if (isNode(value)) {
			vsb = !!value.spaceBefore;
			vcb = value.commentBefore;
			valueComment = value.comment;
		} else {
			vsb = false;
			vcb = null;
			valueComment = null;
			if (value && typeof value === "object") value = doc.createNode(value);
		}
		ctx.implicitKey = false;
		if (!explicitKey && !keyComment && isScalar(value)) ctx.indentAtStart = str.length + 1;
		chompKeep = false;
		if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && isSeq(value) && !value.flow && !value.tag && !value.anchor) ctx.indent = ctx.indent.substring(2);
		let valueCommentDone = false;
		const valueStr = stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true);
		let ws = " ";
		if (keyComment || vsb || vcb) {
			ws = vsb ? "\n" : "";
			if (vcb) {
				const cs = commentString(vcb);
				ws += `
${indentComment(cs, ctx.indent)}`;
			}
			if (valueStr === "" && !ctx.inFlow) {
				if (ws === "\n") ws = "\n\n";
			} else ws += `
${ctx.indent}`;
		} else if (!explicitKey && isCollection(value)) {
			const vs0 = valueStr[0];
			const nl0 = valueStr.indexOf("\n");
			const hasNewline = nl0 !== -1;
			const flow = (_b2 = (_a2 = ctx.inFlow) != null ? _a2 : value.flow) != null ? _b2 : value.items.length === 0;
			if (hasNewline || !flow) {
				let hasPropsLine = false;
				if (hasNewline && (vs0 === "&" || vs0 === "!")) {
					let sp0 = valueStr.indexOf(" ");
					if (vs0 === "&" && sp0 !== -1 && sp0 < nl0 && valueStr[sp0 + 1] === "!") sp0 = valueStr.indexOf(" ", sp0 + 1);
					if (sp0 === -1 || nl0 < sp0) hasPropsLine = true;
				}
				if (!hasPropsLine) ws = `
${ctx.indent}`;
			}
		} else if (valueStr === "" || valueStr[0] === "\n") ws = "";
		str += ws + valueStr;
		if (ctx.inFlow) {
			if (valueCommentDone && onComment) onComment();
		} else if (valueComment && !valueCommentDone) str += lineComment(str, ctx.indent, commentString(valueComment));
		else if (chompKeep && onChompKeep) onChompKeep();
		return str;
	}
	function warn(logLevel, warning) {
		if (logLevel === "debug" || logLevel === "warn") console.warn(warning);
	}
	var MERGE_KEY = "<<";
	var merge = {
		identify: (value) => value === MERGE_KEY || typeof value === "symbol" && value.description === MERGE_KEY,
		default: "key",
		tag: "tag:yaml.org,2002:merge",
		test: /^<<$/,
		resolve: () => Object.assign(new Scalar(Symbol(MERGE_KEY)), { addToJSMap: addMergeToJSMap }),
		stringify: () => MERGE_KEY
	};
	var isMergeKey = (ctx, key) => (merge.identify(key) || isScalar(key) && (!key.type || key.type === Scalar.PLAIN) && merge.identify(key.value)) && (ctx == null ? void 0 : ctx.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default));
	function addMergeToJSMap(ctx, map2, value) {
		value = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
		if (isSeq(value)) for (const it of value.items) mergeValue(ctx, map2, it);
		else if (Array.isArray(value)) for (const it of value) mergeValue(ctx, map2, it);
		else mergeValue(ctx, map2, value);
	}
	function mergeValue(ctx, map2, value) {
		const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
		if (!isMap(source)) throw new Error("Merge sources must be maps or map aliases");
		const srcMap = source.toJSON(null, ctx, Map);
		for (const [key, value2] of srcMap) if (map2 instanceof Map) {
			if (!map2.has(key)) map2.set(key, value2);
		} else if (map2 instanceof Set) map2.add(key);
		else if (!Object.prototype.hasOwnProperty.call(map2, key)) Object.defineProperty(map2, key, {
			value: value2,
			writable: true,
			enumerable: true,
			configurable: true
		});
		return map2;
	}
	function addPairToJSMap(ctx, map2, { key, value }) {
		if (isNode(key) && key.addToJSMap) key.addToJSMap(ctx, map2, value);
		else if (isMergeKey(ctx, key)) addMergeToJSMap(ctx, map2, value);
		else {
			const jsKey = toJS(key, "", ctx);
			if (map2 instanceof Map) map2.set(jsKey, toJS(value, jsKey, ctx));
			else if (map2 instanceof Set) map2.add(jsKey);
			else {
				const stringKey = stringifyKey(key, jsKey, ctx);
				const jsValue = toJS(value, stringKey, ctx);
				if (stringKey in map2) Object.defineProperty(map2, stringKey, {
					value: jsValue,
					writable: true,
					enumerable: true,
					configurable: true
				});
				else map2[stringKey] = jsValue;
			}
		}
		return map2;
	}
	function stringifyKey(key, jsKey, ctx) {
		if (jsKey === null) return "";
		if (typeof jsKey !== "object") return String(jsKey);
		if (isNode(key) && (ctx == null ? void 0 : ctx.doc)) {
			const strCtx = createStringifyContext(ctx.doc, {});
			strCtx.anchors = /* @__PURE__ */ new Set();
			for (const node of ctx.anchors.keys()) strCtx.anchors.add(node.anchor);
			strCtx.inFlow = true;
			strCtx.inStringifyKey = true;
			const strKey = key.toString(strCtx);
			if (!ctx.mapKeyWarned) {
				let jsonStr = JSON.stringify(strKey);
				if (jsonStr.length > 40) jsonStr = jsonStr.substring(0, 36) + "...\"";
				warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
				ctx.mapKeyWarned = true;
			}
			return strKey;
		}
		return JSON.stringify(jsKey);
	}
	function createPair(key, value, ctx) {
		return new Pair(createNode(key, void 0, ctx), createNode(value, void 0, ctx));
	}
	var Pair = class _Pair {
		constructor(key, value = null) {
			Object.defineProperty(this, NODE_TYPE, { value: PAIR });
			this.key = key;
			this.value = value;
		}
		clone(schema4) {
			let { key, value } = this;
			if (isNode(key)) key = key.clone(schema4);
			if (isNode(value)) value = value.clone(schema4);
			return new _Pair(key, value);
		}
		toJSON(_, ctx) {
			return addPairToJSMap(ctx, (ctx == null ? void 0 : ctx.mapAsMap) ? /* @__PURE__ */ new Map() : {}, this);
		}
		toString(ctx, onComment, onChompKeep) {
			return (ctx == null ? void 0 : ctx.doc) ? stringifyPair(this, ctx, onComment, onChompKeep) : JSON.stringify(this);
		}
	};
	function stringifyCollection(collection, ctx, options) {
		var _a2;
		return (((_a2 = ctx.inFlow) != null ? _a2 : collection.flow) ? stringifyFlowCollection : stringifyBlockCollection)(collection, ctx, options);
	}
	function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {
		const { indent, options: { commentString } } = ctx;
		const itemCtx = Object.assign({}, ctx, {
			indent: itemIndent,
			type: null
		});
		let chompKeep = false;
		const lines = [];
		for (let i = 0; i < items.length; ++i) {
			const item = items[i];
			let comment2 = null;
			if (isNode(item)) {
				if (!chompKeep && item.spaceBefore) lines.push("");
				addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
				if (item.comment) comment2 = item.comment;
			} else if (isPair(item)) {
				const ik = isNode(item.key) ? item.key : null;
				if (ik) {
					if (!chompKeep && ik.spaceBefore) lines.push("");
					addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);
				}
			}
			chompKeep = false;
			let str2 = stringify(item, itemCtx, () => comment2 = null, () => chompKeep = true);
			if (comment2) str2 += lineComment(str2, itemIndent, commentString(comment2));
			if (chompKeep && comment2) chompKeep = false;
			lines.push(blockItemPrefix + str2);
		}
		let str;
		if (lines.length === 0) str = flowChars.start + flowChars.end;
		else {
			str = lines[0];
			for (let i = 1; i < lines.length; ++i) {
				const line = lines[i];
				str += line ? `
${indent}${line}` : "\n";
			}
		}
		if (comment) {
			str += "\n" + indentComment(commentString(comment), indent);
			if (onComment) onComment();
		} else if (chompKeep && onChompKeep) onChompKeep();
		return str;
	}
	function stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {
		const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
		itemIndent += indentStep;
		const itemCtx = Object.assign({}, ctx, {
			indent: itemIndent,
			inFlow: true,
			type: null
		});
		let reqNewline = false;
		let linesAtValue = 0;
		const lines = [];
		for (let i = 0; i < items.length; ++i) {
			const item = items[i];
			let comment = null;
			if (isNode(item)) {
				if (item.spaceBefore) lines.push("");
				addCommentBefore(ctx, lines, item.commentBefore, false);
				if (item.comment) comment = item.comment;
			} else if (isPair(item)) {
				const ik = isNode(item.key) ? item.key : null;
				if (ik) {
					if (ik.spaceBefore) lines.push("");
					addCommentBefore(ctx, lines, ik.commentBefore, false);
					if (ik.comment) reqNewline = true;
				}
				const iv = isNode(item.value) ? item.value : null;
				if (iv) {
					if (iv.comment) comment = iv.comment;
					if (iv.commentBefore) reqNewline = true;
				} else if (item.value == null && (ik == null ? void 0 : ik.comment)) comment = ik.comment;
			}
			if (comment) reqNewline = true;
			let str = stringify(item, itemCtx, () => comment = null);
			if (i < items.length - 1) str += ",";
			if (comment) str += lineComment(str, itemIndent, commentString(comment));
			if (!reqNewline && (lines.length > linesAtValue || str.includes("\n"))) reqNewline = true;
			lines.push(str);
			linesAtValue = lines.length;
		}
		const { start, end } = flowChars;
		if (lines.length === 0) return start + end;
		else {
			if (!reqNewline) {
				const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
				reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
			}
			if (reqNewline) {
				let str = start;
				for (const line of lines) str += line ? `
${indentStep}${indent}${line}` : "\n";
				return `${str}
${indent}${end}`;
			} else return `${start}${fcPadding}${lines.join(" ")}${fcPadding}${end}`;
		}
	}
	function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {
		if (comment && chompKeep) comment = comment.replace(/^\n+/, "");
		if (comment) {
			const ic = indentComment(commentString(comment), indent);
			lines.push(ic.trimStart());
		}
	}
	function findPair(items, key) {
		const k2 = isScalar(key) ? key.value : key;
		for (const it of items) if (isPair(it)) {
			if (it.key === key || it.key === k2) return it;
			if (isScalar(it.key) && it.key.value === k2) return it;
		}
	}
	var YAMLMap = class extends Collection {
		static get tagName() {
			return "tag:yaml.org,2002:map";
		}
		constructor(schema4) {
			super(MAP, schema4);
			this.items = [];
		}
		/**
		* A generic collection parsing method that can be extended
		* to other node classes that inherit from YAMLMap
		*/
		static from(schema4, obj, ctx) {
			const { keepUndefined, replacer } = ctx;
			const map2 = new this(schema4);
			const add = (key, value) => {
				if (typeof replacer === "function") value = replacer.call(obj, key, value);
				else if (Array.isArray(replacer) && !replacer.includes(key)) return;
				if (value !== void 0 || keepUndefined) map2.items.push(createPair(key, value, ctx));
			};
			if (obj instanceof Map) for (const [key, value] of obj) add(key, value);
			else if (obj && typeof obj === "object") for (const key of Object.keys(obj)) add(key, obj[key]);
			if (typeof schema4.sortMapEntries === "function") map2.items.sort(schema4.sortMapEntries);
			return map2;
		}
		/**
		* Adds a value to the collection.
		*
		* @param overwrite - If not set `true`, using a key that is already in the
		*   collection will throw. Otherwise, overwrites the previous value.
		*/
		add(pair, overwrite) {
			var _a2;
			let _pair;
			if (isPair(pair)) _pair = pair;
			else if (!pair || typeof pair !== "object" || !("key" in pair)) _pair = new Pair(pair, pair == null ? void 0 : pair.value);
			else _pair = new Pair(pair.key, pair.value);
			const prev = findPair(this.items, _pair.key);
			const sortEntries = (_a2 = this.schema) == null ? void 0 : _a2.sortMapEntries;
			if (prev) {
				if (!overwrite) throw new Error(`Key ${_pair.key} already set`);
				if (isScalar(prev.value) && isScalarValue(_pair.value)) prev.value.value = _pair.value;
				else prev.value = _pair.value;
			} else if (sortEntries) {
				const i = this.items.findIndex((item) => sortEntries(_pair, item) < 0);
				if (i === -1) this.items.push(_pair);
				else this.items.splice(i, 0, _pair);
			} else this.items.push(_pair);
		}
		delete(key) {
			const it = findPair(this.items, key);
			if (!it) return false;
			return this.items.splice(this.items.indexOf(it), 1).length > 0;
		}
		get(key, keepScalar) {
			var _a2;
			const it = findPair(this.items, key);
			const node = it == null ? void 0 : it.value;
			return (_a2 = !keepScalar && isScalar(node) ? node.value : node) != null ? _a2 : void 0;
		}
		has(key) {
			return !!findPair(this.items, key);
		}
		set(key, value) {
			this.add(new Pair(key, value), true);
		}
		/**
		* @param ctx - Conversion context, originally set in Document#toJS()
		* @param {Class} Type - If set, forces the returned collection type
		* @returns Instance of Type, Map, or Object
		*/
		toJSON(_, ctx, Type) {
			const map2 = Type ? new Type() : (ctx == null ? void 0 : ctx.mapAsMap) ? /* @__PURE__ */ new Map() : {};
			if (ctx == null ? void 0 : ctx.onCreate) ctx.onCreate(map2);
			for (const item of this.items) addPairToJSMap(ctx, map2, item);
			return map2;
		}
		toString(ctx, onComment, onChompKeep) {
			if (!ctx) return JSON.stringify(this);
			for (const item of this.items) if (!isPair(item)) throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
			if (!ctx.allNullValues && this.hasAllNullValues(false)) ctx = Object.assign({}, ctx, { allNullValues: true });
			return stringifyCollection(this, ctx, {
				blockItemPrefix: "",
				flowChars: {
					start: "{",
					end: "}"
				},
				itemIndent: ctx.indent || "",
				onChompKeep,
				onComment
			});
		}
	};
	var map = {
		collection: "map",
		default: true,
		nodeClass: YAMLMap,
		tag: "tag:yaml.org,2002:map",
		resolve(map2, onError) {
			if (!isMap(map2)) onError("Expected a mapping for this tag");
			return map2;
		},
		createNode: (schema4, obj, ctx) => YAMLMap.from(schema4, obj, ctx)
	};
	var YAMLSeq = class extends Collection {
		static get tagName() {
			return "tag:yaml.org,2002:seq";
		}
		constructor(schema4) {
			super(SEQ, schema4);
			this.items = [];
		}
		add(value) {
			this.items.push(value);
		}
		/**
		* Removes a value from the collection.
		*
		* `key` must contain a representation of an integer for this to succeed.
		* It may be wrapped in a `Scalar`.
		*
		* @returns `true` if the item was found and removed.
		*/
		delete(key) {
			const idx = asItemIndex(key);
			if (typeof idx !== "number") return false;
			return this.items.splice(idx, 1).length > 0;
		}
		get(key, keepScalar) {
			const idx = asItemIndex(key);
			if (typeof idx !== "number") return void 0;
			const it = this.items[idx];
			return !keepScalar && isScalar(it) ? it.value : it;
		}
		/**
		* Checks if the collection includes a value with the key `key`.
		*
		* `key` must contain a representation of an integer for this to succeed.
		* It may be wrapped in a `Scalar`.
		*/
		has(key) {
			const idx = asItemIndex(key);
			return typeof idx === "number" && idx < this.items.length;
		}
		/**
		* Sets a value in this collection. For `!!set`, `value` needs to be a
		* boolean to add/remove the item from the set.
		*
		* If `key` does not contain a representation of an integer, this will throw.
		* It may be wrapped in a `Scalar`.
		*/
		set(key, value) {
			const idx = asItemIndex(key);
			if (typeof idx !== "number") throw new Error(`Expected a valid index, not ${key}.`);
			const prev = this.items[idx];
			if (isScalar(prev) && isScalarValue(value)) prev.value = value;
			else this.items[idx] = value;
		}
		toJSON(_, ctx) {
			const seq2 = [];
			if (ctx == null ? void 0 : ctx.onCreate) ctx.onCreate(seq2);
			let i = 0;
			for (const item of this.items) seq2.push(toJS(item, String(i++), ctx));
			return seq2;
		}
		toString(ctx, onComment, onChompKeep) {
			if (!ctx) return JSON.stringify(this);
			return stringifyCollection(this, ctx, {
				blockItemPrefix: "- ",
				flowChars: {
					start: "[",
					end: "]"
				},
				itemIndent: (ctx.indent || "") + "  ",
				onChompKeep,
				onComment
			});
		}
		static from(schema4, obj, ctx) {
			const { replacer } = ctx;
			const seq2 = new this(schema4);
			if (obj && Symbol.iterator in Object(obj)) {
				let i = 0;
				for (let it of obj) {
					if (typeof replacer === "function") {
						const key = obj instanceof Set ? it : String(i++);
						it = replacer.call(obj, key, it);
					}
					seq2.items.push(createNode(it, void 0, ctx));
				}
			}
			return seq2;
		}
	};
	function asItemIndex(key) {
		let idx = isScalar(key) ? key.value : key;
		if (idx && typeof idx === "string") idx = Number(idx);
		return typeof idx === "number" && Number.isInteger(idx) && idx >= 0 ? idx : null;
	}
	var seq = {
		collection: "seq",
		default: true,
		nodeClass: YAMLSeq,
		tag: "tag:yaml.org,2002:seq",
		resolve(seq2, onError) {
			if (!isSeq(seq2)) onError("Expected a sequence for this tag");
			return seq2;
		},
		createNode: (schema4, obj, ctx) => YAMLSeq.from(schema4, obj, ctx)
	};
	var string = {
		identify: (value) => typeof value === "string",
		default: true,
		tag: "tag:yaml.org,2002:str",
		resolve: (str) => str,
		stringify(item, ctx, onComment, onChompKeep) {
			ctx = Object.assign({ actualString: true }, ctx);
			return stringifyString(item, ctx, onComment, onChompKeep);
		}
	};
	var nullTag = {
		identify: (value) => value == null,
		createNode: () => new Scalar(null),
		default: true,
		tag: "tag:yaml.org,2002:null",
		test: /^(?:~|[Nn]ull|NULL)?$/,
		resolve: () => new Scalar(null),
		stringify: ({ source }, ctx) => typeof source === "string" && nullTag.test.test(source) ? source : ctx.options.nullStr
	};
	var boolTag = {
		identify: (value) => typeof value === "boolean",
		default: true,
		tag: "tag:yaml.org,2002:bool",
		test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
		resolve: (str) => new Scalar(str[0] === "t" || str[0] === "T"),
		stringify({ source, value }, ctx) {
			if (source && boolTag.test.test(source)) {
				if (value === (source[0] === "t" || source[0] === "T")) return source;
			}
			return value ? ctx.options.trueStr : ctx.options.falseStr;
		}
	};
	function stringifyNumber({ format, minFractionDigits, tag, value }) {
		if (typeof value === "bigint") return String(value);
		const num = typeof value === "number" ? value : Number(value);
		if (!isFinite(num)) return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
		let n4 = JSON.stringify(value);
		if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n4)) {
			let i = n4.indexOf(".");
			if (i < 0) {
				i = n4.length;
				n4 += ".";
			}
			let d = minFractionDigits - (n4.length - i - 1);
			while (d-- > 0) n4 += "0";
		}
		return n4;
	}
	var floatNaN = {
		identify: (value) => typeof value === "number",
		default: true,
		tag: "tag:yaml.org,2002:float",
		test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
		resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
		stringify: stringifyNumber
	};
	var floatExp = {
		identify: (value) => typeof value === "number",
		default: true,
		tag: "tag:yaml.org,2002:float",
		format: "EXP",
		test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
		resolve: (str) => parseFloat(str),
		stringify(node) {
			const num = Number(node.value);
			return isFinite(num) ? num.toExponential() : stringifyNumber(node);
		}
	};
	var float = {
		identify: (value) => typeof value === "number",
		default: true,
		tag: "tag:yaml.org,2002:float",
		test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
		resolve(str) {
			const node = new Scalar(parseFloat(str));
			const dot = str.indexOf(".");
			if (dot !== -1 && str[str.length - 1] === "0") node.minFractionDigits = str.length - dot - 1;
			return node;
		},
		stringify: stringifyNumber
	};
	var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
	var intResolve = (str, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix);
	function intStringify(node, radix, prefix) {
		const { value } = node;
		if (intIdentify(value) && value >= 0) return prefix + value.toString(radix);
		return stringifyNumber(node);
	}
	var intOct = {
		identify: (value) => intIdentify(value) && value >= 0,
		default: true,
		tag: "tag:yaml.org,2002:int",
		format: "OCT",
		test: /^0o[0-7]+$/,
		resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),
		stringify: (node) => intStringify(node, 8, "0o")
	};
	var int = {
		identify: intIdentify,
		default: true,
		tag: "tag:yaml.org,2002:int",
		test: /^[-+]?[0-9]+$/,
		resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
		stringify: stringifyNumber
	};
	var intHex = {
		identify: (value) => intIdentify(value) && value >= 0,
		default: true,
		tag: "tag:yaml.org,2002:int",
		format: "HEX",
		test: /^0x[0-9a-fA-F]+$/,
		resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
		stringify: (node) => intStringify(node, 16, "0x")
	};
	var schema = [
		map,
		seq,
		string,
		nullTag,
		boolTag,
		intOct,
		int,
		intHex,
		floatNaN,
		floatExp,
		float
	];
	function intIdentify2(value) {
		return typeof value === "bigint" || Number.isInteger(value);
	}
	var stringifyJSON = ({ value }) => JSON.stringify(value);
	var jsonScalars = [
		{
			identify: (value) => typeof value === "string",
			default: true,
			tag: "tag:yaml.org,2002:str",
			resolve: (str) => str,
			stringify: stringifyJSON
		},
		{
			identify: (value) => value == null,
			createNode: () => new Scalar(null),
			default: true,
			tag: "tag:yaml.org,2002:null",
			test: /^null$/,
			resolve: () => null,
			stringify: stringifyJSON
		},
		{
			identify: (value) => typeof value === "boolean",
			default: true,
			tag: "tag:yaml.org,2002:bool",
			test: /^true$|^false$/,
			resolve: (str) => str === "true",
			stringify: stringifyJSON
		},
		{
			identify: intIdentify2,
			default: true,
			tag: "tag:yaml.org,2002:int",
			test: /^-?(?:0|[1-9][0-9]*)$/,
			resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),
			stringify: ({ value }) => intIdentify2(value) ? value.toString() : JSON.stringify(value)
		},
		{
			identify: (value) => typeof value === "number",
			default: true,
			tag: "tag:yaml.org,2002:float",
			test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
			resolve: (str) => parseFloat(str),
			stringify: stringifyJSON
		}
	];
	var schema2 = [map, seq].concat(jsonScalars, {
		default: true,
		tag: "",
		test: /^/,
		resolve(str, onError) {
			onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
			return str;
		}
	});
	var binary = {
		identify: (value) => value instanceof Uint8Array,
		default: false,
		tag: "tag:yaml.org,2002:binary",
		resolve(src, onError) {
			if (typeof atob === "function") {
				const str = atob(src.replace(/[\n\r]/g, ""));
				const buffer = new Uint8Array(str.length);
				for (let i = 0; i < str.length; ++i) buffer[i] = str.charCodeAt(i);
				return buffer;
			} else {
				onError("This environment does not support reading binary tags; either Buffer or atob is required");
				return src;
			}
		},
		stringify({ comment, type, value }, ctx, onComment, onChompKeep) {
			if (!value) return "";
			const buf = value;
			let str;
			if (typeof btoa === "function") {
				let s = "";
				for (let i = 0; i < buf.length; ++i) s += String.fromCharCode(buf[i]);
				str = btoa(s);
			} else throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required");
			type ??= Scalar.BLOCK_LITERAL;
			if (type !== Scalar.QUOTE_DOUBLE) {
				const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
				const n4 = Math.ceil(str.length / lineWidth);
				const lines = new Array(n4);
				for (let i = 0, o3 = 0; i < n4; ++i, o3 += lineWidth) lines[i] = str.substr(o3, lineWidth);
				str = lines.join(type === Scalar.BLOCK_LITERAL ? "\n" : " ");
			}
			return stringifyString({
				comment,
				type,
				value: str
			}, ctx, onComment, onChompKeep);
		}
	};
	function resolvePairs(seq2, onError) {
		var _a2;
		if (isSeq(seq2)) for (let i = 0; i < seq2.items.length; ++i) {
			let item = seq2.items[i];
			if (isPair(item)) continue;
			else if (isMap(item)) {
				if (item.items.length > 1) onError("Each pair must have its own sequence indicator");
				const pair = item.items[0] || new Pair(new Scalar(null));
				if (item.commentBefore) pair.key.commentBefore = pair.key.commentBefore ? `${item.commentBefore}
${pair.key.commentBefore}` : item.commentBefore;
				if (item.comment) {
					const cn = (_a2 = pair.value) != null ? _a2 : pair.key;
					cn.comment = cn.comment ? `${item.comment}
${cn.comment}` : item.comment;
				}
				item = pair;
			}
			seq2.items[i] = isPair(item) ? item : new Pair(item);
		}
		else onError("Expected a sequence for this tag");
		return seq2;
	}
	function createPairs(schema4, iterable, ctx) {
		const { replacer } = ctx;
		const pairs2 = new YAMLSeq(schema4);
		pairs2.tag = "tag:yaml.org,2002:pairs";
		let i = 0;
		if (iterable && Symbol.iterator in Object(iterable)) for (let it of iterable) {
			if (typeof replacer === "function") it = replacer.call(iterable, String(i++), it);
			let key, value;
			if (Array.isArray(it)) if (it.length === 2) {
				key = it[0];
				value = it[1];
			} else throw new TypeError(`Expected [key, value] tuple: ${it}`);
			else if (it && it instanceof Object) {
				const keys = Object.keys(it);
				if (keys.length === 1) {
					key = keys[0];
					value = it[key];
				} else throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);
			} else key = it;
			pairs2.items.push(createPair(key, value, ctx));
		}
		return pairs2;
	}
	var pairs = {
		collection: "seq",
		default: false,
		tag: "tag:yaml.org,2002:pairs",
		resolve: resolvePairs,
		createNode: createPairs
	};
	var YAMLOMap = class _YAMLOMap extends YAMLSeq {
		constructor() {
			super();
			this.add = YAMLMap.prototype.add.bind(this);
			this.delete = YAMLMap.prototype.delete.bind(this);
			this.get = YAMLMap.prototype.get.bind(this);
			this.has = YAMLMap.prototype.has.bind(this);
			this.set = YAMLMap.prototype.set.bind(this);
			this.tag = _YAMLOMap.tag;
		}
		/**
		* If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
		* but TypeScript won't allow widening the signature of a child method.
		*/
		toJSON(_, ctx) {
			if (!ctx) return super.toJSON(_);
			const map2 = /* @__PURE__ */ new Map();
			if (ctx == null ? void 0 : ctx.onCreate) ctx.onCreate(map2);
			for (const pair of this.items) {
				let key, value;
				if (isPair(pair)) {
					key = toJS(pair.key, "", ctx);
					value = toJS(pair.value, key, ctx);
				} else key = toJS(pair, "", ctx);
				if (map2.has(key)) throw new Error("Ordered maps must not include duplicate keys");
				map2.set(key, value);
			}
			return map2;
		}
		static from(schema4, iterable, ctx) {
			const pairs2 = createPairs(schema4, iterable, ctx);
			const omap2 = new this();
			omap2.items = pairs2.items;
			return omap2;
		}
	};
	YAMLOMap.tag = "tag:yaml.org,2002:omap";
	var omap = {
		collection: "seq",
		identify: (value) => value instanceof Map,
		nodeClass: YAMLOMap,
		default: false,
		tag: "tag:yaml.org,2002:omap",
		resolve(seq2, onError) {
			const pairs2 = resolvePairs(seq2, onError);
			const seenKeys = [];
			for (const { key } of pairs2.items) if (isScalar(key)) if (seenKeys.includes(key.value)) onError(`Ordered maps must not include duplicate keys: ${key.value}`);
			else seenKeys.push(key.value);
			return Object.assign(new YAMLOMap(), pairs2);
		},
		createNode: (schema4, iterable, ctx) => YAMLOMap.from(schema4, iterable, ctx)
	};
	function boolStringify({ value, source }, ctx) {
		if (source && (value ? trueTag : falseTag).test.test(source)) return source;
		return value ? ctx.options.trueStr : ctx.options.falseStr;
	}
	var trueTag = {
		identify: (value) => value === true,
		default: true,
		tag: "tag:yaml.org,2002:bool",
		test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
		resolve: () => new Scalar(true),
		stringify: boolStringify
	};
	var falseTag = {
		identify: (value) => value === false,
		default: true,
		tag: "tag:yaml.org,2002:bool",
		test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
		resolve: () => new Scalar(false),
		stringify: boolStringify
	};
	var floatNaN2 = {
		identify: (value) => typeof value === "number",
		default: true,
		tag: "tag:yaml.org,2002:float",
		test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
		resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
		stringify: stringifyNumber
	};
	var floatExp2 = {
		identify: (value) => typeof value === "number",
		default: true,
		tag: "tag:yaml.org,2002:float",
		format: "EXP",
		test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
		resolve: (str) => parseFloat(str.replace(/_/g, "")),
		stringify(node) {
			const num = Number(node.value);
			return isFinite(num) ? num.toExponential() : stringifyNumber(node);
		}
	};
	var float2 = {
		identify: (value) => typeof value === "number",
		default: true,
		tag: "tag:yaml.org,2002:float",
		test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
		resolve(str) {
			const node = new Scalar(parseFloat(str.replace(/_/g, "")));
			const dot = str.indexOf(".");
			if (dot !== -1) {
				const f2 = str.substring(dot + 1).replace(/_/g, "");
				if (f2[f2.length - 1] === "0") node.minFractionDigits = f2.length;
			}
			return node;
		},
		stringify: stringifyNumber
	};
	var intIdentify3 = (value) => typeof value === "bigint" || Number.isInteger(value);
	function intResolve2(str, offset, radix, { intAsBigInt }) {
		const sign = str[0];
		if (sign === "-" || sign === "+") offset += 1;
		str = str.substring(offset).replace(/_/g, "");
		if (intAsBigInt) {
			switch (radix) {
				case 2:
					str = `0b${str}`;
					break;
				case 8:
					str = `0o${str}`;
					break;
				case 16:
					str = `0x${str}`;
					break;
			}
			const n5 = BigInt(str);
			return sign === "-" ? BigInt(-1) * n5 : n5;
		}
		const n4 = parseInt(str, radix);
		return sign === "-" ? -1 * n4 : n4;
	}
	function intStringify2(node, radix, prefix) {
		const { value } = node;
		if (intIdentify3(value)) {
			const str = value.toString(radix);
			return value < 0 ? "-" + prefix + str.substr(1) : prefix + str;
		}
		return stringifyNumber(node);
	}
	var intBin = {
		identify: intIdentify3,
		default: true,
		tag: "tag:yaml.org,2002:int",
		format: "BIN",
		test: /^[-+]?0b[0-1_]+$/,
		resolve: (str, _onError, opt) => intResolve2(str, 2, 2, opt),
		stringify: (node) => intStringify2(node, 2, "0b")
	};
	var intOct2 = {
		identify: intIdentify3,
		default: true,
		tag: "tag:yaml.org,2002:int",
		format: "OCT",
		test: /^[-+]?0[0-7_]+$/,
		resolve: (str, _onError, opt) => intResolve2(str, 1, 8, opt),
		stringify: (node) => intStringify2(node, 8, "0")
	};
	var int2 = {
		identify: intIdentify3,
		default: true,
		tag: "tag:yaml.org,2002:int",
		test: /^[-+]?[0-9][0-9_]*$/,
		resolve: (str, _onError, opt) => intResolve2(str, 0, 10, opt),
		stringify: stringifyNumber
	};
	var intHex2 = {
		identify: intIdentify3,
		default: true,
		tag: "tag:yaml.org,2002:int",
		format: "HEX",
		test: /^[-+]?0x[0-9a-fA-F_]+$/,
		resolve: (str, _onError, opt) => intResolve2(str, 2, 16, opt),
		stringify: (node) => intStringify2(node, 16, "0x")
	};
	var YAMLSet = class _YAMLSet extends YAMLMap {
		constructor(schema4) {
			super(schema4);
			this.tag = _YAMLSet.tag;
		}
		add(key) {
			let pair;
			if (isPair(key)) pair = key;
			else if (key && typeof key === "object" && "key" in key && "value" in key && key.value === null) pair = new Pair(key.key, null);
			else pair = new Pair(key, null);
			if (!findPair(this.items, pair.key)) this.items.push(pair);
		}
		/**
		* If `keepPair` is `true`, returns the Pair matching `key`.
		* Otherwise, returns the value of that Pair's key.
		*/
		get(key, keepPair) {
			const pair = findPair(this.items, key);
			return !keepPair && isPair(pair) ? isScalar(pair.key) ? pair.key.value : pair.key : pair;
		}
		set(key, value) {
			if (typeof value !== "boolean") throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
			const prev = findPair(this.items, key);
			if (prev && !value) this.items.splice(this.items.indexOf(prev), 1);
			else if (!prev && value) this.items.push(new Pair(key));
		}
		toJSON(_, ctx) {
			return super.toJSON(_, ctx, Set);
		}
		toString(ctx, onComment, onChompKeep) {
			if (!ctx) return JSON.stringify(this);
			if (this.hasAllNullValues(true)) return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep);
			else throw new Error("Set items must all have null values");
		}
		static from(schema4, iterable, ctx) {
			const { replacer } = ctx;
			const set2 = new this(schema4);
			if (iterable && Symbol.iterator in Object(iterable)) for (let value of iterable) {
				if (typeof replacer === "function") value = replacer.call(iterable, value, value);
				set2.items.push(createPair(value, null, ctx));
			}
			return set2;
		}
	};
	YAMLSet.tag = "tag:yaml.org,2002:set";
	var set = {
		collection: "map",
		identify: (value) => value instanceof Set,
		nodeClass: YAMLSet,
		default: false,
		tag: "tag:yaml.org,2002:set",
		createNode: (schema4, iterable, ctx) => YAMLSet.from(schema4, iterable, ctx),
		resolve(map2, onError) {
			if (isMap(map2)) if (map2.hasAllNullValues(true)) return Object.assign(new YAMLSet(), map2);
			else onError("Set items must all have null values");
			else onError("Expected a mapping for this tag");
			return map2;
		}
	};
	function parseSexagesimal(str, asBigInt) {
		const sign = str[0];
		const parts = sign === "-" || sign === "+" ? str.substring(1) : str;
		const num = (n4) => asBigInt ? BigInt(n4) : Number(n4);
		const res = parts.replace(/_/g, "").split(":").reduce((res2, p2) => res2 * num(60) + num(p2), num(0));
		return sign === "-" ? num(-1) * res : res;
	}
	function stringifySexagesimal(node) {
		let { value } = node;
		let num = (n4) => n4;
		if (typeof value === "bigint") num = (n4) => BigInt(n4);
		else if (isNaN(value) || !isFinite(value)) return stringifyNumber(node);
		let sign = "";
		if (value < 0) {
			sign = "-";
			value *= num(-1);
		}
		const _60 = num(60);
		const parts = [value % _60];
		if (value < 60) parts.unshift(0);
		else {
			value = (value - parts[0]) / _60;
			parts.unshift(value % _60);
			if (value >= 60) {
				value = (value - parts[0]) / _60;
				parts.unshift(value);
			}
		}
		return sign + parts.map((n4) => String(n4).padStart(2, "0")).join(":").replace(/000000\d*$/, "");
	}
	var intTime = {
		identify: (value) => typeof value === "bigint" || Number.isInteger(value),
		default: true,
		tag: "tag:yaml.org,2002:int",
		format: "TIME",
		test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
		resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),
		stringify: stringifySexagesimal
	};
	var floatTime = {
		identify: (value) => typeof value === "number",
		default: true,
		tag: "tag:yaml.org,2002:float",
		format: "TIME",
		test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
		resolve: (str) => parseSexagesimal(str, false),
		stringify: stringifySexagesimal
	};
	var timestamp = {
		identify: (value) => value instanceof Date,
		default: true,
		tag: "tag:yaml.org,2002:timestamp",
		test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"),
		resolve(str) {
			const match = str.match(timestamp.test);
			if (!match) throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
			const [, year, month, day, hour, minute, second] = match.map(Number);
			const millisec = match[7] ? Number((match[7] + "00").substr(1, 3)) : 0;
			let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
			const tz = match[8];
			if (tz && tz !== "Z") {
				let d = parseSexagesimal(tz, false);
				if (Math.abs(d) < 30) d *= 60;
				date -= 6e4 * d;
			}
			return new Date(date);
		},
		stringify: ({ value }) => {
			var _a2;
			return (_a2 = value == null ? void 0 : value.toISOString().replace(/(T00:00:00)?\.000Z$/, "")) != null ? _a2 : "";
		}
	};
	var schema3 = [
		map,
		seq,
		string,
		nullTag,
		trueTag,
		falseTag,
		intBin,
		intOct2,
		int2,
		intHex2,
		floatNaN2,
		floatExp2,
		float2,
		binary,
		merge,
		omap,
		pairs,
		set,
		intTime,
		floatTime,
		timestamp
	];
	var schemas = /* @__PURE__ */ new Map([
		["core", schema],
		["failsafe", [
			map,
			seq,
			string
		]],
		["json", schema2],
		["yaml11", schema3],
		["yaml-1.1", schema3]
	]);
	var tagsByName = {
		binary,
		bool: boolTag,
		float,
		floatExp,
		floatNaN,
		floatTime,
		int,
		intHex,
		intOct,
		intTime,
		map,
		merge,
		null: nullTag,
		omap,
		pairs,
		seq,
		set,
		timestamp
	};
	var coreKnownTags = {
		"tag:yaml.org,2002:binary": binary,
		"tag:yaml.org,2002:merge": merge,
		"tag:yaml.org,2002:omap": omap,
		"tag:yaml.org,2002:pairs": pairs,
		"tag:yaml.org,2002:set": set,
		"tag:yaml.org,2002:timestamp": timestamp
	};
	function getTags(customTags, schemaName, addMergeTag) {
		const schemaTags = schemas.get(schemaName);
		if (schemaTags && !customTags) return addMergeTag && !schemaTags.includes(merge) ? schemaTags.concat(merge) : schemaTags.slice();
		let tags = schemaTags;
		if (!tags) if (Array.isArray(customTags)) tags = [];
		else {
			const keys = Array.from(schemas.keys()).filter((key) => key !== "yaml11").map((key) => JSON.stringify(key)).join(", ");
			throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
		}
		if (Array.isArray(customTags)) for (const tag of customTags) tags = tags.concat(tag);
		else if (typeof customTags === "function") tags = customTags(tags.slice());
		if (addMergeTag) tags = tags.concat(merge);
		return tags.reduce((tags2, tag) => {
			const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
			if (!tagObj) {
				const tagName = JSON.stringify(tag);
				const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", ");
				throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
			}
			if (!tags2.includes(tagObj)) tags2.push(tagObj);
			return tags2;
		}, []);
	}
	var sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
	var Schema = class _Schema {
		constructor({ compat, customTags, merge: merge2, resolveKnownTags, schema: schema4, sortMapEntries, toStringDefaults }) {
			this.compat = Array.isArray(compat) ? getTags(compat, "compat") : compat ? getTags(null, compat) : null;
			this.name = typeof schema4 === "string" && schema4 || "core";
			this.knownTags = resolveKnownTags ? coreKnownTags : {};
			this.tags = getTags(customTags, this.name, merge2);
			this.toStringOptions = toStringDefaults != null ? toStringDefaults : null;
			Object.defineProperty(this, MAP, { value: map });
			Object.defineProperty(this, SCALAR, { value: string });
			Object.defineProperty(this, SEQ, { value: seq });
			this.sortMapEntries = typeof sortMapEntries === "function" ? sortMapEntries : sortMapEntries === true ? sortMapEntriesByKey : null;
		}
		clone() {
			const copy = Object.create(_Schema.prototype, Object.getOwnPropertyDescriptors(this));
			copy.tags = this.tags.slice();
			return copy;
		}
	};
	function stringifyDocument(doc, options) {
		var _a2;
		const lines = [];
		let hasDirectives = options.directives === true;
		if (options.directives !== false && doc.directives) {
			const dir = doc.directives.toString(doc);
			if (dir) {
				lines.push(dir);
				hasDirectives = true;
			} else if (doc.directives.docStart) hasDirectives = true;
		}
		if (hasDirectives) lines.push("---");
		const ctx = createStringifyContext(doc, options);
		const { commentString } = ctx.options;
		if (doc.commentBefore) {
			if (lines.length !== 1) lines.unshift("");
			const cs = commentString(doc.commentBefore);
			lines.unshift(indentComment(cs, ""));
		}
		let chompKeep = false;
		let contentComment = null;
		if (doc.contents) {
			if (isNode(doc.contents)) {
				if (doc.contents.spaceBefore && hasDirectives) lines.push("");
				if (doc.contents.commentBefore) {
					const cs = commentString(doc.contents.commentBefore);
					lines.push(indentComment(cs, ""));
				}
				ctx.forceBlockIndent = !!doc.comment;
				contentComment = doc.contents.comment;
			}
			const onChompKeep = contentComment ? void 0 : () => chompKeep = true;
			let body = stringify(doc.contents, ctx, () => contentComment = null, onChompKeep);
			if (contentComment) body += lineComment(body, "", commentString(contentComment));
			if ((body[0] === "|" || body[0] === ">") && lines[lines.length - 1] === "---") lines[lines.length - 1] = `--- ${body}`;
			else lines.push(body);
		} else lines.push(stringify(doc.contents, ctx));
		if ((_a2 = doc.directives) == null ? void 0 : _a2.docEnd) if (doc.comment) {
			const cs = commentString(doc.comment);
			if (cs.includes("\n")) {
				lines.push("...");
				lines.push(indentComment(cs, ""));
			} else lines.push(`... ${cs}`);
		} else lines.push("...");
		else {
			let dc = doc.comment;
			if (dc && chompKeep) dc = dc.replace(/^\n+/, "");
			if (dc) {
				if ((!chompKeep || contentComment) && lines[lines.length - 1] !== "") lines.push("");
				lines.push(indentComment(commentString(dc), ""));
			}
		}
		return lines.join("\n") + "\n";
	}
	var Document = class _Document {
		constructor(value, replacer, options) {
			this.commentBefore = null;
			this.comment = null;
			this.errors = [];
			this.warnings = [];
			Object.defineProperty(this, NODE_TYPE, { value: DOC });
			let _replacer = null;
			if (typeof replacer === "function" || Array.isArray(replacer)) _replacer = replacer;
			else if (options === void 0 && replacer) {
				options = replacer;
				replacer = void 0;
			}
			const opt = Object.assign({
				intAsBigInt: false,
				keepSourceTokens: false,
				logLevel: "warn",
				prettyErrors: true,
				strict: true,
				stringKeys: false,
				uniqueKeys: true,
				version: "1.2"
			}, options);
			this.options = opt;
			let { version } = opt;
			if (options == null ? void 0 : options._directives) {
				this.directives = options._directives.atDocument();
				if (this.directives.yaml.explicit) version = this.directives.yaml.version;
			} else this.directives = new Directives({ version });
			this.setSchema(version, options);
			this.contents = value === void 0 ? null : this.createNode(value, _replacer, options);
		}
		/**
		* Create a deep copy of this Document and its contents.
		*
		* Custom Node values that inherit from `Object` still refer to their original instances.
		*/
		clone() {
			const copy = Object.create(_Document.prototype, { [NODE_TYPE]: { value: DOC } });
			copy.commentBefore = this.commentBefore;
			copy.comment = this.comment;
			copy.errors = this.errors.slice();
			copy.warnings = this.warnings.slice();
			copy.options = Object.assign({}, this.options);
			if (this.directives) copy.directives = this.directives.clone();
			copy.schema = this.schema.clone();
			copy.contents = isNode(this.contents) ? this.contents.clone(copy.schema) : this.contents;
			if (this.range) copy.range = this.range.slice();
			return copy;
		}
		/** Adds a value to the document. */
		add(value) {
			if (assertCollection(this.contents)) this.contents.add(value);
		}
		/** Adds a value to the document. */
		addIn(path3, value) {
			if (assertCollection(this.contents)) this.contents.addIn(path3, value);
		}
		/**
		* Create a new `Alias` node, ensuring that the target `node` has the required anchor.
		*
		* If `node` already has an anchor, `name` is ignored.
		* Otherwise, the `node.anchor` value will be set to `name`,
		* or if an anchor with that name is already present in the document,
		* `name` will be used as a prefix for a new unique anchor.
		* If `name` is undefined, the generated anchor will use 'a' as a prefix.
		*/
		createAlias(node, name) {
			if (!node.anchor) {
				const prev = anchorNames(this);
				node.anchor = !name || prev.has(name) ? findNewAnchor(name || "a", prev) : name;
			}
			return new Alias(node.anchor);
		}
		createNode(value, replacer, options) {
			let _replacer = void 0;
			if (typeof replacer === "function") {
				value = replacer.call({ "": value }, "", value);
				_replacer = replacer;
			} else if (Array.isArray(replacer)) {
				const keyToStr = (v2) => typeof v2 === "number" || v2 instanceof String || v2 instanceof Number;
				const asStr = replacer.filter(keyToStr).map(String);
				if (asStr.length > 0) replacer = replacer.concat(asStr);
				_replacer = replacer;
			} else if (options === void 0 && replacer) {
				options = replacer;
				replacer = void 0;
			}
			const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options != null ? options : {};
			const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, anchorPrefix || "a");
			const ctx = {
				aliasDuplicateObjects: aliasDuplicateObjects != null ? aliasDuplicateObjects : true,
				keepUndefined: keepUndefined != null ? keepUndefined : false,
				onAnchor,
				onTagObj,
				replacer: _replacer,
				schema: this.schema,
				sourceObjects
			};
			const node = createNode(value, tag, ctx);
			if (flow && isCollection(node)) node.flow = true;
			setAnchors();
			return node;
		}
		/**
		* Convert a key and a value into a `Pair` using the current schema,
		* recursively wrapping all values as `Scalar` or `Collection` nodes.
		*/
		createPair(key, value, options = {}) {
			return new Pair(this.createNode(key, null, options), this.createNode(value, null, options));
		}
		/**
		* Removes a value from the document.
		* @returns `true` if the item was found and removed.
		*/
		delete(key) {
			return assertCollection(this.contents) ? this.contents.delete(key) : false;
		}
		/**
		* Removes a value from the document.
		* @returns `true` if the item was found and removed.
		*/
		deleteIn(path3) {
			if (isEmptyPath(path3)) {
				if (this.contents == null) return false;
				this.contents = null;
				return true;
			}
			return assertCollection(this.contents) ? this.contents.deleteIn(path3) : false;
		}
		/**
		* Returns item at `key`, or `undefined` if not found. By default unwraps
		* scalar values from their surrounding node; to disable set `keepScalar` to
		* `true` (collections are always returned intact).
		*/
		get(key, keepScalar) {
			return isCollection(this.contents) ? this.contents.get(key, keepScalar) : void 0;
		}
		/**
		* Returns item at `path`, or `undefined` if not found. By default unwraps
		* scalar values from their surrounding node; to disable set `keepScalar` to
		* `true` (collections are always returned intact).
		*/
		getIn(path3, keepScalar) {
			if (isEmptyPath(path3)) return !keepScalar && isScalar(this.contents) ? this.contents.value : this.contents;
			return isCollection(this.contents) ? this.contents.getIn(path3, keepScalar) : void 0;
		}
		/**
		* Checks if the document includes a value with the key `key`.
		*/
		has(key) {
			return isCollection(this.contents) ? this.contents.has(key) : false;
		}
		/**
		* Checks if the document includes a value at `path`.
		*/
		hasIn(path3) {
			if (isEmptyPath(path3)) return this.contents !== void 0;
			return isCollection(this.contents) ? this.contents.hasIn(path3) : false;
		}
		/**
		* Sets a value in this document. For `!!set`, `value` needs to be a
		* boolean to add/remove the item from the set.
		*/
		set(key, value) {
			if (this.contents == null) this.contents = collectionFromPath(this.schema, [key], value);
			else if (assertCollection(this.contents)) this.contents.set(key, value);
		}
		/**
		* Sets a value in this document. For `!!set`, `value` needs to be a
		* boolean to add/remove the item from the set.
		*/
		setIn(path3, value) {
			if (isEmptyPath(path3)) this.contents = value;
			else if (this.contents == null) this.contents = collectionFromPath(this.schema, Array.from(path3), value);
			else if (assertCollection(this.contents)) this.contents.setIn(path3, value);
		}
		/**
		* Change the YAML version and schema used by the document.
		* A `null` version disables support for directives, explicit tags, anchors, and aliases.
		* It also requires the `schema` option to be given as a `Schema` instance value.
		*
		* Overrides all previously set schema options.
		*/
		setSchema(version, options = {}) {
			if (typeof version === "number") version = String(version);
			let opt;
			switch (version) {
				case "1.1":
					if (this.directives) this.directives.yaml.version = "1.1";
					else this.directives = new Directives({ version: "1.1" });
					opt = {
						resolveKnownTags: false,
						schema: "yaml-1.1"
					};
					break;
				case "1.2":
				case "next":
					if (this.directives) this.directives.yaml.version = version;
					else this.directives = new Directives({ version });
					opt = {
						resolveKnownTags: true,
						schema: "core"
					};
					break;
				case null:
					if (this.directives) delete this.directives;
					opt = null;
					break;
				default: {
					const sv = JSON.stringify(version);
					throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`);
				}
			}
			if (options.schema instanceof Object) this.schema = options.schema;
			else if (opt) this.schema = new Schema(Object.assign(opt, options));
			else throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
		}
		toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
			const ctx = {
				anchors: /* @__PURE__ */ new Map(),
				doc: this,
				keep: !json,
				mapAsMap: mapAsMap === true,
				mapKeyWarned: false,
				maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100
			};
			const res = toJS(this.contents, jsonArg != null ? jsonArg : "", ctx);
			if (typeof onAnchor === "function") for (const { count, res: res2 } of ctx.anchors.values()) onAnchor(res2, count);
			return typeof reviver === "function" ? applyReviver(reviver, { "": res }, "", res) : res;
		}
		/**
		* A JSON representation of the document `contents`.
		*
		* @param jsonArg Used by `JSON.stringify` to indicate the array index or
		*   property name.
		*/
		toJSON(jsonArg, onAnchor) {
			return this.toJS({
				json: true,
				jsonArg,
				mapAsMap: false,
				onAnchor
			});
		}
		/** A YAML representation of the document. */
		toString(options = {}) {
			if (this.errors.length > 0) throw new Error("Document with errors cannot be stringified");
			if ("indent" in options && (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) {
				const s = JSON.stringify(options.indent);
				throw new Error(`"indent" option must be a positive integer, not ${s}`);
			}
			return stringifyDocument(this, options);
		}
	};
	function assertCollection(contents) {
		if (isCollection(contents)) return true;
		throw new Error("Expected a YAML collection as document contents");
	}
	var YAMLError = class extends Error {
		constructor(name, pos, code, message) {
			super();
			this.name = name;
			this.code = code;
			this.message = message;
			this.pos = pos;
		}
	};
	var YAMLParseError = class extends YAMLError {
		constructor(pos, code, message) {
			super("YAMLParseError", pos, code, message);
		}
	};
	var YAMLWarning = class extends YAMLError {
		constructor(pos, code, message) {
			super("YAMLWarning", pos, code, message);
		}
	};
	var prettifyError = (src, lc) => (error) => {
		if (error.pos[0] === -1) return;
		error.linePos = error.pos.map((pos) => lc.linePos(pos));
		const { line, col } = error.linePos[0];
		error.message += ` at line ${line}, column ${col}`;
		let ci2 = col - 1;
		let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, "");
		if (ci2 >= 60 && lineStr.length > 80) {
			const trimStart = Math.min(ci2 - 39, lineStr.length - 79);
			lineStr = "…" + lineStr.substring(trimStart);
			ci2 -= trimStart - 1;
		}
		if (lineStr.length > 80) lineStr = lineStr.substring(0, 79) + "…";
		if (line > 1 && /^ *$/.test(lineStr.substring(0, ci2))) {
			let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
			if (prev.length > 80) prev = prev.substring(0, 79) + "…\n";
			lineStr = prev + lineStr;
		}
		if (/[^ ]/.test(lineStr)) {
			let count = 1;
			const end = error.linePos[1];
			if (end && end.line === line && end.col > col) count = Math.max(1, Math.min(end.col - col, 80 - ci2));
			const pointer = " ".repeat(ci2) + "^".repeat(count);
			error.message += `:

${lineStr}
${pointer}
`;
		}
	};
	function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) {
		let spaceBefore = false;
		let atNewline = startOnNewline;
		let hasSpace = startOnNewline;
		let comment = "";
		let commentSep = "";
		let hasNewline = false;
		let reqSpace = false;
		let tab = null;
		let anchor = null;
		let tag = null;
		let newlineAfterProp = null;
		let comma = null;
		let found = null;
		let start = null;
		for (const token of tokens) {
			if (reqSpace) {
				if (token.type !== "space" && token.type !== "newline" && token.type !== "comma") onError(token.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
				reqSpace = false;
			}
			if (tab) {
				if (atNewline && token.type !== "comment" && token.type !== "newline") onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
				tab = null;
			}
			switch (token.type) {
				case "space":
					if (!flow && (indicator !== "doc-start" || (next == null ? void 0 : next.type) !== "flow-collection") && token.source.includes("	")) tab = token;
					hasSpace = true;
					break;
				case "comment": {
					if (!hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
					const cb = token.source.substring(1) || " ";
					if (!comment) comment = cb;
					else comment += commentSep + cb;
					commentSep = "";
					atNewline = false;
					break;
				}
				case "newline":
					if (atNewline) {
						if (comment) comment += token.source;
						else if (!found || indicator !== "seq-item-ind") spaceBefore = true;
					} else commentSep += token.source;
					atNewline = true;
					hasNewline = true;
					if (anchor || tag) newlineAfterProp = token;
					hasSpace = true;
					break;
				case "anchor":
					if (anchor) onError(token, "MULTIPLE_ANCHORS", "A node can have at most one anchor");
					if (token.source.endsWith(":")) onError(token.offset + token.source.length - 1, "BAD_ALIAS", "Anchor ending in : is ambiguous", true);
					anchor = token;
					start ??= token.offset;
					atNewline = false;
					hasSpace = false;
					reqSpace = true;
					break;
				case "tag":
					if (tag) onError(token, "MULTIPLE_TAGS", "A node can have at most one tag");
					tag = token;
					start ??= token.offset;
					atNewline = false;
					hasSpace = false;
					reqSpace = true;
					break;
				case indicator:
					if (anchor || tag) onError(token, "BAD_PROP_ORDER", `Anchors and tags must be after the ${token.source} indicator`);
					if (found) onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.source} in ${flow != null ? flow : "collection"}`);
					found = token;
					atNewline = indicator === "seq-item-ind" || indicator === "explicit-key-ind";
					hasSpace = false;
					break;
				case "comma": if (flow) {
					if (comma) onError(token, "UNEXPECTED_TOKEN", `Unexpected , in ${flow}`);
					comma = token;
					atNewline = false;
					hasSpace = false;
					break;
				}
				default:
					onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.type} token`);
					atNewline = false;
					hasSpace = false;
			}
		}
		const last = tokens[tokens.length - 1];
		const end = last ? last.offset + last.source.length : offset;
		if (reqSpace && next && next.type !== "space" && next.type !== "newline" && next.type !== "comma" && (next.type !== "scalar" || next.source !== "")) onError(next.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
		if (tab && (atNewline && tab.indent <= parentIndent || (next == null ? void 0 : next.type) === "block-map" || (next == null ? void 0 : next.type) === "block-seq")) onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
		return {
			comma,
			found,
			spaceBefore,
			comment,
			hasNewline,
			anchor,
			tag,
			newlineAfterProp,
			end,
			start: start != null ? start : end
		};
	}
	function containsNewline(key) {
		if (!key) return null;
		switch (key.type) {
			case "alias":
			case "scalar":
			case "double-quoted-scalar":
			case "single-quoted-scalar":
				if (key.source.includes("\n")) return true;
				if (key.end) {
					for (const st2 of key.end) if (st2.type === "newline") return true;
				}
				return false;
			case "flow-collection":
				for (const it of key.items) {
					for (const st2 of it.start) if (st2.type === "newline") return true;
					if (it.sep) {
						for (const st2 of it.sep) if (st2.type === "newline") return true;
					}
					if (containsNewline(it.key) || containsNewline(it.value)) return true;
				}
				return false;
			default: return true;
		}
	}
	function flowIndentCheck(indent, fc, onError) {
		if ((fc == null ? void 0 : fc.type) === "flow-collection") {
			const end = fc.end[0];
			if (end.indent === indent && (end.source === "]" || end.source === "}") && containsNewline(fc)) onError(end, "BAD_INDENT", "Flow end indicator should be more indented than parent", true);
		}
	}
	function mapIncludes(ctx, items, search) {
		const { uniqueKeys } = ctx.options;
		if (uniqueKeys === false) return false;
		const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || isScalar(a) && isScalar(b) && a.value === b.value;
		return items.some((pair) => isEqual(pair.key, search));
	}
	var startColMsg = "All mapping items must start at the same column";
	function resolveBlockMap({ composeNode: composeNode2, composeEmptyNode: composeEmptyNode2 }, ctx, bm, onError, tag) {
		var _a2, _b2;
		const map2 = new ((_a2 = tag == null ? void 0 : tag.nodeClass) != null ? _a2 : YAMLMap)(ctx.schema);
		if (ctx.atRoot) ctx.atRoot = false;
		let offset = bm.offset;
		let commentEnd = null;
		for (const collItem of bm.items) {
			const { start, key, sep, value } = collItem;
			const keyProps = resolveProps(start, {
				indicator: "explicit-key-ind",
				next: key != null ? key : sep == null ? void 0 : sep[0],
				offset,
				onError,
				parentIndent: bm.indent,
				startOnNewline: true
			});
			const implicitKey = !keyProps.found;
			if (implicitKey) {
				if (key) {
					if (key.type === "block-seq") onError(offset, "BLOCK_AS_IMPLICIT_KEY", "A block sequence may not be used as an implicit map key");
					else if ("indent" in key && key.indent !== bm.indent) onError(offset, "BAD_INDENT", startColMsg);
				}
				if (!keyProps.anchor && !keyProps.tag && !sep) {
					commentEnd = keyProps.end;
					if (keyProps.comment) if (map2.comment) map2.comment += "\n" + keyProps.comment;
					else map2.comment = keyProps.comment;
					continue;
				}
				if (keyProps.newlineAfterProp || containsNewline(key)) onError(key != null ? key : start[start.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
			} else if (((_b2 = keyProps.found) == null ? void 0 : _b2.indent) !== bm.indent) onError(offset, "BAD_INDENT", startColMsg);
			ctx.atKey = true;
			const keyStart = keyProps.end;
			const keyNode = key ? composeNode2(ctx, key, keyProps, onError) : composeEmptyNode2(ctx, keyStart, start, null, keyProps, onError);
			if (ctx.schema.compat) flowIndentCheck(bm.indent, key, onError);
			ctx.atKey = false;
			if (mapIncludes(ctx, map2.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
			const valueProps = resolveProps(sep != null ? sep : [], {
				indicator: "map-value-ind",
				next: value,
				offset: keyNode.range[2],
				onError,
				parentIndent: bm.indent,
				startOnNewline: !key || key.type === "block-scalar"
			});
			offset = valueProps.end;
			if (valueProps.found) {
				if (implicitKey) {
					if ((value == null ? void 0 : value.type) === "block-map" && !valueProps.hasNewline) onError(offset, "BLOCK_AS_IMPLICIT_KEY", "Nested mappings are not allowed in compact mappings");
					if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024) onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
				}
				const valueNode = value ? composeNode2(ctx, value, valueProps, onError) : composeEmptyNode2(ctx, offset, sep, null, valueProps, onError);
				if (ctx.schema.compat) flowIndentCheck(bm.indent, value, onError);
				offset = valueNode.range[2];
				const pair = new Pair(keyNode, valueNode);
				if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
				map2.items.push(pair);
			} else {
				if (implicitKey) onError(keyNode.range, "MISSING_CHAR", "Implicit map keys need to be followed by map values");
				if (valueProps.comment) if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
				else keyNode.comment = valueProps.comment;
				const pair = new Pair(keyNode);
				if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
				map2.items.push(pair);
			}
		}
		if (commentEnd && commentEnd < offset) onError(commentEnd, "IMPOSSIBLE", "Map comment with trailing content");
		map2.range = [
			bm.offset,
			offset,
			commentEnd != null ? commentEnd : offset
		];
		return map2;
	}
	function resolveBlockSeq({ composeNode: composeNode2, composeEmptyNode: composeEmptyNode2 }, ctx, bs, onError, tag) {
		var _a2;
		const seq2 = new ((_a2 = tag == null ? void 0 : tag.nodeClass) != null ? _a2 : YAMLSeq)(ctx.schema);
		if (ctx.atRoot) ctx.atRoot = false;
		if (ctx.atKey) ctx.atKey = false;
		let offset = bs.offset;
		let commentEnd = null;
		for (const { start, value } of bs.items) {
			const props = resolveProps(start, {
				indicator: "seq-item-ind",
				next: value,
				offset,
				onError,
				parentIndent: bs.indent,
				startOnNewline: true
			});
			if (!props.found) if (props.anchor || props.tag || value) if (value && value.type === "block-seq") onError(props.end, "BAD_INDENT", "All sequence items must start at the same column");
			else onError(offset, "MISSING_CHAR", "Sequence item without - indicator");
			else {
				commentEnd = props.end;
				if (props.comment) seq2.comment = props.comment;
				continue;
			}
			const node = value ? composeNode2(ctx, value, props, onError) : composeEmptyNode2(ctx, props.end, start, null, props, onError);
			if (ctx.schema.compat) flowIndentCheck(bs.indent, value, onError);
			offset = node.range[2];
			seq2.items.push(node);
		}
		seq2.range = [
			bs.offset,
			offset,
			commentEnd != null ? commentEnd : offset
		];
		return seq2;
	}
	function resolveEnd(end, offset, reqSpace, onError) {
		let comment = "";
		if (end) {
			let hasSpace = false;
			let sep = "";
			for (const token of end) {
				const { source, type } = token;
				switch (type) {
					case "space":
						hasSpace = true;
						break;
					case "comment": {
						if (reqSpace && !hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
						const cb = source.substring(1) || " ";
						if (!comment) comment = cb;
						else comment += sep + cb;
						sep = "";
						break;
					}
					case "newline":
						if (comment) sep += source;
						hasSpace = true;
						break;
					default: onError(token, "UNEXPECTED_TOKEN", `Unexpected ${type} at node end`);
				}
				offset += source.length;
			}
		}
		return {
			comment,
			offset
		};
	}
	var blockMsg = "Block collections are not allowed within flow collections";
	var isBlock = (token) => token && (token.type === "block-map" || token.type === "block-seq");
	function resolveFlowCollection({ composeNode: composeNode2, composeEmptyNode: composeEmptyNode2 }, ctx, fc, onError, tag) {
		var _a2, _b2;
		const isMap2 = fc.start.source === "{";
		const fcName = isMap2 ? "flow map" : "flow sequence";
		const coll = new ((_a2 = tag == null ? void 0 : tag.nodeClass) != null ? _a2 : isMap2 ? YAMLMap : YAMLSeq)(ctx.schema);
		coll.flow = true;
		const atRoot = ctx.atRoot;
		if (atRoot) ctx.atRoot = false;
		if (ctx.atKey) ctx.atKey = false;
		let offset = fc.offset + fc.start.source.length;
		for (let i = 0; i < fc.items.length; ++i) {
			const collItem = fc.items[i];
			const { start, key, sep, value } = collItem;
			const props = resolveProps(start, {
				flow: fcName,
				indicator: "explicit-key-ind",
				next: key != null ? key : sep == null ? void 0 : sep[0],
				offset,
				onError,
				parentIndent: fc.indent,
				startOnNewline: false
			});
			if (!props.found) {
				if (!props.anchor && !props.tag && !sep && !value) {
					if (i === 0 && props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
					else if (i < fc.items.length - 1) onError(props.start, "UNEXPECTED_TOKEN", `Unexpected empty item in ${fcName}`);
					if (props.comment) if (coll.comment) coll.comment += "\n" + props.comment;
					else coll.comment = props.comment;
					offset = props.end;
					continue;
				}
				if (!isMap2 && ctx.options.strict && containsNewline(key)) onError(key, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
			}
			if (i === 0) {
				if (props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
			} else {
				if (!props.comma) onError(props.start, "MISSING_CHAR", `Missing , between ${fcName} items`);
				if (props.comment) {
					let prevItemComment = "";
					loop: for (const st2 of start) switch (st2.type) {
						case "comma":
						case "space": break;
						case "comment":
							prevItemComment = st2.source.substring(1);
							break loop;
						default: break loop;
					}
					if (prevItemComment) {
						let prev = coll.items[coll.items.length - 1];
						if (isPair(prev)) prev = (_b2 = prev.value) != null ? _b2 : prev.key;
						if (prev.comment) prev.comment += "\n" + prevItemComment;
						else prev.comment = prevItemComment;
						props.comment = props.comment.substring(prevItemComment.length + 1);
					}
				}
			}
			if (!isMap2 && !sep && !props.found) {
				const valueNode = value ? composeNode2(ctx, value, props, onError) : composeEmptyNode2(ctx, props.end, sep, null, props, onError);
				coll.items.push(valueNode);
				offset = valueNode.range[2];
				if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
			} else {
				ctx.atKey = true;
				const keyStart = props.end;
				const keyNode = key ? composeNode2(ctx, key, props, onError) : composeEmptyNode2(ctx, keyStart, start, null, props, onError);
				if (isBlock(key)) onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
				ctx.atKey = false;
				const valueProps = resolveProps(sep != null ? sep : [], {
					flow: fcName,
					indicator: "map-value-ind",
					next: value,
					offset: keyNode.range[2],
					onError,
					parentIndent: fc.indent,
					startOnNewline: false
				});
				if (valueProps.found) {
					if (!isMap2 && !props.found && ctx.options.strict) {
						if (sep) for (const st2 of sep) {
							if (st2 === valueProps.found) break;
							if (st2.type === "newline") {
								onError(st2, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
								break;
							}
						}
						if (props.start < valueProps.found.offset - 1024) onError(valueProps.found, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit flow sequence key");
					}
				} else if (value) if ("source" in value && value.source && value.source[0] === ":") onError(value, "MISSING_CHAR", `Missing space after : in ${fcName}`);
				else onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
				const valueNode = value ? composeNode2(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode2(ctx, valueProps.end, sep, null, valueProps, onError) : null;
				if (valueNode) {
					if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
				} else if (valueProps.comment) if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
				else keyNode.comment = valueProps.comment;
				const pair = new Pair(keyNode, valueNode);
				if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
				if (isMap2) {
					const map2 = coll;
					if (mapIncludes(ctx, map2.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
					map2.items.push(pair);
				} else {
					const map2 = new YAMLMap(ctx.schema);
					map2.flow = true;
					map2.items.push(pair);
					const endRange = (valueNode != null ? valueNode : keyNode).range;
					map2.range = [
						keyNode.range[0],
						endRange[1],
						endRange[2]
					];
					coll.items.push(map2);
				}
				offset = valueNode ? valueNode.range[2] : valueProps.end;
			}
		}
		const expectedEnd = isMap2 ? "}" : "]";
		const [ce, ...ee2] = fc.end;
		let cePos = offset;
		if (ce && ce.source === expectedEnd) cePos = ce.offset + ce.source.length;
		else {
			const name = fcName[0].toUpperCase() + fcName.substring(1);
			const msg = atRoot ? `${name} must end with a ${expectedEnd}` : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
			onError(offset, atRoot ? "MISSING_CHAR" : "BAD_INDENT", msg);
			if (ce && ce.source.length !== 1) ee2.unshift(ce);
		}
		if (ee2.length > 0) {
			const end = resolveEnd(ee2, cePos, ctx.options.strict, onError);
			if (end.comment) if (coll.comment) coll.comment += "\n" + end.comment;
			else coll.comment = end.comment;
			coll.range = [
				fc.offset,
				cePos,
				end.offset
			];
		} else coll.range = [
			fc.offset,
			cePos,
			cePos
		];
		return coll;
	}
	function resolveCollection(CN2, ctx, token, onError, tagName, tag) {
		const coll = token.type === "block-map" ? resolveBlockMap(CN2, ctx, token, onError, tag) : token.type === "block-seq" ? resolveBlockSeq(CN2, ctx, token, onError, tag) : resolveFlowCollection(CN2, ctx, token, onError, tag);
		const Coll = coll.constructor;
		if (tagName === "!" || tagName === Coll.tagName) {
			coll.tag = Coll.tagName;
			return coll;
		}
		if (tagName) coll.tag = tagName;
		return coll;
	}
	function composeCollection(CN2, ctx, token, props, onError) {
		var _a2, _b2, _c;
		const tagToken = props.tag;
		const tagName = !tagToken ? null : ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg));
		if (token.type === "block-seq") {
			const { anchor, newlineAfterProp: nl2 } = props;
			const lastProp = anchor && tagToken ? anchor.offset > tagToken.offset ? anchor : tagToken : anchor != null ? anchor : tagToken;
			if (lastProp && (!nl2 || nl2.offset < lastProp.offset)) onError(lastProp, "MISSING_CHAR", "Missing newline after block sequence props");
		}
		const expType = token.type === "block-map" ? "map" : token.type === "block-seq" ? "seq" : token.start.source === "{" ? "map" : "seq";
		if (!tagToken || !tagName || tagName === "!" || tagName === YAMLMap.tagName && expType === "map" || tagName === YAMLSeq.tagName && expType === "seq") return resolveCollection(CN2, ctx, token, onError, tagName);
		let tag = ctx.schema.tags.find((t3) => t3.tag === tagName && t3.collection === expType);
		if (!tag) {
			const kt2 = ctx.schema.knownTags[tagName];
			if (kt2 && kt2.collection === expType) {
				ctx.schema.tags.push(Object.assign({}, kt2, { default: false }));
				tag = kt2;
			} else {
				if (kt2) onError(tagToken, "BAD_COLLECTION_TYPE", `${kt2.tag} used for ${expType} collection, but expects ${(_a2 = kt2.collection) != null ? _a2 : "scalar"}`, true);
				else onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, true);
				return resolveCollection(CN2, ctx, token, onError, tagName);
			}
		}
		const coll = resolveCollection(CN2, ctx, token, onError, tagName, tag);
		const res = (_c = (_b2 = tag.resolve) == null ? void 0 : _b2.call(tag, coll, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg), ctx.options)) != null ? _c : coll;
		const node = isNode(res) ? res : new Scalar(res);
		node.range = coll.range;
		node.tag = tagName;
		if (tag == null ? void 0 : tag.format) node.format = tag.format;
		return node;
	}
	function resolveBlockScalar(ctx, scalar, onError) {
		const start = scalar.offset;
		const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError);
		if (!header) return {
			value: "",
			type: null,
			comment: "",
			range: [
				start,
				start,
				start
			]
		};
		const type = header.mode === ">" ? Scalar.BLOCK_FOLDED : Scalar.BLOCK_LITERAL;
		const lines = scalar.source ? splitLines(scalar.source) : [];
		let chompStart = lines.length;
		for (let i = lines.length - 1; i >= 0; --i) {
			const content = lines[i][1];
			if (content === "" || content === "\r") chompStart = i;
			else break;
		}
		if (chompStart === 0) {
			const value2 = header.chomp === "+" && lines.length > 0 ? "\n".repeat(Math.max(1, lines.length - 1)) : "";
			let end2 = start + header.length;
			if (scalar.source) end2 += scalar.source.length;
			return {
				value: value2,
				type,
				comment: header.comment,
				range: [
					start,
					end2,
					end2
				]
			};
		}
		let trimIndent = scalar.indent + header.indent;
		let offset = scalar.offset + header.length;
		let contentStart = 0;
		for (let i = 0; i < chompStart; ++i) {
			const [indent, content] = lines[i];
			if (content === "" || content === "\r") {
				if (header.indent === 0 && indent.length > trimIndent) trimIndent = indent.length;
			} else {
				if (indent.length < trimIndent) onError(offset + indent.length, "MISSING_CHAR", "Block scalars with more-indented leading empty lines must use an explicit indentation indicator");
				if (header.indent === 0) trimIndent = indent.length;
				contentStart = i;
				if (trimIndent === 0 && !ctx.atRoot) onError(offset, "BAD_INDENT", "Block scalar values in collections must be indented");
				break;
			}
			offset += indent.length + content.length + 1;
		}
		for (let i = lines.length - 1; i >= chompStart; --i) if (lines[i][0].length > trimIndent) chompStart = i + 1;
		let value = "";
		let sep = "";
		let prevMoreIndented = false;
		for (let i = 0; i < contentStart; ++i) value += lines[i][0].slice(trimIndent) + "\n";
		for (let i = contentStart; i < chompStart; ++i) {
			let [indent, content] = lines[i];
			offset += indent.length + content.length + 1;
			const crlf = content[content.length - 1] === "\r";
			if (crlf) content = content.slice(0, -1);
			if (content && indent.length < trimIndent) {
				const message = `Block scalar lines must not be less indented than their ${header.indent ? "explicit indentation indicator" : "first line"}`;
				onError(offset - content.length - (crlf ? 2 : 1), "BAD_INDENT", message);
				indent = "";
			}
			if (type === Scalar.BLOCK_LITERAL) {
				value += sep + indent.slice(trimIndent) + content;
				sep = "\n";
			} else if (indent.length > trimIndent || content[0] === "	") {
				if (sep === " ") sep = "\n";
				else if (!prevMoreIndented && sep === "\n") sep = "\n\n";
				value += sep + indent.slice(trimIndent) + content;
				sep = "\n";
				prevMoreIndented = true;
			} else if (content === "") if (sep === "\n") value += "\n";
			else sep = "\n";
			else {
				value += sep + content;
				sep = " ";
				prevMoreIndented = false;
			}
		}
		switch (header.chomp) {
			case "-": break;
			case "+":
				for (let i = chompStart; i < lines.length; ++i) value += "\n" + lines[i][0].slice(trimIndent);
				if (value[value.length - 1] !== "\n") value += "\n";
				break;
			default: value += "\n";
		}
		const end = start + header.length + scalar.source.length;
		return {
			value,
			type,
			comment: header.comment,
			range: [
				start,
				end,
				end
			]
		};
	}
	function parseBlockScalarHeader({ offset, props }, strict, onError) {
		if (props[0].type !== "block-scalar-header") {
			onError(props[0], "IMPOSSIBLE", "Block scalar header not found");
			return null;
		}
		const { source } = props[0];
		const mode = source[0];
		let indent = 0;
		let chomp = "";
		let error = -1;
		for (let i = 1; i < source.length; ++i) {
			const ch = source[i];
			if (!chomp && (ch === "-" || ch === "+")) chomp = ch;
			else {
				const n4 = Number(ch);
				if (!indent && n4) indent = n4;
				else if (error === -1) error = offset + i;
			}
		}
		if (error !== -1) onError(error, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source}`);
		let hasSpace = false;
		let comment = "";
		let length = source.length;
		for (let i = 1; i < props.length; ++i) {
			const token = props[i];
			switch (token.type) {
				case "space": hasSpace = true;
				case "newline":
					length += token.source.length;
					break;
				case "comment":
					if (strict && !hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
					length += token.source.length;
					comment = token.source.substring(1);
					break;
				case "error":
					onError(token, "UNEXPECTED_TOKEN", token.message);
					length += token.source.length;
					break;
				default: {
					onError(token, "UNEXPECTED_TOKEN", `Unexpected token in block scalar header: ${token.type}`);
					const ts = token.source;
					if (ts && typeof ts === "string") length += ts.length;
				}
			}
		}
		return {
			mode,
			indent,
			chomp,
			comment,
			length
		};
	}
	function splitLines(source) {
		const split = source.split(/\n( *)/);
		const first = split[0];
		const m2 = first.match(/^( *)/);
		const lines = [(m2 == null ? void 0 : m2[1]) ? [m2[1], first.slice(m2[1].length)] : ["", first]];
		for (let i = 1; i < split.length; i += 2) lines.push([split[i], split[i + 1]]);
		return lines;
	}
	function resolveFlowScalar(scalar, strict, onError) {
		const { offset, type, source, end } = scalar;
		let _type;
		let value;
		const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
		switch (type) {
			case "scalar":
				_type = Scalar.PLAIN;
				value = plainValue(source, _onError);
				break;
			case "single-quoted-scalar":
				_type = Scalar.QUOTE_SINGLE;
				value = singleQuotedValue(source, _onError);
				break;
			case "double-quoted-scalar":
				_type = Scalar.QUOTE_DOUBLE;
				value = doubleQuotedValue(source, _onError);
				break;
			default:
				onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
				return {
					value: "",
					type: null,
					comment: "",
					range: [
						offset,
						offset + source.length,
						offset + source.length
					]
				};
		}
		const valueEnd = offset + source.length;
		const re = resolveEnd(end, valueEnd, strict, onError);
		return {
			value,
			type: _type,
			comment: re.comment,
			range: [
				offset,
				valueEnd,
				re.offset
			]
		};
	}
	function plainValue(source, onError) {
		let badChar = "";
		switch (source[0]) {
			case "	":
				badChar = "a tab character";
				break;
			case ",":
				badChar = "flow indicator character ,";
				break;
			case "%":
				badChar = "directive indicator character %";
				break;
			case "|":
			case ">":
				badChar = `block scalar indicator ${source[0]}`;
				break;
			case "@":
			case "`":
				badChar = `reserved character ${source[0]}`;
				break;
		}
		if (badChar) onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
		return foldLines(source);
	}
	function singleQuotedValue(source, onError) {
		if (source[source.length - 1] !== "'" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
		return foldLines(source.slice(1, -1)).replace(/''/g, "'");
	}
	function foldLines(source) {
		var _a2;
		let first, line;
		try {
			first = /* @__PURE__ */ new RegExp("(.*?)(?<![ 	])[ 	]*\r?\n", "sy");
			line = /* @__PURE__ */ new RegExp("[ 	]*(.*?)(?:(?<![ 	])[ 	]*)?\r?\n", "sy");
		} catch (e) {
			first = /* @__PURE__ */ new RegExp("(.*?)[ \\t]*\\r?\\n", "sy");
			line = /* @__PURE__ */ new RegExp("[ \\t]*(.*?)[ \\t]*\\r?\\n", "sy");
		}
		let match = first.exec(source);
		if (!match) return source;
		let res = match[1];
		let sep = " ";
		let pos = first.lastIndex;
		line.lastIndex = pos;
		while (match = line.exec(source)) {
			if (match[1] === "") if (sep === "\n") res += sep;
			else sep = "\n";
			else {
				res += sep + match[1];
				sep = " ";
			}
			pos = line.lastIndex;
		}
		const last = /* @__PURE__ */ new RegExp("[ \\t]*(.*)", "sy");
		last.lastIndex = pos;
		match = last.exec(source);
		return res + sep + ((_a2 = match == null ? void 0 : match[1]) != null ? _a2 : "");
	}
	function doubleQuotedValue(source, onError) {
		let res = "";
		for (let i = 1; i < source.length - 1; ++i) {
			const ch = source[i];
			if (ch === "\r" && source[i + 1] === "\n") continue;
			if (ch === "\n") {
				const { fold, offset } = foldNewline(source, i);
				res += fold;
				i = offset;
			} else if (ch === "\\") {
				let next = source[++i];
				const cc = escapeCodes[next];
				if (cc) res += cc;
				else if (next === "\n") {
					next = source[i + 1];
					while (next === " " || next === "	") next = source[++i + 1];
				} else if (next === "\r" && source[i + 1] === "\n") {
					next = source[++i + 1];
					while (next === " " || next === "	") next = source[++i + 1];
				} else if (next === "x" || next === "u" || next === "U") {
					const length = {
						x: 2,
						u: 4,
						U: 8
					}[next];
					res += parseCharCode(source, i + 1, length, onError);
					i += length;
				} else {
					const raw = source.substr(i - 1, 2);
					onError(i - 1, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
					res += raw;
				}
			} else if (ch === " " || ch === "	") {
				const wsStart = i;
				let next = source[i + 1];
				while (next === " " || next === "	") next = source[++i + 1];
				if (next !== "\n" && !(next === "\r" && source[i + 2] === "\n")) res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
			} else res += ch;
		}
		if (source[source.length - 1] !== "\"" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing \"quote");
		return res;
	}
	function foldNewline(source, offset) {
		let fold = "";
		let ch = source[offset + 1];
		while (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
			if (ch === "\r" && source[offset + 2] !== "\n") break;
			if (ch === "\n") fold += "\n";
			offset += 1;
			ch = source[offset + 1];
		}
		if (!fold) fold = " ";
		return {
			fold,
			offset
		};
	}
	var escapeCodes = {
		"0": "\0",
		a: "\x07",
		b: "\b",
		e: "\x1B",
		f: "\f",
		n: "\n",
		r: "\r",
		t: "	",
		v: "\v",
		N: "…",
		_: "\xA0",
		L: "\u2028",
		P: "\u2029",
		" ": " ",
		"\"": "\"",
		"/": "/",
		"\\": "\\",
		"	": "	"
	};
	function parseCharCode(source, offset, length, onError) {
		const cc = source.substr(offset, length);
		const code = cc.length === length && /^[0-9a-fA-F]+$/.test(cc) ? parseInt(cc, 16) : NaN;
		if (isNaN(code)) {
			const raw = source.substr(offset - 2, length + 2);
			onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
			return raw;
		}
		return String.fromCodePoint(code);
	}
	function composeScalar(ctx, token, tagToken, onError) {
		const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar(ctx, token, onError) : resolveFlowScalar(token, ctx.options.strict, onError);
		const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
		let tag;
		if (ctx.options.stringKeys && ctx.atKey) tag = ctx.schema[SCALAR];
		else if (tagName) tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);
		else if (token.type === "scalar") tag = findScalarTagByTest(ctx, value, token, onError);
		else tag = ctx.schema[SCALAR];
		let scalar;
		try {
			const res = tag.resolve(value, (msg) => onError(tagToken != null ? tagToken : token, "TAG_RESOLVE_FAILED", msg), ctx.options);
			scalar = isScalar(res) ? res : new Scalar(res);
		} catch (error) {
			const msg = error instanceof Error ? error.message : String(error);
			onError(tagToken != null ? tagToken : token, "TAG_RESOLVE_FAILED", msg);
			scalar = new Scalar(value);
		}
		scalar.range = range;
		scalar.source = value;
		if (type) scalar.type = type;
		if (tagName) scalar.tag = tagName;
		if (tag.format) scalar.format = tag.format;
		if (comment) scalar.comment = comment;
		return scalar;
	}
	function findScalarTagByName(schema4, value, tagName, tagToken, onError) {
		var _a2;
		if (tagName === "!") return schema4[SCALAR];
		const matchWithTest = [];
		for (const tag of schema4.tags) if (!tag.collection && tag.tag === tagName) if (tag.default && tag.test) matchWithTest.push(tag);
		else return tag;
		for (const tag of matchWithTest) if ((_a2 = tag.test) == null ? void 0 : _a2.test(value)) return tag;
		const kt2 = schema4.knownTags[tagName];
		if (kt2 && !kt2.collection) {
			schema4.tags.push(Object.assign({}, kt2, {
				default: false,
				test: void 0
			}));
			return kt2;
		}
		onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
		return schema4[SCALAR];
	}
	function findScalarTagByTest({ atKey, directives, schema: schema4 }, value, token, onError) {
		var _a2;
		const tag = schema4.tags.find((tag2) => {
			var _a3;
			return (tag2.default === true || atKey && tag2.default === "key") && ((_a3 = tag2.test) == null ? void 0 : _a3.test(value));
		}) || schema4[SCALAR];
		if (schema4.compat) {
			const compat = (_a2 = schema4.compat.find((tag2) => {
				var _a3;
				return tag2.default && ((_a3 = tag2.test) == null ? void 0 : _a3.test(value));
			})) != null ? _a2 : schema4[SCALAR];
			if (tag.tag !== compat.tag) onError(token, "TAG_RESOLVE_FAILED", `Value may be parsed as either ${directives.tagString(tag.tag)} or ${directives.tagString(compat.tag)}`, true);
		}
		return tag;
	}
	function emptyScalarPosition(offset, before, pos) {
		if (before) {
			pos ??= before.length;
			for (let i = pos - 1; i >= 0; --i) {
				let st2 = before[i];
				switch (st2.type) {
					case "space":
					case "comment":
					case "newline":
						offset -= st2.source.length;
						continue;
				}
				st2 = before[++i];
				while ((st2 == null ? void 0 : st2.type) === "space") {
					offset += st2.source.length;
					st2 = before[++i];
				}
				break;
			}
		}
		return offset;
	}
	var CN = {
		composeNode,
		composeEmptyNode
	};
	function composeNode(ctx, token, props, onError) {
		const atKey = ctx.atKey;
		const { spaceBefore, comment, anchor, tag } = props;
		let node;
		let isSrcToken = true;
		switch (token.type) {
			case "alias":
				node = composeAlias(ctx, token, onError);
				if (anchor || tag) onError(token, "ALIAS_PROPS", "An alias node must not specify any properties");
				break;
			case "scalar":
			case "single-quoted-scalar":
			case "double-quoted-scalar":
			case "block-scalar":
				node = composeScalar(ctx, token, tag, onError);
				if (anchor) node.anchor = anchor.source.substring(1);
				break;
			case "block-map":
			case "block-seq":
			case "flow-collection":
				node = composeCollection(CN, ctx, token, props, onError);
				if (anchor) node.anchor = anchor.source.substring(1);
				break;
			default:
				onError(token, "UNEXPECTED_TOKEN", token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`);
				node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError);
				isSrcToken = false;
		}
		if (anchor && node.anchor === "") onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
		if (atKey && ctx.options.stringKeys && (!isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) onError(tag != null ? tag : token, "NON_STRING_KEY", "With stringKeys, all keys must be strings");
		if (spaceBefore) node.spaceBefore = true;
		if (comment) if (token.type === "scalar" && token.source === "") node.comment = comment;
		else node.commentBefore = comment;
		if (ctx.options.keepSourceTokens && isSrcToken) node.srcToken = token;
		return node;
	}
	function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
		const node = composeScalar(ctx, {
			type: "scalar",
			offset: emptyScalarPosition(offset, before, pos),
			indent: -1,
			source: ""
		}, tag, onError);
		if (anchor) {
			node.anchor = anchor.source.substring(1);
			if (node.anchor === "") onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
		}
		if (spaceBefore) node.spaceBefore = true;
		if (comment) {
			node.comment = comment;
			node.range[2] = end;
		}
		return node;
	}
	function composeAlias({ options }, { offset, source, end }, onError) {
		const alias = new Alias(source.substring(1));
		if (alias.source === "") onError(offset, "BAD_ALIAS", "Alias cannot be an empty string");
		if (alias.source.endsWith(":")) onError(offset + source.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true);
		const valueEnd = offset + source.length;
		const re = resolveEnd(end, valueEnd, options.strict, onError);
		alias.range = [
			offset,
			valueEnd,
			re.offset
		];
		if (re.comment) alias.comment = re.comment;
		return alias;
	}
	function composeDoc(options, directives, { offset, start, value, end }, onError) {
		const doc = new Document(void 0, Object.assign({ _directives: directives }, options));
		const ctx = {
			atKey: false,
			atRoot: true,
			directives: doc.directives,
			options: doc.options,
			schema: doc.schema
		};
		const props = resolveProps(start, {
			indicator: "doc-start",
			next: value != null ? value : end == null ? void 0 : end[0],
			offset,
			onError,
			parentIndent: 0,
			startOnNewline: true
		});
		if (props.found) {
			doc.directives.docStart = true;
			if (value && (value.type === "block-map" || value.type === "block-seq") && !props.hasNewline) onError(props.end, "MISSING_CHAR", "Block collection cannot start on same line with directives-end marker");
		}
		doc.contents = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
		const contentEnd = doc.contents.range[2];
		const re = resolveEnd(end, contentEnd, false, onError);
		if (re.comment) doc.comment = re.comment;
		doc.range = [
			offset,
			contentEnd,
			re.offset
		];
		return doc;
	}
	function getErrorPos(src) {
		if (typeof src === "number") return [src, src + 1];
		if (Array.isArray(src)) return src.length === 2 ? src : [src[0], src[1]];
		const { offset, source } = src;
		return [offset, offset + (typeof source === "string" ? source.length : 1)];
	}
	function parsePrelude(prelude) {
		var _a2;
		let comment = "";
		let atComment = false;
		let afterEmptyLine = false;
		for (let i = 0; i < prelude.length; ++i) {
			const source = prelude[i];
			switch (source[0]) {
				case "#":
					comment += (comment === "" ? "" : afterEmptyLine ? "\n\n" : "\n") + (source.substring(1) || " ");
					atComment = true;
					afterEmptyLine = false;
					break;
				case "%":
					if (((_a2 = prelude[i + 1]) == null ? void 0 : _a2[0]) !== "#") i += 1;
					atComment = false;
					break;
				default:
					if (!atComment) afterEmptyLine = true;
					atComment = false;
			}
		}
		return {
			comment,
			afterEmptyLine
		};
	}
	var Composer = class {
		constructor(options = {}) {
			this.doc = null;
			this.atDirectives = false;
			this.prelude = [];
			this.errors = [];
			this.warnings = [];
			this.onError = (source, code, message, warning) => {
				const pos = getErrorPos(source);
				if (warning) this.warnings.push(new YAMLWarning(pos, code, message));
				else this.errors.push(new YAMLParseError(pos, code, message));
			};
			this.directives = new Directives({ version: options.version || "1.2" });
			this.options = options;
		}
		decorate(doc, afterDoc) {
			const { comment, afterEmptyLine } = parsePrelude(this.prelude);
			if (comment) {
				const dc = doc.contents;
				if (afterDoc) doc.comment = doc.comment ? `${doc.comment}
${comment}` : comment;
				else if (afterEmptyLine || doc.directives.docStart || !dc) doc.commentBefore = comment;
				else if (isCollection(dc) && !dc.flow && dc.items.length > 0) {
					let it = dc.items[0];
					if (isPair(it)) it = it.key;
					const cb = it.commentBefore;
					it.commentBefore = cb ? `${comment}
${cb}` : comment;
				} else {
					const cb = dc.commentBefore;
					dc.commentBefore = cb ? `${comment}
${cb}` : comment;
				}
			}
			if (afterDoc) {
				Array.prototype.push.apply(doc.errors, this.errors);
				Array.prototype.push.apply(doc.warnings, this.warnings);
			} else {
				doc.errors = this.errors;
				doc.warnings = this.warnings;
			}
			this.prelude = [];
			this.errors = [];
			this.warnings = [];
		}
		/**
		* Current stream status information.
		*
		* Mostly useful at the end of input for an empty stream.
		*/
		streamInfo() {
			return {
				comment: parsePrelude(this.prelude).comment,
				directives: this.directives,
				errors: this.errors,
				warnings: this.warnings
			};
		}
		/**
		* Compose tokens into documents.
		*
		* @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
		* @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
		*/
		*compose(tokens, forceDoc = false, endOffset = -1) {
			for (const token of tokens) yield* __yieldStar(this.next(token));
			yield* __yieldStar(this.end(forceDoc, endOffset));
		}
		/** Advance the composer by one CST token. */
		*next(token) {
			switch (token.type) {
				case "directive":
					this.directives.add(token.source, (offset, message, warning) => {
						const pos = getErrorPos(token);
						pos[0] += offset;
						this.onError(pos, "BAD_DIRECTIVE", message, warning);
					});
					this.prelude.push(token.source);
					this.atDirectives = true;
					break;
				case "document": {
					const doc = composeDoc(this.options, this.directives, token, this.onError);
					if (this.atDirectives && !doc.directives.docStart) this.onError(token, "MISSING_CHAR", "Missing directives-end/doc-start indicator line");
					this.decorate(doc, false);
					if (this.doc) yield this.doc;
					this.doc = doc;
					this.atDirectives = false;
					break;
				}
				case "byte-order-mark":
				case "space": break;
				case "comment":
				case "newline":
					this.prelude.push(token.source);
					break;
				case "error": {
					const msg = token.source ? `${token.message}: ${JSON.stringify(token.source)}` : token.message;
					const error = new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg);
					if (this.atDirectives || !this.doc) this.errors.push(error);
					else this.doc.errors.push(error);
					break;
				}
				case "doc-end": {
					if (!this.doc) {
						this.errors.push(new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", "Unexpected doc-end without preceding document"));
						break;
					}
					this.doc.directives.docEnd = true;
					const end = resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
					this.decorate(this.doc, true);
					if (end.comment) {
						const dc = this.doc.comment;
						this.doc.comment = dc ? `${dc}
${end.comment}` : end.comment;
					}
					this.doc.range[2] = end.offset;
					break;
				}
				default: this.errors.push(new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", `Unsupported token ${token.type}`));
			}
		}
		/**
		* Call at end of input to yield any remaining document.
		*
		* @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
		* @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
		*/
		*end(forceDoc = false, endOffset = -1) {
			if (this.doc) {
				this.decorate(this.doc, true);
				yield this.doc;
				this.doc = null;
			} else if (forceDoc) {
				const doc = new Document(void 0, Object.assign({ _directives: this.directives }, this.options));
				if (this.atDirectives) this.onError(endOffset, "MISSING_CHAR", "Missing directives-end indicator line");
				doc.range = [
					0,
					endOffset,
					endOffset
				];
				this.decorate(doc, false);
				yield doc;
			}
		}
	};
	var cst_exports = {};
	__export(cst_exports, {
		BOM: () => BOM,
		DOCUMENT: () => DOCUMENT,
		FLOW_END: () => FLOW_END,
		SCALAR: () => SCALAR2,
		createScalarToken: () => createScalarToken,
		isCollection: () => isCollection2,
		isScalar: () => isScalar2,
		prettyToken: () => prettyToken,
		resolveAsScalar: () => resolveAsScalar,
		setScalarValue: () => setScalarValue,
		stringify: () => stringify2,
		tokenType: () => tokenType,
		visit: () => visit2
	});
	function resolveAsScalar(token, strict = true, onError) {
		if (token) {
			const _onError = (pos, code, message) => {
				const offset = typeof pos === "number" ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
				if (onError) onError(offset, code, message);
				else throw new YAMLParseError([offset, offset + 1], code, message);
			};
			switch (token.type) {
				case "scalar":
				case "single-quoted-scalar":
				case "double-quoted-scalar": return resolveFlowScalar(token, strict, _onError);
				case "block-scalar": return resolveBlockScalar({ options: { strict } }, token, _onError);
			}
		}
		return null;
	}
	function createScalarToken(value, context) {
		var _a2;
		const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context;
		const source = stringifyString({
			type,
			value
		}, {
			implicitKey,
			indent: indent > 0 ? " ".repeat(indent) : "",
			inFlow,
			options: {
				blockQuote: true,
				lineWidth: -1
			}
		});
		const end = (_a2 = context.end) != null ? _a2 : [{
			type: "newline",
			offset: -1,
			indent,
			source: "\n"
		}];
		switch (source[0]) {
			case "|":
			case ">": {
				const he = source.indexOf("\n");
				const head = source.substring(0, he);
				const body = source.substring(he + 1) + "\n";
				const props = [{
					type: "block-scalar-header",
					offset,
					indent,
					source: head
				}];
				if (!addEndtoBlockProps(props, end)) props.push({
					type: "newline",
					offset: -1,
					indent,
					source: "\n"
				});
				return {
					type: "block-scalar",
					offset,
					indent,
					props,
					source: body
				};
			}
			case "\"": return {
				type: "double-quoted-scalar",
				offset,
				indent,
				source,
				end
			};
			case "'": return {
				type: "single-quoted-scalar",
				offset,
				indent,
				source,
				end
			};
			default: return {
				type: "scalar",
				offset,
				indent,
				source,
				end
			};
		}
	}
	function setScalarValue(token, value, context = {}) {
		let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
		let indent = "indent" in token ? token.indent : null;
		if (afterKey && typeof indent === "number") indent += 2;
		if (!type) switch (token.type) {
			case "single-quoted-scalar":
				type = "QUOTE_SINGLE";
				break;
			case "double-quoted-scalar":
				type = "QUOTE_DOUBLE";
				break;
			case "block-scalar": {
				const header = token.props[0];
				if (header.type !== "block-scalar-header") throw new Error("Invalid block scalar header");
				type = header.source[0] === ">" ? "BLOCK_FOLDED" : "BLOCK_LITERAL";
				break;
			}
			default: type = "PLAIN";
		}
		const source = stringifyString({
			type,
			value
		}, {
			implicitKey: implicitKey || indent === null,
			indent: indent !== null && indent > 0 ? " ".repeat(indent) : "",
			inFlow,
			options: {
				blockQuote: true,
				lineWidth: -1
			}
		});
		switch (source[0]) {
			case "|":
			case ">":
				setBlockScalarValue(token, source);
				break;
			case "\"":
				setFlowScalarValue(token, source, "double-quoted-scalar");
				break;
			case "'":
				setFlowScalarValue(token, source, "single-quoted-scalar");
				break;
			default: setFlowScalarValue(token, source, "scalar");
		}
	}
	function setBlockScalarValue(token, source) {
		const he = source.indexOf("\n");
		const head = source.substring(0, he);
		const body = source.substring(he + 1) + "\n";
		if (token.type === "block-scalar") {
			const header = token.props[0];
			if (header.type !== "block-scalar-header") throw new Error("Invalid block scalar header");
			header.source = head;
			token.source = body;
		} else {
			const { offset } = token;
			const indent = "indent" in token ? token.indent : -1;
			const props = [{
				type: "block-scalar-header",
				offset,
				indent,
				source: head
			}];
			if (!addEndtoBlockProps(props, "end" in token ? token.end : void 0)) props.push({
				type: "newline",
				offset: -1,
				indent,
				source: "\n"
			});
			for (const key of Object.keys(token)) if (key !== "type" && key !== "offset") delete token[key];
			Object.assign(token, {
				type: "block-scalar",
				indent,
				props,
				source: body
			});
		}
	}
	function addEndtoBlockProps(props, end) {
		if (end) for (const st2 of end) switch (st2.type) {
			case "space":
			case "comment":
				props.push(st2);
				break;
			case "newline":
				props.push(st2);
				return true;
		}
		return false;
	}
	function setFlowScalarValue(token, source, type) {
		switch (token.type) {
			case "scalar":
			case "double-quoted-scalar":
			case "single-quoted-scalar":
				token.type = type;
				token.source = source;
				break;
			case "block-scalar": {
				const end = token.props.slice(1);
				let oa = source.length;
				if (token.props[0].type === "block-scalar-header") oa -= token.props[0].source.length;
				for (const tok of end) tok.offset += oa;
				delete token.props;
				Object.assign(token, {
					type,
					source,
					end
				});
				break;
			}
			case "block-map":
			case "block-seq": {
				const nl2 = {
					type: "newline",
					offset: token.offset + source.length,
					indent: token.indent,
					source: "\n"
				};
				delete token.items;
				Object.assign(token, {
					type,
					source,
					end: [nl2]
				});
				break;
			}
			default: {
				const indent = "indent" in token ? token.indent : -1;
				const end = "end" in token && Array.isArray(token.end) ? token.end.filter((st2) => st2.type === "space" || st2.type === "comment" || st2.type === "newline") : [];
				for (const key of Object.keys(token)) if (key !== "type" && key !== "offset") delete token[key];
				Object.assign(token, {
					type,
					indent,
					source,
					end
				});
			}
		}
	}
	var stringify2 = (cst) => "type" in cst ? stringifyToken(cst) : stringifyItem(cst);
	function stringifyToken(token) {
		switch (token.type) {
			case "block-scalar": {
				let res = "";
				for (const tok of token.props) res += stringifyToken(tok);
				return res + token.source;
			}
			case "block-map":
			case "block-seq": {
				let res = "";
				for (const item of token.items) res += stringifyItem(item);
				return res;
			}
			case "flow-collection": {
				let res = token.start.source;
				for (const item of token.items) res += stringifyItem(item);
				for (const st2 of token.end) res += st2.source;
				return res;
			}
			case "document": {
				let res = stringifyItem(token);
				if (token.end) for (const st2 of token.end) res += st2.source;
				return res;
			}
			default: {
				let res = token.source;
				if ("end" in token && token.end) for (const st2 of token.end) res += st2.source;
				return res;
			}
		}
	}
	function stringifyItem({ start, key, sep, value }) {
		let res = "";
		for (const st2 of start) res += st2.source;
		if (key) res += stringifyToken(key);
		if (sep) for (const st2 of sep) res += st2.source;
		if (value) res += stringifyToken(value);
		return res;
	}
	var BREAK2 = Symbol("break visit");
	var SKIP2 = Symbol("skip children");
	var REMOVE2 = Symbol("remove item");
	function visit2(cst, visitor) {
		if ("type" in cst && cst.type === "document") cst = {
			start: cst.start,
			value: cst.value
		};
		_visit(Object.freeze([]), cst, visitor);
	}
	visit2.BREAK = BREAK2;
	visit2.SKIP = SKIP2;
	visit2.REMOVE = REMOVE2;
	visit2.itemAtPath = (cst, path3) => {
		let item = cst;
		for (const [field, index] of path3) {
			const tok = item == null ? void 0 : item[field];
			if (tok && "items" in tok) item = tok.items[index];
			else return void 0;
		}
		return item;
	};
	visit2.parentCollection = (cst, path3) => {
		const parent = visit2.itemAtPath(cst, path3.slice(0, -1));
		const field = path3[path3.length - 1][0];
		const coll = parent == null ? void 0 : parent[field];
		if (coll && "items" in coll) return coll;
		throw new Error("Parent collection not found");
	};
	function _visit(path3, item, visitor) {
		let ctrl = visitor(item, path3);
		if (typeof ctrl === "symbol") return ctrl;
		for (const field of ["key", "value"]) {
			const token = item[field];
			if (token && "items" in token) {
				for (let i = 0; i < token.items.length; ++i) {
					const ci2 = _visit(Object.freeze(path3.concat([[field, i]])), token.items[i], visitor);
					if (typeof ci2 === "number") i = ci2 - 1;
					else if (ci2 === BREAK2) return BREAK2;
					else if (ci2 === REMOVE2) {
						token.items.splice(i, 1);
						i -= 1;
					}
				}
				if (typeof ctrl === "function" && field === "key") ctrl = ctrl(item, path3);
			}
		}
		return typeof ctrl === "function" ? ctrl(item, path3) : ctrl;
	}
	var BOM = "";
	var DOCUMENT = "";
	var FLOW_END = "";
	var SCALAR2 = "";
	var isCollection2 = (token) => !!token && "items" in token;
	var isScalar2 = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
	function prettyToken(token) {
		switch (token) {
			case BOM: return "<BOM>";
			case DOCUMENT: return "<DOC>";
			case FLOW_END: return "<FLOW_END>";
			case SCALAR2: return "<SCALAR>";
			default: return JSON.stringify(token);
		}
	}
	function tokenType(source) {
		switch (source) {
			case BOM: return "byte-order-mark";
			case DOCUMENT: return "doc-mode";
			case FLOW_END: return "flow-error-end";
			case SCALAR2: return "scalar";
			case "---": return "doc-start";
			case "...": return "doc-end";
			case "":
			case "\n":
			case "\r\n": return "newline";
			case "-": return "seq-item-ind";
			case "?": return "explicit-key-ind";
			case ":": return "map-value-ind";
			case "{": return "flow-map-start";
			case "}": return "flow-map-end";
			case "[": return "flow-seq-start";
			case "]": return "flow-seq-end";
			case ",": return "comma";
		}
		switch (source[0]) {
			case " ":
			case "	": return "space";
			case "#": return "comment";
			case "%": return "directive-line";
			case "*": return "alias";
			case "&": return "anchor";
			case "!": return "tag";
			case "'": return "single-quoted-scalar";
			case "\"": return "double-quoted-scalar";
			case "|":
			case ">": return "block-scalar-header";
		}
		return null;
	}
	function isEmpty(ch) {
		switch (ch) {
			case void 0:
			case " ":
			case "\n":
			case "\r":
			case "	": return true;
			default: return false;
		}
	}
	var hexDigits = /* @__PURE__ */ new Set("0123456789ABCDEFabcdef");
	var tagChars = /* @__PURE__ */ new Set("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()");
	var flowIndicatorChars = /* @__PURE__ */ new Set(",[]{}");
	var invalidAnchorChars = /* @__PURE__ */ new Set(" ,[]{}\n\r	");
	var isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);
	var Lexer = class {
		constructor() {
			this.atEnd = false;
			this.blockScalarIndent = -1;
			this.blockScalarKeep = false;
			this.buffer = "";
			this.flowKey = false;
			this.flowLevel = 0;
			this.indentNext = 0;
			this.indentValue = 0;
			this.lineEndPos = null;
			this.next = null;
			this.pos = 0;
		}
		/**
		* Generate YAML tokens from the `source` string. If `incomplete`,
		* a part of the last line may be left as a buffer for the next call.
		*
		* @returns A generator of lexical tokens
		*/
		*lex(source, incomplete = false) {
			var _a2;
			if (source) {
				if (typeof source !== "string") throw TypeError("source is not a string");
				this.buffer = this.buffer ? this.buffer + source : source;
				this.lineEndPos = null;
			}
			this.atEnd = !incomplete;
			let next = (_a2 = this.next) != null ? _a2 : "stream";
			while (next && (incomplete || this.hasChars(1))) next = yield* __yieldStar(this.parseNext(next));
		}
		atLineEnd() {
			let i = this.pos;
			let ch = this.buffer[i];
			while (ch === " " || ch === "	") ch = this.buffer[++i];
			if (!ch || ch === "#" || ch === "\n") return true;
			if (ch === "\r") return this.buffer[i + 1] === "\n";
			return false;
		}
		charAt(n4) {
			return this.buffer[this.pos + n4];
		}
		continueScalar(offset) {
			let ch = this.buffer[offset];
			if (this.indentNext > 0) {
				let indent = 0;
				while (ch === " ") ch = this.buffer[++indent + offset];
				if (ch === "\r") {
					const next = this.buffer[indent + offset + 1];
					if (next === "\n" || !next && !this.atEnd) return offset + indent + 1;
				}
				return ch === "\n" || indent >= this.indentNext || !ch && !this.atEnd ? offset + indent : -1;
			}
			if (ch === "-" || ch === ".") {
				const dt2 = this.buffer.substr(offset, 3);
				if ((dt2 === "---" || dt2 === "...") && isEmpty(this.buffer[offset + 3])) return -1;
			}
			return offset;
		}
		getLine() {
			let end = this.lineEndPos;
			if (typeof end !== "number" || end !== -1 && end < this.pos) {
				end = this.buffer.indexOf("\n", this.pos);
				this.lineEndPos = end;
			}
			if (end === -1) return this.atEnd ? this.buffer.substring(this.pos) : null;
			if (this.buffer[end - 1] === "\r") end -= 1;
			return this.buffer.substring(this.pos, end);
		}
		hasChars(n4) {
			return this.pos + n4 <= this.buffer.length;
		}
		setNext(state) {
			this.buffer = this.buffer.substring(this.pos);
			this.pos = 0;
			this.lineEndPos = null;
			this.next = state;
			return null;
		}
		peek(n4) {
			return this.buffer.substr(this.pos, n4);
		}
		*parseNext(next) {
			switch (next) {
				case "stream": return yield* __yieldStar(this.parseStream());
				case "line-start": return yield* __yieldStar(this.parseLineStart());
				case "block-start": return yield* __yieldStar(this.parseBlockStart());
				case "doc": return yield* __yieldStar(this.parseDocument());
				case "flow": return yield* __yieldStar(this.parseFlowCollection());
				case "quoted-scalar": return yield* __yieldStar(this.parseQuotedScalar());
				case "block-scalar": return yield* __yieldStar(this.parseBlockScalar());
				case "plain-scalar": return yield* __yieldStar(this.parsePlainScalar());
			}
		}
		*parseStream() {
			let line = this.getLine();
			if (line === null) return this.setNext("stream");
			if (line[0] === BOM) {
				yield* __yieldStar(this.pushCount(1));
				line = line.substring(1);
			}
			if (line[0] === "%") {
				let dirEnd = line.length;
				let cs = line.indexOf("#");
				while (cs !== -1) {
					const ch = line[cs - 1];
					if (ch === " " || ch === "	") {
						dirEnd = cs - 1;
						break;
					} else cs = line.indexOf("#", cs + 1);
				}
				while (true) {
					const ch = line[dirEnd - 1];
					if (ch === " " || ch === "	") dirEnd -= 1;
					else break;
				}
				const n4 = (yield* __yieldStar(this.pushCount(dirEnd))) + (yield* __yieldStar(this.pushSpaces(true)));
				yield* __yieldStar(this.pushCount(line.length - n4));
				this.pushNewline();
				return "stream";
			}
			if (this.atLineEnd()) {
				const sp = yield* __yieldStar(this.pushSpaces(true));
				yield* __yieldStar(this.pushCount(line.length - sp));
				yield* __yieldStar(this.pushNewline());
				return "stream";
			}
			yield DOCUMENT;
			return yield* __yieldStar(this.parseLineStart());
		}
		*parseLineStart() {
			const ch = this.charAt(0);
			if (!ch && !this.atEnd) return this.setNext("line-start");
			if (ch === "-" || ch === ".") {
				if (!this.atEnd && !this.hasChars(4)) return this.setNext("line-start");
				const s = this.peek(3);
				if ((s === "---" || s === "...") && isEmpty(this.charAt(3))) {
					yield* __yieldStar(this.pushCount(3));
					this.indentValue = 0;
					this.indentNext = 0;
					return s === "---" ? "doc" : "stream";
				}
			}
			this.indentValue = yield* __yieldStar(this.pushSpaces(false));
			if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1))) this.indentNext = this.indentValue;
			return yield* __yieldStar(this.parseBlockStart());
		}
		*parseBlockStart() {
			const [ch0, ch1] = this.peek(2);
			if (!ch1 && !this.atEnd) return this.setNext("block-start");
			if ((ch0 === "-" || ch0 === "?" || ch0 === ":") && isEmpty(ch1)) {
				const n4 = (yield* __yieldStar(this.pushCount(1))) + (yield* __yieldStar(this.pushSpaces(true)));
				this.indentNext = this.indentValue + 1;
				this.indentValue += n4;
				return yield* __yieldStar(this.parseBlockStart());
			}
			return "doc";
		}
		*parseDocument() {
			yield* __yieldStar(this.pushSpaces(true));
			const line = this.getLine();
			if (line === null) return this.setNext("doc");
			let n4 = yield* __yieldStar(this.pushIndicators());
			switch (line[n4]) {
				case "#": yield* __yieldStar(this.pushCount(line.length - n4));
				case void 0:
					yield* __yieldStar(this.pushNewline());
					return yield* __yieldStar(this.parseLineStart());
				case "{":
				case "[":
					yield* __yieldStar(this.pushCount(1));
					this.flowKey = false;
					this.flowLevel = 1;
					return "flow";
				case "}":
				case "]":
					yield* __yieldStar(this.pushCount(1));
					return "doc";
				case "*":
					yield* __yieldStar(this.pushUntil(isNotAnchorChar));
					return "doc";
				case "\"":
				case "'": return yield* __yieldStar(this.parseQuotedScalar());
				case "|":
				case ">":
					n4 += yield* __yieldStar(this.parseBlockScalarHeader());
					n4 += yield* __yieldStar(this.pushSpaces(true));
					yield* __yieldStar(this.pushCount(line.length - n4));
					yield* __yieldStar(this.pushNewline());
					return yield* __yieldStar(this.parseBlockScalar());
				default: return yield* __yieldStar(this.parsePlainScalar());
			}
		}
		*parseFlowCollection() {
			let nl2, sp;
			let indent = -1;
			do {
				nl2 = yield* __yieldStar(this.pushNewline());
				if (nl2 > 0) {
					sp = yield* __yieldStar(this.pushSpaces(false));
					this.indentValue = indent = sp;
				} else sp = 0;
				sp += yield* __yieldStar(this.pushSpaces(true));
			} while (nl2 + sp > 0);
			const line = this.getLine();
			if (line === null) return this.setNext("flow");
			if (indent !== -1 && indent < this.indentNext && line[0] !== "#" || indent === 0 && (line.startsWith("---") || line.startsWith("...")) && isEmpty(line[3])) {
				if (!(indent === this.indentNext - 1 && this.flowLevel === 1 && (line[0] === "]" || line[0] === "}"))) {
					this.flowLevel = 0;
					yield FLOW_END;
					return yield* __yieldStar(this.parseLineStart());
				}
			}
			let n4 = 0;
			while (line[n4] === ",") {
				n4 += yield* __yieldStar(this.pushCount(1));
				n4 += yield* __yieldStar(this.pushSpaces(true));
				this.flowKey = false;
			}
			n4 += yield* __yieldStar(this.pushIndicators());
			switch (line[n4]) {
				case void 0: return "flow";
				case "#":
					yield* __yieldStar(this.pushCount(line.length - n4));
					return "flow";
				case "{":
				case "[":
					yield* __yieldStar(this.pushCount(1));
					this.flowKey = false;
					this.flowLevel += 1;
					return "flow";
				case "}":
				case "]":
					yield* __yieldStar(this.pushCount(1));
					this.flowKey = true;
					this.flowLevel -= 1;
					return this.flowLevel ? "flow" : "doc";
				case "*":
					yield* __yieldStar(this.pushUntil(isNotAnchorChar));
					return "flow";
				case "\"":
				case "'":
					this.flowKey = true;
					return yield* __yieldStar(this.parseQuotedScalar());
				case ":": {
					const next = this.charAt(1);
					if (this.flowKey || isEmpty(next) || next === ",") {
						this.flowKey = false;
						yield* __yieldStar(this.pushCount(1));
						yield* __yieldStar(this.pushSpaces(true));
						return "flow";
					}
				}
				default:
					this.flowKey = false;
					return yield* __yieldStar(this.parsePlainScalar());
			}
		}
		*parseQuotedScalar() {
			const quote = this.charAt(0);
			let end = this.buffer.indexOf(quote, this.pos + 1);
			if (quote === "'") while (end !== -1 && this.buffer[end + 1] === "'") end = this.buffer.indexOf("'", end + 2);
			else while (end !== -1) {
				let n4 = 0;
				while (this.buffer[end - 1 - n4] === "\\") n4 += 1;
				if (n4 % 2 === 0) break;
				end = this.buffer.indexOf("\"", end + 1);
			}
			const qb = this.buffer.substring(0, end);
			let nl2 = qb.indexOf("\n", this.pos);
			if (nl2 !== -1) {
				while (nl2 !== -1) {
					const cs = this.continueScalar(nl2 + 1);
					if (cs === -1) break;
					nl2 = qb.indexOf("\n", cs);
				}
				if (nl2 !== -1) end = nl2 - (qb[nl2 - 1] === "\r" ? 2 : 1);
			}
			if (end === -1) {
				if (!this.atEnd) return this.setNext("quoted-scalar");
				end = this.buffer.length;
			}
			yield* __yieldStar(this.pushToIndex(end + 1, false));
			return this.flowLevel ? "flow" : "doc";
		}
		*parseBlockScalarHeader() {
			this.blockScalarIndent = -1;
			this.blockScalarKeep = false;
			let i = this.pos;
			while (true) {
				const ch = this.buffer[++i];
				if (ch === "+") this.blockScalarKeep = true;
				else if (ch > "0" && ch <= "9") this.blockScalarIndent = Number(ch) - 1;
				else if (ch !== "-") break;
			}
			return yield* __yieldStar(this.pushUntil((ch) => isEmpty(ch) || ch === "#"));
		}
		*parseBlockScalar() {
			let nl2 = this.pos - 1;
			let indent = 0;
			let ch;
			loop: for (let i2 = this.pos; ch = this.buffer[i2]; ++i2) switch (ch) {
				case " ":
					indent += 1;
					break;
				case "\n":
					nl2 = i2;
					indent = 0;
					break;
				case "\r": {
					const next = this.buffer[i2 + 1];
					if (!next && !this.atEnd) return this.setNext("block-scalar");
					if (next === "\n") break;
				}
				default: break loop;
			}
			if (!ch && !this.atEnd) return this.setNext("block-scalar");
			if (indent >= this.indentNext) {
				if (this.blockScalarIndent === -1) this.indentNext = indent;
				else this.indentNext = this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext);
				do {
					const cs = this.continueScalar(nl2 + 1);
					if (cs === -1) break;
					nl2 = this.buffer.indexOf("\n", cs);
				} while (nl2 !== -1);
				if (nl2 === -1) {
					if (!this.atEnd) return this.setNext("block-scalar");
					nl2 = this.buffer.length;
				}
			}
			let i = nl2 + 1;
			ch = this.buffer[i];
			while (ch === " ") ch = this.buffer[++i];
			if (ch === "	") {
				while (ch === "	" || ch === " " || ch === "\r" || ch === "\n") ch = this.buffer[++i];
				nl2 = i - 1;
			} else if (!this.blockScalarKeep) do {
				let i2 = nl2 - 1;
				let ch2 = this.buffer[i2];
				if (ch2 === "\r") ch2 = this.buffer[--i2];
				const lastChar = i2;
				while (ch2 === " ") ch2 = this.buffer[--i2];
				if (ch2 === "\n" && i2 >= this.pos && i2 + 1 + indent > lastChar) nl2 = i2;
				else break;
			} while (true);
			yield SCALAR2;
			yield* __yieldStar(this.pushToIndex(nl2 + 1, true));
			return yield* __yieldStar(this.parseLineStart());
		}
		*parsePlainScalar() {
			const inFlow = this.flowLevel > 0;
			let end = this.pos - 1;
			let i = this.pos - 1;
			let ch;
			while (ch = this.buffer[++i]) if (ch === ":") {
				const next = this.buffer[i + 1];
				if (isEmpty(next) || inFlow && flowIndicatorChars.has(next)) break;
				end = i;
			} else if (isEmpty(ch)) {
				let next = this.buffer[i + 1];
				if (ch === "\r") if (next === "\n") {
					i += 1;
					ch = "\n";
					next = this.buffer[i + 1];
				} else end = i;
				if (next === "#" || inFlow && flowIndicatorChars.has(next)) break;
				if (ch === "\n") {
					const cs = this.continueScalar(i + 1);
					if (cs === -1) break;
					i = Math.max(i, cs - 2);
				}
			} else {
				if (inFlow && flowIndicatorChars.has(ch)) break;
				end = i;
			}
			if (!ch && !this.atEnd) return this.setNext("plain-scalar");
			yield SCALAR2;
			yield* __yieldStar(this.pushToIndex(end + 1, true));
			return inFlow ? "flow" : "doc";
		}
		*pushCount(n4) {
			if (n4 > 0) {
				yield this.buffer.substr(this.pos, n4);
				this.pos += n4;
				return n4;
			}
			return 0;
		}
		*pushToIndex(i, allowEmpty) {
			const s = this.buffer.slice(this.pos, i);
			if (s) {
				yield s;
				this.pos += s.length;
				return s.length;
			} else if (allowEmpty) yield "";
			return 0;
		}
		*pushIndicators() {
			switch (this.charAt(0)) {
				case "!": return (yield* __yieldStar(this.pushTag())) + (yield* __yieldStar(this.pushSpaces(true))) + (yield* __yieldStar(this.pushIndicators()));
				case "&": return (yield* __yieldStar(this.pushUntil(isNotAnchorChar))) + (yield* __yieldStar(this.pushSpaces(true))) + (yield* __yieldStar(this.pushIndicators()));
				case "-":
				case "?":
				case ":": {
					const inFlow = this.flowLevel > 0;
					const ch1 = this.charAt(1);
					if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
						if (!inFlow) this.indentNext = this.indentValue + 1;
						else if (this.flowKey) this.flowKey = false;
						return (yield* __yieldStar(this.pushCount(1))) + (yield* __yieldStar(this.pushSpaces(true))) + (yield* __yieldStar(this.pushIndicators()));
					}
				}
			}
			return 0;
		}
		*pushTag() {
			if (this.charAt(1) === "<") {
				let i = this.pos + 2;
				let ch = this.buffer[i];
				while (!isEmpty(ch) && ch !== ">") ch = this.buffer[++i];
				return yield* __yieldStar(this.pushToIndex(ch === ">" ? i + 1 : i, false));
			} else {
				let i = this.pos + 1;
				let ch = this.buffer[i];
				while (ch) if (tagChars.has(ch)) ch = this.buffer[++i];
				else if (ch === "%" && hexDigits.has(this.buffer[i + 1]) && hexDigits.has(this.buffer[i + 2])) ch = this.buffer[i += 3];
				else break;
				return yield* __yieldStar(this.pushToIndex(i, false));
			}
		}
		*pushNewline() {
			const ch = this.buffer[this.pos];
			if (ch === "\n") return yield* __yieldStar(this.pushCount(1));
			else if (ch === "\r" && this.charAt(1) === "\n") return yield* __yieldStar(this.pushCount(2));
			else return 0;
		}
		*pushSpaces(allowTabs) {
			let i = this.pos - 1;
			let ch;
			do
				ch = this.buffer[++i];
			while (ch === " " || allowTabs && ch === "	");
			const n4 = i - this.pos;
			if (n4 > 0) {
				yield this.buffer.substr(this.pos, n4);
				this.pos = i;
			}
			return n4;
		}
		*pushUntil(test) {
			let i = this.pos;
			let ch = this.buffer[i];
			while (!test(ch)) ch = this.buffer[++i];
			return yield* __yieldStar(this.pushToIndex(i, false));
		}
	};
	var LineCounter = class {
		constructor() {
			this.lineStarts = [];
			this.addNewLine = (offset) => this.lineStarts.push(offset);
			this.linePos = (offset) => {
				let low = 0;
				let high = this.lineStarts.length;
				while (low < high) {
					const mid = low + high >> 1;
					if (this.lineStarts[mid] < offset) low = mid + 1;
					else high = mid;
				}
				if (this.lineStarts[low] === offset) return {
					line: low + 1,
					col: 1
				};
				if (low === 0) return {
					line: 0,
					col: offset
				};
				const start = this.lineStarts[low - 1];
				return {
					line: low,
					col: offset - start + 1
				};
			};
		}
	};
	function includesToken(list, type) {
		for (let i = 0; i < list.length; ++i) if (list[i].type === type) return true;
		return false;
	}
	function findNonEmptyIndex(list) {
		for (let i = 0; i < list.length; ++i) switch (list[i].type) {
			case "space":
			case "comment":
			case "newline": break;
			default: return i;
		}
		return -1;
	}
	function isFlowToken(token) {
		switch (token == null ? void 0 : token.type) {
			case "alias":
			case "scalar":
			case "single-quoted-scalar":
			case "double-quoted-scalar":
			case "flow-collection": return true;
			default: return false;
		}
	}
	function getPrevProps(parent) {
		var _a2;
		switch (parent.type) {
			case "document": return parent.start;
			case "block-map": {
				const it = parent.items[parent.items.length - 1];
				return (_a2 = it.sep) != null ? _a2 : it.start;
			}
			case "block-seq": return parent.items[parent.items.length - 1].start;
			default: return [];
		}
	}
	function getFirstKeyStartProps(prev) {
		var _a2;
		if (prev.length === 0) return [];
		let i = prev.length;
		loop: while (--i >= 0) switch (prev[i].type) {
			case "doc-start":
			case "explicit-key-ind":
			case "map-value-ind":
			case "seq-item-ind":
			case "newline": break loop;
		}
		while (((_a2 = prev[++i]) == null ? void 0 : _a2.type) === "space");
		return prev.splice(i, prev.length);
	}
	function fixFlowSeqItems(fc) {
		if (fc.start.type === "flow-seq-start") {
			for (const it of fc.items) if (it.sep && !it.value && !includesToken(it.start, "explicit-key-ind") && !includesToken(it.sep, "map-value-ind")) {
				if (it.key) it.value = it.key;
				delete it.key;
				if (isFlowToken(it.value)) if (it.value.end) Array.prototype.push.apply(it.value.end, it.sep);
				else it.value.end = it.sep;
				else Array.prototype.push.apply(it.start, it.sep);
				delete it.sep;
			}
		}
	}
	var Parser = class {
		/**
		* @param onNewLine - If defined, called separately with the start position of
		*   each new line (in `parse()`, including the start of input).
		*/
		constructor(onNewLine) {
			this.atNewLine = true;
			this.atScalar = false;
			this.indent = 0;
			this.offset = 0;
			this.onKeyLine = false;
			this.stack = [];
			this.source = "";
			this.type = "";
			this.lexer = new Lexer();
			this.onNewLine = onNewLine;
		}
		/**
		* Parse `source` as a YAML stream.
		* If `incomplete`, a part of the last line may be left as a buffer for the next call.
		*
		* Errors are not thrown, but yielded as `{ type: 'error', message }` tokens.
		*
		* @returns A generator of tokens representing each directive, document, and other structure.
		*/
		*parse(source, incomplete = false) {
			if (this.onNewLine && this.offset === 0) this.onNewLine(0);
			for (const lexeme of this.lexer.lex(source, incomplete)) yield* __yieldStar(this.next(lexeme));
			if (!incomplete) yield* __yieldStar(this.end());
		}
		/**
		* Advance the parser by the `source` of one lexical token.
		*/
		*next(source) {
			this.source = source;
			if (this.atScalar) {
				this.atScalar = false;
				yield* __yieldStar(this.step());
				this.offset += source.length;
				return;
			}
			const type = tokenType(source);
			if (!type) {
				const message = `Not a YAML token: ${source}`;
				yield* __yieldStar(this.pop({
					type: "error",
					offset: this.offset,
					message,
					source
				}));
				this.offset += source.length;
			} else if (type === "scalar") {
				this.atNewLine = false;
				this.atScalar = true;
				this.type = "scalar";
			} else {
				this.type = type;
				yield* __yieldStar(this.step());
				switch (type) {
					case "newline":
						this.atNewLine = true;
						this.indent = 0;
						if (this.onNewLine) this.onNewLine(this.offset + source.length);
						break;
					case "space":
						if (this.atNewLine && source[0] === " ") this.indent += source.length;
						break;
					case "explicit-key-ind":
					case "map-value-ind":
					case "seq-item-ind":
						if (this.atNewLine) this.indent += source.length;
						break;
					case "doc-mode":
					case "flow-error-end": return;
					default: this.atNewLine = false;
				}
				this.offset += source.length;
			}
		}
		/** Call at end of input to push out any remaining constructions */
		*end() {
			while (this.stack.length > 0) yield* __yieldStar(this.pop());
		}
		get sourceToken() {
			return {
				type: this.type,
				offset: this.offset,
				indent: this.indent,
				source: this.source
			};
		}
		*step() {
			const top = this.peek(1);
			if (this.type === "doc-end" && (!top || top.type !== "doc-end")) {
				while (this.stack.length > 0) yield* __yieldStar(this.pop());
				this.stack.push({
					type: "doc-end",
					offset: this.offset,
					source: this.source
				});
				return;
			}
			if (!top) return yield* __yieldStar(this.stream());
			switch (top.type) {
				case "document": return yield* __yieldStar(this.document(top));
				case "alias":
				case "scalar":
				case "single-quoted-scalar":
				case "double-quoted-scalar": return yield* __yieldStar(this.scalar(top));
				case "block-scalar": return yield* __yieldStar(this.blockScalar(top));
				case "block-map": return yield* __yieldStar(this.blockMap(top));
				case "block-seq": return yield* __yieldStar(this.blockSequence(top));
				case "flow-collection": return yield* __yieldStar(this.flowCollection(top));
				case "doc-end": return yield* __yieldStar(this.documentEnd(top));
			}
			yield* __yieldStar(this.pop());
		}
		peek(n4) {
			return this.stack[this.stack.length - n4];
		}
		*pop(error) {
			const token = error != null ? error : this.stack.pop();
			if (!token) yield {
				type: "error",
				offset: this.offset,
				source: "",
				message: "Tried to pop an empty stack"
			};
			else if (this.stack.length === 0) yield token;
			else {
				const top = this.peek(1);
				if (token.type === "block-scalar") token.indent = "indent" in top ? top.indent : 0;
				else if (token.type === "flow-collection" && top.type === "document") token.indent = 0;
				if (token.type === "flow-collection") fixFlowSeqItems(token);
				switch (top.type) {
					case "document":
						top.value = token;
						break;
					case "block-scalar":
						top.props.push(token);
						break;
					case "block-map": {
						const it = top.items[top.items.length - 1];
						if (it.value) {
							top.items.push({
								start: [],
								key: token,
								sep: []
							});
							this.onKeyLine = true;
							return;
						} else if (it.sep) it.value = token;
						else {
							Object.assign(it, {
								key: token,
								sep: []
							});
							this.onKeyLine = !it.explicitKey;
							return;
						}
						break;
					}
					case "block-seq": {
						const it = top.items[top.items.length - 1];
						if (it.value) top.items.push({
							start: [],
							value: token
						});
						else it.value = token;
						break;
					}
					case "flow-collection": {
						const it = top.items[top.items.length - 1];
						if (!it || it.value) top.items.push({
							start: [],
							key: token,
							sep: []
						});
						else if (it.sep) it.value = token;
						else Object.assign(it, {
							key: token,
							sep: []
						});
						return;
					}
					default:
						yield* __yieldStar(this.pop());
						yield* __yieldStar(this.pop(token));
				}
				if ((top.type === "document" || top.type === "block-map" || top.type === "block-seq") && (token.type === "block-map" || token.type === "block-seq")) {
					const last = token.items[token.items.length - 1];
					if (last && !last.sep && !last.value && last.start.length > 0 && findNonEmptyIndex(last.start) === -1 && (token.indent === 0 || last.start.every((st2) => st2.type !== "comment" || st2.indent < token.indent))) {
						if (top.type === "document") top.end = last.start;
						else top.items.push({ start: last.start });
						token.items.splice(-1, 1);
					}
				}
			}
		}
		*stream() {
			switch (this.type) {
				case "directive-line":
					yield {
						type: "directive",
						offset: this.offset,
						source: this.source
					};
					return;
				case "byte-order-mark":
				case "space":
				case "comment":
				case "newline":
					yield this.sourceToken;
					return;
				case "doc-mode":
				case "doc-start": {
					const doc = {
						type: "document",
						offset: this.offset,
						start: []
					};
					if (this.type === "doc-start") doc.start.push(this.sourceToken);
					this.stack.push(doc);
					return;
				}
			}
			yield {
				type: "error",
				offset: this.offset,
				message: `Unexpected ${this.type} token in YAML stream`,
				source: this.source
			};
		}
		*document(doc) {
			if (doc.value) return yield* __yieldStar(this.lineEnd(doc));
			switch (this.type) {
				case "doc-start":
					if (findNonEmptyIndex(doc.start) !== -1) {
						yield* __yieldStar(this.pop());
						yield* __yieldStar(this.step());
					} else doc.start.push(this.sourceToken);
					return;
				case "anchor":
				case "tag":
				case "space":
				case "comment":
				case "newline":
					doc.start.push(this.sourceToken);
					return;
			}
			const bv = this.startBlockValue(doc);
			if (bv) this.stack.push(bv);
			else yield {
				type: "error",
				offset: this.offset,
				message: `Unexpected ${this.type} token in YAML document`,
				source: this.source
			};
		}
		*scalar(scalar) {
			if (this.type === "map-value-ind") {
				const start = getFirstKeyStartProps(getPrevProps(this.peek(2)));
				let sep;
				if (scalar.end) {
					sep = scalar.end;
					sep.push(this.sourceToken);
					delete scalar.end;
				} else sep = [this.sourceToken];
				const map2 = {
					type: "block-map",
					offset: scalar.offset,
					indent: scalar.indent,
					items: [{
						start,
						key: scalar,
						sep
					}]
				};
				this.onKeyLine = true;
				this.stack[this.stack.length - 1] = map2;
			} else yield* __yieldStar(this.lineEnd(scalar));
		}
		*blockScalar(scalar) {
			switch (this.type) {
				case "space":
				case "comment":
				case "newline":
					scalar.props.push(this.sourceToken);
					return;
				case "scalar":
					scalar.source = this.source;
					this.atNewLine = true;
					this.indent = 0;
					if (this.onNewLine) {
						let nl2 = this.source.indexOf("\n") + 1;
						while (nl2 !== 0) {
							this.onNewLine(this.offset + nl2);
							nl2 = this.source.indexOf("\n", nl2) + 1;
						}
					}
					yield* __yieldStar(this.pop());
					break;
				default:
					yield* __yieldStar(this.pop());
					yield* __yieldStar(this.step());
			}
		}
		*blockMap(map2) {
			var _a2;
			const it = map2.items[map2.items.length - 1];
			switch (this.type) {
				case "newline":
					this.onKeyLine = false;
					if (it.value) {
						const end = "end" in it.value ? it.value.end : void 0;
						const last = Array.isArray(end) ? end[end.length - 1] : void 0;
						if ((last == null ? void 0 : last.type) === "comment") end?.push(this.sourceToken);
						else map2.items.push({ start: [this.sourceToken] });
					} else if (it.sep) it.sep.push(this.sourceToken);
					else it.start.push(this.sourceToken);
					return;
				case "space":
				case "comment":
					if (it.value) map2.items.push({ start: [this.sourceToken] });
					else if (it.sep) it.sep.push(this.sourceToken);
					else {
						if (this.atIndentedComment(it.start, map2.indent)) {
							const prev = map2.items[map2.items.length - 2];
							const end = (_a2 = prev == null ? void 0 : prev.value) == null ? void 0 : _a2.end;
							if (Array.isArray(end)) {
								Array.prototype.push.apply(end, it.start);
								end.push(this.sourceToken);
								map2.items.pop();
								return;
							}
						}
						it.start.push(this.sourceToken);
					}
					return;
			}
			if (this.indent >= map2.indent) {
				const atMapIndent = !this.onKeyLine && this.indent === map2.indent;
				const atNextItem = atMapIndent && (it.sep || it.explicitKey) && this.type !== "seq-item-ind";
				let start = [];
				if (atNextItem && it.sep && !it.value) {
					const nl2 = [];
					for (let i = 0; i < it.sep.length; ++i) {
						const st2 = it.sep[i];
						switch (st2.type) {
							case "newline":
								nl2.push(i);
								break;
							case "space": break;
							case "comment":
								if (st2.indent > map2.indent) nl2.length = 0;
								break;
							default: nl2.length = 0;
						}
					}
					if (nl2.length >= 2) start = it.sep.splice(nl2[1]);
				}
				switch (this.type) {
					case "anchor":
					case "tag":
						if (atNextItem || it.value) {
							start.push(this.sourceToken);
							map2.items.push({ start });
							this.onKeyLine = true;
						} else if (it.sep) it.sep.push(this.sourceToken);
						else it.start.push(this.sourceToken);
						return;
					case "explicit-key-ind":
						if (!it.sep && !it.explicitKey) {
							it.start.push(this.sourceToken);
							it.explicitKey = true;
						} else if (atNextItem || it.value) {
							start.push(this.sourceToken);
							map2.items.push({
								start,
								explicitKey: true
							});
						} else this.stack.push({
							type: "block-map",
							offset: this.offset,
							indent: this.indent,
							items: [{
								start: [this.sourceToken],
								explicitKey: true
							}]
						});
						this.onKeyLine = true;
						return;
					case "map-value-ind":
						if (it.explicitKey) if (!it.sep) if (includesToken(it.start, "newline")) Object.assign(it, {
							key: null,
							sep: [this.sourceToken]
						});
						else {
							const start2 = getFirstKeyStartProps(it.start);
							this.stack.push({
								type: "block-map",
								offset: this.offset,
								indent: this.indent,
								items: [{
									start: start2,
									key: null,
									sep: [this.sourceToken]
								}]
							});
						}
						else if (it.value) map2.items.push({
							start: [],
							key: null,
							sep: [this.sourceToken]
						});
						else if (includesToken(it.sep, "map-value-ind")) this.stack.push({
							type: "block-map",
							offset: this.offset,
							indent: this.indent,
							items: [{
								start,
								key: null,
								sep: [this.sourceToken]
							}]
						});
						else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
							const start2 = getFirstKeyStartProps(it.start);
							const key = it.key;
							const sep = it.sep;
							sep.push(this.sourceToken);
							delete it.key;
							delete it.sep;
							this.stack.push({
								type: "block-map",
								offset: this.offset,
								indent: this.indent,
								items: [{
									start: start2,
									key,
									sep
								}]
							});
						} else if (start.length > 0) it.sep = it.sep.concat(start, this.sourceToken);
						else it.sep.push(this.sourceToken);
						else if (!it.sep) Object.assign(it, {
							key: null,
							sep: [this.sourceToken]
						});
						else if (it.value || atNextItem) map2.items.push({
							start,
							key: null,
							sep: [this.sourceToken]
						});
						else if (includesToken(it.sep, "map-value-ind")) this.stack.push({
							type: "block-map",
							offset: this.offset,
							indent: this.indent,
							items: [{
								start: [],
								key: null,
								sep: [this.sourceToken]
							}]
						});
						else it.sep.push(this.sourceToken);
						this.onKeyLine = true;
						return;
					case "alias":
					case "scalar":
					case "single-quoted-scalar":
					case "double-quoted-scalar": {
						const fs6 = this.flowScalar(this.type);
						if (atNextItem || it.value) {
							map2.items.push({
								start,
								key: fs6,
								sep: []
							});
							this.onKeyLine = true;
						} else if (it.sep) this.stack.push(fs6);
						else {
							Object.assign(it, {
								key: fs6,
								sep: []
							});
							this.onKeyLine = true;
						}
						return;
					}
					default: {
						const bv = this.startBlockValue(map2);
						if (bv) {
							if (bv.type === "block-seq") {
								if (!it.explicitKey && it.sep && !includesToken(it.sep, "newline")) {
									yield* __yieldStar(this.pop({
										type: "error",
										offset: this.offset,
										message: "Unexpected block-seq-ind on same line with key",
										source: this.source
									}));
									return;
								}
							} else if (atMapIndent) map2.items.push({ start });
							this.stack.push(bv);
							return;
						}
					}
				}
			}
			yield* __yieldStar(this.pop());
			yield* __yieldStar(this.step());
		}
		*blockSequence(seq2) {
			var _a2;
			const it = seq2.items[seq2.items.length - 1];
			switch (this.type) {
				case "newline":
					if (it.value) {
						const end = "end" in it.value ? it.value.end : void 0;
						const last = Array.isArray(end) ? end[end.length - 1] : void 0;
						if ((last == null ? void 0 : last.type) === "comment") end?.push(this.sourceToken);
						else seq2.items.push({ start: [this.sourceToken] });
					} else it.start.push(this.sourceToken);
					return;
				case "space":
				case "comment":
					if (it.value) seq2.items.push({ start: [this.sourceToken] });
					else {
						if (this.atIndentedComment(it.start, seq2.indent)) {
							const prev = seq2.items[seq2.items.length - 2];
							const end = (_a2 = prev == null ? void 0 : prev.value) == null ? void 0 : _a2.end;
							if (Array.isArray(end)) {
								Array.prototype.push.apply(end, it.start);
								end.push(this.sourceToken);
								seq2.items.pop();
								return;
							}
						}
						it.start.push(this.sourceToken);
					}
					return;
				case "anchor":
				case "tag":
					if (it.value || this.indent <= seq2.indent) break;
					it.start.push(this.sourceToken);
					return;
				case "seq-item-ind":
					if (this.indent !== seq2.indent) break;
					if (it.value || includesToken(it.start, "seq-item-ind")) seq2.items.push({ start: [this.sourceToken] });
					else it.start.push(this.sourceToken);
					return;
			}
			if (this.indent > seq2.indent) {
				const bv = this.startBlockValue(seq2);
				if (bv) {
					this.stack.push(bv);
					return;
				}
			}
			yield* __yieldStar(this.pop());
			yield* __yieldStar(this.step());
		}
		*flowCollection(fc) {
			const it = fc.items[fc.items.length - 1];
			if (this.type === "flow-error-end") {
				let top;
				do {
					yield* __yieldStar(this.pop());
					top = this.peek(1);
				} while (top && top.type === "flow-collection");
			} else if (fc.end.length === 0) {
				switch (this.type) {
					case "comma":
					case "explicit-key-ind":
						if (!it || it.sep) fc.items.push({ start: [this.sourceToken] });
						else it.start.push(this.sourceToken);
						return;
					case "map-value-ind":
						if (!it || it.value) fc.items.push({
							start: [],
							key: null,
							sep: [this.sourceToken]
						});
						else if (it.sep) it.sep.push(this.sourceToken);
						else Object.assign(it, {
							key: null,
							sep: [this.sourceToken]
						});
						return;
					case "space":
					case "comment":
					case "newline":
					case "anchor":
					case "tag":
						if (!it || it.value) fc.items.push({ start: [this.sourceToken] });
						else if (it.sep) it.sep.push(this.sourceToken);
						else it.start.push(this.sourceToken);
						return;
					case "alias":
					case "scalar":
					case "single-quoted-scalar":
					case "double-quoted-scalar": {
						const fs6 = this.flowScalar(this.type);
						if (!it || it.value) fc.items.push({
							start: [],
							key: fs6,
							sep: []
						});
						else if (it.sep) this.stack.push(fs6);
						else Object.assign(it, {
							key: fs6,
							sep: []
						});
						return;
					}
					case "flow-map-end":
					case "flow-seq-end":
						fc.end.push(this.sourceToken);
						return;
				}
				const bv = this.startBlockValue(fc);
				if (bv) this.stack.push(bv);
				else {
					yield* __yieldStar(this.pop());
					yield* __yieldStar(this.step());
				}
			} else {
				const parent = this.peek(2);
				if (parent.type === "block-map" && (this.type === "map-value-ind" && parent.indent === fc.indent || this.type === "newline" && !parent.items[parent.items.length - 1].sep)) {
					yield* __yieldStar(this.pop());
					yield* __yieldStar(this.step());
				} else if (this.type === "map-value-ind" && parent.type !== "flow-collection") {
					const start = getFirstKeyStartProps(getPrevProps(parent));
					fixFlowSeqItems(fc);
					const sep = fc.end.splice(1, fc.end.length);
					sep.push(this.sourceToken);
					const map2 = {
						type: "block-map",
						offset: fc.offset,
						indent: fc.indent,
						items: [{
							start,
							key: fc,
							sep
						}]
					};
					this.onKeyLine = true;
					this.stack[this.stack.length - 1] = map2;
				} else yield* __yieldStar(this.lineEnd(fc));
			}
		}
		flowScalar(type) {
			if (this.onNewLine) {
				let nl2 = this.source.indexOf("\n") + 1;
				while (nl2 !== 0) {
					this.onNewLine(this.offset + nl2);
					nl2 = this.source.indexOf("\n", nl2) + 1;
				}
			}
			return {
				type,
				offset: this.offset,
				indent: this.indent,
				source: this.source
			};
		}
		startBlockValue(parent) {
			switch (this.type) {
				case "alias":
				case "scalar":
				case "single-quoted-scalar":
				case "double-quoted-scalar": return this.flowScalar(this.type);
				case "block-scalar-header": return {
					type: "block-scalar",
					offset: this.offset,
					indent: this.indent,
					props: [this.sourceToken],
					source: ""
				};
				case "flow-map-start":
				case "flow-seq-start": return {
					type: "flow-collection",
					offset: this.offset,
					indent: this.indent,
					start: this.sourceToken,
					items: [],
					end: []
				};
				case "seq-item-ind": return {
					type: "block-seq",
					offset: this.offset,
					indent: this.indent,
					items: [{ start: [this.sourceToken] }]
				};
				case "explicit-key-ind": {
					this.onKeyLine = true;
					const start = getFirstKeyStartProps(getPrevProps(parent));
					start.push(this.sourceToken);
					return {
						type: "block-map",
						offset: this.offset,
						indent: this.indent,
						items: [{
							start,
							explicitKey: true
						}]
					};
				}
				case "map-value-ind": {
					this.onKeyLine = true;
					const start = getFirstKeyStartProps(getPrevProps(parent));
					return {
						type: "block-map",
						offset: this.offset,
						indent: this.indent,
						items: [{
							start,
							key: null,
							sep: [this.sourceToken]
						}]
					};
				}
			}
			return null;
		}
		atIndentedComment(start, indent) {
			if (this.type !== "comment") return false;
			if (this.indent <= indent) return false;
			return start.every((st2) => st2.type === "newline" || st2.type === "space");
		}
		*documentEnd(docEnd) {
			if (this.type !== "doc-mode") {
				if (docEnd.end) docEnd.end.push(this.sourceToken);
				else docEnd.end = [this.sourceToken];
				if (this.type === "newline") yield* __yieldStar(this.pop());
			}
		}
		*lineEnd(token) {
			switch (this.type) {
				case "comma":
				case "doc-start":
				case "doc-end":
				case "flow-seq-end":
				case "flow-map-end":
				case "map-value-ind":
					yield* __yieldStar(this.pop());
					yield* __yieldStar(this.step());
					break;
				case "newline": this.onKeyLine = false;
				default:
					if (token.end) token.end.push(this.sourceToken);
					else token.end = [this.sourceToken];
					if (this.type === "newline") yield* __yieldStar(this.pop());
			}
		}
	};
	function parseOptions(options) {
		const prettyErrors = options.prettyErrors !== false;
		return {
			lineCounter: options.lineCounter || prettyErrors && new LineCounter() || null,
			prettyErrors
		};
	}
	function parseAllDocuments(source, options = {}) {
		const { lineCounter, prettyErrors } = parseOptions(options);
		const parser = new Parser(lineCounter == null ? void 0 : lineCounter.addNewLine);
		const composer = new Composer(options);
		const docs = Array.from(composer.compose(parser.parse(source)));
		if (prettyErrors && lineCounter) for (const doc of docs) {
			doc.errors.forEach(prettifyError(source, lineCounter));
			doc.warnings.forEach(prettifyError(source, lineCounter));
		}
		if (docs.length > 0) return docs;
		return Object.assign([], { empty: true }, composer.streamInfo());
	}
	function parseDocument(source, options = {}) {
		const { lineCounter, prettyErrors } = parseOptions(options);
		const parser = new Parser(lineCounter == null ? void 0 : lineCounter.addNewLine);
		const composer = new Composer(options);
		let doc = null;
		for (const _doc of composer.compose(parser.parse(source), true, source.length)) if (!doc) doc = _doc;
		else if (doc.options.logLevel !== "silent") {
			doc.errors.push(new YAMLParseError(_doc.range.slice(0, 2), "MULTIPLE_DOCS", "Source contains multiple documents; please use YAML.parseAllDocuments()"));
			break;
		}
		if (prettyErrors && lineCounter) {
			doc.errors.forEach(prettifyError(source, lineCounter));
			doc.warnings.forEach(prettifyError(source, lineCounter));
		}
		return doc;
	}
	function parse(src, reviver, options) {
		let _reviver = void 0;
		if (typeof reviver === "function") _reviver = reviver;
		else if (options === void 0 && reviver && typeof reviver === "object") options = reviver;
		const doc = parseDocument(src, options);
		if (!doc) return null;
		doc.warnings.forEach((warning) => warn(doc.options.logLevel, warning));
		if (doc.errors.length > 0) if (doc.options.logLevel !== "silent") throw doc.errors[0];
		else doc.errors = [];
		return doc.toJS(Object.assign({ reviver: _reviver }, options));
	}
	function stringify3(value, replacer, options) {
		var _a2;
		let _replacer = null;
		if (typeof replacer === "function" || Array.isArray(replacer)) _replacer = replacer;
		else if (options === void 0 && replacer) options = replacer;
		if (typeof options === "string") options = options.length;
		if (typeof options === "number") {
			const indent = Math.round(options);
			options = indent < 1 ? void 0 : indent > 8 ? { indent: 8 } : { indent };
		}
		if (value === void 0) {
			const { keepUndefined } = (_a2 = options != null ? options : replacer) != null ? _a2 : {};
			if (!keepUndefined) return void 0;
		}
		if (isDocument(value) && !_replacer) return value.toString(options);
		return new Document(value, _replacer, options).toString(options);
	}
	var browser_default = dist_exports;
	var _fs = __toESM(require_lib(), 1);
	var import_create_require = __toESM(require_create_require(), 1);
	init_node();
	init_node();
	init_node_fetch_native_DfbY2q_x();
	var _a, _b;
	var o2 = !!((_b = (_a = globalThis.process) == null ? void 0 : _a.env) == null ? void 0 : _b.FORCE_NODE_FETCH);
	var r = !o2 && globalThis.fetch || Mi;
	!o2 && globalThis.Blob;
	!o2 && globalThis.File;
	!o2 && globalThis.FormData;
	!o2 && globalThis.Headers;
	!o2 && globalThis.Request;
	!o2 && globalThis.Response;
	var T = !o2 && globalThis.AbortController || Mn;
	var importRequireRe = /((\.{3}|\s|[!%&(*+,/:;<=>?[^{|}~-]|^)(require\s?\(\s?|import\s?\(?\s?)|\sfrom)\s?$/;
	var isDep = (v2, re) => !!v2 && re.test(v2);
	var isSpace = (v2) => v2 === " " || v2 === "\n" || v2 === "	";
	var isQ = (v2) => `"'\``.includes(v2);
	var normalizeOpts = (opts) => __spreadValues({
		bufferSize: 1e3,
		comments: false,
		re: importRequireRe,
		offset: 19
	}, opts);
	var depseekSync = (input, opts) => extract(readify(input.toString()), opts);
	var readify = (input) => {
		const chunks = [null, input];
		return { read: () => chunks.pop() };
	};
	var extract = (readable, _opts) => {
		const { re, comments, bufferSize, offset } = normalizeOpts(_opts);
		const refs = [];
		const pushRef = (type, value, index) => refs.push({
			type,
			value,
			index
		});
		let i = 0;
		let prev = "";
		let chunk;
		let c2 = null;
		let q = null;
		let token = "";
		let strLiteral = "";
		let commentBlock = "";
		let commentValue = "";
		while (null !== (chunk = readable.read(bufferSize))) {
			const len = chunk.length;
			let j = 0;
			while (j < len) {
				const char = chunk[j];
				if (c2 === q) if (isSpace(char)) {
					if (!isSpace(prev)) token += char;
				} else if (prev === "/" && (char === "/" || char === "*")) c2 = char;
				else if (isQ(char)) q = char;
				else token += char;
				else if (c2 === null) if (isSpace(char) || isQ(char)) {
					if (strLiteral && isDep(token.slice(-offset), re)) pushRef("dep", strLiteral, i - strLiteral.length);
					strLiteral = "";
					token = "";
					q = null;
				} else strLiteral += char;
				else if (q === null) {
					if (c2 === "/" && char === "\n" || c2 === "*" && prev === "*" && char === "/") {
						commentValue = c2 === "*" ? commentBlock.slice(0, -1) : commentBlock;
						if (commentValue && comments) pushRef("comment", commentValue, i - commentValue.length);
						commentBlock = "";
						token = token.slice(0, -1);
						c2 = null;
					} else if (comments) commentBlock += char;
				}
				prev = char;
				i++;
				j++;
			}
		}
		return refs;
	};
	var import_minimist = __toESM(require_minimist(), 1);
	var import_node_fs5 = __toESM(__require("fs"), 1);
	var import_node_path4 = __toESM(__require("path"), 1);
	var import_node_util3 = __require("util");
	var DOTENV = ".env";
	var Q1 = "\"";
	var Q2 = "'";
	var Q3 = "`";
	var KR = /^[a-zA-Z_]\w*$/;
	var SR = /\s/;
	var decoder = new import_node_util3.TextDecoder();
	var parse2 = (content) => {
		const e = {};
		let k2 = "";
		let b = "";
		let q = "";
		let i = 0;
		const cap = () => {
			k2 = k2.trim();
			if (k2) {
				if (!KR.test(k2)) throw new Error(`Invalid identifier: ${k2}`);
				e[k2] = b.trim();
				b = k2 = "";
			}
		};
		for (const c2 of typeof content === "string" ? content : decoder.decode(content)) {
			if (i) {
				if (c2 === "\n") i = 0;
				continue;
			}
			if (!q) {
				if (c2 === "#") {
					i = 1;
					continue;
				}
				if (c2 === "\n") {
					cap();
					continue;
				}
				if (SR.test(c2)) {
					if (!k2 && b === "export") b = "";
					if (!b) continue;
				}
				if (c2 === "=") {
					if (!k2) {
						k2 = b;
						b = "";
						continue;
					}
				}
			}
			if (c2 === Q1 || c2 === Q2 || c2 === Q3) {
				if (!q && !b) {
					q = c2;
					continue;
				}
				if (q === c2) {
					q = "";
					b && cap();
					continue;
				}
			}
			b += c2;
		}
		cap();
		return e;
	};
	var formatValue = (v2) => {
		const q1 = v2.includes(Q1);
		const q2 = v2.includes(Q2);
		const q3 = v2.includes(Q3);
		const s = SR.test(v2);
		if (!q1 && !q2 && !q3 && !s) return v2;
		if (!q1) return `${Q1}${v2}${Q1}`;
		if (!q2) return `${Q2}${v2}${Q2}`;
		if (parse2(`V=${Q3}${v2}${Q3}`).V !== v2) throw new Error(`Invalid value: ${v2}`);
		return `${Q3}${v2}${Q3}`;
	};
	var stringify4 = (env) => Object.entries(env).map(([k2, v2]) => `${k2}=${formatValue(v2 || "")}`).join("\n");
	var _load = (read, ...files) => files.reverse().reduce((m2, f2) => Object.assign(m2, parse2(read(import_node_path4.default.resolve(f2)))), {});
	var load = (...files) => _load((file) => import_node_fs5.default.readFileSync(file, "utf8"), ...files);
	var loadSafe = (...files) => _load((file) => import_node_fs5.default.existsSync(file) ? import_node_fs5.default.readFileSync(file, "utf8") : "", ...files);
	var populate = (env, extra) => Object.assign(env, extra);
	var config = (def = DOTENV, ...files) => populate(process.env, loadSafe(def, ...files));
	var index_default = {
		parse: parse2,
		stringify: stringify4,
		load,
		loadSafe,
		config
	};
	var { wrap } = require_internals().bus;
	var globalVar = "Deno" in globalThis ? globalThis : global;
	globalVar.AbortController = globalVar.AbortController || T;
	var createRequire = import_create_require.default;
	var globbyModule = {
		convertPathToPattern,
		globby,
		sync: globbySync,
		globbySync,
		globbyStream,
		generateGlobTasksSync,
		generateGlobTasks,
		isGitIgnoredSync,
		isGitIgnored,
		isDynamicPattern
	};
	var _glob = Object.assign(function globby2(patterns, options) {
		return globbyModule.globby(patterns, options);
	}, globbyModule);
	var _YAML = browser_exports;
	var depseek = wrap("depseek", depseekSync);
	var dotenv = wrap("dotenv", index_default);
	var fs5 = wrap("fs", _fs);
	var YAML = wrap("YAML", _YAML);
	var glob = wrap("glob", _glob);
	var nodeFetch = wrap("nodeFetch", r);
	var minimist = wrap("minimist", import_minimist.default);
}));
//#endregion
//#region node_modules/zx/build/vendor.cjs
var require_vendor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { __reExport, __toCommonJS } = require_esblib();
	var vendor_exports = {};
	module.exports = __toCommonJS(vendor_exports);
	__reExport(vendor_exports, require_vendor_core(), module.exports);
	__reExport(vendor_exports, require_vendor_extra(), module.exports);
}));
//#endregion
//#region node_modules/zx/build/index.js
var import_build = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { __pow, __export, __reExport, __toESM, __toCommonJS, __async, __forAwait } = require_esblib();
	var index_exports = {};
	__export(index_exports, {
		VERSION: () => VERSION,
		YAML: () => import_vendor2.YAML,
		argv: () => argv,
		dotenv: () => import_vendor2.dotenv,
		echo: () => echo,
		expBackoff: () => expBackoff,
		fetch: () => fetch,
		fs: () => import_vendor2.fs,
		glob: () => import_vendor2.glob,
		globby: () => import_vendor2.glob,
		minimist: () => import_vendor2.minimist,
		nothrow: () => nothrow,
		parseArgv: () => parseArgv,
		question: () => question,
		quiet: () => quiet,
		retry: () => retry,
		sleep: () => sleep,
		spinner: () => spinner,
		stdin: () => stdin,
		tempdir: () => tempdir,
		tempfile: () => tempfile,
		tmpdir: () => tempdir,
		tmpfile: () => tempfile,
		updateArgv: () => updateArgv,
		version: () => version,
		versions: () => versions
	});
	module.exports = __toCommonJS(index_exports);
	var import_core2 = require_core();
	var import_node_buffer = __require("buffer");
	var import_node_process = __toESM(__require("process"), 1);
	var import_node_readline = __require("readline");
	var import_node_stream = __require("stream");
	var import_core = require_core();
	var import_util = require_util();
	var import_vendor = require_vendor();
	var versions = {
		zx: "8.8.5",
		chalk: "5.6.2",
		depseek: "0.4.3",
		dotenv: "0.2.3",
		fetch: "1.6.7",
		fs: "11.3.2",
		glob: "15.0.0",
		minimist: "1.2.8",
		ps: "1.0.0",
		which: "5.0.0",
		yaml: "2.8.1"
	};
	function tempdir(prefix = `zx-${(0, import_util.randomId)()}`, mode) {
		const dirpath = import_core.path.join(import_core.os.tmpdir(), prefix);
		import_vendor.fs.mkdirSync(dirpath, {
			recursive: true,
			mode
		});
		return dirpath;
	}
	function tempfile(name, data, mode) {
		const filepath = name ? import_core.path.join(tempdir(), name) : import_core.path.join(import_core.os.tmpdir(), `zx-${(0, import_util.randomId)()}`);
		if (data === void 0) import_vendor.fs.closeSync(import_vendor.fs.openSync(filepath, "w", mode));
		else import_vendor.fs.writeFileSync(filepath, data, { mode });
		return filepath;
	}
	var parseArgv = (args = import_node_process.default.argv.slice(2), opts = {}, defs = {}) => Object.entries((0, import_vendor.minimist)(args, opts)).reduce((m, [k, v]) => {
		const kTrans = opts.camelCase ? import_util.toCamelCase : import_util.identity;
		const vTrans = opts.parseBoolean ? import_util.parseBool : import_util.identity;
		const [_k, _v] = k === "--" || k === "_" ? [k, v] : [kTrans(k), vTrans(v)];
		m[_k] = _v;
		return m;
	}, defs);
	function updateArgv(args, opts) {
		for (const k in argv) delete argv[k];
		parseArgv(args, opts, argv);
	}
	var argv = parseArgv();
	function sleep(duration) {
		return new Promise((resolve) => {
			setTimeout(resolve, (0, import_util.parseDuration)(duration));
		});
	}
	var responseToReadable = (response, rs) => {
		var _a;
		const reader = (_a = response.body) == null ? void 0 : _a.getReader();
		if (!reader) {
			rs.push(null);
			return rs;
		}
		rs._read = () => __async(null, null, function* () {
			const result = yield reader.read();
			rs.push(result.done ? null : import_node_buffer.Buffer.from(result.value));
		});
		return rs;
	};
	function fetch(url, init) {
		import_core.$.log({
			kind: "fetch",
			url,
			init,
			verbose: !import_core.$.quiet && import_core.$.verbose
		});
		const p = (0, import_vendor.nodeFetch)(url, init);
		return Object.assign(p, { pipe(dest, ...args) {
			const rs = new import_node_stream.Readable();
			const _dest = (0, import_util.isStringLiteral)(dest, ...args) ? (0, import_core.$)({
				halt: true,
				signal: init == null ? void 0 : init.signal
			})(dest, ...args) : dest;
			p.then((r) => {
				var _a;
				return responseToReadable(r, rs).pipe((_a = _dest.run) == null ? void 0 : _a.call(_dest));
			}, (err) => {
				var _a;
				return (_a = _dest.abort) == null ? void 0 : _a.call(_dest, err);
			});
			return _dest;
		} });
	}
	function echo(pieces, ...args) {
		const msg = (0, import_util.isStringLiteral)(pieces, ...args) ? args.map((a, i) => pieces[i] + stringify(a)).join("") + (0, import_util.getLast)(pieces) : [pieces, ...args].map(stringify).join(" ");
		console.log(msg);
	}
	function stringify(arg) {
		return arg instanceof import_core.ProcessOutput ? arg.toString().trimEnd() : `${arg}`;
	}
	function question(_0) {
		return __async(this, arguments, function* (query, { choices, input = import_node_process.default.stdin, output = import_node_process.default.stdout } = {}) {
			const completer = Array.isArray(choices) ? (line) => {
				const hits = choices.filter((c) => c.startsWith(line));
				return [hits.length ? hits : choices, line];
			} : void 0;
			const rl = (0, import_node_readline.createInterface)({
				input,
				output,
				terminal: true,
				completer
			});
			return new Promise((resolve) => rl.question(query != null ? query : "", (answer) => {
				rl.close();
				resolve(answer);
			}));
		});
	}
	function stdin() {
		return __async(this, arguments, function* (stream = import_node_process.default.stdin) {
			let buf = "";
			try {
				for (var iter = __forAwait(stream.setEncoding("utf8")), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
					const chunk = temp.value;
					buf += chunk;
				}
			} catch (temp) {
				error = [temp];
			} finally {
				try {
					more && (temp = iter.return) && (yield temp.call(iter));
				} finally {
					if (error) throw error[0];
				}
			}
			return buf;
		});
	}
	function retry(count, d, cb) {
		return __async(this, null, function* () {
			if (typeof d === "function") return retry(count, 0, d);
			if (!cb) throw new import_core.Fail("Callback is required for retry");
			const total = count;
			const gen = typeof d === "object" ? d : (function* (d2) {
				while (true) yield d2;
			})((0, import_util.parseDuration)(d));
			let attempt = 0;
			let lastErr;
			while (count-- > 0) {
				attempt++;
				try {
					return yield cb();
				} catch (err) {
					lastErr = err;
					const delay = gen.next().value;
					import_core.$.log({
						kind: "retry",
						total,
						attempt,
						delay,
						exception: err,
						verbose: !import_core.$.quiet && import_core.$.verbose,
						error: `FAIL Attempt: ${attempt}/${total}, next: ${delay}`
					});
					if (delay > 0) yield sleep(delay);
				}
			}
			throw lastErr;
		});
	}
	function* expBackoff(max = "60s", delay = "100ms") {
		const maxMs = (0, import_util.parseDuration)(max);
		const randMs = (0, import_util.parseDuration)(delay);
		let n = 0;
		while (true) yield Math.min(randMs * __pow(2, n++), maxMs);
	}
	function spinner(title, callback) {
		return __async(this, null, function* () {
			if (typeof title === "function") return spinner("", title);
			if (import_core.$.quiet || import_node_process.default.env.CI) return callback();
			let i = 0;
			const stream = import_core.$.log.output || import_node_process.default.stderr;
			const spin = () => stream.write(`  ${"⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[i++ % 10]} ${title}\r`);
			return (0, import_core.within)(() => __async(null, null, function* () {
				import_core.$.verbose = false;
				const id = setInterval(spin, 100);
				try {
					return yield callback();
				} finally {
					clearInterval(id);
					stream.write(" ".repeat((import_node_process.default.stdout.columns || 1) - 1) + "\r");
				}
			}));
		});
	}
	__reExport(index_exports, require_core(), module.exports);
	var import_vendor2 = require_vendor();
	import_core2.bus.lock();
	var VERSION = versions.zx || "0.0.0";
	var version = VERSION;
	function nothrow(promise) {
		return promise.nothrow();
	}
	function quiet(promise) {
		return promise.quiet();
	}
})))(), 1);
var { VERSION, YAML, argv, dotenv, echo, expBackoff, fetch, fs, glob, globby, minimist, nothrow, parseArgv, question, quiet, retry, sleep, spinner, stdin, tempdir, tempfile, tmpdir, tmpfile, updateArgv, version, versions, $, Fail, ProcessOutput, ProcessPromise, bus, cd, chalk, defaults, kill, log, os: os$1, path, ps, quote, quotePowerShell, resolveDefaults, syncProcessCwd, useBash, usePowerShell, usePwsh, which, within } = globalThis.Deno ? globalThis.require("./index.cjs") : import_build;
//#endregion
//#region src/index.ts
$.verbose = true;
(async function main() {
	try {
		await ssh();
		await dep();
	} catch (err) {
		setFailed(err instanceof Error ? err.message : String(err));
	}
})();
async function ssh() {
	if (getBooleanInput("skip-ssh-setup")) return;
	const sshHomeDir = `${process.env["HOME"]}/.ssh`;
	if (!fs.existsSync(sshHomeDir)) fs.mkdirSync(sshHomeDir);
	const authSock = "/tmp/ssh-auth.sock";
	await $`ssh-agent -a ${authSock}`;
	exportVariable("SSH_AUTH_SOCK", authSock);
	let privateKey = getInput("private-key");
	if (privateKey !== "") {
		privateKey = privateKey.replace(/\r/g, "").trim() + "\n";
		const p = $`ssh-add -`;
		p.stdin.write(privateKey);
		p.stdin.end();
		await p;
	}
	const knownHosts = getInput("known-hosts");
	if (knownHosts !== "") {
		fs.appendFileSync(`${sshHomeDir}/known_hosts`, knownHosts);
		fs.chmodSync(`${sshHomeDir}/known_hosts`, "600");
	} else {
		fs.appendFileSync(`${sshHomeDir}/config`, `StrictHostKeyChecking no`);
		fs.chmodSync(`${sshHomeDir}/config`, "600");
	}
	const sshConfig = getInput("ssh-config");
	if (sshConfig !== "") {
		fs.writeFileSync(`${sshHomeDir}/config`, sshConfig);
		fs.chmodSync(`${sshHomeDir}/config`, "600");
	}
}
async function dep() {
	let bin = getInput("deployer-binary");
	const subDirectory = getInput("sub-directory").trim();
	if (subDirectory !== "") cd(subDirectory);
	if (bin === "") {
		for (const c of [
			"vendor/bin/deployer.phar",
			"vendor/bin/dep",
			"deployer.phar"
		]) if (fs.existsSync(c)) {
			bin = c;
			console.log(`Using "${c}".`);
			break;
		}
	}
	if (bin === "") {
		let version = getInput("deployer-version");
		if (version === "" && fs.existsSync("composer.lock")) {
			const lock = JSON.parse(fs.readFileSync("composer.lock", "utf8"));
			if (lock.packages) version = lock.packages.find((p) => p.name === "deployer/deployer")?.version;
			if ((version === "" || version === void 0) && lock["packages-dev"]) version = lock["packages-dev"].find((p) => p.name === "deployer/deployer")?.version;
		}
		if (version === "" || version === void 0) throw new Error("Deployer binary not found. Please specify deployer-binary or deployer-version.");
		version = version.replace(/^v/, "");
		const manifest = JSON.parse((await $`curl -L https://deployer.org/manifest.json`).stdout);
		let url;
		for (const asset of manifest) if (asset.version === version) {
			url = asset.url;
			break;
		}
		if (url === void 0) setFailed(`The version "${version}" does not exist in the "https://deployer.org/manifest.json" file.`);
		else {
			console.log(`Downloading "${url}".`);
			await $`curl -LO ${url}`;
		}
		await $`sudo chmod +x deployer.phar`;
		bin = "deployer.phar";
	}
	const cmd = getInput("dep").split(" ");
	const recipeArgs = [];
	const recipeInput = getInput("recipe");
	if (recipeInput !== "") recipeArgs.push(`--file=${recipeInput}`);
	const ansi = getBooleanInput("ansi") ? "--ansi" : "--no-ansi";
	const verbosityArgs = [];
	const verbosityInput = getInput("verbosity");
	if (verbosityInput !== "") verbosityArgs.push(verbosityInput);
	const options = [];
	try {
		const optionsArg = getInput("options");
		if (optionsArg !== "") for (const [key, value] of Object.entries(JSON.parse(optionsArg))) options.push("-o", `${key}=${value}`);
	} catch (e) {
		console.error("Invalid JSON in options");
	}
	let phpBin = "php";
	const phpBinArg = getInput("php-binary");
	if (phpBinArg !== "") phpBin = phpBinArg;
	try {
		await $`${phpBin} ${bin} ${cmd} ${recipeArgs} --no-interaction ${ansi} ${verbosityArgs} ${options}`;
	} catch (err) {
		setFailed(`Failed: dep ${cmd}`);
	}
}
//#endregion
export {};


================================================
FILE: package.json
================================================
{
  "private": true,
  "type": "module",
  "engines": {
    "node": ">=22"
  },
  "scripts": {
    "build": "vite build",
    "typecheck": "tsc --noEmit",
    "format": "prettier --write .",
    "format:check": "prettier --check ."
  },
  "dependencies": {
    "@actions/core": "^3.0.0",
    "zx": "^8.8.5"
  },
  "devDependencies": {
    "@types/node": "^22.0.0",
    "prettier": "^3.8.1",
    "typescript": "^5.7.0",
    "vite": "^8.0.5"
  },
  "prettier": {
    "semi": false,
    "singleQuote": true,
    "endOfLine": "lf"
  }
}


================================================
FILE: src/index.ts
================================================
import * as core from '@actions/core'
import { $, fs, cd } from 'zx'

$.verbose = true

interface ComposerLock {
  packages?: Array<{ name: string; version: string }>
  'packages-dev'?: Array<{ name: string; version: string }>
}

interface DeployerManifestEntry {
  version: string
  url: string
}

void (async function main(): Promise<void> {
  try {
    await ssh()
    await dep()
  } catch (err) {
    core.setFailed(err instanceof Error ? err.message : String(err))
  }
})()

async function ssh(): Promise<void> {
  if (core.getBooleanInput('skip-ssh-setup')) {
    return
  }

  const sshHomeDir = `${process.env['HOME']}/.ssh`

  if (!fs.existsSync(sshHomeDir)) {
    fs.mkdirSync(sshHomeDir)
  }

  const authSock = '/tmp/ssh-auth.sock'
  await $`ssh-agent -a ${authSock}`
  core.exportVariable('SSH_AUTH_SOCK', authSock)

  let privateKey = core.getInput('private-key')
  if (privateKey !== '') {
    privateKey = privateKey.replace(/\r/g, '').trim() + '\n'
    const p = $`ssh-add -`
    p.stdin.write(privateKey)
    p.stdin.end()
    await p
  }

  const knownHosts = core.getInput('known-hosts')
  if (knownHosts !== '') {
    fs.appendFileSync(`${sshHomeDir}/known_hosts`, knownHosts)
    fs.chmodSync(`${sshHomeDir}/known_hosts`, '600')
  } else {
    fs.appendFileSync(`${sshHomeDir}/config`, `StrictHostKeyChecking no`)
    fs.chmodSync(`${sshHomeDir}/config`, '600')
  }

  const sshConfig = core.getInput('ssh-config')
  if (sshConfig !== '') {
    fs.writeFileSync(`${sshHomeDir}/config`, sshConfig)
    fs.chmodSync(`${sshHomeDir}/config`, '600')
  }
}

async function dep(): Promise<void> {
  let bin = core.getInput('deployer-binary')
  const subDirectory = core.getInput('sub-directory').trim()

  if (subDirectory !== '') {
    cd(subDirectory)
  }

  if (bin === '') {
    for (const c of [
      'vendor/bin/deployer.phar',
      'vendor/bin/dep',
      'deployer.phar',
    ]) {
      if (fs.existsSync(c)) {
        bin = c
        console.log(`Using "${c}".`)
        break
      }
    }
  }

  if (bin === '') {
    let version: string | undefined = core.getInput('deployer-version')
    if (version === '' && fs.existsSync('composer.lock')) {
      const lock: ComposerLock = JSON.parse(
        fs.readFileSync('composer.lock', 'utf8'),
      )
      if (lock.packages) {
        version = lock.packages.find(
          (p) => p.name === 'deployer/deployer',
        )?.version
      }
      if ((version === '' || version === undefined) && lock['packages-dev']) {
        version = lock['packages-dev'].find(
          (p) => p.name === 'deployer/deployer',
        )?.version
      }
    }
    if (version === '' || version === undefined) {
      throw new Error(
        'Deployer binary not found. Please specify deployer-binary or deployer-version.',
      )
    }
    version = version.replace(/^v/, '')
    const manifest: DeployerManifestEntry[] = JSON.parse(
      (await $`curl -L https://deployer.org/manifest.json`).stdout,
    )
    let url: string | undefined
    for (const asset of manifest) {
      if (asset.version === version) {
        url = asset.url
        break
      }
    }
    if (url === undefined) {
      core.setFailed(
        `The version "${version}" does not exist in the "https://deployer.org/manifest.json" file.`,
      )
    } else {
      console.log(`Downloading "${url}".`)
      await $`curl -LO ${url}`
    }

    await $`sudo chmod +x deployer.phar`
    bin = 'deployer.phar'
  }

  const cmd = core.getInput('dep').split(' ')
  const recipeArgs: string[] = []
  const recipeInput = core.getInput('recipe')
  if (recipeInput !== '') {
    recipeArgs.push(`--file=${recipeInput}`)
  }

  const ansi = core.getBooleanInput('ansi') ? '--ansi' : '--no-ansi'
  const verbosityArgs: string[] = []
  const verbosityInput = core.getInput('verbosity')
  if (verbosityInput !== '') {
    verbosityArgs.push(verbosityInput)
  }
  const options: string[] = []
  try {
    const optionsArg = core.getInput('options')
    if (optionsArg !== '') {
      for (const [key, value] of Object.entries(JSON.parse(optionsArg))) {
        options.push('-o', `${key}=${value}`)
      }
    }
  } catch (e) {
    console.error('Invalid JSON in options')
  }

  let phpBin = 'php'
  const phpBinArg = core.getInput('php-binary')
  if (phpBinArg !== '') {
    phpBin = phpBinArg
  }

  try {
    await $`${phpBin} ${bin} ${cmd} ${recipeArgs} --no-interaction ${ansi} ${verbosityArgs} ${options}`
  } catch (err) {
    core.setFailed(`Failed: dep ${cmd}`)
  }
}


================================================
FILE: tsconfig.json
================================================
{
  "compilerOptions": {
    "target": "ES2023",
    "module": "ES2022",
    "moduleResolution": "bundler",
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "strict": true,
    "skipLibCheck": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "declaration": false,
    "sourceMap": false,
    "types": ["node"],
    "lib": ["ES2023"]
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules", "dist"]
}


================================================
FILE: vite.config.ts
================================================
import { defineConfig } from 'vite'
import { resolve } from 'path'

export default defineConfig({
  build: {
    target: 'node22',
    ssr: true,
    outDir: 'dist',
    lib: {
      entry: resolve(__dirname, 'src/index.ts'),
      formats: ['es'],
      fileName: () => 'index.js',
    },
    rollupOptions: {
      external: [],
    },
    minify: false,
    sourcemap: false,
    emptyOutDir: true,
  },
  ssr: {
    noExternal: [/./],
    target: 'node',
  },
})