import { createRequire } from "node:module";
import * as path$2 from "path";
import * as fs$1 from "fs";
import { constants, existsSync, promises, readFileSync, writeFileSync } from "fs";
import * as os$4 from "os";
import os, { EOL } from "os";
import * as crypto from "crypto";
import * as http$4 from "http";
import * as https$3 from "https";
import * as events from "events";
import { EventEmitter } from "events";
import assert, { ok } from "assert";
import * as util$2 from "util";
import http from "node:http";
import Stream, { Readable, Transform } from "node:stream";
import buffer from "node:buffer";
import util, { inspect } from "node:util";
import zlib from "node:zlib";
import { createHmac } from "node:crypto";
import * as child from "child_process";
import { setTimeout as setTimeout$1 } from "timers";
import path from "node:path";
import * as stream from "stream";
import { Readable as Readable$1 } from "stream";
import { URL as URL$1 } from "url";
import * as os$2 from "node:os";
import os$1, { EOL as EOL$1 } from "node:os";
import process$1 from "node:process";
import https from "node:https";
import * as buffer$1 from "buffer";
import { Buffer as Buffer$1 } from "buffer";
import fs from "node:fs";
//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", {
	value,
	configurable: true
});
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esmMin = (fn, res, err) => () => {
	if (err) throw err[0];
	try {
		return fn && (res = fn(fn = 0)), res;
	} catch (e) {
		throw err = [e], e;
	}
};
var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
var __exportAll = (all, no_symbols) => {
	let target = {};
	for (var name in all) __defProp(target, name, {
		get: all[name],
		enumerable: true
	});
	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
	return target;
};
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 || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));
var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64.js
var require_base64 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
	/**
	* Encode an integer in the range of 0 to 63 to a single base 64 digit.
	*/
	exports.encode = function(number) {
		if (0 <= number && number < intToCharMap.length) return intToCharMap[number];
		throw new TypeError("Must be between 0 and 63: " + number);
	};
	/**
	* Decode a single base 64 character code digit to an integer. Returns -1 on
	* failure.
	*/
	exports.decode = function(charCode) {
		var bigA = 65;
		var bigZ = 90;
		var littleA = 97;
		var littleZ = 122;
		var zero = 48;
		var nine = 57;
		var plus = 43;
		var slash = 47;
		var littleOffset = 26;
		var numberOffset = 52;
		if (bigA <= charCode && charCode <= bigZ) return charCode - bigA;
		if (littleA <= charCode && charCode <= littleZ) return charCode - littleA + littleOffset;
		if (zero <= charCode && charCode <= nine) return charCode - zero + numberOffset;
		if (charCode == plus) return 62;
		if (charCode == slash) return 63;
		return -1;
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64-vlq.js
var require_base64_vlq = /* @__PURE__ */ __commonJSMin(((exports) => {
	var base64 = require_base64();
	var VLQ_BASE_SHIFT = 5;
	var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
	var VLQ_BASE_MASK = VLQ_BASE - 1;
	var VLQ_CONTINUATION_BIT = VLQ_BASE;
	/**
	* Converts from a two-complement value to a value where the sign bit is
	* placed in the least significant bit.  For example, as decimals:
	*   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
	*   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
	*/
	function toVLQSigned(aValue) {
		return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
	}
	/**
	* Converts to a two-complement value from a value where the sign bit is
	* placed in the least significant bit.  For example, as decimals:
	*   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
	*   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
	*/
	function fromVLQSigned(aValue) {
		var isNegative = (aValue & 1) === 1;
		var shifted = aValue >> 1;
		return isNegative ? -shifted : shifted;
	}
	/**
	* Returns the base 64 VLQ encoded value.
	*/
	exports.encode = function base64VLQ_encode(aValue) {
		var encoded = "";
		var digit;
		var vlq = toVLQSigned(aValue);
		do {
			digit = vlq & VLQ_BASE_MASK;
			vlq >>>= VLQ_BASE_SHIFT;
			if (vlq > 0) digit |= VLQ_CONTINUATION_BIT;
			encoded += base64.encode(digit);
		} while (vlq > 0);
		return encoded;
	};
	/**
	* Decodes the next base 64 VLQ value from the given string and returns the
	* value and the rest of the string via the out parameter.
	*/
	exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
		var strLen = aStr.length;
		var result = 0;
		var shift = 0;
		var continuation;
		var digit;
		do {
			if (aIndex >= strLen) throw new Error("Expected more digits in base 64 VLQ value.");
			digit = base64.decode(aStr.charCodeAt(aIndex++));
			if (digit === -1) throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
			continuation = !!(digit & VLQ_CONTINUATION_BIT);
			digit &= VLQ_BASE_MASK;
			result = result + (digit << shift);
			shift += VLQ_BASE_SHIFT;
		} while (continuation);
		aOutParam.value = fromVLQSigned(result);
		aOutParam.rest = aIndex;
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/util.js
var require_util$8 = /* @__PURE__ */ __commonJSMin(((exports) => {
	/**
	* This is a helper function for getting values from parameter/options
	* objects.
	*
	* @param args The object we are extracting values from
	* @param name The name of the property we are getting.
	* @param defaultValue An optional value to return if the property is missing
	* from the object. If this is not specified and the property is missing, an
	* error will be thrown.
	*/
	function getArg(aArgs, aName, aDefaultValue) {
		if (aName in aArgs) return aArgs[aName];
		else if (arguments.length === 3) return aDefaultValue;
		else throw new Error("\"" + aName + "\" is a required argument.");
	}
	exports.getArg = getArg;
	var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
	var dataUrlRegexp = /^data:.+\,.+$/;
	function urlParse(aUrl) {
		var match = aUrl.match(urlRegexp);
		if (!match) return null;
		return {
			scheme: match[1],
			auth: match[2],
			host: match[3],
			port: match[4],
			path: match[5]
		};
	}
	exports.urlParse = urlParse;
	function urlGenerate(aParsedUrl) {
		var url = "";
		if (aParsedUrl.scheme) url += aParsedUrl.scheme + ":";
		url += "//";
		if (aParsedUrl.auth) url += aParsedUrl.auth + "@";
		if (aParsedUrl.host) url += aParsedUrl.host;
		if (aParsedUrl.port) url += ":" + aParsedUrl.port;
		if (aParsedUrl.path) url += aParsedUrl.path;
		return url;
	}
	exports.urlGenerate = urlGenerate;
	/**
	* Normalizes a path, or the path portion of a URL:
	*
	* - Replaces consecutive slashes with one slash.
	* - Removes unnecessary '.' parts.
	* - Removes unnecessary '<dir>/..' parts.
	*
	* Based on code in the Node.js 'path' core module.
	*
	* @param aPath The path or url to normalize.
	*/
	function normalize(aPath) {
		var path = aPath;
		var url = urlParse(aPath);
		if (url) {
			if (!url.path) return aPath;
			path = url.path;
		}
		var isAbsolute = exports.isAbsolute(path);
		var parts = path.split(/\/+/);
		for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
			part = parts[i];
			if (part === ".") parts.splice(i, 1);
			else if (part === "..") up++;
			else if (up > 0) {
				if (part === "") {
					parts.splice(i + 1, up);
					up = 0;
				} else {
					parts.splice(i, 2);
					up--;
				}
			}
		}
		path = parts.join("/");
		if (path === "") path = isAbsolute ? "/" : ".";
		if (url) {
			url.path = path;
			return urlGenerate(url);
		}
		return path;
	}
	exports.normalize = normalize;
	/**
	* Joins two paths/URLs.
	*
	* @param aRoot The root path or URL.
	* @param aPath The path or URL to be joined with the root.
	*
	* - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
	*   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
	*   first.
	* - Otherwise aPath is a path. If aRoot is a URL, then its path portion
	*   is updated with the result and aRoot is returned. Otherwise the result
	*   is returned.
	*   - If aPath is absolute, the result is aPath.
	*   - Otherwise the two paths are joined with a slash.
	* - Joining for example 'http://' and 'www.example.com' is also supported.
	*/
	function join(aRoot, aPath) {
		if (aRoot === "") aRoot = ".";
		if (aPath === "") aPath = ".";
		var aPathUrl = urlParse(aPath);
		var aRootUrl = urlParse(aRoot);
		if (aRootUrl) aRoot = aRootUrl.path || "/";
		if (aPathUrl && !aPathUrl.scheme) {
			if (aRootUrl) aPathUrl.scheme = aRootUrl.scheme;
			return urlGenerate(aPathUrl);
		}
		if (aPathUrl || aPath.match(dataUrlRegexp)) return aPath;
		if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
			aRootUrl.host = aPath;
			return urlGenerate(aRootUrl);
		}
		var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
		if (aRootUrl) {
			aRootUrl.path = joined;
			return urlGenerate(aRootUrl);
		}
		return joined;
	}
	exports.join = join;
	exports.isAbsolute = function(aPath) {
		return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
	};
	/**
	* Make a path relative to a URL or another path.
	*
	* @param aRoot The root path or URL.
	* @param aPath The path or URL to be made relative to aRoot.
	*/
	function relative(aRoot, aPath) {
		if (aRoot === "") aRoot = ".";
		aRoot = aRoot.replace(/\/$/, "");
		var level = 0;
		while (aPath.indexOf(aRoot + "/") !== 0) {
			var index = aRoot.lastIndexOf("/");
			if (index < 0) return aPath;
			aRoot = aRoot.slice(0, index);
			if (aRoot.match(/^([^\/]+:\/)?\/*$/)) return aPath;
			++level;
		}
		return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
	}
	exports.relative = relative;
	var supportsNullProto = function() {
		return !("__proto__" in Object.create(null));
	}();
	function identity(s) {
		return s;
	}
	/**
	* Because behavior goes wacky when you set `__proto__` on objects, we
	* have to prefix all the strings in our set with an arbitrary character.
	*
	* See https://github.com/mozilla/source-map/pull/31 and
	* https://github.com/mozilla/source-map/issues/30
	*
	* @param String aStr
	*/
	function toSetString(aStr) {
		if (isProtoString(aStr)) return "$" + aStr;
		return aStr;
	}
	exports.toSetString = supportsNullProto ? identity : toSetString;
	function fromSetString(aStr) {
		if (isProtoString(aStr)) return aStr.slice(1);
		return aStr;
	}
	exports.fromSetString = supportsNullProto ? identity : fromSetString;
	function isProtoString(s) {
		if (!s) return false;
		var length = s.length;
		if (length < 9) return false;
		if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) return false;
		for (var i = length - 10; i >= 0; i--) if (s.charCodeAt(i) !== 36) return false;
		return true;
	}
	/**
	* Comparator between two mappings where the original positions are compared.
	*
	* Optionally pass in `true` as `onlyCompareGenerated` to consider two
	* mappings with the same original source/line/column, but different generated
	* line and column the same. Useful when searching for a mapping with a
	* stubbed out mapping.
	*/
	function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
		var cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0 || onlyCompareOriginal) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByOriginalPositions = compareByOriginalPositions;
	/**
	* Comparator between two mappings with deflated source and name indices where
	* the generated positions are compared.
	*
	* Optionally pass in `true` as `onlyCompareGenerated` to consider two
	* mappings with the same generated line and column, but different
	* source/name/original line and column the same. Useful when searching for a
	* mapping with a stubbed out mapping.
	*/
	function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
		var cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0 || onlyCompareGenerated) return cmp;
		cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
	function strcmp(aStr1, aStr2) {
		if (aStr1 === aStr2) return 0;
		if (aStr1 === null) return 1;
		if (aStr2 === null) return -1;
		if (aStr1 > aStr2) return 1;
		return -1;
	}
	/**
	* Comparator between two mappings with inflated source and name strings where
	* the generated positions are compared.
	*/
	function compareByGeneratedPositionsInflated(mappingA, mappingB) {
		var cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0) return cmp;
		cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
	/**
	* Strip any JSON XSSI avoidance prefix from the string (as documented
	* in the source maps specification), and then parse the string as
	* JSON.
	*/
	function parseSourceMapInput(str) {
		return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
	}
	exports.parseSourceMapInput = parseSourceMapInput;
	/**
	* Compute the URL of a source given the the source root, the source's
	* URL, and the source map's URL.
	*/
	function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
		sourceURL = sourceURL || "";
		if (sourceRoot) {
			if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") sourceRoot += "/";
			sourceURL = sourceRoot + sourceURL;
		}
		if (sourceMapURL) {
			var parsed = urlParse(sourceMapURL);
			if (!parsed) throw new Error("sourceMapURL could not be parsed");
			if (parsed.path) {
				var index = parsed.path.lastIndexOf("/");
				if (index >= 0) parsed.path = parsed.path.substring(0, index + 1);
			}
			sourceURL = join(urlGenerate(parsed), sourceURL);
		}
		return normalize(sourceURL);
	}
	exports.computeSourceURL = computeSourceURL;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/array-set.js
var require_array_set = /* @__PURE__ */ __commonJSMin(((exports) => {
	var util = require_util$8();
	var has = Object.prototype.hasOwnProperty;
	var hasNativeMap = typeof Map !== "undefined";
	/**
	* A data structure which is a combination of an array and a set. Adding a new
	* member is O(1), testing for membership is O(1), and finding the index of an
	* element is O(1). Removing elements from the set is not supported. Only
	* strings are supported for membership.
	*/
	function ArraySet() {
		this._array = [];
		this._set = hasNativeMap ? /* @__PURE__ */ new Map() : Object.create(null);
	}
	/**
	* Static method for creating ArraySet instances from an existing array.
	*/
	ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
		var set = new ArraySet();
		for (var i = 0, len = aArray.length; i < len; i++) set.add(aArray[i], aAllowDuplicates);
		return set;
	};
	/**
	* Return how many unique items are in this ArraySet. If duplicates have been
	* added, than those do not count towards the size.
	*
	* @returns Number
	*/
	ArraySet.prototype.size = function ArraySet_size() {
		return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
	};
	/**
	* Add the given string to this set.
	*
	* @param String aStr
	*/
	ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
		var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
		var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
		var idx = this._array.length;
		if (!isDuplicate || aAllowDuplicates) this._array.push(aStr);
		if (!isDuplicate) {
			if (hasNativeMap) this._set.set(aStr, idx);
			else this._set[sStr] = idx;
		}
	};
	/**
	* Is the given string a member of this set?
	*
	* @param String aStr
	*/
	ArraySet.prototype.has = function ArraySet_has(aStr) {
		if (hasNativeMap) return this._set.has(aStr);
		else {
			var sStr = util.toSetString(aStr);
			return has.call(this._set, sStr);
		}
	};
	/**
	* What is the index of the given string in the array?
	*
	* @param String aStr
	*/
	ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
		if (hasNativeMap) {
			var idx = this._set.get(aStr);
			if (idx >= 0) return idx;
		} else {
			var sStr = util.toSetString(aStr);
			if (has.call(this._set, sStr)) return this._set[sStr];
		}
		throw new Error("\"" + aStr + "\" is not in the set.");
	};
	/**
	* What is the element at the given index?
	*
	* @param Number aIdx
	*/
	ArraySet.prototype.at = function ArraySet_at(aIdx) {
		if (aIdx >= 0 && aIdx < this._array.length) return this._array[aIdx];
		throw new Error("No element indexed by " + aIdx);
	};
	/**
	* Returns the array representation of this set (which has the proper indices
	* indicated by indexOf). Note that this is a copy of the internal array used
	* for storing the members so that no one can mess with internal state.
	*/
	ArraySet.prototype.toArray = function ArraySet_toArray() {
		return this._array.slice();
	};
	exports.ArraySet = ArraySet;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/mapping-list.js
var require_mapping_list = /* @__PURE__ */ __commonJSMin(((exports) => {
	var util = require_util$8();
	/**
	* Determine whether mappingB is after mappingA with respect to generated
	* position.
	*/
	function generatedPositionAfter(mappingA, mappingB) {
		var lineA = mappingA.generatedLine;
		var lineB = mappingB.generatedLine;
		var columnA = mappingA.generatedColumn;
		var columnB = mappingB.generatedColumn;
		return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
	}
	/**
	* A data structure to provide a sorted view of accumulated mappings in a
	* performance conscious manner. It trades a neglibable overhead in general
	* case for a large speedup in case of mappings being added in order.
	*/
	function MappingList() {
		this._array = [];
		this._sorted = true;
		this._last = {
			generatedLine: -1,
			generatedColumn: 0
		};
	}
	/**
	* Iterate through internal items. This method takes the same arguments that
	* `Array.prototype.forEach` takes.
	*
	* NOTE: The order of the mappings is NOT guaranteed.
	*/
	MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
		this._array.forEach(aCallback, aThisArg);
	};
	/**
	* Add the given source mapping.
	*
	* @param Object aMapping
	*/
	MappingList.prototype.add = function MappingList_add(aMapping) {
		if (generatedPositionAfter(this._last, aMapping)) {
			this._last = aMapping;
			this._array.push(aMapping);
		} else {
			this._sorted = false;
			this._array.push(aMapping);
		}
	};
	/**
	* Returns the flat, sorted array of mappings. The mappings are sorted by
	* generated position.
	*
	* WARNING: This method returns internal data without copying, for
	* performance. The return value must NOT be mutated, and should be treated as
	* an immutable borrow. If you want to take ownership, you must make your own
	* copy.
	*/
	MappingList.prototype.toArray = function MappingList_toArray() {
		if (!this._sorted) {
			this._array.sort(util.compareByGeneratedPositionsInflated);
			this._sorted = true;
		}
		return this._array;
	};
	exports.MappingList = MappingList;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-map-generator.js
var require_source_map_generator = /* @__PURE__ */ __commonJSMin(((exports) => {
	var base64VLQ = require_base64_vlq();
	var util = require_util$8();
	var ArraySet = require_array_set().ArraySet;
	var MappingList = require_mapping_list().MappingList;
	/**
	* An instance of the SourceMapGenerator represents a source map which is
	* being built incrementally. You may pass an object with the following
	* properties:
	*
	*   - file: The filename of the generated source.
	*   - sourceRoot: A root for all relative URLs in this source map.
	*/
	function SourceMapGenerator(aArgs) {
		if (!aArgs) aArgs = {};
		this._file = util.getArg(aArgs, "file", null);
		this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
		this._skipValidation = util.getArg(aArgs, "skipValidation", false);
		this._sources = new ArraySet();
		this._names = new ArraySet();
		this._mappings = new MappingList();
		this._sourcesContents = null;
	}
	SourceMapGenerator.prototype._version = 3;
	/**
	* Creates a new SourceMapGenerator based on a SourceMapConsumer
	*
	* @param aSourceMapConsumer The SourceMap.
	*/
	SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
		var sourceRoot = aSourceMapConsumer.sourceRoot;
		var generator = new SourceMapGenerator({
			file: aSourceMapConsumer.file,
			sourceRoot
		});
		aSourceMapConsumer.eachMapping(function(mapping) {
			var newMapping = { generated: {
				line: mapping.generatedLine,
				column: mapping.generatedColumn
			} };
			if (mapping.source != null) {
				newMapping.source = mapping.source;
				if (sourceRoot != null) newMapping.source = util.relative(sourceRoot, newMapping.source);
				newMapping.original = {
					line: mapping.originalLine,
					column: mapping.originalColumn
				};
				if (mapping.name != null) newMapping.name = mapping.name;
			}
			generator.addMapping(newMapping);
		});
		aSourceMapConsumer.sources.forEach(function(sourceFile) {
			var sourceRelative = sourceFile;
			if (sourceRoot !== null) sourceRelative = util.relative(sourceRoot, sourceFile);
			if (!generator._sources.has(sourceRelative)) generator._sources.add(sourceRelative);
			var content = aSourceMapConsumer.sourceContentFor(sourceFile);
			if (content != null) generator.setSourceContent(sourceFile, content);
		});
		return generator;
	};
	/**
	* Add a single mapping from original source line and column to the generated
	* source's line and column for this source map being created. The mapping
	* object should have the following properties:
	*
	*   - generated: An object with the generated line and column positions.
	*   - original: An object with the original line and column positions.
	*   - source: The original source file (relative to the sourceRoot).
	*   - name: An optional original token name for this mapping.
	*/
	SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
		var generated = util.getArg(aArgs, "generated");
		var original = util.getArg(aArgs, "original", null);
		var source = util.getArg(aArgs, "source", null);
		var name = util.getArg(aArgs, "name", null);
		if (!this._skipValidation) this._validateMapping(generated, original, source, name);
		if (source != null) {
			source = String(source);
			if (!this._sources.has(source)) this._sources.add(source);
		}
		if (name != null) {
			name = String(name);
			if (!this._names.has(name)) this._names.add(name);
		}
		this._mappings.add({
			generatedLine: generated.line,
			generatedColumn: generated.column,
			originalLine: original != null && original.line,
			originalColumn: original != null && original.column,
			source,
			name
		});
	};
	/**
	* Set the source content for a source file.
	*/
	SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
		var source = aSourceFile;
		if (this._sourceRoot != null) source = util.relative(this._sourceRoot, source);
		if (aSourceContent != null) {
			if (!this._sourcesContents) this._sourcesContents = Object.create(null);
			this._sourcesContents[util.toSetString(source)] = aSourceContent;
		} else if (this._sourcesContents) {
			delete this._sourcesContents[util.toSetString(source)];
			if (Object.keys(this._sourcesContents).length === 0) this._sourcesContents = null;
		}
	};
	/**
	* Applies the mappings of a sub-source-map for a specific source file to the
	* source map being generated. Each mapping to the supplied source file is
	* rewritten using the supplied source map. Note: The resolution for the
	* resulting mappings is the minimium of this map and the supplied map.
	*
	* @param aSourceMapConsumer The source map to be applied.
	* @param aSourceFile Optional. The filename of the source file.
	*        If omitted, SourceMapConsumer's file property will be used.
	* @param aSourceMapPath Optional. The dirname of the path to the source map
	*        to be applied. If relative, it is relative to the SourceMapConsumer.
	*        This parameter is needed when the two source maps aren't in the same
	*        directory, and the source map to be applied contains relative source
	*        paths. If so, those relative source paths need to be rewritten
	*        relative to the SourceMapGenerator.
	*/
	SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
		var sourceFile = aSourceFile;
		if (aSourceFile == null) {
			if (aSourceMapConsumer.file == null) throw new Error("SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's \"file\" property. Both were omitted.");
			sourceFile = aSourceMapConsumer.file;
		}
		var sourceRoot = this._sourceRoot;
		if (sourceRoot != null) sourceFile = util.relative(sourceRoot, sourceFile);
		var newSources = new ArraySet();
		var newNames = new ArraySet();
		this._mappings.unsortedForEach(function(mapping) {
			if (mapping.source === sourceFile && mapping.originalLine != null) {
				var original = aSourceMapConsumer.originalPositionFor({
					line: mapping.originalLine,
					column: mapping.originalColumn
				});
				if (original.source != null) {
					mapping.source = original.source;
					if (aSourceMapPath != null) mapping.source = util.join(aSourceMapPath, mapping.source);
					if (sourceRoot != null) mapping.source = util.relative(sourceRoot, mapping.source);
					mapping.originalLine = original.line;
					mapping.originalColumn = original.column;
					if (original.name != null) mapping.name = original.name;
				}
			}
			var source = mapping.source;
			if (source != null && !newSources.has(source)) newSources.add(source);
			var name = mapping.name;
			if (name != null && !newNames.has(name)) newNames.add(name);
		}, this);
		this._sources = newSources;
		this._names = newNames;
		aSourceMapConsumer.sources.forEach(function(sourceFile) {
			var content = aSourceMapConsumer.sourceContentFor(sourceFile);
			if (content != null) {
				if (aSourceMapPath != null) sourceFile = util.join(aSourceMapPath, sourceFile);
				if (sourceRoot != null) sourceFile = util.relative(sourceRoot, sourceFile);
				this.setSourceContent(sourceFile, content);
			}
		}, this);
	};
	/**
	* A mapping can have one of the three levels of data:
	*
	*   1. Just the generated position.
	*   2. The Generated position, original position, and original source.
	*   3. Generated and original position, original source, as well as a name
	*      token.
	*
	* To maintain consistency, we validate that any new mapping being added falls
	* in to one of these categories.
	*/
	SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
		if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") throw new Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.");
		if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) return;
		else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) return;
		else throw new Error("Invalid mapping: " + JSON.stringify({
			generated: aGenerated,
			source: aSource,
			original: aOriginal,
			name: aName
		}));
	};
	/**
	* Serialize the accumulated mappings in to the stream of base 64 VLQs
	* specified by the source map format.
	*/
	SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
		var previousGeneratedColumn = 0;
		var previousGeneratedLine = 1;
		var previousOriginalColumn = 0;
		var previousOriginalLine = 0;
		var previousName = 0;
		var previousSource = 0;
		var result = "";
		var next;
		var mapping;
		var nameIdx;
		var sourceIdx;
		var mappings = this._mappings.toArray();
		for (var i = 0, len = mappings.length; i < len; i++) {
			mapping = mappings[i];
			next = "";
			if (mapping.generatedLine !== previousGeneratedLine) {
				previousGeneratedColumn = 0;
				while (mapping.generatedLine !== previousGeneratedLine) {
					next += ";";
					previousGeneratedLine++;
				}
			} else if (i > 0) {
				if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) continue;
				next += ",";
			}
			next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
			previousGeneratedColumn = mapping.generatedColumn;
			if (mapping.source != null) {
				sourceIdx = this._sources.indexOf(mapping.source);
				next += base64VLQ.encode(sourceIdx - previousSource);
				previousSource = sourceIdx;
				next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
				previousOriginalLine = mapping.originalLine - 1;
				next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
				previousOriginalColumn = mapping.originalColumn;
				if (mapping.name != null) {
					nameIdx = this._names.indexOf(mapping.name);
					next += base64VLQ.encode(nameIdx - previousName);
					previousName = nameIdx;
				}
			}
			result += next;
		}
		return result;
	};
	SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
		return aSources.map(function(source) {
			if (!this._sourcesContents) return null;
			if (aSourceRoot != null) source = util.relative(aSourceRoot, source);
			var key = util.toSetString(source);
			return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
		}, this);
	};
	/**
	* Externalize the source map.
	*/
	SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
		var map = {
			version: this._version,
			sources: this._sources.toArray(),
			names: this._names.toArray(),
			mappings: this._serializeMappings()
		};
		if (this._file != null) map.file = this._file;
		if (this._sourceRoot != null) map.sourceRoot = this._sourceRoot;
		if (this._sourcesContents) map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
		return map;
	};
	/**
	* Render the source map being generated to a string.
	*/
	SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
		return JSON.stringify(this.toJSON());
	};
	exports.SourceMapGenerator = SourceMapGenerator;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/binary-search.js
var require_binary_search = /* @__PURE__ */ __commonJSMin(((exports) => {
	exports.GREATEST_LOWER_BOUND = 1;
	exports.LEAST_UPPER_BOUND = 2;
	/**
	* Recursive implementation of binary search.
	*
	* @param aLow Indices here and lower do not contain the needle.
	* @param aHigh Indices here and higher do not contain the needle.
	* @param aNeedle The element being searched for.
	* @param aHaystack The non-empty array being searched.
	* @param aCompare Function which takes two elements and returns -1, 0, or 1.
	* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
	*     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*/
	function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
		var mid = Math.floor((aHigh - aLow) / 2) + aLow;
		var cmp = aCompare(aNeedle, aHaystack[mid], true);
		if (cmp === 0) return mid;
		else if (cmp > 0) {
			if (aHigh - mid > 1) return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
			if (aBias == exports.LEAST_UPPER_BOUND) return aHigh < aHaystack.length ? aHigh : -1;
			else return mid;
		} else {
			if (mid - aLow > 1) return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
			if (aBias == exports.LEAST_UPPER_BOUND) return mid;
			else return aLow < 0 ? -1 : aLow;
		}
	}
	/**
	* This is an implementation of binary search which will always try and return
	* the index of the closest element if there is no exact hit. This is because
	* mappings between original and generated line/col pairs are single points,
	* and there is an implicit region between each of them, so a miss just means
	* that you aren't on the very start of a region.
	*
	* @param aNeedle The element you are looking for.
	* @param aHaystack The array that is being searched.
	* @param aCompare A function which takes the needle and an element in the
	*     array and returns -1, 0, or 1 depending on whether the needle is less
	*     than, equal to, or greater than the element, respectively.
	* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
	*     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
	*/
	exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
		if (aHaystack.length === 0) return -1;
		var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports.GREATEST_LOWER_BOUND);
		if (index < 0) return -1;
		while (index - 1 >= 0) {
			if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) break;
			--index;
		}
		return index;
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/quick-sort.js
var require_quick_sort = /* @__PURE__ */ __commonJSMin(((exports) => {
	/**
	* Swap the elements indexed by `x` and `y` in the array `ary`.
	*
	* @param {Array} ary
	*        The array.
	* @param {Number} x
	*        The index of the first item.
	* @param {Number} y
	*        The index of the second item.
	*/
	function swap(ary, x, y) {
		var temp = ary[x];
		ary[x] = ary[y];
		ary[y] = temp;
	}
	/**
	* Returns a random integer within the range `low .. high` inclusive.
	*
	* @param {Number} low
	*        The lower bound on the range.
	* @param {Number} high
	*        The upper bound on the range.
	*/
	function randomIntInRange(low, high) {
		return Math.round(low + Math.random() * (high - low));
	}
	/**
	* The Quick Sort algorithm.
	*
	* @param {Array} ary
	*        An array to sort.
	* @param {function} comparator
	*        Function to use to compare two items.
	* @param {Number} p
	*        Start index of the array
	* @param {Number} r
	*        End index of the array
	*/
	function doQuickSort(ary, comparator, p, r) {
		if (p < r) {
			var pivotIndex = randomIntInRange(p, r);
			var i = p - 1;
			swap(ary, pivotIndex, r);
			var pivot = ary[r];
			for (var j = p; j < r; j++) if (comparator(ary[j], pivot) <= 0) {
				i += 1;
				swap(ary, i, j);
			}
			swap(ary, i + 1, j);
			var q = i + 1;
			doQuickSort(ary, comparator, p, q - 1);
			doQuickSort(ary, comparator, q + 1, r);
		}
	}
	/**
	* Sort the given array in-place with the given comparator function.
	*
	* @param {Array} ary
	*        An array to sort.
	* @param {function} comparator
	*        Function to use to compare two items.
	*/
	exports.quickSort = function(ary, comparator) {
		doQuickSort(ary, comparator, 0, ary.length - 1);
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-map-consumer.js
var require_source_map_consumer = /* @__PURE__ */ __commonJSMin(((exports) => {
	var util = require_util$8();
	var binarySearch = require_binary_search();
	var ArraySet = require_array_set().ArraySet;
	var base64VLQ = require_base64_vlq();
	var quickSort = require_quick_sort().quickSort;
	function SourceMapConsumer(aSourceMap, aSourceMapURL) {
		var sourceMap = aSourceMap;
		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
		return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
	}
	SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
		return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
	};
	/**
	* The version of the source mapping spec that we are consuming.
	*/
	SourceMapConsumer.prototype._version = 3;
	SourceMapConsumer.prototype.__generatedMappings = null;
	Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
		configurable: true,
		enumerable: true,
		get: function() {
			if (!this.__generatedMappings) this._parseMappings(this._mappings, this.sourceRoot);
			return this.__generatedMappings;
		}
	});
	SourceMapConsumer.prototype.__originalMappings = null;
	Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
		configurable: true,
		enumerable: true,
		get: function() {
			if (!this.__originalMappings) this._parseMappings(this._mappings, this.sourceRoot);
			return this.__originalMappings;
		}
	});
	SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
		var c = aStr.charAt(index);
		return c === ";" || c === ",";
	};
	/**
	* Parse the mappings in a string in to a data structure which we can easily
	* query (the ordered arrays in the `this.__generatedMappings` and
	* `this.__originalMappings` properties).
	*/
	SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
		throw new Error("Subclasses must implement _parseMappings");
	};
	SourceMapConsumer.GENERATED_ORDER = 1;
	SourceMapConsumer.ORIGINAL_ORDER = 2;
	SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
	SourceMapConsumer.LEAST_UPPER_BOUND = 2;
	/**
	* Iterate over each mapping between an original source/line/column and a
	* generated line/column in this source map.
	*
	* @param Function aCallback
	*        The function that is called with each mapping.
	* @param Object aContext
	*        Optional. If specified, this object will be the value of `this` every
	*        time that `aCallback` is called.
	* @param aOrder
	*        Either `SourceMapConsumer.GENERATED_ORDER` or
	*        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
	*        iterate over the mappings sorted by the generated file's line/column
	*        order or the original's source/line/column order, respectively. Defaults to
	*        `SourceMapConsumer.GENERATED_ORDER`.
	*/
	SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
		var context = aContext || null;
		var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
		var mappings;
		switch (order) {
			case SourceMapConsumer.GENERATED_ORDER:
				mappings = this._generatedMappings;
				break;
			case SourceMapConsumer.ORIGINAL_ORDER:
				mappings = this._originalMappings;
				break;
			default: throw new Error("Unknown order of iteration.");
		}
		var sourceRoot = this.sourceRoot;
		mappings.map(function(mapping) {
			var source = mapping.source === null ? null : this._sources.at(mapping.source);
			source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
			return {
				source,
				generatedLine: mapping.generatedLine,
				generatedColumn: mapping.generatedColumn,
				originalLine: mapping.originalLine,
				originalColumn: mapping.originalColumn,
				name: mapping.name === null ? null : this._names.at(mapping.name)
			};
		}, this).forEach(aCallback, context);
	};
	/**
	* Returns all generated line and column information for the original source,
	* line, and column provided. If no column is provided, returns all mappings
	* corresponding to a either the line we are searching for or the next
	* closest line that has any mappings. Otherwise, returns all mappings
	* corresponding to the given line and either the column we are searching for
	* or the next closest column that has any offsets.
	*
	* The only argument is an object with the following properties:
	*
	*   - source: The filename of the original source.
	*   - line: The line number in the original source.  The line number is 1-based.
	*   - column: Optional. the column number in the original source.
	*    The column number is 0-based.
	*
	* and an array of objects is returned, each with the following properties:
	*
	*   - line: The line number in the generated source, or null.  The
	*    line number is 1-based.
	*   - column: The column number in the generated source, or null.
	*    The column number is 0-based.
	*/
	SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
		var line = util.getArg(aArgs, "line");
		var needle = {
			source: util.getArg(aArgs, "source"),
			originalLine: line,
			originalColumn: util.getArg(aArgs, "column", 0)
		};
		needle.source = this._findSourceIndex(needle.source);
		if (needle.source < 0) return [];
		var mappings = [];
		var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND);
		if (index >= 0) {
			var mapping = this._originalMappings[index];
			if (aArgs.column === void 0) {
				var originalLine = mapping.originalLine;
				while (mapping && mapping.originalLine === originalLine) {
					mappings.push({
						line: util.getArg(mapping, "generatedLine", null),
						column: util.getArg(mapping, "generatedColumn", null),
						lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
					});
					mapping = this._originalMappings[++index];
				}
			} else {
				var originalColumn = mapping.originalColumn;
				while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
					mappings.push({
						line: util.getArg(mapping, "generatedLine", null),
						column: util.getArg(mapping, "generatedColumn", null),
						lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
					});
					mapping = this._originalMappings[++index];
				}
			}
		}
		return mappings;
	};
	exports.SourceMapConsumer = SourceMapConsumer;
	/**
	* A BasicSourceMapConsumer instance represents a parsed source map which we can
	* query for information about the original file positions by giving it a file
	* position in the generated source.
	*
	* The first parameter is the raw source map (either as a JSON string, or
	* already parsed to an object). According to the spec, source maps have the
	* following attributes:
	*
	*   - version: Which version of the source map spec this map is following.
	*   - sources: An array of URLs to the original source files.
	*   - names: An array of identifiers which can be referrenced by individual mappings.
	*   - sourceRoot: Optional. The URL root from which all sources are relative.
	*   - sourcesContent: Optional. An array of contents of the original source files.
	*   - mappings: A string of base64 VLQs which contain the actual mappings.
	*   - file: Optional. The generated file this source map is associated with.
	*
	* Here is an example source map, taken from the source map spec[0]:
	*
	*     {
	*       version : 3,
	*       file: "out.js",
	*       sourceRoot : "",
	*       sources: ["foo.js", "bar.js"],
	*       names: ["src", "maps", "are", "fun"],
	*       mappings: "AA,AB;;ABCDE;"
	*     }
	*
	* The second parameter, if given, is a string whose value is the URL
	* at which the source map was found.  This URL is used to compute the
	* sources array.
	*
	* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
	*/
	function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
		var sourceMap = aSourceMap;
		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
		var version = util.getArg(sourceMap, "version");
		var sources = util.getArg(sourceMap, "sources");
		var names = util.getArg(sourceMap, "names", []);
		var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
		var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
		var mappings = util.getArg(sourceMap, "mappings");
		var file = util.getArg(sourceMap, "file", null);
		if (version != this._version) throw new Error("Unsupported version: " + version);
		if (sourceRoot) sourceRoot = util.normalize(sourceRoot);
		sources = sources.map(String).map(util.normalize).map(function(source) {
			return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
		});
		this._names = ArraySet.fromArray(names.map(String), true);
		this._sources = ArraySet.fromArray(sources, true);
		this._absoluteSources = this._sources.toArray().map(function(s) {
			return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
		});
		this.sourceRoot = sourceRoot;
		this.sourcesContent = sourcesContent;
		this._mappings = mappings;
		this._sourceMapURL = aSourceMapURL;
		this.file = file;
	}
	BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
	BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
	/**
	* Utility function to find the index of a source.  Returns -1 if not
	* found.
	*/
	BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
		var relativeSource = aSource;
		if (this.sourceRoot != null) relativeSource = util.relative(this.sourceRoot, relativeSource);
		if (this._sources.has(relativeSource)) return this._sources.indexOf(relativeSource);
		var i;
		for (i = 0; i < this._absoluteSources.length; ++i) if (this._absoluteSources[i] == aSource) return i;
		return -1;
	};
	/**
	* Create a BasicSourceMapConsumer from a SourceMapGenerator.
	*
	* @param SourceMapGenerator aSourceMap
	*        The source map that will be consumed.
	* @param String aSourceMapURL
	*        The URL at which the source map can be found (optional)
	* @returns BasicSourceMapConsumer
	*/
	BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
		var smc = Object.create(BasicSourceMapConsumer.prototype);
		var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
		var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
		smc.sourceRoot = aSourceMap._sourceRoot;
		smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot);
		smc.file = aSourceMap._file;
		smc._sourceMapURL = aSourceMapURL;
		smc._absoluteSources = smc._sources.toArray().map(function(s) {
			return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
		});
		var generatedMappings = aSourceMap._mappings.toArray().slice();
		var destGeneratedMappings = smc.__generatedMappings = [];
		var destOriginalMappings = smc.__originalMappings = [];
		for (var i = 0, length = generatedMappings.length; i < length; i++) {
			var srcMapping = generatedMappings[i];
			var destMapping = new Mapping();
			destMapping.generatedLine = srcMapping.generatedLine;
			destMapping.generatedColumn = srcMapping.generatedColumn;
			if (srcMapping.source) {
				destMapping.source = sources.indexOf(srcMapping.source);
				destMapping.originalLine = srcMapping.originalLine;
				destMapping.originalColumn = srcMapping.originalColumn;
				if (srcMapping.name) destMapping.name = names.indexOf(srcMapping.name);
				destOriginalMappings.push(destMapping);
			}
			destGeneratedMappings.push(destMapping);
		}
		quickSort(smc.__originalMappings, util.compareByOriginalPositions);
		return smc;
	};
	/**
	* The version of the source mapping spec that we are consuming.
	*/
	BasicSourceMapConsumer.prototype._version = 3;
	/**
	* The list of original sources.
	*/
	Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", { get: function() {
		return this._absoluteSources.slice();
	} });
	/**
	* Provide the JIT with a nice shape / hidden class.
	*/
	function Mapping() {
		this.generatedLine = 0;
		this.generatedColumn = 0;
		this.source = null;
		this.originalLine = null;
		this.originalColumn = null;
		this.name = null;
	}
	/**
	* Parse the mappings in a string in to a data structure which we can easily
	* query (the ordered arrays in the `this.__generatedMappings` and
	* `this.__originalMappings` properties).
	*/
	BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
		var generatedLine = 1;
		var previousGeneratedColumn = 0;
		var previousOriginalLine = 0;
		var previousOriginalColumn = 0;
		var previousSource = 0;
		var previousName = 0;
		var length = aStr.length;
		var index = 0;
		var cachedSegments = {};
		var temp = {};
		var originalMappings = [];
		var generatedMappings = [];
		var mapping;
		var str;
		var segment;
		var end;
		var value;
		while (index < length) if (aStr.charAt(index) === ";") {
			generatedLine++;
			index++;
			previousGeneratedColumn = 0;
		} else if (aStr.charAt(index) === ",") index++;
		else {
			mapping = new Mapping();
			mapping.generatedLine = generatedLine;
			for (end = index; end < length; end++) if (this._charIsMappingSeparator(aStr, end)) break;
			str = aStr.slice(index, end);
			segment = cachedSegments[str];
			if (segment) index += str.length;
			else {
				segment = [];
				while (index < end) {
					base64VLQ.decode(aStr, index, temp);
					value = temp.value;
					index = temp.rest;
					segment.push(value);
				}
				if (segment.length === 2) throw new Error("Found a source, but no line and column");
				if (segment.length === 3) throw new Error("Found a source and line, but no column");
				cachedSegments[str] = segment;
			}
			mapping.generatedColumn = previousGeneratedColumn + segment[0];
			previousGeneratedColumn = mapping.generatedColumn;
			if (segment.length > 1) {
				mapping.source = previousSource + segment[1];
				previousSource += segment[1];
				mapping.originalLine = previousOriginalLine + segment[2];
				previousOriginalLine = mapping.originalLine;
				mapping.originalLine += 1;
				mapping.originalColumn = previousOriginalColumn + segment[3];
				previousOriginalColumn = mapping.originalColumn;
				if (segment.length > 4) {
					mapping.name = previousName + segment[4];
					previousName += segment[4];
				}
			}
			generatedMappings.push(mapping);
			if (typeof mapping.originalLine === "number") originalMappings.push(mapping);
		}
		quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
		this.__generatedMappings = generatedMappings;
		quickSort(originalMappings, util.compareByOriginalPositions);
		this.__originalMappings = originalMappings;
	};
	/**
	* Find the mapping that best matches the hypothetical "needle" mapping that
	* we are searching for in the given "haystack" of mappings.
	*/
	BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
		if (aNeedle[aLineName] <= 0) throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
		if (aNeedle[aColumnName] < 0) throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
		return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
	};
	/**
	* Compute the last column for each generated mapping. The last column is
	* inclusive.
	*/
	BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
		for (var index = 0; index < this._generatedMappings.length; ++index) {
			var mapping = this._generatedMappings[index];
			if (index + 1 < this._generatedMappings.length) {
				var nextMapping = this._generatedMappings[index + 1];
				if (mapping.generatedLine === nextMapping.generatedLine) {
					mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
					continue;
				}
			}
			mapping.lastGeneratedColumn = Infinity;
		}
	};
	/**
	* Returns the original source, line, and column information for the generated
	* source's line and column positions provided. The only argument is an object
	* with the following properties:
	*
	*   - line: The line number in the generated source.  The line number
	*     is 1-based.
	*   - column: The column number in the generated source.  The column
	*     number is 0-based.
	*   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
	*     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
	*
	* and an object is returned with the following properties:
	*
	*   - source: The original source file, or null.
	*   - line: The line number in the original source, or null.  The
	*     line number is 1-based.
	*   - column: The column number in the original source, or null.  The
	*     column number is 0-based.
	*   - name: The original identifier, or null.
	*/
	BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
		var needle = {
			generatedLine: util.getArg(aArgs, "line"),
			generatedColumn: util.getArg(aArgs, "column")
		};
		var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
		if (index >= 0) {
			var mapping = this._generatedMappings[index];
			if (mapping.generatedLine === needle.generatedLine) {
				var source = util.getArg(mapping, "source", null);
				if (source !== null) {
					source = this._sources.at(source);
					source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
				}
				var name = util.getArg(mapping, "name", null);
				if (name !== null) name = this._names.at(name);
				return {
					source,
					line: util.getArg(mapping, "originalLine", null),
					column: util.getArg(mapping, "originalColumn", null),
					name
				};
			}
		}
		return {
			source: null,
			line: null,
			column: null,
			name: null
		};
	};
	/**
	* Return true if we have the source content for every source in the source
	* map, false otherwise.
	*/
	BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
		if (!this.sourcesContent) return false;
		return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
			return sc == null;
		});
	};
	/**
	* Returns the original source content. The only argument is the url of the
	* original source file. Returns null if no original source content is
	* available.
	*/
	BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
		if (!this.sourcesContent) return null;
		var index = this._findSourceIndex(aSource);
		if (index >= 0) return this.sourcesContent[index];
		var relativeSource = aSource;
		if (this.sourceRoot != null) relativeSource = util.relative(this.sourceRoot, relativeSource);
		var url;
		if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
			var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
			if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
			if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
		}
		if (nullOnMissing) return null;
		else throw new Error("\"" + relativeSource + "\" is not in the SourceMap.");
	};
	/**
	* Returns the generated line and column information for the original source,
	* line, and column positions provided. The only argument is an object with
	* the following properties:
	*
	*   - source: The filename of the original source.
	*   - line: The line number in the original source.  The line number
	*     is 1-based.
	*   - column: The column number in the original source.  The column
	*     number is 0-based.
	*   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
	*     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
	*
	* and an object is returned with the following properties:
	*
	*   - line: The line number in the generated source, or null.  The
	*     line number is 1-based.
	*   - column: The column number in the generated source, or null.
	*     The column number is 0-based.
	*/
	BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
		var source = util.getArg(aArgs, "source");
		source = this._findSourceIndex(source);
		if (source < 0) return {
			line: null,
			column: null,
			lastColumn: null
		};
		var needle = {
			source,
			originalLine: util.getArg(aArgs, "line"),
			originalColumn: util.getArg(aArgs, "column")
		};
		var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
		if (index >= 0) {
			var mapping = this._originalMappings[index];
			if (mapping.source === needle.source) return {
				line: util.getArg(mapping, "generatedLine", null),
				column: util.getArg(mapping, "generatedColumn", null),
				lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
			};
		}
		return {
			line: null,
			column: null,
			lastColumn: null
		};
	};
	exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
	/**
	* An IndexedSourceMapConsumer instance represents a parsed source map which
	* we can query for information. It differs from BasicSourceMapConsumer in
	* that it takes "indexed" source maps (i.e. ones with a "sections" field) as
	* input.
	*
	* The first parameter is a raw source map (either as a JSON string, or already
	* parsed to an object). According to the spec for indexed source maps, they
	* have the following attributes:
	*
	*   - version: Which version of the source map spec this map is following.
	*   - file: Optional. The generated file this source map is associated with.
	*   - sections: A list of section definitions.
	*
	* Each value under the "sections" field has two fields:
	*   - offset: The offset into the original specified at which this section
	*       begins to apply, defined as an object with a "line" and "column"
	*       field.
	*   - map: A source map definition. This source map could also be indexed,
	*       but doesn't have to be.
	*
	* Instead of the "map" field, it's also possible to have a "url" field
	* specifying a URL to retrieve a source map from, but that's currently
	* unsupported.
	*
	* Here's an example source map, taken from the source map spec[0], but
	* modified to omit a section which uses the "url" field.
	*
	*  {
	*    version : 3,
	*    file: "app.js",
	*    sections: [{
	*      offset: {line:100, column:10},
	*      map: {
	*        version : 3,
	*        file: "section.js",
	*        sources: ["foo.js", "bar.js"],
	*        names: ["src", "maps", "are", "fun"],
	*        mappings: "AAAA,E;;ABCDE;"
	*      }
	*    }],
	*  }
	*
	* The second parameter, if given, is a string whose value is the URL
	* at which the source map was found.  This URL is used to compute the
	* sources array.
	*
	* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
	*/
	function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
		var sourceMap = aSourceMap;
		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
		var version = util.getArg(sourceMap, "version");
		var sections = util.getArg(sourceMap, "sections");
		if (version != this._version) throw new Error("Unsupported version: " + version);
		this._sources = new ArraySet();
		this._names = new ArraySet();
		var lastOffset = {
			line: -1,
			column: 0
		};
		this._sections = sections.map(function(s) {
			if (s.url) throw new Error("Support for url field in sections not implemented.");
			var offset = util.getArg(s, "offset");
			var offsetLine = util.getArg(offset, "line");
			var offsetColumn = util.getArg(offset, "column");
			if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) throw new Error("Section offsets must be ordered and non-overlapping.");
			lastOffset = offset;
			return {
				generatedOffset: {
					generatedLine: offsetLine + 1,
					generatedColumn: offsetColumn + 1
				},
				consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
			};
		});
	}
	IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
	IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
	/**
	* The version of the source mapping spec that we are consuming.
	*/
	IndexedSourceMapConsumer.prototype._version = 3;
	/**
	* The list of original sources.
	*/
	Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", { get: function() {
		var sources = [];
		for (var i = 0; i < this._sections.length; i++) for (var j = 0; j < this._sections[i].consumer.sources.length; j++) sources.push(this._sections[i].consumer.sources[j]);
		return sources;
	} });
	/**
	* Returns the original source, line, and column information for the generated
	* source's line and column positions provided. The only argument is an object
	* with the following properties:
	*
	*   - line: The line number in the generated source.  The line number
	*     is 1-based.
	*   - column: The column number in the generated source.  The column
	*     number is 0-based.
	*
	* and an object is returned with the following properties:
	*
	*   - source: The original source file, or null.
	*   - line: The line number in the original source, or null.  The
	*     line number is 1-based.
	*   - column: The column number in the original source, or null.  The
	*     column number is 0-based.
	*   - name: The original identifier, or null.
	*/
	IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
		var needle = {
			generatedLine: util.getArg(aArgs, "line"),
			generatedColumn: util.getArg(aArgs, "column")
		};
		var sectionIndex = binarySearch.search(needle, this._sections, function(needle, section) {
			var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
			if (cmp) return cmp;
			return needle.generatedColumn - section.generatedOffset.generatedColumn;
		});
		var section = this._sections[sectionIndex];
		if (!section) return {
			source: null,
			line: null,
			column: null,
			name: null
		};
		return section.consumer.originalPositionFor({
			line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
			column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
			bias: aArgs.bias
		});
	};
	/**
	* Return true if we have the source content for every source in the source
	* map, false otherwise.
	*/
	IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
		return this._sections.every(function(s) {
			return s.consumer.hasContentsOfAllSources();
		});
	};
	/**
	* Returns the original source content. The only argument is the url of the
	* original source file. Returns null if no original source content is
	* available.
	*/
	IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
		for (var i = 0; i < this._sections.length; i++) {
			var content = this._sections[i].consumer.sourceContentFor(aSource, true);
			if (content) return content;
		}
		if (nullOnMissing) return null;
		else throw new Error("\"" + aSource + "\" is not in the SourceMap.");
	};
	/**
	* Returns the generated line and column information for the original source,
	* line, and column positions provided. The only argument is an object with
	* the following properties:
	*
	*   - source: The filename of the original source.
	*   - line: The line number in the original source.  The line number
	*     is 1-based.
	*   - column: The column number in the original source.  The column
	*     number is 0-based.
	*
	* and an object is returned with the following properties:
	*
	*   - line: The line number in the generated source, or null.  The
	*     line number is 1-based. 
	*   - column: The column number in the generated source, or null.
	*     The column number is 0-based.
	*/
	IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
		for (var i = 0; i < this._sections.length; i++) {
			var section = this._sections[i];
			if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) continue;
			var generatedPosition = section.consumer.generatedPositionFor(aArgs);
			if (generatedPosition) return {
				line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
				column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
			};
		}
		return {
			line: null,
			column: null
		};
	};
	/**
	* Parse the mappings in a string in to a data structure which we can easily
	* query (the ordered arrays in the `this.__generatedMappings` and
	* `this.__originalMappings` properties).
	*/
	IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
		this.__generatedMappings = [];
		this.__originalMappings = [];
		for (var i = 0; i < this._sections.length; i++) {
			var section = this._sections[i];
			var sectionMappings = section.consumer._generatedMappings;
			for (var j = 0; j < sectionMappings.length; j++) {
				var mapping = sectionMappings[j];
				var source = section.consumer._sources.at(mapping.source);
				source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
				this._sources.add(source);
				source = this._sources.indexOf(source);
				var name = null;
				if (mapping.name) {
					name = section.consumer._names.at(mapping.name);
					this._names.add(name);
					name = this._names.indexOf(name);
				}
				var adjustedMapping = {
					source,
					generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
					generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
					originalLine: mapping.originalLine,
					originalColumn: mapping.originalColumn,
					name
				};
				this.__generatedMappings.push(adjustedMapping);
				if (typeof adjustedMapping.originalLine === "number") this.__originalMappings.push(adjustedMapping);
			}
		}
		quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
		quickSort(this.__originalMappings, util.compareByOriginalPositions);
	};
	exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-node.js
var require_source_node = /* @__PURE__ */ __commonJSMin(((exports) => {
	var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
	var util = require_util$8();
	var REGEX_NEWLINE = /(\r?\n)/;
	var NEWLINE_CODE = 10;
	var isSourceNode = "$$$isSourceNode$$$";
	/**
	* SourceNodes provide a way to abstract over interpolating/concatenating
	* snippets of generated JavaScript source code while maintaining the line and
	* column information associated with the original source code.
	*
	* @param aLine The original line number.
	* @param aColumn The original column number.
	* @param aSource The original source's filename.
	* @param aChunks Optional. An array of strings which are snippets of
	*        generated JS, or other SourceNodes.
	* @param aName The original identifier.
	*/
	function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
		this.children = [];
		this.sourceContents = {};
		this.line = aLine == null ? null : aLine;
		this.column = aColumn == null ? null : aColumn;
		this.source = aSource == null ? null : aSource;
		this.name = aName == null ? null : aName;
		this[isSourceNode] = true;
		if (aChunks != null) this.add(aChunks);
	}
	/**
	* Creates a SourceNode from generated code and a SourceMapConsumer.
	*
	* @param aGeneratedCode The generated code
	* @param aSourceMapConsumer The SourceMap for the generated code
	* @param aRelativePath Optional. The path that relative sources in the
	*        SourceMapConsumer should be relative to.
	*/
	SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
		var node = new SourceNode();
		var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
		var remainingLinesIndex = 0;
		var shiftNextLine = function() {
			return getNextLine() + (getNextLine() || "");
			function getNextLine() {
				return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0;
			}
		};
		var lastGeneratedLine = 1;
		var lastGeneratedColumn = 0;
		var lastMapping = null;
		aSourceMapConsumer.eachMapping(function(mapping) {
			if (lastMapping !== null) {
				if (lastGeneratedLine < mapping.generatedLine) {
					addMappingWithCode(lastMapping, shiftNextLine());
					lastGeneratedLine++;
					lastGeneratedColumn = 0;
				} else {
					var nextLine = remainingLines[remainingLinesIndex] || "";
					var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
					remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
					lastGeneratedColumn = mapping.generatedColumn;
					addMappingWithCode(lastMapping, code);
					lastMapping = mapping;
					return;
				}
			}
			while (lastGeneratedLine < mapping.generatedLine) {
				node.add(shiftNextLine());
				lastGeneratedLine++;
			}
			if (lastGeneratedColumn < mapping.generatedColumn) {
				var nextLine = remainingLines[remainingLinesIndex] || "";
				node.add(nextLine.substr(0, mapping.generatedColumn));
				remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
				lastGeneratedColumn = mapping.generatedColumn;
			}
			lastMapping = mapping;
		}, this);
		if (remainingLinesIndex < remainingLines.length) {
			if (lastMapping) addMappingWithCode(lastMapping, shiftNextLine());
			node.add(remainingLines.splice(remainingLinesIndex).join(""));
		}
		aSourceMapConsumer.sources.forEach(function(sourceFile) {
			var content = aSourceMapConsumer.sourceContentFor(sourceFile);
			if (content != null) {
				if (aRelativePath != null) sourceFile = util.join(aRelativePath, sourceFile);
				node.setSourceContent(sourceFile, content);
			}
		});
		return node;
		function addMappingWithCode(mapping, code) {
			if (mapping === null || mapping.source === void 0) node.add(code);
			else {
				var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
				node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name));
			}
		}
	};
	/**
	* Add a chunk of generated JS to this source node.
	*
	* @param aChunk A string snippet of generated JS code, another instance of
	*        SourceNode, or an array where each member is one of those things.
	*/
	SourceNode.prototype.add = function SourceNode_add(aChunk) {
		if (Array.isArray(aChunk)) aChunk.forEach(function(chunk) {
			this.add(chunk);
		}, this);
		else if (aChunk[isSourceNode] || typeof aChunk === "string") {
			if (aChunk) this.children.push(aChunk);
		} else throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
		return this;
	};
	/**
	* Add a chunk of generated JS to the beginning of this source node.
	*
	* @param aChunk A string snippet of generated JS code, another instance of
	*        SourceNode, or an array where each member is one of those things.
	*/
	SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
		if (Array.isArray(aChunk)) for (var i = aChunk.length - 1; i >= 0; i--) this.prepend(aChunk[i]);
		else if (aChunk[isSourceNode] || typeof aChunk === "string") this.children.unshift(aChunk);
		else throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
		return this;
	};
	/**
	* Walk over the tree of JS snippets in this node and its children. The
	* walking function is called once for each snippet of JS and is passed that
	* snippet and the its original associated source's line/column location.
	*
	* @param aFn The traversal function.
	*/
	SourceNode.prototype.walk = function SourceNode_walk(aFn) {
		var chunk;
		for (var i = 0, len = this.children.length; i < len; i++) {
			chunk = this.children[i];
			if (chunk[isSourceNode]) chunk.walk(aFn);
			else if (chunk !== "") aFn(chunk, {
				source: this.source,
				line: this.line,
				column: this.column,
				name: this.name
			});
		}
	};
	/**
	* Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
	* each of `this.children`.
	*
	* @param aSep The separator.
	*/
	SourceNode.prototype.join = function SourceNode_join(aSep) {
		var newChildren;
		var i;
		var len = this.children.length;
		if (len > 0) {
			newChildren = [];
			for (i = 0; i < len - 1; i++) {
				newChildren.push(this.children[i]);
				newChildren.push(aSep);
			}
			newChildren.push(this.children[i]);
			this.children = newChildren;
		}
		return this;
	};
	/**
	* Call String.prototype.replace on the very right-most source snippet. Useful
	* for trimming whitespace from the end of a source node, etc.
	*
	* @param aPattern The pattern to replace.
	* @param aReplacement The thing to replace the pattern with.
	*/
	SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
		var lastChild = this.children[this.children.length - 1];
		if (lastChild[isSourceNode]) lastChild.replaceRight(aPattern, aReplacement);
		else if (typeof lastChild === "string") this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
		else this.children.push("".replace(aPattern, aReplacement));
		return this;
	};
	/**
	* Set the source content for a source file. This will be added to the SourceMapGenerator
	* in the sourcesContent field.
	*
	* @param aSourceFile The filename of the source file
	* @param aSourceContent The content of the source file
	*/
	SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
		this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
	};
	/**
	* Walk over the tree of SourceNodes. The walking function is called for each
	* source file content and is passed the filename and source content.
	*
	* @param aFn The traversal function.
	*/
	SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
		for (var i = 0, len = this.children.length; i < len; i++) if (this.children[i][isSourceNode]) this.children[i].walkSourceContents(aFn);
		var sources = Object.keys(this.sourceContents);
		for (var i = 0, len = sources.length; i < len; i++) aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
	};
	/**
	* Return the string representation of this source node. Walks over the tree
	* and concatenates all the various snippets together to one string.
	*/
	SourceNode.prototype.toString = function SourceNode_toString() {
		var str = "";
		this.walk(function(chunk) {
			str += chunk;
		});
		return str;
	};
	/**
	* Returns the string representation of this source node along with a source
	* map.
	*/
	SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
		var generated = {
			code: "",
			line: 1,
			column: 0
		};
		var map = new SourceMapGenerator(aArgs);
		var sourceMappingActive = false;
		var lastOriginalSource = null;
		var lastOriginalLine = null;
		var lastOriginalColumn = null;
		var lastOriginalName = null;
		this.walk(function(chunk, original) {
			generated.code += chunk;
			if (original.source !== null && original.line !== null && original.column !== null) {
				if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) map.addMapping({
					source: original.source,
					original: {
						line: original.line,
						column: original.column
					},
					generated: {
						line: generated.line,
						column: generated.column
					},
					name: original.name
				});
				lastOriginalSource = original.source;
				lastOriginalLine = original.line;
				lastOriginalColumn = original.column;
				lastOriginalName = original.name;
				sourceMappingActive = true;
			} else if (sourceMappingActive) {
				map.addMapping({ generated: {
					line: generated.line,
					column: generated.column
				} });
				lastOriginalSource = null;
				sourceMappingActive = false;
			}
			for (var idx = 0, length = chunk.length; idx < length; idx++) if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
				generated.line++;
				generated.column = 0;
				if (idx + 1 === length) {
					lastOriginalSource = null;
					sourceMappingActive = false;
				} else if (sourceMappingActive) map.addMapping({
					source: original.source,
					original: {
						line: original.line,
						column: original.column
					},
					generated: {
						line: generated.line,
						column: generated.column
					},
					name: original.name
				});
			} else generated.column++;
		});
		this.walkSourceContents(function(sourceFile, sourceContent) {
			map.setSourceContent(sourceFile, sourceContent);
		});
		return {
			code: generated.code,
			map
		};
	};
	exports.SourceNode = SourceNode;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/source-map.js
var require_source_map = /* @__PURE__ */ __commonJSMin(((exports) => {
	exports.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
	exports.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
	exports.SourceNode = require_source_node().SourceNode;
}));
//#endregion
//#region node_modules/.pnpm/buffer-from@1.1.2/node_modules/buffer-from/index.js
var require_buffer_from = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var toString = Object.prototype.toString;
	var isModern = typeof Buffer !== "undefined" && typeof Buffer.alloc === "function" && typeof Buffer.allocUnsafe === "function" && typeof Buffer.from === "function";
	function isArrayBuffer(input) {
		return toString.call(input).slice(8, -1) === "ArrayBuffer";
	}
	function fromArrayBuffer(obj, byteOffset, length) {
		byteOffset >>>= 0;
		var maxLength = obj.byteLength - byteOffset;
		if (maxLength < 0) throw new RangeError("'offset' is out of bounds");
		if (length === void 0) length = maxLength;
		else {
			length >>>= 0;
			if (length > maxLength) throw new RangeError("'length' is out of bounds");
		}
		return isModern ? Buffer.from(obj.slice(byteOffset, byteOffset + length)) : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)));
	}
	function fromString(string, encoding) {
		if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
		if (!Buffer.isEncoding(encoding)) throw new TypeError("\"encoding\" must be a valid string encoding");
		return isModern ? Buffer.from(string, encoding) : new Buffer(string, encoding);
	}
	function bufferFrom(value, encodingOrOffset, length) {
		if (typeof value === "number") throw new TypeError("\"value\" argument must not be a number");
		if (isArrayBuffer(value)) return fromArrayBuffer(value, encodingOrOffset, length);
		if (typeof value === "string") return fromString(value, encodingOrOffset);
		return isModern ? Buffer.from(value) : new Buffer(value);
	}
	module.exports = bufferFrom;
}));
//#endregion
//#region node_modules/.pnpm/source-map-support@0.5.21/node_modules/source-map-support/register.js
(/* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SourceMapConsumer = require_source_map().SourceMapConsumer;
	var path$3 = __require("path");
	var fs;
	try {
		fs = __require("fs");
		if (!fs.existsSync || !fs.readFileSync) fs = null;
	} catch (err) {}
	var bufferFrom = require_buffer_from();
	/**
	* Requires a module which is protected against bundler minification.
	*
	* @param {NodeModule} mod
	* @param {string} request
	*/
	function dynamicRequire(mod, request) {
		return mod.require(request);
	}
	var errorFormatterInstalled = false;
	var uncaughtShimInstalled = false;
	var emptyCacheBetweenOperations = false;
	var environment = "auto";
	var fileContentsCache = {};
	var sourceMapCache = {};
	var reSourceMap = /^data:application\/json[^,]+base64,/;
	var retrieveFileHandlers = [];
	var retrieveMapHandlers = [];
	function isInBrowser() {
		if (environment === "browser") return true;
		if (environment === "node") return false;
		return typeof window !== "undefined" && typeof XMLHttpRequest === "function" && !(window.require && window.module && window.process && window.process.type === "renderer");
	}
	function hasGlobalProcessEventEmitter() {
		return typeof process === "object" && process !== null && typeof process.on === "function";
	}
	function globalProcessVersion() {
		if (typeof process === "object" && process !== null) return process.version;
		else return "";
	}
	function globalProcessStderr() {
		if (typeof process === "object" && process !== null) return process.stderr;
	}
	function globalProcessExit(code) {
		if (typeof process === "object" && process !== null && typeof process.exit === "function") return process.exit(code);
	}
	function handlerExec(list) {
		return function(arg) {
			for (var i = 0; i < list.length; i++) {
				var ret = list[i](arg);
				if (ret) return ret;
			}
			return null;
		};
	}
	var retrieveFile = handlerExec(retrieveFileHandlers);
	retrieveFileHandlers.push(function(path) {
		path = path.trim();
		if (/^file:/.test(path)) path = path.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
			return drive ? "" : "/";
		});
		if (path in fileContentsCache) return fileContentsCache[path];
		var contents = "";
		try {
			if (!fs) {
				var xhr = new XMLHttpRequest();
				xhr.open(
					"GET",
					path,
					/** async */
					false
				);
				xhr.send(null);
				if (xhr.readyState === 4 && xhr.status === 200) contents = xhr.responseText;
			} else if (fs.existsSync(path)) contents = fs.readFileSync(path, "utf8");
		} catch (er) {}
		return fileContentsCache[path] = contents;
	});
	function supportRelativeURL(file, url) {
		if (!file) return url;
		var dir = path$3.dirname(file);
		var match = /^\w+:\/\/[^\/]*/.exec(dir);
		var protocol = match ? match[0] : "";
		var startPath = dir.slice(protocol.length);
		if (protocol && /^\/\w\:/.test(startPath)) {
			protocol += "/";
			return protocol + path$3.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
		}
		return protocol + path$3.resolve(dir.slice(protocol.length), url);
	}
	function retrieveSourceMapURL(source) {
		var fileData;
		if (isInBrowser()) try {
			var xhr = new XMLHttpRequest();
			xhr.open("GET", source, false);
			xhr.send(null);
			fileData = xhr.readyState === 4 ? xhr.responseText : null;
			var sourceMapHeader = xhr.getResponseHeader("SourceMap") || xhr.getResponseHeader("X-SourceMap");
			if (sourceMapHeader) return sourceMapHeader;
		} catch (e) {}
		fileData = retrieveFile(source);
		var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/gm;
		var lastMatch;
		var match;
		while (match = re.exec(fileData)) lastMatch = match;
		if (!lastMatch) return null;
		return lastMatch[1];
	}
	var retrieveSourceMap = handlerExec(retrieveMapHandlers);
	retrieveMapHandlers.push(function(source) {
		var sourceMappingURL = retrieveSourceMapURL(source);
		if (!sourceMappingURL) return null;
		var sourceMapData;
		if (reSourceMap.test(sourceMappingURL)) {
			sourceMapData = bufferFrom(sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1), "base64").toString();
			sourceMappingURL = source;
		} else {
			sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
			sourceMapData = retrieveFile(sourceMappingURL);
		}
		if (!sourceMapData) return null;
		return {
			url: sourceMappingURL,
			map: sourceMapData
		};
	});
	function mapSourcePosition(position) {
		var sourceMap = sourceMapCache[position.source];
		if (!sourceMap) {
			var urlAndMap = retrieveSourceMap(position.source);
			if (urlAndMap) {
				sourceMap = sourceMapCache[position.source] = {
					url: urlAndMap.url,
					map: new SourceMapConsumer(urlAndMap.map)
				};
				if (sourceMap.map.sourcesContent) sourceMap.map.sources.forEach(function(source, i) {
					var contents = sourceMap.map.sourcesContent[i];
					if (contents) {
						var url = supportRelativeURL(sourceMap.url, source);
						fileContentsCache[url] = contents;
					}
				});
			} else sourceMap = sourceMapCache[position.source] = {
				url: null,
				map: null
			};
		}
		if (sourceMap && sourceMap.map && typeof sourceMap.map.originalPositionFor === "function") {
			var originalPosition = sourceMap.map.originalPositionFor(position);
			if (originalPosition.source !== null) {
				originalPosition.source = supportRelativeURL(sourceMap.url, originalPosition.source);
				return originalPosition;
			}
		}
		return position;
	}
	function mapEvalOrigin(origin) {
		var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
		if (match) {
			var position = mapSourcePosition({
				source: match[2],
				line: +match[3],
				column: match[4] - 1
			});
			return "eval at " + match[1] + " (" + position.source + ":" + position.line + ":" + (position.column + 1) + ")";
		}
		match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
		if (match) return "eval at " + match[1] + " (" + mapEvalOrigin(match[2]) + ")";
		return origin;
	}
	function CallSiteToString() {
		var fileName;
		var fileLocation = "";
		if (this.isNative()) fileLocation = "native";
		else {
			fileName = this.getScriptNameOrSourceURL();
			if (!fileName && this.isEval()) {
				fileLocation = this.getEvalOrigin();
				fileLocation += ", ";
			}
			if (fileName) fileLocation += fileName;
			else fileLocation += "<anonymous>";
			var lineNumber = this.getLineNumber();
			if (lineNumber != null) {
				fileLocation += ":" + lineNumber;
				var columnNumber = this.getColumnNumber();
				if (columnNumber) fileLocation += ":" + columnNumber;
			}
		}
		var line = "";
		var functionName = this.getFunctionName();
		var addSuffix = true;
		var isConstructor = this.isConstructor();
		if (!(this.isToplevel() || isConstructor)) {
			var typeName = this.getTypeName();
			if (typeName === "[object Object]") typeName = "null";
			var methodName = this.getMethodName();
			if (functionName) {
				if (typeName && functionName.indexOf(typeName) != 0) line += typeName + ".";
				line += functionName;
				if (methodName && functionName.indexOf("." + methodName) != functionName.length - methodName.length - 1) line += " [as " + methodName + "]";
			} else line += typeName + "." + (methodName || "<anonymous>");
		} else if (isConstructor) line += "new " + (functionName || "<anonymous>");
		else if (functionName) line += functionName;
		else {
			line += fileLocation;
			addSuffix = false;
		}
		if (addSuffix) line += " (" + fileLocation + ")";
		return line;
	}
	function cloneCallSite(frame) {
		var object = {};
		Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function(name) {
			object[name] = /^(?:is|get)/.test(name) ? function() {
				return frame[name].call(frame);
			} : frame[name];
		});
		object.toString = CallSiteToString;
		return object;
	}
	function wrapCallSite(frame, state) {
		if (state === void 0) state = {
			nextPosition: null,
			curPosition: null
		};
		if (frame.isNative()) {
			state.curPosition = null;
			return frame;
		}
		var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
		if (source) {
			var line = frame.getLineNumber();
			var column = frame.getColumnNumber() - 1;
			var headerLength = /^v(10\.1[6-9]|10\.[2-9][0-9]|10\.[0-9]{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/.test(globalProcessVersion()) ? 0 : 62;
			if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) column -= headerLength;
			var position = mapSourcePosition({
				source,
				line,
				column
			});
			state.curPosition = position;
			frame = cloneCallSite(frame);
			var originalFunctionName = frame.getFunctionName;
			frame.getFunctionName = function() {
				if (state.nextPosition == null) return originalFunctionName();
				return state.nextPosition.name || originalFunctionName();
			};
			frame.getFileName = function() {
				return position.source;
			};
			frame.getLineNumber = function() {
				return position.line;
			};
			frame.getColumnNumber = function() {
				return position.column + 1;
			};
			frame.getScriptNameOrSourceURL = function() {
				return position.source;
			};
			return frame;
		}
		var origin = frame.isEval() && frame.getEvalOrigin();
		if (origin) {
			origin = mapEvalOrigin(origin);
			frame = cloneCallSite(frame);
			frame.getEvalOrigin = function() {
				return origin;
			};
			return frame;
		}
		return frame;
	}
	function prepareStackTrace(error, stack) {
		if (emptyCacheBetweenOperations) {
			fileContentsCache = {};
			sourceMapCache = {};
		}
		var name = error.name || "Error";
		var message = error.message || "";
		var errorString = name + ": " + message;
		var state = {
			nextPosition: null,
			curPosition: null
		};
		var processedStack = [];
		for (var i = stack.length - 1; i >= 0; i--) {
			processedStack.push("\n    at " + wrapCallSite(stack[i], state));
			state.nextPosition = state.curPosition;
		}
		state.curPosition = state.nextPosition = null;
		return errorString + processedStack.reverse().join("");
	}
	function getErrorSource(error) {
		var match = /\n    at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
		if (match) {
			var source = match[1];
			var line = +match[2];
			var column = +match[3];
			var contents = fileContentsCache[source];
			if (!contents && fs && fs.existsSync(source)) try {
				contents = fs.readFileSync(source, "utf8");
			} catch (er) {
				contents = "";
			}
			if (contents) {
				var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
				if (code) return source + ":" + line + "\n" + code + "\n" + new Array(column).join(" ") + "^";
			}
		}
		return null;
	}
	function printErrorAndExit(error) {
		var source = getErrorSource(error);
		var stderr = globalProcessStderr();
		if (stderr && stderr._handle && stderr._handle.setBlocking) stderr._handle.setBlocking(true);
		if (source) {
			console.error();
			console.error(source);
		}
		console.error(error.stack);
		globalProcessExit(1);
	}
	function shimEmitUncaughtException() {
		var origEmit = process.emit;
		process.emit = function(type) {
			if (type === "uncaughtException") {
				var hasStack = arguments[1] && arguments[1].stack;
				var hasListeners = this.listeners(type).length > 0;
				if (hasStack && !hasListeners) return printErrorAndExit(arguments[1]);
			}
			return origEmit.apply(this, arguments);
		};
	}
	var originalRetrieveFileHandlers = retrieveFileHandlers.slice(0);
	var originalRetrieveMapHandlers = retrieveMapHandlers.slice(0);
	exports.wrapCallSite = wrapCallSite;
	exports.getErrorSource = getErrorSource;
	exports.mapSourcePosition = mapSourcePosition;
	exports.retrieveSourceMap = retrieveSourceMap;
	exports.install = function(options) {
		options = options || {};
		if (options.environment) {
			environment = options.environment;
			if ([
				"node",
				"browser",
				"auto"
			].indexOf(environment) === -1) throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}");
		}
		if (options.retrieveFile) {
			if (options.overrideRetrieveFile) retrieveFileHandlers.length = 0;
			retrieveFileHandlers.unshift(options.retrieveFile);
		}
		if (options.retrieveSourceMap) {
			if (options.overrideRetrieveSourceMap) retrieveMapHandlers.length = 0;
			retrieveMapHandlers.unshift(options.retrieveSourceMap);
		}
		if (options.hookRequire && !isInBrowser()) {
			var Module = dynamicRequire(module, "module");
			var $compile = Module.prototype._compile;
			if (!$compile.__sourceMapSupport) {
				Module.prototype._compile = function(content, filename) {
					fileContentsCache[filename] = content;
					sourceMapCache[filename] = void 0;
					return $compile.call(this, content, filename);
				};
				Module.prototype._compile.__sourceMapSupport = true;
			}
		}
		if (!emptyCacheBetweenOperations) emptyCacheBetweenOperations = "emptyCacheBetweenOperations" in options ? options.emptyCacheBetweenOperations : false;
		if (!errorFormatterInstalled) {
			errorFormatterInstalled = true;
			Error.prepareStackTrace = prepareStackTrace;
		}
		if (!uncaughtShimInstalled) {
			var installHandler = "handleUncaughtExceptions" in options ? options.handleUncaughtExceptions : true;
			try {
				if (dynamicRequire(module, "worker_threads").isMainThread === false) installHandler = false;
			} catch (e) {}
			if (installHandler && hasGlobalProcessEventEmitter()) {
				uncaughtShimInstalled = true;
				shimEmitUncaughtException();
			}
		}
	};
	exports.resetRetrieveHandlers = function() {
		retrieveFileHandlers.length = 0;
		retrieveMapHandlers.length = 0;
		retrieveFileHandlers = originalRetrieveFileHandlers.slice(0);
		retrieveMapHandlers = originalRetrieveMapHandlers.slice(0);
		retrieveSourceMap = handlerExec(retrieveMapHandlers);
		retrieveFile = handlerExec(retrieveFileHandlers);
	};
})))().install();
//#endregion
//#region node_modules/.pnpm/@actions+core@3.0.1/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/.pnpm/@actions+core@3.0.1/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$4.EOL);
}
function issue(name, message = "") {
	issueCommand(name, {}, message);
}
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/.pnpm/@actions+http-client@4.0.1/node_modules/@actions/http-client/lib/proxy.js
function getProxyUrl(reqUrl) {
	const usingSsl = reqUrl.protocol === "https:";
	if (checkBypass(reqUrl)) return;
	const proxyVar = (() => {
		if (usingSsl) return process.env["https_proxy"] || process.env["HTTPS_PROXY"];
		else return process.env["http_proxy"] || process.env["HTTP_PROXY"];
	})();
	if (proxyVar) try {
		return new DecodedURL(proxyVar);
	} catch (_a) {
		if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://")) return new DecodedURL(`http://${proxyVar}`);
	}
	else return;
}
function checkBypass(reqUrl) {
	if (!reqUrl.hostname) return false;
	const reqHost = reqUrl.hostname;
	if (isLoopbackAddress(reqHost)) return true;
	const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || "";
	if (!noProxy) return false;
	let reqPort;
	if (reqUrl.port) reqPort = Number(reqUrl.port);
	else if (reqUrl.protocol === "http:") reqPort = 80;
	else if (reqUrl.protocol === "https:") reqPort = 443;
	const upperReqHosts = [reqUrl.hostname.toUpperCase()];
	if (typeof reqPort === "number") upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
	for (const upperNoProxyItem of noProxy.split(",").map((x) => x.trim().toUpperCase()).filter((x) => x)) if (upperNoProxyItem === "*" || upperReqHosts.some((x) => x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x.endsWith(`${upperNoProxyItem}`))) return true;
	return false;
}
function isLoopbackAddress(host) {
	const hostLower = host.toLowerCase();
	return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]");
}
var DecodedURL = class extends URL {
	constructor(url, base) {
		super(url, base);
		this._decodedUsername = decodeURIComponent(super.username);
		this._decodedPassword = decodeURIComponent(super.password);
	}
	get username() {
		return this._decodedUsername;
	}
	get password() {
		return this._decodedPassword;
	}
};
//#endregion
//#region node_modules/.pnpm/tunnel@0.0.6/node_modules/tunnel/lib/tunnel.js
var require_tunnel$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	__require("net");
	var tls$2 = __require("tls");
	var http$6 = __require("http");
	var https$4 = __require("https");
	var events$1 = __require("events");
	__require("assert");
	var util$5 = __require("util");
	exports.httpOverHttp = httpOverHttp;
	exports.httpsOverHttp = httpsOverHttp;
	exports.httpOverHttps = httpOverHttps;
	exports.httpsOverHttps = httpsOverHttps;
	function httpOverHttp(options) {
		var agent = new TunnelingAgent(options);
		agent.request = http$6.request;
		return agent;
	}
	function httpsOverHttp(options) {
		var agent = new TunnelingAgent(options);
		agent.request = http$6.request;
		agent.createSocket = createSecureSocket;
		agent.defaultPort = 443;
		return agent;
	}
	function httpOverHttps(options) {
		var agent = new TunnelingAgent(options);
		agent.request = https$4.request;
		return agent;
	}
	function httpsOverHttps(options) {
		var agent = new TunnelingAgent(options);
		agent.request = https$4.request;
		agent.createSocket = createSecureSocket;
		agent.defaultPort = 443;
		return agent;
	}
	function TunnelingAgent(options) {
		var self = this;
		self.options = options || {};
		self.proxyOptions = self.options.proxy || {};
		self.maxSockets = self.options.maxSockets || http$6.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$5.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 createSecureSocket(options, cb) {
		var self = this;
		TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
			var hostHeader = options.request.getHeader("host");
			var tlsOptions = mergeOptions({}, self.options, {
				socket,
				servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host
			});
			var secureSocket = tls$2.connect(0, tlsOptions);
			self.sockets[self.sockets.indexOf(socket)] = secureSocket;
			cb(secureSocket);
		});
	}
	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() {};
	exports.debug = debug;
}));
//#endregion
//#region node_modules/.pnpm/tunnel@0.0.6/node_modules/tunnel/index.js
var require_tunnel = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = require_tunnel$1();
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/core/constants.js
var require_constants$5 = /* @__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/.pnpm/undici@6.28.0/node_modules/undici/lib/core/tree.js
var require_tree = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { wellknownHeaderNames, headerNameLowerCasedRecord } = require_constants$5();
	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/.pnpm/undici@6.28.0/node_modules/undici/lib/core/util.js
var require_util$7 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$28 = __require("node:assert");
	var { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols$4();
	var { IncomingMessage } = __require("node:http");
	var stream$1 = __require("node:stream");
	var net$5 = __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$5();
	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$28(!this[kBodyUsed], "disturbed");
			this[kBodyUsed] = true;
			yield* this[kBody];
		}
	};
	function wrapRequestBody(body) {
		if (isStream(body)) {
			if (bodyLength(body) === 0) body.on("data", function() {
				assert$28(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$28(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$28(typeof host === "string");
		const servername = getHostname(host);
		if (net$5.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$1.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$1.isDisturbed(body) || body[kBodyUsed]));
	}
	function isErrored(body) {
		return !!(body && stream$1.isErrored(body));
	}
	function isReadable(body) {
		return !!(body && stream$1.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$28(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/.pnpm/undici@6.28.0/node_modules/undici/lib/core/diagnostics.js
var require_diagnostics = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var diagnosticsChannel = __require("node:diagnostics_channel");
	var util$4 = __require("node:util");
	var undiciDebugLog = util$4.debuglog("undici");
	var fetchDebuglog = util$4.debuglog("fetch");
	var websocketDebuglog = util$4.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/.pnpm/undici@6.28.0/node_modules/undici/lib/core/request.js
var require_request$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { InvalidArgumentError, NotSupportedError } = require_errors();
	var assert$27 = __require("node:assert");
	var { isValidHTTPToken, isValidHeaderValue, isStream, destroy, isBuffer, isFormDataLike, isIterable, isBlobLike, buildURL, validateHandler, getServerName, normalizedMethodRecords } = require_util$7();
	var { channels } = require_diagnostics();
	var { headerNameLowerCasedRecord } = require_constants$5();
	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$27(!this.aborted);
			assert$27(!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$27(!this.aborted);
			assert$27(!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$27(!this.aborted);
			assert$27(!this.completed);
			try {
				return this[kHandler].onData(chunk);
			} catch (err) {
				this.abort(err);
				return false;
			}
		}
		onUpgrade(statusCode, headers, socket) {
			assert$27(!this.aborted);
			assert$27(!this.completed);
			return this[kHandler].onUpgrade(statusCode, headers, socket);
		}
		onComplete(trailers) {
			this.onFinally();
			assert$27(!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 {
				const str = `${val[i]}`;
				if (!isValidHeaderValue(str)) throw new InvalidArgumentError(`invalid ${key} header`);
				arr.push(str);
			}
			val = arr;
		} else if (typeof val === "string") {
			if (!isValidHeaderValue(val)) throw new InvalidArgumentError(`invalid ${key} header`);
		} else if (val === null) val = "";
		else {
			val = `${val}`;
			if (!isValidHeaderValue(val)) throw new InvalidArgumentError(`invalid ${key} header`);
		}
		if (headerName === "host") {
			if (request.host !== null) throw new InvalidArgumentError("duplicate host header");
			if (typeof val !== "string") throw new InvalidArgumentError("invalid host header");
			request.host = val;
		} else if (headerName === "content-length") {
			if (request.contentLength !== null) throw new InvalidArgumentError("duplicate content-length header");
			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/.pnpm/undici@6.28.0/node_modules/undici/lib/dispatcher/dispatcher.js
var require_dispatcher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var EventEmitter$1 = __require("node:events");
	var Dispatcher = class extends EventEmitter$1 {
		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/.pnpm/undici@6.28.0/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 kWebSocketOptions = Symbol("webSocketOptions");
	var DispatcherBase = class extends Dispatcher {
		constructor(opts) {
			super();
			this[kDestroyed] = false;
			this[kOnDestroyed] = null;
			this[kClosed] = false;
			this[kOnClosed] = [];
			this[kWebSocketOptions] = opts?.webSocket ?? {};
		}
		get webSocketOptions() {
			return {
				maxFragments: this[kWebSocketOptions].maxFragments ?? 131072,
				maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? 134217728
			};
		}
		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 ? /* istanbul ignore next: should never error */ 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/.pnpm/undici@6.28.0/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 = 499;
	/**
	* 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 = {
		/**
		* The setTimeout() method sets a timer which executes a function once the
		* timer expires.
		* @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] An optional argument to be passed to the callback function
		* when the timer expires.
		* @returns {NodeJS.Timeout|FastTimer}
		*/
		setTimeout(callback, delay, arg) {
			return delay <= RESOLUTION_MS ? setTimeout(callback, delay, arg) : new FastTimer(callback, delay, arg);
		},
		/**
		* The clearTimeout method cancels an instantiated Timer previously created
		* by calling setTimeout.
		*
		* @param {NodeJS.Timeout|FastTimer} timeout
		*/
		clearTimeout(timeout) {
			if (timeout[kFastTimer])
 /**
			* @type {FastTimer}
			*/
			timeout.clear();
			else clearTimeout(timeout);
		},
		/**
		* The setFastTimeout() method sets a fastTimer which executes a function once
		* the timer expires.
		* @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] An optional argument to be passed to the callback function
		* when the timer expires.
		* @returns {FastTimer}
		*/
		setFastTimeout(callback, delay, arg) {
			return new FastTimer(callback, delay, arg);
		},
		/**
		* The clearTimeout method cancels an instantiated FastTimer previously
		* created by calling setFastTimeout.
		*
		* @param {FastTimer} timeout
		*/
		clearFastTimeout(timeout) {
			timeout.clear();
		},
		/**
		* The now method returns the value of the internal fast timer clock.
		*
		* @returns {number}
		*/
		now() {
			return fastNow;
		},
		/**
		* Trigger the onTick function to process the fastTimers array.
		* Exported for testing purposes only.
		* Marking as deprecated to discourage any use outside of testing.
		* @deprecated
		* @param {number} [delay=0] The delay in milliseconds to add to the now value.
		*/
		tick(delay = 0) {
			fastNow += delay - RESOLUTION_MS + 1;
			onTick();
			onTick();
		},
		/**
		* Reset FastTimers.
		* Exported for testing purposes only.
		* Marking as deprecated to discourage any use outside of testing.
		* @deprecated
		*/
		reset() {
			fastNow = 0;
			fastTimers.length = 0;
			clearTimeout(fastNowTimeout);
			fastNowTimeout = null;
		},
		/**
		* Exporting for testing purposes only.
		* Marking as deprecated to discourage any use outside of testing.
		* @deprecated
		*/
		kFastTimer
	};
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/node_modules/undici/lib/core/connect.js
var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var net$4 = __require("node:net");
	var assert$26 = __require("node:assert");
	var util = require_util$7();
	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$26(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$26(!httpSocket, "httpSocket can only be sent on TLS update");
				port = port || 80;
				socket = net$4.connect({
					highWaterMark: 65536,
					...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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/llhttp/constants.js
var require_constants$4 = /* @__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/.pnpm/undici@6.28.0/node_modules/undici/lib/llhttp/llhttp-wasm.js
var require_llhttp_wasm = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Buffer: Buffer$3 } = __require("node:buffer");
	module.exports = Buffer$3.from(" ", "base64");
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js
var require_llhttp_simd_wasm = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Buffer: Buffer$2 } = __require("node:buffer");
	module.exports = Buffer$2.from(" ", "base64");
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fetch/constants.js
var require_constants$3 = /* @__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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fetch/data-url.js
var require_data_url = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$25 = __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$25(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,
			/** @type {Map<string, string>} */
			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$25(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$25(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$25(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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fetch/webidl.js
var require_webidl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { types: types$4, inspect: inspect$1 } = __require("node:util");
	var { markAsUncloneable } = __require("node:worker_threads");
	var { toUSVString } = require_util$7();
	/** @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$1(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$4.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$4.isAnyArrayBuffer(V)) throw webidl.errors.conversionFailed({
			prefix,
			argument: `${argument} ("${webidl.util.Stringify(V)}")`,
			types: ["ArrayBuffer"]
		});
		if (opts?.allowShared === false && types$4.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$4.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$4.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$4.isDataView(V)) throw webidl.errors.exception({
			header: prefix,
			message: `${name} is not a DataView.`
		});
		if (opts?.allowShared === false && types$4.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$4.isAnyArrayBuffer(V)) return webidl.converters.ArrayBuffer(V, prefix, name, {
			...opts,
			allowShared: false
		});
		if (types$4.isTypedArray(V)) return webidl.converters.TypedArray(V, V.constructor, prefix, name, {
			...opts,
			allowShared: false
		});
		if (types$4.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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fetch/util.js
var require_util$6 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Transform: Transform$3 } = __require("node:stream");
	var zlib$2 = __require("node:zlib");
	var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants$3();
	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$7();
	var assert$24 = __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;
			}
			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$24(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;
			}
			/**
			* 1. If referrerURL is a potentially trustworthy URL and
			* request’s current URL is not a potentially trustworthy URL,
			* then return no referrer.
			* 2. 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$24(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$24(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];
				}
				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$24(!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$24("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$24("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$3 {
		#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$2.createInflate(this.#zlibOptions) : zlib$2.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$24(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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fetch/file.js
var require_file = /* @__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 = {}) {
			const n = fileName;
			const t = options.type;
			const d = options.lastModified ?? Date.now();
			this[kState] = {
				blobLike,
				name: n,
				type: t,
				lastModified: d
			};
		}
		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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fetch/formdata.js
var require_formdata = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { isBlobLike, iteratorMixin } = require_util$6();
	var { kState } = require_symbols$3();
	var { kEnumerableProperty } = require_util$7();
	var { FileLike, isFileLike } = require_file();
	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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fetch/formdata-parser.js
var require_formdata_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { isUSVString, bufferToLowerCasedHeaderName } = require_util$7();
	var { utf8DecodeBytes } = require_util$6();
	var { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = require_data_url();
	var { isFileLike } = require_file();
	var { makeEntry } = require_formdata();
	var assert$23 = __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$23(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$23(isUSVString(name));
			assert$23(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$23(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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fetch/body.js
var require_body = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var util = require_util$7();
	var { ReadableStreamFrom, isBlobLike, isReadableStreamLike, readableStreamClose, createDeferredPromise, fullyReadBody, extractMimeType, utf8DecodeBytes } = require_util$6();
	var { FormData } = require_formdata();
	var { kState } = require_symbols$3();
	var { webidl } = require_webidl();
	var { Blob: Blob$1 } = __require("node:buffer");
	var assert$22 = __require("node:assert");
	var { isErrored, isDisturbed } = __require("node:stream");
	var { isArrayBuffer: isArrayBuffer$1 } = __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$22(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$1(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$22(!util.isDisturbed(object), "The body has already been consumed.");
			// istanbul ignore next
			assert$22(!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/.pnpm/undici@6.28.0/node_modules/undici/lib/dispatcher/client-h1.js
var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$21 = __require("node:assert");
	var util = require_util$7();
	var { channels } = require_diagnostics();
	var timers = require_timers();
	var { RequestContentLengthMismatchError, ResponseContentLengthMismatchError, RequestAbortedError, InvalidArgumentError, 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$4();
	var EMPTY_BUF = Buffer.alloc(0);
	var FastBuffer = Buffer[Symbol.species];
	var addListener = util.addListener;
	var removeAllListeners = util.removeAllListeners;
	var kIdleSocketValidation = Symbol("kIdleSocketValidation");
	var kIdleSocketValidationTimeout = Symbol("kIdleSocketValidationTimeout");
	var kSocketUsed = Symbol("kSocketUsed");
	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$21(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$21(currentParser.ptr === p);
				return currentParser.onMessageBegin() || 0;
			},
			wasm_on_header_field: (p, at, len) => {
				assert$21(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$21(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$21(currentParser.ptr === p);
				return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
			},
			wasm_on_body: (p, at, len) => {
				assert$21(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$21(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_FAST_TIMER = 1;
	var TIMEOUT_HEADERS = 3;
	var TIMEOUT_BODY = 5;
	var TIMEOUT_KEEP_ALIVE = 8;
	var Parser = class {
		constructor(client, socket, { exports: exports$3 }) {
			assert$21(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
			this.llhttp = exports$3;
			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$21(this.ptr != null);
			assert$21(currentParser == null);
			this.llhttp.llhttp_resume(this.ptr);
			assert$21(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$21(this.ptr != null);
			assert$21(currentParser == null);
			assert$21(!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.OK) {
					const body = data.subarray(offset);
					if (ret === constants.ERROR.PAUSED_UPGRADE) this.onUpgrade(body);
					else if (ret === constants.ERROR.PAUSED) {
						this.paused = true;
						socket.unshift(body);
					} else throw this.createError(ret, body);
				}
			} catch (err) {
				util.destroy(socket, err);
			}
		}
		finish() {
			assert$21(currentParser === null);
			assert$21(this.ptr != null);
			assert$21(!this.paused);
			const { llhttp } = this;
			let ret;
			try {
				currentParser = this;
				ret = llhttp.llhttp_finish(this.ptr);
			} finally {
				currentParser = null;
			}
			if (ret === constants.ERROR.OK) return null;
			if (ret === constants.ERROR.PAUSED || ret === constants.ERROR.PAUSED_UPGRADE) {
				this.paused = true;
				return null;
			}
			return this.createError(ret, EMPTY_BUF);
		}
		createError(ret, data) {
			const { llhttp, contentLength, bytesRead } = this;
			if (contentLength && bytesRead !== parseInt(contentLength, 10)) return new ResponseContentLengthMismatchError();
			const ptr = llhttp.llhttp_get_error_reason(this.ptr);
			let message = "";
			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() + ")";
			}
			return new HTTPParserError(message, constants.ERROR[ret], data);
		}
		destroy() {
			assert$21(this.ptr != null);
			assert$21(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;
			if (client[kRunning] === 0) {
				util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
				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$21(upgrade);
			assert$21(client[kSocket] === socket);
			assert$21(!socket.destroyed);
			assert$21(!this.paused);
			assert$21((headers.length & 1) === 0);
			const request = client[kQueue][client[kRunningIdx]];
			assert$21(request);
			assert$21(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;
			if (client[kRunning] === 0) {
				util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
				return -1;
			}
			const request = client[kQueue][client[kRunningIdx]];
			/* istanbul ignore next: difficult to make a test case for */
			if (!request) return -1;
			assert$21(!this.upgrade);
			assert$21(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$21(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$21(client[kRunning] === 1);
				this.upgrade = true;
				return 2;
			}
			if (upgrade) {
				assert$21(client[kRunning] === 1);
				this.upgrade = true;
				return 2;
			}
			assert$21((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$21(request);
			assert$21(this.timeoutType === TIMEOUT_BODY);
			if (this.timeout) {
				// istanbul ignore else: only for jest
				if (this.timeout.refresh) this.timeout.refresh();
			}
			assert$21(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$21(statusCode >= 100);
			assert$21((this.headers.length & 1) === 0);
			const request = client[kQueue][client[kRunningIdx]];
			assert$21(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;
			socket[kSocketUsed] = true;
			if (socket[kWriting]) {
				assert$21(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$21(!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$21(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[kIdleSocketValidation] = 0;
		socket[kIdleSocketValidationTimeout] = null;
		socket[kSocketUsed] = false;
		socket[kParser] = new Parser(client, socket, llhttpInstance);
		addListener(socket, "error", function(err) {
			assert$21(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
			const parser = this[kParser];
			if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
				const parserErr = parser.finish();
				if (parserErr) {
					this[kError] = parserErr;
					this[kClient][kOnError](parserErr);
				}
				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) {
				const parserErr = parser.finish();
				if (parserErr) util.destroy(this, parserErr);
				return;
			}
			util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
		});
		addListener(socket, "close", function() {
			const client = this[kClient];
			const parser = this[kParser];
			clearIdleSocketValidation(this);
			if (parser) {
				if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) this[kError] = parser.finish() || this[kError];
				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$21(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$21(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] || socket[kIdleSocketValidation] === 1) 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 clearIdleSocketValidation(socket) {
		if (socket[kIdleSocketValidationTimeout]) {
			clearTimeout(socket[kIdleSocketValidationTimeout]);
			socket[kIdleSocketValidationTimeout] = null;
		}
		socket[kIdleSocketValidation] = 0;
	}
	function scheduleIdleSocketValidation(client, socket) {
		socket[kIdleSocketValidation] = 1;
		socket[kIdleSocketValidationTimeout] = setTimeout(() => {
			socket[kIdleSocketValidationTimeout] = null;
			socket[kIdleSocketValidation] = 2;
			if (client[kSocket] === socket && !socket.destroyed) client[kResume]();
		}, 0);
		socket[kIdleSocketValidationTimeout].unref?.();
	}
	/**
	* @param {import('./client.js')} client
	*/
	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[kRunning] === 0 && client[kPending] > 0 && socket[kSocketUsed]) {
				if (socket[kIdleSocketValidation] === 0) {
					scheduleIdleSocketValidation(client, socket);
					socket[kParser].readMore();
					if (socket.destroyed) return;
					return;
				}
				if (socket[kIdleSocketValidation] === 1) {
					socket[kParser].readMore();
					if (socket.destroyed) return;
					return;
				}
			}
			if (client[kRunning] === 0) {
				socket[kParser].readMore();
				if (socket.destroyed) return;
			}
			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) {
			const contentType = body.type;
			if (contentType) {
				const contentTypeValue = `${contentType}`;
				if (!util.isValidHeaderValue(contentTypeValue)) {
					util.errorRequest(client, request, new InvalidArgumentError("invalid content-type header"));
					return false;
				}
				headers.push("content-type", contentTypeValue);
			}
		}
		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];
		clearIdleSocketValidation(socket);
		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$21(false);
		return true;
	}
	function writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload) {
		assert$21(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$21(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$21(contentLength === null, "no body must not have content length");
					socket.write(`${header}\r\n`, "latin1");
				}
			} else if (util.isBuffer(body)) {
				assert$21(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$21(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$21(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$21(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$21(client[kRunning] <= 1, "pipeline should only contain this request");
				abort(err);
			}
		}
	};
	module.exports = connectH1;
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/node_modules/undici/lib/dispatcher/client-h2.js
var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$20 = __require("node:assert");
	var { pipeline: pipeline$2 } = __require("node:stream");
	var util = require_util$7();
	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$20(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$20(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$20(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$20(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$20(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$20(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$20(false);
		}
	}
	function writeBuffer(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
		try {
			if (body != null && util.isBuffer(body)) {
				assert$20(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$20(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$20(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$20(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$20(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/.pnpm/undici@6.28.0/node_modules/undici/lib/handler/redirect-handler.js
var require_redirect_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var util = require_util$7();
	var { kBodyUsed } = require_symbols$4();
	var assert$19 = __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$19(!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$19(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$19(headers == null, "headers must be an object or an array");
		return ret;
	}
	module.exports = RedirectHandler;
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/dispatcher/client.js
var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$18 = __require("node:assert");
	var net$3 = __require("node:net");
	var http$5 = __require("node:http");
	var util = require_util$7();
	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, webSocket } = {}) {
			super({ webSocket });
			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$3.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$5.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$18(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$18(client[kSize] === 0);
		}
	}
	/**
	* @param {Client} client
	* @returns
	*/
	async function connect(client) {
		assert$18(!client[kConnecting]);
		assert$18(!client[kHTTPContext]);
		let { host, hostname, protocol, port } = client[kUrl];
		if (hostname[0] === "[") {
			const idx = hostname.indexOf("]");
			assert$18(idx !== -1);
			const ip = hostname.substring(1, idx);
			assert$18(net$3.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$18(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$18(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$18(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/.pnpm/undici@6.28.0/node_modules/undici/lib/dispatcher/fixed-queue.js
var require_fixed_queue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var kSize = 2048;
	var kMask = 2047;
	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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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(opts) {
			super(opts);
			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/.pnpm/undici@6.28.0/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$7();
	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 } = {}) {
			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
			});
			super(options);
			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/.pnpm/undici@6.28.0/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$7();
	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/.pnpm/undici@6.28.0/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$7();
	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 } = {}) {
			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");
			super(options);
			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/.pnpm/undici@6.28.0/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$2 } = __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$2(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$2) && !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$2(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$2(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$2(opts);
			else if (opts instanceof URL$2) return opts;
			else return new URL$2(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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/handler/retry-handler.js
var require_retry_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$17 = __require("node:assert");
	var { kRetryHandlerDefaultRetry } = require_symbols$4();
	var { RequestRetryError } = require_errors();
	var { isDisturbed, parseHeaders, parseRangeHeader, wrapRequestBody } = require_util$7();
	function calculateRetryAfterHeader(retryAfter) {
		const current = Date.now();
		return new Date(retryAfter).getTime() - current;
	}
	function validatePartialResponseContentLength(headers, range, statusCode, retryCount) {
		const contentLength = headers["content-length"];
		if (contentLength == null) return null;
		if (!Number.isFinite(range.start) || !Number.isFinite(range.end)) return null;
		const length = Number(contentLength);
		const expectedLength = range.end - range.start + 1;
		if (!Number.isFinite(length) || length !== expectedLength) return new RequestRetryError("Content-Length mismatch", statusCode, {
			headers,
			data: { count: retryCount }
		});
		return null;
	}
	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 ?? 3e4,
				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 contentLengthError = validatePartialResponseContentLength(headers, contentRange, statusCode, this.retryCount);
				if (contentLengthError != null) {
					this.abort(contentLengthError);
					return false;
				}
				const { start, size, end = size - 1 } = contentRange;
				assert$17(this.start === start, "content-range mismatch");
				assert$17(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 contentLengthError = validatePartialResponseContentLength(headers, range, statusCode, this.retryCount);
					if (contentLengthError != null) {
						this.abort(contentLengthError);
						return false;
					}
					const { start, size, end = size - 1 } = range;
					assert$17(start != null && Number.isFinite(start), "content-range mismatch");
					assert$17(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$17(Number.isFinite(this.start));
				assert$17(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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/api/readable.js
var require_readable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$16 = __require("node:assert");
	var { Readable: Readable$4 } = __require("node:stream");
	var { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require_errors();
	var util = require_util$7();
	var { ReadableStreamFrom } = require_util$7();
	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$4 {
		constructor({ resume, abort, contentType = "", contentLength, highWaterMark = 65536 }) {
			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$16(this[kBody].locked);
				}
			}
			return this[kBody];
		}
		async dump(opts) {
			let limit = Number.isFinite(opts?.limit) ? opts.limit : 131072;
			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$16(!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 /* @__PURE__ */ 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/.pnpm/undici@6.28.0/node_modules/undici/lib/api/util.js
var require_util$5 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$15 = __require("node:assert");
	var { ResponseStatusCodeError } = require_errors();
	var { chunksDecode } = require_readable();
	var CHUNK_LIMIT = 131072;
	async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) {
		assert$15(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/.pnpm/undici@6.28.0/node_modules/undici/lib/api/api-request.js
var require_api_request = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$14 = __require("node:assert");
	var { Readable } = require_readable();
	var { InvalidArgumentError, RequestAbortedError } = require_errors();
	var util = require_util$7();
	var { getResolveErrorBodyCallback } = require_util$5();
	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$14(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/.pnpm/undici@6.28.0/node_modules/undici/lib/api/abort-signal.js
var require_abort_signal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { addAbortListener } = require_util$7();
	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/.pnpm/undici@6.28.0/node_modules/undici/lib/api/api-stream.js
var require_api_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$13 = __require("node:assert");
	var { finished: finished$1, PassThrough: PassThrough$1 } = __require("node:stream");
	var { InvalidArgumentError, InvalidReturnValueError } = require_errors();
	var util = require_util$7();
	var { getResolveErrorBodyCallback } = require_util$5();
	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$13(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/.pnpm/undici@6.28.0/node_modules/undici/lib/api/api-pipeline.js
var require_api_pipeline = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Readable: Readable$3, Duplex, PassThrough } = __require("node:stream");
	var { InvalidArgumentError, InvalidReturnValueError, RequestAbortedError } = require_errors();
	var util = require_util$7();
	var { AsyncResource: AsyncResource$2 } = __require("node:async_hooks");
	var { addSignal, removeSignal } = require_abort_signal();
	var assert$12 = __require("node:assert");
	var kResume = Symbol("resume");
	var PipelineRequest = class extends Readable$3 {
		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$3 {
		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$12(!res, "pipeline cannot be retried");
			assert$12(!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/.pnpm/undici@6.28.0/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$7();
	var { addSignal, removeSignal } = require_abort_signal();
	var assert$11 = __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$11(this.callback);
			this.abort = abort;
			this.context = null;
		}
		onHeaders() {
			throw new SocketError("bad upgrade", null);
		}
		onUpgrade(statusCode, rawHeaders, socket) {
			assert$11(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/.pnpm/undici@6.28.0/node_modules/undici/lib/api/api-connect.js
var require_api_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$10 = __require("node:assert");
	var { AsyncResource } = __require("node:async_hooks");
	var { InvalidArgumentError, SocketError } = require_errors();
	var util = require_util$7();
	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$10(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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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$7();
	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/.pnpm/undici@6.28.0/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$7();
	/**
	* 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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/mock/pending-interceptors-formatter.js
var require_pending_interceptors_formatter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Transform: Transform$2 } = __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$2({ 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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/interceptor/dump.js
var require_dump = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var util = require_util$7();
	var { InvalidArgumentError, RequestAbortedError } = require_errors();
	var DecoratorHandler = require_decorator_handler();
	var DumpHandler = class extends DecoratorHandler {
		#maxSize = 1048576;
		#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: 1048576 }) {
		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/.pnpm/undici@6.28.0/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);
			}
		}
	};
	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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fetch/headers.js
var require_headers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kConstruct } = require_symbols$4();
	var { kEnumerableProperty } = require_util$7();
	var { iteratorMixin, isValidHeaderName, isValidHeaderValue } = require_util$6();
	var { webidl } = require_webidl();
	var assert$9 = __require("node:assert");
	var util$3 = __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$9(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$9(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$9(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$3.inspect.custom](depth, options) {
			options.depth ??= depth;
			return `Headers ${util$3.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$3.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$3.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/.pnpm/undici@6.28.0/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$7();
	var nodeUtil$1 = __require("node:util");
	var { kEnumerableProperty } = util;
	var { isValidReasonPhrase, isCancelled, isAborted, isBlobLike, serializeJavascriptValueToJSONString, isErrorLike, isomorphicEncode, environmentSettingsObject: relevantRealm } = require_util$6();
	var { redirectStatusSet, nullBodyStatus } = require_constants$3();
	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$8 = __require("node:assert");
	var { types: types$3 } = __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$8(!(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$8(false);
	}
	function makeAppropriateNetworkError(fetchParams, err = null) {
		assert$8(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$3.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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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$7();
	var nodeUtil = __require("node:util");
	var { isValidHTTPToken, sameOrigin, environmentSettingsObject } = require_util$6();
	var { forbiddenMethodsSet, corsSafeListedMethodsSet, referrerPolicy, requestRedirect, requestMode, requestCredentials, requestCache, requestDuplex } = require_constants$3();
	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$7 = __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$7(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/.pnpm/undici@6.28.0/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$1 = __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$6();
	var { kState, kDispatcher } = require_symbols$3();
	var assert$6 = __require("node:assert");
	var { safelyExtractBody, extractBody } = require_body();
	var { redirectStatusSet, nullBodyStatus, safeMethodsSet, requestBodyHeader, subresourceSet } = require_constants$3();
	var EE = __require("node:events");
	var { Readable: Readable$2, pipeline: pipeline$1, finished } = __require("node:stream");
	var { addAbortListener, isErrored, isReadable, bufferToLowerCasedHeaderName } = require_util$7();
	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$6(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$6(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$6(!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$6(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$6(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$6(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;
		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) {}
		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$6(!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$2({ 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$1.createGunzip({
								flush: zlib$1.constants.Z_SYNC_FLUSH,
								finishFlush: zlib$1.constants.Z_SYNC_FLUSH
							}));
							else if (coding === "deflate") decoders.push(createInflate({
								flush: zlib$1.constants.Z_SYNC_FLUSH,
								finishFlush: zlib$1.constants.Z_SYNC_FLUSH
							}));
							else if (coding === "br") decoders.push(zlib$1.createBrotliDecompress({
								flush: zlib$1.constants.BROTLI_OPERATION_FLUSH,
								finishFlush: zlib$1.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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fileapi/util.js
var require_util$4 = /* @__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$2 } = __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$2.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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/fileapi/filereader.js
var require_filereader = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { staticPropertyDescriptors, readOperation, fireAProgressEvent } = require_util$4();
	var { kState, kError, kResult, kEvents, kAborted } = require_symbols$2();
	var { webidl } = require_webidl();
	var { kEnumerableProperty } = require_util$7();
	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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/cache/util.js
var require_util$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var assert$5 = __require("node:assert");
	var { URLSerializer } = require_data_url();
	var { isValidHeaderName } = require_util$6();
	/**
	* @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$5(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/.pnpm/undici@6.28.0/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$3();
	var { kEnumerableProperty, isDisturbed } = require_util$7();
	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$6();
	var assert$4 = __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$4(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$4(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$4(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/.pnpm/undici@6.28.0/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$7();
	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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/cookies/constants.js
var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = {
		maxAttributeValueSize: 1024,
		maxNameValuePairSize: 4096
	};
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/node_modules/undici/lib/web/cookies/util.js
var require_util$2 = /* @__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 > 126 || code === 59) throw new Error("Invalid cookie path");
		}
	}
	/**
	* <let-dig> ::= <letter> | <digit>
	*
	* <letter> ::= any one of the 52 alphabetic characters A through Z in
	* upper case and a through z in lower case
	*
	* <digit> ::= any one of the ten digits 0 through 9r
	*
	* @see https://www.rfc-editor.org/rfc/rfc1034#section-3.5
	* @param {number} code
	*/
	function isLetterOrDigit(code) {
		return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
	}
	/**
	* Validates a cookie domain against the "preferred name syntax".
	*
	* <domain>      ::= <subdomain> | " "
	* <subdomain>   ::= <label> | <subdomain> "." <label>
	* <label>       ::= <let-dig> [ [ <ldh-str> ] <let-dig> ]
	* <ldh-str>     ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
	* <let-dig-hyp> ::= <let-dig> | "-"
	*
	* @see https://www.rfc-editor.org/rfc/rfc1034#section-3.5
	* @see https://www.rfc-editor.org/rfc/rfc1123#section-2.1
	* @see https://www.rfc-editor.org/rfc/rfc1035#section-2.3.4
	* @param {string} domain
	*/
	function validateCookieDomain(domain) {
		if (domain === " ") return;
		if (domain.length > 255) throw new Error("Invalid cookie domain");
		let labelLength = 0;
		for (let i = 0; i < domain.length; ++i) {
			const code = domain.charCodeAt(i);
			if (code === 46) {
				if (labelLength === 0) throw new Error("Invalid cookie domain");
				if (domain.charCodeAt(i - 1) === 45) throw new Error("Invalid cookie domain");
				labelLength = 0;
				continue;
			}
			if (labelLength === 0 && !isLetterOrDigit(code)) throw new Error("Invalid cookie domain");
			if (!isLetterOrDigit(code) && code !== 45) throw new Error("Invalid cookie domain");
			if (++labelLength > 63) throw new Error("Invalid cookie domain");
		}
		if (labelLength === 0 || domain.charCodeAt(domain.length - 1) === 45) 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("=");
			const trimmedKey = key.trim();
			const joinedValue = value.join("=");
			validateCookieName(trimmedKey);
			validateCookieValue(joinedValue);
			out.push(`${trimmedKey}=${joinedValue}`);
		}
		return out.join("; ");
	}
	module.exports = {
		isCTLExcludingHtab,
		validateCookieName,
		validateCookiePath,
		validateCookieValue,
		toIMFDate,
		stringify
	};
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/node_modules/undici/lib/web/cookies/parse.js
var require_parse$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { maxNameValuePairSize, maxAttributeValueSize } = require_constants$2();
	var { isCTLExcludingHtab } = require_util$2();
	var { collectASequenceOfCodePointsFast } = require_data_url();
	var assert$3 = __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$3(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") {
			const attributeValueLowercase = attributeValue.toLowerCase();
			if (attributeValueLowercase === "none") cookieAttributeList.sameSite = "None";
			else if (attributeValueLowercase === "strict") cookieAttributeList.sameSite = "Strict";
			else if (attributeValueLowercase === "lax") cookieAttributeList.sameSite = "Lax";
		} else {
			cookieAttributeList.unparsed ??= [];
			cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`);
		}
		return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
	}
	module.exports = {
		parseSetCookie,
		parseUnparsedAttributes
	};
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/node_modules/undici/lib/web/cookies/index.js
var require_cookies = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { parseSetCookie } = require_parse$1();
	var { stringify } = require_util$2();
	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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/websocket/events.js
var require_events = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { webidl } = require_webidl();
	var { kEnumerableProperty } = require_util$7();
	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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/websocket/constants.js
var require_constants$1 = /* @__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/.pnpm/undici@6.28.0/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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/websocket/util.js
var require_util$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols();
	var { states, opcodes } = require_constants$1();
	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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/websocket/frame.js
var require_frame = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { maxUnsigned16Bit } = require_constants$1();
	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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/websocket/connection.js
var require_connection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require_constants$1();
	var { kReadyState, kSentClose, kByteParser, kReceivedClose, kResponse } = require_symbols();
	var { fireEvent, failWebsocketConnection, isClosing, isClosed, isEstablished, parseExtensions } = require_util$1();
	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$6();
	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/.pnpm/undici@6.28.0/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$1();
	var { MessageSizeExceededError } = require_errors();
	var tail = Buffer.from([
		0,
		0,
		255,
		255
	]);
	var kBuffer = Symbol("kBuffer");
	var kLength = Symbol("kLength");
	var PerMessageDeflate = class {
		/** @type {import('node:zlib').InflateRaw} */
		#inflate;
		#options = {};
		#maxPayloadSize = 0;
		/**
		* @param {Map<string, string>} extensions
		*/
		constructor(extensions, options) {
			this.#options.serverNoContextTakeover = extensions.has("server_no_context_takeover");
			this.#options.serverMaxWindowBits = extensions.get("server_max_window_bits");
			this.#maxPayloadSize = options.maxPayloadSize;
		}
		/**
		* Decompress a compressed payload.
		* @param {Buffer} chunk Compressed data
		* @param {boolean} fin Final fragment flag
		* @param {Function} callback Callback function
		*/
		decompress(chunk, fin, callback) {
			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) => {
					this.#inflate[kLength] += data.length;
					if (this.#maxPayloadSize > 0 && this.#inflate[kLength] > this.#maxPayloadSize) {
						callback(new MessageSizeExceededError());
						this.#inflate.removeAllListeners();
						this.#inflate = null;
						return;
					}
					this.#inflate[kBuffer].push(data);
				});
				this.#inflate.on("error", (err) => {
					this.#inflate = null;
					callback(err);
				});
			}
			this.#inflate.write(chunk);
			if (fin) this.#inflate.write(tail);
			this.#inflate.flush(() => {
				if (!this.#inflate) return;
				const full = Buffer.concat(this.#inflate[kBuffer], this.#inflate[kLength]);
				this.#inflate[kBuffer].length = 0;
				this.#inflate[kLength] = 0;
				callback(null, full);
			});
		}
	};
	module.exports = { PerMessageDeflate };
}));
//#endregion
//#region node_modules/.pnpm/undici@6.28.0/node_modules/undici/lib/web/websocket/receiver.js
var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Writable } = __require("node:stream");
	var assert$2 = __require("node:assert");
	var { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require_constants$1();
	var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols();
	var { channels } = require_diagnostics();
	var { isValidStatusCode, isValidOpcode, failWebsocketConnection, websocketMessageReceived, utf8Decode, isControlFrame, isTextBinaryFrame, isContinuationFrame } = require_util$1();
	var { WebsocketFrameSend } = require_frame();
	var { closeWebSocketConnection } = require_connection();
	var { PerMessageDeflate } = require_permessage_deflate();
	var { MessageSizeExceededError } = require_errors();
	function failWebsocketConnectionWithCode(ws, code, reason) {
		closeWebSocketConnection(ws, code, reason, Buffer.byteLength(reason));
		failWebsocketConnection(ws, reason);
	}
	var ByteParser = class extends Writable {
		#buffers = [];
		#fragmentsBytes = 0;
		#byteOffset = 0;
		#loop = false;
		#state = parserStates.INFO;
		#info = {};
		#fragments = [];
		/** @type {Map<string, PerMessageDeflate>} */
		#extensions;
		/** @type {number} */
		#maxFragments;
		/** @type {number} */
		#maxPayloadSize;
		/**
		* @param {import('./websocket').WebSocket} ws
		* @param {Map<string, string>|null} extensions
		* @param {{ maxFragments?: number, maxPayloadSize?: number }} [options]
		*/
		constructor(ws, extensions, options = {}) {
			super();
			this.ws = ws;
			this.#extensions = extensions == null ? /* @__PURE__ */ new Map() : extensions;
			this.#maxFragments = options.maxFragments ?? 0;
			this.#maxPayloadSize = options.maxPayloadSize ?? 0;
			if (this.#extensions.has("permessage-deflate")) this.#extensions.set("permessage-deflate", new PerMessageDeflate(extensions, options));
		}
		/**
		* @param {Buffer} chunk
		* @param {() => void} callback
		*/
		_write(chunk, _, callback) {
			this.#buffers.push(chunk);
			this.#byteOffset += chunk.length;
			this.#loop = true;
			this.run(callback);
		}
		#validatePayloadLength() {
			if (this.#maxPayloadSize > 0 && !isControlFrame(this.#info.opcode) && this.#info.payloadLength + this.#fragmentsBytes > this.#maxPayloadSize) {
				failWebsocketConnectionWithCode(this.ws, 1009, "Payload size exceeds maximum allowed size");
				return false;
			}
			return true;
		}
		/**
		* 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;
					if (!this.#validatePayloadLength()) return;
				} 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;
				if (!this.#validatePayloadLength()) return;
			} 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;
				if (!this.#validatePayloadLength()) return;
			} 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) {
					if (!this.writeFragments(body)) return;
					if (this.#maxPayloadSize > 0 && this.#fragmentsBytes > this.#maxPayloadSize) {
						failWebsocketConnectionWithCode(this.ws, 1009, new MessageSizeExceededError().message);
						return;
					}
					if (!this.#info.fragmented && this.#info.fin) websocketMessageReceived(this.ws, this.#info.binaryType, this.consumeFragments());
					this.#state = parserStates.INFO;
				} else {
					this.#extensions.get("permessage-deflate").decompress(body, this.#info.fin, (error, data) => {
						if (error) {
							const code = error instanceof MessageSizeExceededError ? 1009 : 1007;
							failWebsocketConnectionWithCode(this.ws, code, error.message);
							return;
						}
						if (!this.writeFragments(data)) return;
						if (this.#maxPayloadSize > 0 && this.#fragmentsBytes > this.#maxPayloadSize) {
							failWebsocketConnectionWithCode(this.ws, 1009, new MessageSizeExceededError().message);
							return;
						}
						if (!this.#info.fin) {
							this.#state = parserStates.INFO;
							this.#loop = true;
							this.run(callback);
							return;
						}
						websocketMessageReceived(this.ws, this.#info.binaryType, this.consumeFragments());
						this.#loop = true;
						this.#state = parserStates.INFO;
						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;
		}
		writeFragments(fragment) {
			if (this.#maxFragments > 0 && this.#fragments.length === this.#maxFragments) {
				failWebsocketConnectionWithCode(this.ws, 1008, "Too many message fragments");
				return false;
			}
			this.#fragmentsBytes += fragment.length;
			this.#fragments.push(fragment);
			return true;
		}
		consumeFragments() {
			const fragments = this.#fragments;
			if (fragments.length === 1) {
				this.#fragmentsBytes = 0;
				return fragments.shift();
			}
			const output = Buffer.concat(fragments, this.#fragmentsBytes);
			this.#fragments = [];
			this.#fragmentsBytes = 0;
			return output;
		}
		parseCloseBody(data) {
			assert$2(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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/websocket/sender.js
var require_sender = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { WebsocketFrameSend } = require_frame();
	var { opcodes, sendHints } = require_constants$1();
	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/.pnpm/undici@6.28.0/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$6();
	var { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = require_constants$1();
	var { kWebSocketURL, kReadyState, kController, kBinaryType, kResponse, kSentClose, kByteParser } = require_symbols();
	var { isConnecting, isEstablished, isClosing, isValidSubprotocol, fireEvent } = require_util$1();
	var { establishWebSocketConnection, closeWebSocketConnection } = require_connection();
	var { ByteParser } = require_receiver();
	var { kEnumerableProperty, isBlobLike } = require_util$7();
	var { getGlobalDispatcher } = require_global();
	var { types: types$1 } = __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$1.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 webSocketOptions = this[kController]?.dispatcher?.webSocketOptions;
			const maxFragments = webSocketOptions?.maxFragments;
			const maxPayloadSize = webSocketOptions?.maxPayloadSize;
			const parser = new ByteParser(this, parsedExtensions, {
				maxFragments,
				maxPayloadSize
			});
			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$1.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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/eventsource/util.js
var require_util = /* @__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/.pnpm/undici@6.28.0/node_modules/undici/lib/web/eventsource/eventsource-stream.js
var require_eventsource_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { Transform: Transform$1 } = __require("node:stream");
	var { isASCIINumber, isValidLastEventId } = require_util();
	/**
	* @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$1 {
		/**
		* @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;
			}
			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;
			}
		}
		/**
		* @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/.pnpm/undici@6.28.0/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();
	var { kEnumerableProperty } = require_util$7();
	var { environmentSettingsObject } = require_util$6();
	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/.pnpm/undici@6.28.0/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$7();
	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;
}));
//#endregion
//#region node_modules/.pnpm/@actions+http-client@4.0.1/node_modules/@actions/http-client/lib/index.js
var import_tunnel = /* @__PURE__ */ __toESM(require_tunnel(), 1);
var import_undici = require_undici();
var __awaiter$24 = 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 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 = {}));
var HttpRedirectCodes = [
	HttpCodes.MovedPermanently,
	HttpCodes.ResourceMoved,
	HttpCodes.SeeOther,
	HttpCodes.TemporaryRedirect,
	HttpCodes.PermanentRedirect
];
var HttpResponseRetryCodes = [
	HttpCodes.BadGateway,
	HttpCodes.ServiceUnavailable,
	HttpCodes.GatewayTimeout
];
var RetryableHttpVerbs = [
	"OPTIONS",
	"GET",
	"DELETE",
	"HEAD"
];
var ExponentialBackoffCeiling = 10;
var ExponentialBackoffTimeSlice = 5;
var HttpClientError = class HttpClientError extends Error {
	constructor(message, statusCode) {
		super(message);
		this.name = "HttpClientError";
		this.statusCode = statusCode;
		Object.setPrototypeOf(this, HttpClientError.prototype);
	}
};
var HttpClientResponse = class {
	constructor(message) {
		this.message = message;
	}
	readBody() {
		return __awaiter$24(this, void 0, void 0, function* () {
			return new Promise((resolve) => __awaiter$24(this, void 0, void 0, function* () {
				let output = Buffer.alloc(0);
				this.message.on("data", (chunk) => {
					output = Buffer.concat([output, chunk]);
				});
				this.message.on("end", () => {
					resolve(output.toString());
				});
			}));
		});
	}
	readBodyBuffer() {
		return __awaiter$24(this, void 0, void 0, function* () {
			return new Promise((resolve) => __awaiter$24(this, void 0, void 0, function* () {
				const chunks = [];
				this.message.on("data", (chunk) => {
					chunks.push(chunk);
				});
				this.message.on("end", () => {
					resolve(Buffer.concat(chunks));
				});
			}));
		});
	}
};
var HttpClient = class {
	constructor(userAgent, handlers, requestOptions) {
		this._ignoreSslError = false;
		this._allowRedirects = true;
		this._allowRedirectDowngrade = false;
		this._maxRedirects = 50;
		this._allowRetries = false;
		this._maxRetries = 1;
		this._keepAlive = false;
		this._disposed = false;
		this.userAgent = this._getUserAgentWithOrchestrationId(userAgent);
		this.handlers = handlers || [];
		this.requestOptions = requestOptions;
		if (requestOptions) {
			if (requestOptions.ignoreSslError != null) this._ignoreSslError = requestOptions.ignoreSslError;
			this._socketTimeout = requestOptions.socketTimeout;
			if (requestOptions.allowRedirects != null) this._allowRedirects = requestOptions.allowRedirects;
			if (requestOptions.allowRedirectDowngrade != null) this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
			if (requestOptions.maxRedirects != null) this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
			if (requestOptions.keepAlive != null) this._keepAlive = requestOptions.keepAlive;
			if (requestOptions.allowRetries != null) this._allowRetries = requestOptions.allowRetries;
			if (requestOptions.maxRetries != null) this._maxRetries = requestOptions.maxRetries;
		}
	}
	options(requestUrl, additionalHeaders) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return this.request("OPTIONS", requestUrl, null, additionalHeaders || {});
		});
	}
	get(requestUrl, additionalHeaders) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return this.request("GET", requestUrl, null, additionalHeaders || {});
		});
	}
	del(requestUrl, additionalHeaders) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return this.request("DELETE", requestUrl, null, additionalHeaders || {});
		});
	}
	post(requestUrl, data, additionalHeaders) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return this.request("POST", requestUrl, data, additionalHeaders || {});
		});
	}
	patch(requestUrl, data, additionalHeaders) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return this.request("PATCH", requestUrl, data, additionalHeaders || {});
		});
	}
	put(requestUrl, data, additionalHeaders) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return this.request("PUT", requestUrl, data, additionalHeaders || {});
		});
	}
	head(requestUrl, additionalHeaders) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return this.request("HEAD", requestUrl, null, additionalHeaders || {});
		});
	}
	sendStream(verb, requestUrl, stream, additionalHeaders) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return this.request(verb, requestUrl, stream, additionalHeaders);
		});
	}
	/**
	* Gets a typed object from an endpoint
	* Be aware that not found returns a null.  Other errors (4xx, 5xx) reject the promise
	*/
	getJson(requestUrl_1) {
		return __awaiter$24(this, arguments, void 0, function* (requestUrl, additionalHeaders = {}) {
			additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
			const res = yield this.get(requestUrl, additionalHeaders);
			return this._processResponse(res, this.requestOptions);
		});
	}
	postJson(requestUrl_1, obj_1) {
		return __awaiter$24(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
			const data = JSON.stringify(obj, null, 2);
			additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
			additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
			const res = yield this.post(requestUrl, data, additionalHeaders);
			return this._processResponse(res, this.requestOptions);
		});
	}
	putJson(requestUrl_1, obj_1) {
		return __awaiter$24(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
			const data = JSON.stringify(obj, null, 2);
			additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
			additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
			const res = yield this.put(requestUrl, data, additionalHeaders);
			return this._processResponse(res, this.requestOptions);
		});
	}
	patchJson(requestUrl_1, obj_1) {
		return __awaiter$24(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
			const data = JSON.stringify(obj, null, 2);
			additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
			additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
			const res = yield this.patch(requestUrl, data, additionalHeaders);
			return this._processResponse(res, this.requestOptions);
		});
	}
	/**
	* Makes a raw http request.
	* All other methods such as get, post, patch, and request ultimately call this.
	* Prefer get, del, post and patch
	*/
	request(verb, requestUrl, data, headers) {
		return __awaiter$24(this, void 0, void 0, function* () {
			if (this._disposed) throw new Error("Client has already been disposed.");
			const parsedUrl = new URL(requestUrl);
			let info = this._prepareRequest(verb, parsedUrl, headers);
			const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1;
			let numTries = 0;
			let response;
			do {
				response = yield this.requestRaw(info, data);
				if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) {
					let authenticationHandler;
					for (const handler of this.handlers) if (handler.canHandleAuthentication(response)) {
						authenticationHandler = handler;
						break;
					}
					if (authenticationHandler) return authenticationHandler.handleAuthentication(this, info, data);
					else return response;
				}
				let redirectsRemaining = this._maxRedirects;
				while (response.message.statusCode && HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0) {
					const redirectUrl = response.message.headers["location"];
					if (!redirectUrl) break;
					const parsedRedirectUrl = new URL(redirectUrl);
					if (parsedUrl.protocol === "https:" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.");
					yield response.readBody();
					if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
						for (const header in headers) if (header.toLowerCase() === "authorization") delete headers[header];
					}
					info = this._prepareRequest(verb, parsedRedirectUrl, headers);
					response = yield this.requestRaw(info, data);
					redirectsRemaining--;
				}
				if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode)) return response;
				numTries += 1;
				if (numTries < maxTries) {
					yield response.readBody();
					yield this._performExponentialBackoff(numTries);
				}
			} while (numTries < maxTries);
			return response;
		});
	}
	/**
	* Needs to be called if keepAlive is set to true in request options.
	*/
	dispose() {
		if (this._agent) this._agent.destroy();
		this._disposed = true;
	}
	/**
	* Raw request.
	* @param info
	* @param data
	*/
	requestRaw(info, data) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return new Promise((resolve, reject) => {
				function callbackForResult(err, res) {
					if (err) reject(err);
					else if (!res) reject(/* @__PURE__ */ new Error("Unknown error"));
					else resolve(res);
				}
				this.requestRawWithCallback(info, data, callbackForResult);
			});
		});
	}
	/**
	* Raw request with callback.
	* @param info
	* @param data
	* @param onResult
	*/
	requestRawWithCallback(info, data, onResult) {
		if (typeof data === "string") {
			if (!info.options.headers) info.options.headers = {};
			info.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8");
		}
		let callbackCalled = false;
		function handleResult(err, res) {
			if (!callbackCalled) {
				callbackCalled = true;
				onResult(err, res);
			}
		}
		const req = info.httpModule.request(info.options, (msg) => {
			handleResult(void 0, new HttpClientResponse(msg));
		});
		let socket;
		req.on("socket", (sock) => {
			socket = sock;
		});
		req.setTimeout(this._socketTimeout || 18e4, () => {
			if (socket) socket.end();
			handleResult(/* @__PURE__ */ new Error(`Request timeout: ${info.options.path}`));
		});
		req.on("error", function(err) {
			handleResult(err);
		});
		if (data && typeof data === "string") req.write(data, "utf8");
		if (data && typeof data !== "string") {
			data.on("close", function() {
				req.end();
			});
			data.pipe(req);
		} else req.end();
	}
	/**
	* Gets an http agent. This function is useful when you need an http agent that handles
	* routing through a proxy server - depending upon the url and proxy environment variables.
	* @param serverUrl  The server URL where the request will be sent. For example, https://api.github.com
	*/
	getAgent(serverUrl) {
		const parsedUrl = new URL(serverUrl);
		return this._getAgent(parsedUrl);
	}
	getAgentDispatcher(serverUrl) {
		const parsedUrl = new URL(serverUrl);
		const proxyUrl = getProxyUrl(parsedUrl);
		if (!(proxyUrl && proxyUrl.hostname)) return;
		return this._getProxyAgentDispatcher(parsedUrl, proxyUrl);
	}
	_prepareRequest(method, requestUrl, headers) {
		const info = {};
		info.parsedUrl = requestUrl;
		const usingSsl = info.parsedUrl.protocol === "https:";
		info.httpModule = usingSsl ? https$3 : http$4;
		const defaultPort = usingSsl ? 443 : 80;
		info.options = {};
		info.options.host = info.parsedUrl.hostname;
		info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort;
		info.options.path = (info.parsedUrl.pathname || "") + (info.parsedUrl.search || "");
		info.options.method = method;
		info.options.headers = this._mergeHeaders(headers);
		if (this.userAgent != null) info.options.headers["user-agent"] = this.userAgent;
		info.options.agent = this._getAgent(info.parsedUrl);
		if (this.handlers) for (const handler of this.handlers) handler.prepareRequest(info.options);
		return info;
	}
	_mergeHeaders(headers) {
		if (this.requestOptions && this.requestOptions.headers) return Object.assign({}, lowercaseKeys$1(this.requestOptions.headers), lowercaseKeys$1(headers || {}));
		return lowercaseKeys$1(headers || {});
	}
	/**
	* Gets an existing header value or returns a default.
	* Handles converting number header values to strings since HTTP headers must be strings.
	* Note: This returns string | string[] since some headers can have multiple values.
	* For headers that must always be a single string (like Content-Type), use the
	* specialized _getExistingOrDefaultContentTypeHeader method instead.
	*/
	_getExistingOrDefaultHeader(additionalHeaders, header, _default) {
		let clientHeader;
		if (this.requestOptions && this.requestOptions.headers) {
			const headerValue = lowercaseKeys$1(this.requestOptions.headers)[header];
			if (headerValue) clientHeader = typeof headerValue === "number" ? headerValue.toString() : headerValue;
		}
		const additionalValue = additionalHeaders[header];
		if (additionalValue !== void 0) return typeof additionalValue === "number" ? additionalValue.toString() : additionalValue;
		if (clientHeader !== void 0) return clientHeader;
		return _default;
	}
	/**
	* Specialized version of _getExistingOrDefaultHeader for Content-Type header.
	* Always returns a single string (not an array) since Content-Type should be a single value.
	* Converts arrays to comma-separated strings and numbers to strings to ensure type safety.
	* This was split from _getExistingOrDefaultHeader to provide stricter typing for callers
	* that assign the result to places expecting a string (e.g., additionalHeaders[Headers.ContentType]).
	*/
	_getExistingOrDefaultContentTypeHeader(additionalHeaders, _default) {
		let clientHeader;
		if (this.requestOptions && this.requestOptions.headers) {
			const headerValue = lowercaseKeys$1(this.requestOptions.headers)[Headers.ContentType];
			if (headerValue) {
				if (typeof headerValue === "number") clientHeader = String(headerValue);
				else if (Array.isArray(headerValue)) clientHeader = headerValue.join(", ");
				else clientHeader = headerValue;
			}
		}
		const additionalValue = additionalHeaders[Headers.ContentType];
		if (additionalValue !== void 0) {
			if (typeof additionalValue === "number") return String(additionalValue);
			else if (Array.isArray(additionalValue)) return additionalValue.join(", ");
			else return additionalValue;
		}
		if (clientHeader !== void 0) return clientHeader;
		return _default;
	}
	_getAgent(parsedUrl) {
		let agent;
		const proxyUrl = getProxyUrl(parsedUrl);
		const useProxy = proxyUrl && proxyUrl.hostname;
		if (this._keepAlive && useProxy) agent = this._proxyAgent;
		if (!useProxy) agent = this._agent;
		if (agent) return agent;
		const usingSsl = parsedUrl.protocol === "https:";
		let maxSockets = 100;
		if (this.requestOptions) maxSockets = this.requestOptions.maxSockets || http$4.globalAgent.maxSockets;
		if (proxyUrl && proxyUrl.hostname) {
			const agentOptions = {
				maxSockets,
				keepAlive: this._keepAlive,
				proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && { proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` }), {
					host: proxyUrl.hostname,
					port: proxyUrl.port
				})
			};
			let tunnelAgent;
			const overHttps = proxyUrl.protocol === "https:";
			if (usingSsl) tunnelAgent = overHttps ? import_tunnel.httpsOverHttps : import_tunnel.httpsOverHttp;
			else tunnelAgent = overHttps ? import_tunnel.httpOverHttps : import_tunnel.httpOverHttp;
			agent = tunnelAgent(agentOptions);
			this._proxyAgent = agent;
		}
		if (!agent) {
			const options = {
				keepAlive: this._keepAlive,
				maxSockets
			};
			agent = usingSsl ? new https$3.Agent(options) : new http$4.Agent(options);
			this._agent = agent;
		}
		if (usingSsl && this._ignoreSslError) agent.options = Object.assign(agent.options || {}, { rejectUnauthorized: false });
		return agent;
	}
	_getProxyAgentDispatcher(parsedUrl, proxyUrl) {
		let proxyAgent;
		if (this._keepAlive) proxyAgent = this._proxyAgentDispatcher;
		if (proxyAgent) return proxyAgent;
		const usingSsl = parsedUrl.protocol === "https:";
		proxyAgent = new import_undici.ProxyAgent(Object.assign({
			uri: proxyUrl.href,
			pipelining: !this._keepAlive ? 0 : 1
		}, (proxyUrl.username || proxyUrl.password) && { token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString("base64")}` }));
		this._proxyAgentDispatcher = proxyAgent;
		if (usingSsl && this._ignoreSslError) proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, { rejectUnauthorized: false });
		return proxyAgent;
	}
	_getUserAgentWithOrchestrationId(userAgent) {
		const baseUserAgent = userAgent || "actions/http-client";
		const orchId = process.env["ACTIONS_ORCHESTRATION_ID"];
		if (orchId) return `${baseUserAgent} actions_orchestration_id/${orchId.replace(/[^a-z0-9_.-]/gi, "_")}`;
		return baseUserAgent;
	}
	_performExponentialBackoff(retryNumber) {
		return __awaiter$24(this, void 0, void 0, function* () {
			retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
			const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
			return new Promise((resolve) => setTimeout(() => resolve(), ms));
		});
	}
	_processResponse(res, options) {
		return __awaiter$24(this, void 0, void 0, function* () {
			return new Promise((resolve, reject) => __awaiter$24(this, void 0, void 0, function* () {
				const statusCode = res.message.statusCode || 0;
				const response = {
					statusCode,
					result: null,
					headers: {}
				};
				if (statusCode === HttpCodes.NotFound) resolve(response);
				function dateTimeDeserializer(key, value) {
					if (typeof value === "string") {
						const a = new Date(value);
						if (!isNaN(a.valueOf())) return a;
					}
					return value;
				}
				let obj;
				let contents;
				try {
					contents = yield res.readBody();
					if (contents && contents.length > 0) {
						if (options && options.deserializeDates) obj = JSON.parse(contents, dateTimeDeserializer);
						else obj = JSON.parse(contents);
						response.result = obj;
					}
					response.headers = res.message.headers;
				} catch (err) {}
				if (statusCode > 299) {
					let msg;
					if (obj && obj.message) msg = obj.message;
					else if (contents && contents.length > 0) msg = contents;
					else msg = `Failed request: (${statusCode})`;
					const err = new HttpClientError(msg, statusCode);
					err.result = response.result;
					reject(err);
				} else resolve(response);
			}));
		});
	}
};
var lowercaseKeys$1 = /* @__PURE__ */ __name((obj) => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}), "lowercaseKeys");
//#endregion
//#region node_modules/.pnpm/@actions+http-client@4.0.1/node_modules/@actions/http-client/lib/auth.js
var __awaiter$23 = 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 BearerCredentialHandler = class {
	constructor(token) {
		this.token = token;
	}
	prepareRequest(options) {
		if (!options.headers) throw Error("The request has no headers");
		options.headers["Authorization"] = `Bearer ${this.token}`;
	}
	canHandleAuthentication() {
		return false;
	}
	handleAuthentication() {
		return __awaiter$23(this, void 0, void 0, function* () {
			throw new Error("not implemented");
		});
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+core@3.0.1/node_modules/@actions/core/lib/summary.js
var __awaiter$21 = 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: access$1, 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$21(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$1(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$21(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$21(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();
	}
};
var summary = new Summary();
//#endregion
//#region node_modules/.pnpm/@actions+io@3.0.2/node_modules/@actions/io/lib/io-util.js
var __awaiter$20 = 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$8 = process.platform === "win32";
fs$1.constants.O_RDONLY;
function exists(fsPath) {
	return __awaiter$20(this, void 0, void 0, function* () {
		try {
			yield stat(fsPath);
		} catch (err) {
			if (err.code === "ENOENT") return false;
			throw err;
		}
		return true;
	});
}
/**
* 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$1(p);
	if (!p) throw new Error("isRooted() parameter \"p\" cannot be empty");
	if (IS_WINDOWS$8) 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$20(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$8) {
				const upperExt = path$2.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$8) {
					try {
						const directory = path$2.dirname(filePath);
						const upperName = path$2.basename(filePath).toUpperCase();
						for (const actualName of yield readdir(directory)) if (upperName === actualName.toUpperCase()) {
							filePath = path$2.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$1(p) {
	p = p || "";
	if (IS_WINDOWS$8) {
		p = p.replace(/\//g, "\\");
		return p.replace(/\\\\+/g, "\\");
	}
	return p.replace(/\/\/+/g, "/");
}
__name(normalizeSeparators$1, "normalizeSeparators");
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/.pnpm/@actions+io@3.0.2/node_modules/@actions/io/lib/io.js
var __awaiter$19 = 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());
	});
};
/**
* Make a directory.  Creates the full path with folders in between
* Will throw if it fails
*
* @param   fsPath        path to create
* @returns Promise<void>
*/
function mkdirP(fsPath) {
	return __awaiter$19(this, void 0, void 0, function* () {
		ok(fsPath, "a path argument must be provided");
		yield mkdir(fsPath, { recursive: true });
	});
}
/**
* 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(tool, check) {
	return __awaiter$19(this, void 0, void 0, function* () {
		if (!tool) throw new Error("parameter 'tool' is required");
		if (check) {
			const result = yield which(tool, false);
			if (!result) {
				if (IS_WINDOWS$8) 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$19(this, void 0, void 0, function* () {
		if (!tool) throw new Error("parameter 'tool' is required");
		const extensions = [];
		if (IS_WINDOWS$8 && process.env["PATHEXT"]) {
			for (const extension of process.env["PATHEXT"].split(path$2.delimiter)) if (extension) extensions.push(extension);
		}
		if (isRooted(tool)) {
			const filePath = yield tryGetExecutablePath(tool, extensions);
			if (filePath) return [filePath];
			return [];
		}
		if (tool.includes(path$2.sep)) return [];
		const directories = [];
		if (process.env.PATH) {
			for (const p of process.env.PATH.split(path$2.delimiter)) if (p) directories.push(p);
		}
		const matches = [];
		for (const directory of directories) {
			const filePath = yield tryGetExecutablePath(path$2.join(directory, tool), extensions);
			if (filePath) matches.push(filePath);
		}
		return matches;
	});
}
//#endregion
//#region node_modules/.pnpm/@actions+exec@3.0.0/node_modules/@actions/exec/lib/toolrunner.js
var __awaiter$18 = 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 IS_WINDOWS$7 = process.platform === "win32";
var ToolRunner = class extends events.EventEmitter {
	constructor(toolPath, args, options) {
		super();
		if (!toolPath) throw new Error("Parameter 'toolPath' cannot be null or empty.");
		this.toolPath = toolPath;
		this.args = args || [];
		this.options = options || {};
	}
	_debug(message) {
		if (this.options.listeners && this.options.listeners.debug) this.options.listeners.debug(message);
	}
	_getCommandString(options, noPrefix) {
		const toolPath = this._getSpawnFileName();
		const args = this._getSpawnArgs(options);
		let cmd = noPrefix ? "" : "[command]";
		if (IS_WINDOWS$7) {
			if (this._isCmdFile()) {
				cmd += toolPath;
				for (const a of args) cmd += ` ${a}`;
			} else if (options.windowsVerbatimArguments) {
				cmd += `"${toolPath}"`;
				for (const a of args) cmd += ` ${a}`;
			} else {
				cmd += this._windowsQuoteCmdArg(toolPath);
				for (const a of args) cmd += ` ${this._windowsQuoteCmdArg(a)}`;
			}
		} else {
			cmd += toolPath;
			for (const a of args) cmd += ` ${a}`;
		}
		return cmd;
	}
	_processLineBuffer(data, strBuffer, onLine) {
		try {
			let s = strBuffer + data.toString();
			let n = s.indexOf(os$4.EOL);
			while (n > -1) {
				onLine(s.substring(0, n));
				s = s.substring(n + os$4.EOL.length);
				n = s.indexOf(os$4.EOL);
			}
			return s;
		} catch (err) {
			this._debug(`error processing line. Failed with error ${err}`);
			return "";
		}
	}
	_getSpawnFileName() {
		if (IS_WINDOWS$7) {
			if (this._isCmdFile()) return process.env["COMSPEC"] || "cmd.exe";
		}
		return this.toolPath;
	}
	_getSpawnArgs(options) {
		if (IS_WINDOWS$7) {
			if (this._isCmdFile()) {
				let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`;
				for (const a of this.args) {
					argline += " ";
					argline += options.windowsVerbatimArguments ? a : this._windowsQuoteCmdArg(a);
				}
				argline += "\"";
				return [argline];
			}
		}
		return this.args;
	}
	_endsWith(str, end) {
		return str.endsWith(end);
	}
	_isCmdFile() {
		const upperToolPath = this.toolPath.toUpperCase();
		return this._endsWith(upperToolPath, ".CMD") || this._endsWith(upperToolPath, ".BAT");
	}
	_windowsQuoteCmdArg(arg) {
		if (!this._isCmdFile()) return this._uvQuoteCmdArg(arg);
		if (!arg) return "\"\"";
		const cmdSpecialChars = [
			" ",
			"	",
			"&",
			"(",
			")",
			"[",
			"]",
			"{",
			"}",
			"^",
			"=",
			";",
			"!",
			"'",
			"+",
			",",
			"`",
			"~",
			"|",
			"<",
			">",
			"\""
		];
		let needsQuotes = false;
		for (const char of arg) if (cmdSpecialChars.some((x) => x === char)) {
			needsQuotes = true;
			break;
		}
		if (!needsQuotes) return arg;
		let reverse = "\"";
		let quoteHit = true;
		for (let i = arg.length; i > 0; i--) {
			reverse += arg[i - 1];
			if (quoteHit && arg[i - 1] === "\\") reverse += "\\";
			else if (arg[i - 1] === "\"") {
				quoteHit = true;
				reverse += "\"";
			} else quoteHit = false;
		}
		reverse += "\"";
		return reverse.split("").reverse().join("");
	}
	_uvQuoteCmdArg(arg) {
		if (!arg) return "\"\"";
		if (!arg.includes(" ") && !arg.includes("	") && !arg.includes("\"")) return arg;
		if (!arg.includes("\"") && !arg.includes("\\")) return `"${arg}"`;
		let reverse = "\"";
		let quoteHit = true;
		for (let i = arg.length; i > 0; i--) {
			reverse += arg[i - 1];
			if (quoteHit && arg[i - 1] === "\\") reverse += "\\";
			else if (arg[i - 1] === "\"") {
				quoteHit = true;
				reverse += "\\";
			} else quoteHit = false;
		}
		reverse += "\"";
		return reverse.split("").reverse().join("");
	}
	_cloneExecOptions(options) {
		options = options || {};
		const result = {
			cwd: options.cwd || process.cwd(),
			env: options.env || process.env,
			silent: options.silent || false,
			windowsVerbatimArguments: options.windowsVerbatimArguments || false,
			failOnStdErr: options.failOnStdErr || false,
			ignoreReturnCode: options.ignoreReturnCode || false,
			delay: options.delay || 1e4
		};
		result.outStream = options.outStream || process.stdout;
		result.errStream = options.errStream || process.stderr;
		return result;
	}
	_getSpawnOptions(options, toolPath) {
		options = options || {};
		const result = {};
		result.cwd = options.cwd;
		result.env = options.env;
		result["windowsVerbatimArguments"] = options.windowsVerbatimArguments || this._isCmdFile();
		if (options.windowsVerbatimArguments) result.argv0 = `"${toolPath}"`;
		return result;
	}
	/**
	* Exec a tool.
	* Output will be streamed to the live console.
	* Returns promise with return code
	*
	* @param     tool     path to tool to exec
	* @param     options  optional exec options.  See ExecOptions
	* @returns   number
	*/
	exec() {
		return __awaiter$18(this, void 0, void 0, function* () {
			if (!isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS$7 && this.toolPath.includes("\\"))) this.toolPath = path$2.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
			this.toolPath = yield which(this.toolPath, true);
			return new Promise((resolve, reject) => __awaiter$18(this, void 0, void 0, function* () {
				this._debug(`exec tool: ${this.toolPath}`);
				this._debug("arguments:");
				for (const arg of this.args) this._debug(`   ${arg}`);
				const optionsNonNull = this._cloneExecOptions(this.options);
				if (!optionsNonNull.silent && optionsNonNull.outStream) optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os$4.EOL);
				const state = new ExecState(optionsNonNull, this.toolPath);
				state.on("debug", (message) => {
					this._debug(message);
				});
				if (this.options.cwd && !(yield exists(this.options.cwd))) return reject(/* @__PURE__ */ new Error(`The cwd: ${this.options.cwd} does not exist!`));
				const fileName = this._getSpawnFileName();
				const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
				let stdbuffer = "";
				if (cp.stdout) cp.stdout.on("data", (data) => {
					if (this.options.listeners && this.options.listeners.stdout) this.options.listeners.stdout(data);
					if (!optionsNonNull.silent && optionsNonNull.outStream) optionsNonNull.outStream.write(data);
					stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => {
						if (this.options.listeners && this.options.listeners.stdline) this.options.listeners.stdline(line);
					});
				});
				let errbuffer = "";
				if (cp.stderr) cp.stderr.on("data", (data) => {
					state.processStderr = true;
					if (this.options.listeners && this.options.listeners.stderr) this.options.listeners.stderr(data);
					if (!optionsNonNull.silent && optionsNonNull.errStream && optionsNonNull.outStream) (optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream).write(data);
					errbuffer = this._processLineBuffer(data, errbuffer, (line) => {
						if (this.options.listeners && this.options.listeners.errline) this.options.listeners.errline(line);
					});
				});
				cp.on("error", (err) => {
					state.processError = err.message;
					state.processExited = true;
					state.processClosed = true;
					state.CheckComplete();
				});
				cp.on("exit", (code) => {
					state.processExitCode = code;
					state.processExited = true;
					this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
					state.CheckComplete();
				});
				cp.on("close", (code) => {
					state.processExitCode = code;
					state.processExited = true;
					state.processClosed = true;
					this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
					state.CheckComplete();
				});
				state.on("done", (error, exitCode) => {
					if (stdbuffer.length > 0) this.emit("stdline", stdbuffer);
					if (errbuffer.length > 0) this.emit("errline", errbuffer);
					cp.removeAllListeners();
					if (error) reject(error);
					else resolve(exitCode);
				});
				if (this.options.input) {
					if (!cp.stdin) throw new Error("child process missing stdin");
					cp.stdin.end(this.options.input);
				}
			}));
		});
	}
};
/**
* Convert an arg string to an array of args. Handles escaping
*
* @param    argString   string of arguments
* @returns  string[]    array of arguments
*/
function argStringToArray(argString) {
	const args = [];
	let inQuotes = false;
	let escaped = false;
	let arg = "";
	function append(c) {
		if (escaped && c !== "\"") arg += "\\";
		arg += c;
		escaped = false;
	}
	for (let i = 0; i < argString.length; i++) {
		const c = argString.charAt(i);
		if (c === "\"") {
			if (!escaped) inQuotes = !inQuotes;
			else append(c);
			continue;
		}
		if (c === "\\" && escaped) {
			append(c);
			continue;
		}
		if (c === "\\" && inQuotes) {
			escaped = true;
			continue;
		}
		if (c === " " && !inQuotes) {
			if (arg.length > 0) {
				args.push(arg);
				arg = "";
			}
			continue;
		}
		append(c);
	}
	if (arg.length > 0) args.push(arg.trim());
	return args;
}
var ExecState = class ExecState extends events.EventEmitter {
	constructor(options, toolPath) {
		super();
		this.processClosed = false;
		this.processError = "";
		this.processExitCode = 0;
		this.processExited = false;
		this.processStderr = false;
		this.delay = 1e4;
		this.done = false;
		this.timeout = null;
		if (!toolPath) throw new Error("toolPath must not be empty");
		this.options = options;
		this.toolPath = toolPath;
		if (options.delay) this.delay = options.delay;
	}
	CheckComplete() {
		if (this.done) return;
		if (this.processClosed) this._setResult();
		else if (this.processExited) this.timeout = setTimeout$1(ExecState.HandleTimeout, this.delay, this);
	}
	_debug(message) {
		this.emit("debug", message);
	}
	_setResult() {
		let error;
		if (this.processExited) {
			if (this.processError) error = /* @__PURE__ */ new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);
			else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) error = /* @__PURE__ */ new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);
			else if (this.processStderr && this.options.failOnStdErr) error = /* @__PURE__ */ new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);
		}
		if (this.timeout) {
			clearTimeout(this.timeout);
			this.timeout = null;
		}
		this.done = true;
		this.emit("done", error, this.processExitCode);
	}
	static HandleTimeout(state) {
		if (state.done) return;
		if (!state.processClosed && state.processExited) {
			const message = `The STDIO streams did not close within ${state.delay / 1e3} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
			state._debug(message);
		}
		state._setResult();
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+exec@3.0.0/node_modules/@actions/exec/lib/exec.js
var __awaiter$17 = 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());
	});
};
/**
* Exec a command.
* Output will be streamed to the live console.
* Returns promise with return code
*
* @param     commandLine        command to execute (can include additional args). Must be correctly escaped.
* @param     args               optional arguments for tool. Escaping is handled by the lib.
* @param     options            optional exec options.  See ExecOptions
* @returns   Promise<number>    exit code
*/
function exec(commandLine, args, options) {
	return __awaiter$17(this, void 0, void 0, function* () {
		const commandArgs = argStringToArray(commandLine);
		if (commandArgs.length === 0) throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
		const toolPath = commandArgs[0];
		args = commandArgs.slice(1).concat(args || []);
		return new ToolRunner(toolPath, args, options).exec();
	});
}
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 = {}));
/**
* Registers a secret which will get masked from logs
*
* @param secret - Value of the secret to be masked
* @remarks
* This function instructs the Actions runner to mask the specified value in any
* logs produced during the workflow run. Once registered, the secret value will
* be replaced with asterisks (***) whenever it appears in console output, logs,
* or error messages.
*
* This is useful for protecting sensitive information such as:
* - API keys
* - Access tokens
* - Authentication credentials
* - URL parameters containing signatures (SAS tokens)
*
* Note that masking only affects future logs; any previous appearances of the
* secret in logs before calling this function will remain unmasked.
*
* @example
* ```typescript
* // Register an API token as a secret
* const apiToken = "abc123xyz456";
* setSecret(apiToken);
*
* // Now any logs containing this value will show *** instead
* console.log(`Using token: ${apiToken}`); // Outputs: "Using token: ***"
* ```
*/
function setSecret(secret) {
	issueCommand("add-mask", {}, secret);
}
/**
* 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$1(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();
}
__name(getInput$1, "getInput");
/**
* 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);
}
/**
* Gets whether Actions Step Debug is on or not
*/
function isDebug() {
	return process.env["RUNNER_DEBUG"] === "1";
}
/**
* Writes debug message to user log
* @param message debug message
*/
function debug(message) {
	issueCommand("debug", {}, 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);
}
/**
* Adds a warning issue
* @param message warning issue message. Errors will be converted to string via toString()
* @param properties optional properties to add to the annotation.
*/
function warning(message, properties = {}) {
	issueCommand("warning", toCommandProperties(properties), message instanceof Error ? message.toString() : message);
}
/**
* Adds a notice issue
* @param message notice issue message. Errors will be converted to string via toString()
* @param properties optional properties to add to the annotation.
*/
function notice(message, properties = {}) {
	issueCommand("notice", toCommandProperties(properties), message instanceof Error ? message.toString() : message);
}
/**
* Writes info to log with console.log.
* @param message info message
*/
function info(message) {
	process.stdout.write(message + os$4.EOL);
}
/**
* Begin an output group.
*
* Output until the next `groupEnd` will be foldable in this group
*
* @param name The name of the output group
*/
function startGroup(name) {
	issue("group", name);
}
/**
* End an output group.
*/
function endGroup() {
	issue("endgroup");
}
//#endregion
//#region node_modules/.pnpm/@actions+github@9.1.1/node_modules/@actions/github/lib/context.js
var Context = class {
	/**
	* Hydrate the context from the environment
	*/
	constructor() {
		var _a;
		var _b;
		var _c;
		this.payload = {};
		if (process.env.GITHUB_EVENT_PATH) {
			if (existsSync(process.env.GITHUB_EVENT_PATH)) this.payload = JSON.parse(readFileSync(process.env.GITHUB_EVENT_PATH, { encoding: "utf8" }));
			else {
				const path = process.env.GITHUB_EVENT_PATH;
				process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${EOL}`);
			}
		}
		this.eventName = process.env.GITHUB_EVENT_NAME;
		this.sha = process.env.GITHUB_SHA;
		this.ref = process.env.GITHUB_REF;
		this.workflow = process.env.GITHUB_WORKFLOW;
		this.action = process.env.GITHUB_ACTION;
		this.actor = process.env.GITHUB_ACTOR;
		this.job = process.env.GITHUB_JOB;
		this.runAttempt = parseInt(process.env.GITHUB_RUN_ATTEMPT, 10);
		this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10);
		this.runId = parseInt(process.env.GITHUB_RUN_ID, 10);
		this.apiUrl = (_a = process.env.GITHUB_API_URL) !== null && _a !== void 0 ? _a : `https://api.github.com`;
		this.serverUrl = (_b = process.env.GITHUB_SERVER_URL) !== null && _b !== void 0 ? _b : `https://github.com`;
		this.graphqlUrl = (_c = process.env.GITHUB_GRAPHQL_URL) !== null && _c !== void 0 ? _c : `https://api.github.com/graphql`;
	}
	get issue() {
		const payload = this.payload;
		return Object.assign(Object.assign({}, this.repo), { number: (payload.issue || payload.pull_request || payload).number });
	}
	get repo() {
		if (process.env.GITHUB_REPOSITORY) {
			const [owner, repo] = process.env.GITHUB_REPOSITORY.split("/");
			return {
				owner,
				repo
			};
		}
		if (this.payload.repository) return {
			owner: this.payload.repository.owner.login,
			repo: this.payload.repository.name
		};
		throw new Error("context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'");
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+http-client@3.0.2/node_modules/@actions/http-client/lib/proxy.js
var require_proxy = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.getProxyUrl = getProxyUrl;
	exports.checkBypass = checkBypass;
	function getProxyUrl(reqUrl) {
		const usingSsl = reqUrl.protocol === "https:";
		if (checkBypass(reqUrl)) return;
		const proxyVar = (() => {
			if (usingSsl) return process.env["https_proxy"] || process.env["HTTPS_PROXY"];
			else return process.env["http_proxy"] || process.env["HTTP_PROXY"];
		})();
		if (proxyVar) try {
			return new DecodedURL(proxyVar);
		} catch (_a) {
			if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://")) return new DecodedURL(`http://${proxyVar}`);
		}
		else return;
	}
	function checkBypass(reqUrl) {
		if (!reqUrl.hostname) return false;
		const reqHost = reqUrl.hostname;
		if (isLoopbackAddress(reqHost)) return true;
		const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || "";
		if (!noProxy) return false;
		let reqPort;
		if (reqUrl.port) reqPort = Number(reqUrl.port);
		else if (reqUrl.protocol === "http:") reqPort = 80;
		else if (reqUrl.protocol === "https:") reqPort = 443;
		const upperReqHosts = [reqUrl.hostname.toUpperCase()];
		if (typeof reqPort === "number") upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
		for (const upperNoProxyItem of noProxy.split(",").map((x) => x.trim().toUpperCase()).filter((x) => x)) if (upperNoProxyItem === "*" || upperReqHosts.some((x) => x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x.endsWith(`${upperNoProxyItem}`))) return true;
		return false;
	}
	function isLoopbackAddress(host) {
		const hostLower = host.toLowerCase();
		return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]");
	}
	var DecodedURL = class extends URL {
		constructor(url, base) {
			super(url, base);
			this._decodedUsername = decodeURIComponent(super.username);
			this._decodedPassword = decodeURIComponent(super.password);
		}
		get username() {
			return this._decodedUsername;
		}
		get password() {
			return this._decodedPassword;
		}
	};
}));
//#endregion
//#region node_modules/.pnpm/@actions+github@9.1.1/node_modules/@actions/github/lib/internal/utils.js
var import_lib = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
	var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	});
	var __importStar = exports && exports.__importStar || (function() {
		var ownKeys = function(o) {
			ownKeys = Object.getOwnPropertyNames || function(o) {
				var ar = [];
				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
				return ar;
			};
			return ownKeys(o);
		};
		return function(mod) {
			if (mod && mod.__esModule) return mod;
			var result = {};
			if (mod != null) {
				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
			}
			__setModuleDefault(result, mod);
			return result;
		};
	})();
	var __awaiter = exports && exports.__awaiter || 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());
		});
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.HttpClient = exports.HttpClientResponse = exports.HttpClientError = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0;
	exports.getProxyUrl = getProxyUrl;
	exports.isHttps = isHttps;
	var http$3 = __importStar(__require("http"));
	var https$2 = __importStar(__require("https"));
	var pm = __importStar(require_proxy());
	var tunnel = __importStar(require_tunnel());
	var undici_1 = 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 || (exports.HttpCodes = HttpCodes = {}));
	var Headers;
	(function(Headers) {
		Headers["Accept"] = "accept";
		Headers["ContentType"] = "content-type";
	})(Headers || (exports.Headers = Headers = {}));
	var MediaTypes;
	(function(MediaTypes) {
		MediaTypes["ApplicationJson"] = "application/json";
	})(MediaTypes || (exports.MediaTypes = MediaTypes = {}));
	/**
	* Returns the proxy URL, depending upon the supplied url and proxy environment variables.
	* @param serverUrl  The server URL where the request will be sent. For example, https://api.github.com
	*/
	function getProxyUrl(serverUrl) {
		const proxyUrl = pm.getProxyUrl(new URL(serverUrl));
		return proxyUrl ? proxyUrl.href : "";
	}
	var HttpRedirectCodes = [
		HttpCodes.MovedPermanently,
		HttpCodes.ResourceMoved,
		HttpCodes.SeeOther,
		HttpCodes.TemporaryRedirect,
		HttpCodes.PermanentRedirect
	];
	var HttpResponseRetryCodes = [
		HttpCodes.BadGateway,
		HttpCodes.ServiceUnavailable,
		HttpCodes.GatewayTimeout
	];
	var RetryableHttpVerbs = [
		"OPTIONS",
		"GET",
		"DELETE",
		"HEAD"
	];
	var ExponentialBackoffCeiling = 10;
	var ExponentialBackoffTimeSlice = 5;
	var HttpClientError = class HttpClientError extends Error {
		constructor(message, statusCode) {
			super(message);
			this.name = "HttpClientError";
			this.statusCode = statusCode;
			Object.setPrototypeOf(this, HttpClientError.prototype);
		}
	};
	exports.HttpClientError = HttpClientError;
	var HttpClientResponse = class {
		constructor(message) {
			this.message = message;
		}
		readBody() {
			return __awaiter(this, void 0, void 0, function* () {
				return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
					let output = Buffer.alloc(0);
					this.message.on("data", (chunk) => {
						output = Buffer.concat([output, chunk]);
					});
					this.message.on("end", () => {
						resolve(output.toString());
					});
				}));
			});
		}
		readBodyBuffer() {
			return __awaiter(this, void 0, void 0, function* () {
				return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
					const chunks = [];
					this.message.on("data", (chunk) => {
						chunks.push(chunk);
					});
					this.message.on("end", () => {
						resolve(Buffer.concat(chunks));
					});
				}));
			});
		}
	};
	exports.HttpClientResponse = HttpClientResponse;
	function isHttps(requestUrl) {
		return new URL(requestUrl).protocol === "https:";
	}
	var HttpClient = class {
		constructor(userAgent, handlers, requestOptions) {
			this._ignoreSslError = false;
			this._allowRedirects = true;
			this._allowRedirectDowngrade = false;
			this._maxRedirects = 50;
			this._allowRetries = false;
			this._maxRetries = 1;
			this._keepAlive = false;
			this._disposed = false;
			this.userAgent = this._getUserAgentWithOrchestrationId(userAgent);
			this.handlers = handlers || [];
			this.requestOptions = requestOptions;
			if (requestOptions) {
				if (requestOptions.ignoreSslError != null) this._ignoreSslError = requestOptions.ignoreSslError;
				this._socketTimeout = requestOptions.socketTimeout;
				if (requestOptions.allowRedirects != null) this._allowRedirects = requestOptions.allowRedirects;
				if (requestOptions.allowRedirectDowngrade != null) this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
				if (requestOptions.maxRedirects != null) this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
				if (requestOptions.keepAlive != null) this._keepAlive = requestOptions.keepAlive;
				if (requestOptions.allowRetries != null) this._allowRetries = requestOptions.allowRetries;
				if (requestOptions.maxRetries != null) this._maxRetries = requestOptions.maxRetries;
			}
		}
		options(requestUrl, additionalHeaders) {
			return __awaiter(this, void 0, void 0, function* () {
				return this.request("OPTIONS", requestUrl, null, additionalHeaders || {});
			});
		}
		get(requestUrl, additionalHeaders) {
			return __awaiter(this, void 0, void 0, function* () {
				return this.request("GET", requestUrl, null, additionalHeaders || {});
			});
		}
		del(requestUrl, additionalHeaders) {
			return __awaiter(this, void 0, void 0, function* () {
				return this.request("DELETE", requestUrl, null, additionalHeaders || {});
			});
		}
		post(requestUrl, data, additionalHeaders) {
			return __awaiter(this, void 0, void 0, function* () {
				return this.request("POST", requestUrl, data, additionalHeaders || {});
			});
		}
		patch(requestUrl, data, additionalHeaders) {
			return __awaiter(this, void 0, void 0, function* () {
				return this.request("PATCH", requestUrl, data, additionalHeaders || {});
			});
		}
		put(requestUrl, data, additionalHeaders) {
			return __awaiter(this, void 0, void 0, function* () {
				return this.request("PUT", requestUrl, data, additionalHeaders || {});
			});
		}
		head(requestUrl, additionalHeaders) {
			return __awaiter(this, void 0, void 0, function* () {
				return this.request("HEAD", requestUrl, null, additionalHeaders || {});
			});
		}
		sendStream(verb, requestUrl, stream, additionalHeaders) {
			return __awaiter(this, void 0, void 0, function* () {
				return this.request(verb, requestUrl, stream, additionalHeaders);
			});
		}
		/**
		* Gets a typed object from an endpoint
		* Be aware that not found returns a null.  Other errors (4xx, 5xx) reject the promise
		*/
		getJson(requestUrl_1) {
			return __awaiter(this, arguments, void 0, function* (requestUrl, additionalHeaders = {}) {
				additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
				const res = yield this.get(requestUrl, additionalHeaders);
				return this._processResponse(res, this.requestOptions);
			});
		}
		postJson(requestUrl_1, obj_1) {
			return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
				const data = JSON.stringify(obj, null, 2);
				additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
				additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
				const res = yield this.post(requestUrl, data, additionalHeaders);
				return this._processResponse(res, this.requestOptions);
			});
		}
		putJson(requestUrl_1, obj_1) {
			return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
				const data = JSON.stringify(obj, null, 2);
				additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
				additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
				const res = yield this.put(requestUrl, data, additionalHeaders);
				return this._processResponse(res, this.requestOptions);
			});
		}
		patchJson(requestUrl_1, obj_1) {
			return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
				const data = JSON.stringify(obj, null, 2);
				additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
				additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
				const res = yield this.patch(requestUrl, data, additionalHeaders);
				return this._processResponse(res, this.requestOptions);
			});
		}
		/**
		* Makes a raw http request.
		* All other methods such as get, post, patch, and request ultimately call this.
		* Prefer get, del, post and patch
		*/
		request(verb, requestUrl, data, headers) {
			return __awaiter(this, void 0, void 0, function* () {
				if (this._disposed) throw new Error("Client has already been disposed.");
				const parsedUrl = new URL(requestUrl);
				let info = this._prepareRequest(verb, parsedUrl, headers);
				const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1;
				let numTries = 0;
				let response;
				do {
					response = yield this.requestRaw(info, data);
					if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) {
						let authenticationHandler;
						for (const handler of this.handlers) if (handler.canHandleAuthentication(response)) {
							authenticationHandler = handler;
							break;
						}
						if (authenticationHandler) return authenticationHandler.handleAuthentication(this, info, data);
						else return response;
					}
					let redirectsRemaining = this._maxRedirects;
					while (response.message.statusCode && HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0) {
						const redirectUrl = response.message.headers["location"];
						if (!redirectUrl) break;
						const parsedRedirectUrl = new URL(redirectUrl);
						if (parsedUrl.protocol === "https:" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.");
						yield response.readBody();
						if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
							for (const header in headers) if (header.toLowerCase() === "authorization") delete headers[header];
						}
						info = this._prepareRequest(verb, parsedRedirectUrl, headers);
						response = yield this.requestRaw(info, data);
						redirectsRemaining--;
					}
					if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode)) return response;
					numTries += 1;
					if (numTries < maxTries) {
						yield response.readBody();
						yield this._performExponentialBackoff(numTries);
					}
				} while (numTries < maxTries);
				return response;
			});
		}
		/**
		* Needs to be called if keepAlive is set to true in request options.
		*/
		dispose() {
			if (this._agent) this._agent.destroy();
			this._disposed = true;
		}
		/**
		* Raw request.
		* @param info
		* @param data
		*/
		requestRaw(info, data) {
			return __awaiter(this, void 0, void 0, function* () {
				return new Promise((resolve, reject) => {
					function callbackForResult(err, res) {
						if (err) reject(err);
						else if (!res) reject(/* @__PURE__ */ new Error("Unknown error"));
						else resolve(res);
					}
					this.requestRawWithCallback(info, data, callbackForResult);
				});
			});
		}
		/**
		* Raw request with callback.
		* @param info
		* @param data
		* @param onResult
		*/
		requestRawWithCallback(info, data, onResult) {
			if (typeof data === "string") {
				if (!info.options.headers) info.options.headers = {};
				info.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8");
			}
			let callbackCalled = false;
			function handleResult(err, res) {
				if (!callbackCalled) {
					callbackCalled = true;
					onResult(err, res);
				}
			}
			const req = info.httpModule.request(info.options, (msg) => {
				handleResult(void 0, new HttpClientResponse(msg));
			});
			let socket;
			req.on("socket", (sock) => {
				socket = sock;
			});
			req.setTimeout(this._socketTimeout || 18e4, () => {
				if (socket) socket.end();
				handleResult(/* @__PURE__ */ new Error(`Request timeout: ${info.options.path}`));
			});
			req.on("error", function(err) {
				handleResult(err);
			});
			if (data && typeof data === "string") req.write(data, "utf8");
			if (data && typeof data !== "string") {
				data.on("close", function() {
					req.end();
				});
				data.pipe(req);
			} else req.end();
		}
		/**
		* Gets an http agent. This function is useful when you need an http agent that handles
		* routing through a proxy server - depending upon the url and proxy environment variables.
		* @param serverUrl  The server URL where the request will be sent. For example, https://api.github.com
		*/
		getAgent(serverUrl) {
			const parsedUrl = new URL(serverUrl);
			return this._getAgent(parsedUrl);
		}
		getAgentDispatcher(serverUrl) {
			const parsedUrl = new URL(serverUrl);
			const proxyUrl = pm.getProxyUrl(parsedUrl);
			if (!(proxyUrl && proxyUrl.hostname)) return;
			return this._getProxyAgentDispatcher(parsedUrl, proxyUrl);
		}
		_prepareRequest(method, requestUrl, headers) {
			const info = {};
			info.parsedUrl = requestUrl;
			const usingSsl = info.parsedUrl.protocol === "https:";
			info.httpModule = usingSsl ? https$2 : http$3;
			const defaultPort = usingSsl ? 443 : 80;
			info.options = {};
			info.options.host = info.parsedUrl.hostname;
			info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort;
			info.options.path = (info.parsedUrl.pathname || "") + (info.parsedUrl.search || "");
			info.options.method = method;
			info.options.headers = this._mergeHeaders(headers);
			if (this.userAgent != null) info.options.headers["user-agent"] = this.userAgent;
			info.options.agent = this._getAgent(info.parsedUrl);
			if (this.handlers) for (const handler of this.handlers) handler.prepareRequest(info.options);
			return info;
		}
		_mergeHeaders(headers) {
			if (this.requestOptions && this.requestOptions.headers) return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {}));
			return lowercaseKeys(headers || {});
		}
		/**
		* Gets an existing header value or returns a default.
		* Handles converting number header values to strings since HTTP headers must be strings.
		* Note: This returns string | string[] since some headers can have multiple values.
		* For headers that must always be a single string (like Content-Type), use the
		* specialized _getExistingOrDefaultContentTypeHeader method instead.
		*/
		_getExistingOrDefaultHeader(additionalHeaders, header, _default) {
			let clientHeader;
			if (this.requestOptions && this.requestOptions.headers) {
				const headerValue = lowercaseKeys(this.requestOptions.headers)[header];
				if (headerValue) clientHeader = typeof headerValue === "number" ? headerValue.toString() : headerValue;
			}
			const additionalValue = additionalHeaders[header];
			if (additionalValue !== void 0) return typeof additionalValue === "number" ? additionalValue.toString() : additionalValue;
			if (clientHeader !== void 0) return clientHeader;
			return _default;
		}
		/**
		* Specialized version of _getExistingOrDefaultHeader for Content-Type header.
		* Always returns a single string (not an array) since Content-Type should be a single value.
		* Converts arrays to comma-separated strings and numbers to strings to ensure type safety.
		* This was split from _getExistingOrDefaultHeader to provide stricter typing for callers
		* that assign the result to places expecting a string (e.g., additionalHeaders[Headers.ContentType]).
		*/
		_getExistingOrDefaultContentTypeHeader(additionalHeaders, _default) {
			let clientHeader;
			if (this.requestOptions && this.requestOptions.headers) {
				const headerValue = lowercaseKeys(this.requestOptions.headers)[Headers.ContentType];
				if (headerValue) {
					if (typeof headerValue === "number") clientHeader = String(headerValue);
					else if (Array.isArray(headerValue)) clientHeader = headerValue.join(", ");
					else clientHeader = headerValue;
				}
			}
			const additionalValue = additionalHeaders[Headers.ContentType];
			if (additionalValue !== void 0) {
				if (typeof additionalValue === "number") return String(additionalValue);
				else if (Array.isArray(additionalValue)) return additionalValue.join(", ");
				else return additionalValue;
			}
			if (clientHeader !== void 0) return clientHeader;
			return _default;
		}
		_getAgent(parsedUrl) {
			let agent;
			const proxyUrl = pm.getProxyUrl(parsedUrl);
			const useProxy = proxyUrl && proxyUrl.hostname;
			if (this._keepAlive && useProxy) agent = this._proxyAgent;
			if (!useProxy) agent = this._agent;
			if (agent) return agent;
			const usingSsl = parsedUrl.protocol === "https:";
			let maxSockets = 100;
			if (this.requestOptions) maxSockets = this.requestOptions.maxSockets || http$3.globalAgent.maxSockets;
			if (proxyUrl && proxyUrl.hostname) {
				const agentOptions = {
					maxSockets,
					keepAlive: this._keepAlive,
					proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && { proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` }), {
						host: proxyUrl.hostname,
						port: proxyUrl.port
					})
				};
				let tunnelAgent;
				const overHttps = proxyUrl.protocol === "https:";
				if (usingSsl) tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
				else tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
				agent = tunnelAgent(agentOptions);
				this._proxyAgent = agent;
			}
			if (!agent) {
				const options = {
					keepAlive: this._keepAlive,
					maxSockets
				};
				agent = usingSsl ? new https$2.Agent(options) : new http$3.Agent(options);
				this._agent = agent;
			}
			if (usingSsl && this._ignoreSslError) agent.options = Object.assign(agent.options || {}, { rejectUnauthorized: false });
			return agent;
		}
		_getProxyAgentDispatcher(parsedUrl, proxyUrl) {
			let proxyAgent;
			if (this._keepAlive) proxyAgent = this._proxyAgentDispatcher;
			if (proxyAgent) return proxyAgent;
			const usingSsl = parsedUrl.protocol === "https:";
			proxyAgent = new undici_1.ProxyAgent(Object.assign({
				uri: proxyUrl.href,
				pipelining: !this._keepAlive ? 0 : 1
			}, (proxyUrl.username || proxyUrl.password) && { token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString("base64")}` }));
			this._proxyAgentDispatcher = proxyAgent;
			if (usingSsl && this._ignoreSslError) proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, { rejectUnauthorized: false });
			return proxyAgent;
		}
		_getUserAgentWithOrchestrationId(userAgent) {
			const baseUserAgent = userAgent || "actions/http-client";
			const orchId = process.env["ACTIONS_ORCHESTRATION_ID"];
			if (orchId) return `${baseUserAgent} actions_orchestration_id/${orchId.replace(/[^a-z0-9_.-]/gi, "_")}`;
			return baseUserAgent;
		}
		_performExponentialBackoff(retryNumber) {
			return __awaiter(this, void 0, void 0, function* () {
				retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
				const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
				return new Promise((resolve) => setTimeout(() => resolve(), ms));
			});
		}
		_processResponse(res, options) {
			return __awaiter(this, void 0, void 0, function* () {
				return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
					const statusCode = res.message.statusCode || 0;
					const response = {
						statusCode,
						result: null,
						headers: {}
					};
					if (statusCode === HttpCodes.NotFound) resolve(response);
					function dateTimeDeserializer(key, value) {
						if (typeof value === "string") {
							const a = new Date(value);
							if (!isNaN(a.valueOf())) return a;
						}
						return value;
					}
					let obj;
					let contents;
					try {
						contents = yield res.readBody();
						if (contents && contents.length > 0) {
							if (options && options.deserializeDates) obj = JSON.parse(contents, dateTimeDeserializer);
							else obj = JSON.parse(contents);
							response.result = obj;
						}
						response.headers = res.message.headers;
					} catch (err) {}
					if (statusCode > 299) {
						let msg;
						if (obj && obj.message) msg = obj.message;
						else if (contents && contents.length > 0) msg = contents;
						else msg = `Failed request: (${statusCode})`;
						const err = new HttpClientError(msg, statusCode);
						err.result = response.result;
						reject(err);
					} else resolve(response);
				}));
			});
		}
	};
	exports.HttpClient = HttpClient;
	var lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {});
})))(), 1);
var __awaiter$14 = 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());
	});
};
function getProxyAgent(destinationUrl) {
	return new import_lib.HttpClient().getAgent(destinationUrl);
}
function getProxyAgentDispatcher(destinationUrl) {
	return new import_lib.HttpClient().getAgentDispatcher(destinationUrl);
}
function getProxyFetch(destinationUrl) {
	const httpDispatcher = getProxyAgentDispatcher(destinationUrl);
	const proxyFetch = (url, opts) => __awaiter$14(this, void 0, void 0, function* () {
		return (0, import_undici.fetch)(url, Object.assign(Object.assign({}, opts), { dispatcher: httpDispatcher }));
	});
	return proxyFetch;
}
function getApiBaseUrl() {
	return process.env["GITHUB_API_URL"] || "https://api.github.com";
}
//#endregion
//#region node_modules/.pnpm/universal-user-agent@7.0.3/node_modules/universal-user-agent/index.js
function getUserAgent() {
	if (typeof navigator === "object" && "userAgent" in navigator) return navigator.userAgent;
	if (typeof process === "object" && process.version !== void 0) return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
	return "<environment undetectable>";
}
//#endregion
//#region node_modules/.pnpm/before-after-hook@4.0.0/node_modules/before-after-hook/lib/register.js
function register(state, name, method, options) {
	if (typeof method !== "function") throw new Error("method for before hook must be a function");
	if (!options) options = {};
	if (Array.isArray(name)) return name.reverse().reduce((callback, name) => {
		return register.bind(null, state, name, callback, options);
	}, method)();
	return Promise.resolve().then(() => {
		if (!state.registry[name]) return method(options);
		return state.registry[name].reduce((method, registered) => {
			return registered.hook.bind(null, method, options);
		}, method)();
	});
}
//#endregion
//#region node_modules/.pnpm/before-after-hook@4.0.0/node_modules/before-after-hook/lib/add.js
function addHook(state, kind, name, hook) {
	const orig = hook;
	if (!state.registry[name]) state.registry[name] = [];
	if (kind === "before") hook = (method, options) => {
		return Promise.resolve().then(orig.bind(null, options)).then(method.bind(null, options));
	};
	if (kind === "after") hook = (method, options) => {
		let result;
		return Promise.resolve().then(method.bind(null, options)).then((result_) => {
			result = result_;
			return orig(result, options);
		}).then(() => {
			return result;
		});
	};
	if (kind === "error") hook = (method, options) => {
		return Promise.resolve().then(method.bind(null, options)).catch((error) => {
			return orig(error, options);
		});
	};
	state.registry[name].push({
		hook,
		orig
	});
}
//#endregion
//#region node_modules/.pnpm/before-after-hook@4.0.0/node_modules/before-after-hook/lib/remove.js
function removeHook(state, name, method) {
	if (!state.registry[name]) return;
	const index = state.registry[name].map((registered) => {
		return registered.orig;
	}).indexOf(method);
	if (index === -1) return;
	state.registry[name].splice(index, 1);
}
//#endregion
//#region node_modules/.pnpm/before-after-hook@4.0.0/node_modules/before-after-hook/index.js
var bind = Function.bind;
var bindable = bind.bind(bind);
function bindApi(hook, state, name) {
	const removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state]);
	hook.api = { remove: removeHookRef };
	hook.remove = removeHookRef;
	[
		"before",
		"error",
		"after",
		"wrap"
	].forEach((kind) => {
		const args = name ? [
			state,
			kind,
			name
		] : [state, kind];
		hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args);
	});
}
function Singular() {
	const singularHookName = Symbol("Singular");
	const singularHookState = { registry: {} };
	const singularHook = register.bind(null, singularHookState, singularHookName);
	bindApi(singularHook, singularHookState, singularHookName);
	return singularHook;
}
function Collection() {
	const state = { registry: {} };
	const hook = register.bind(null, state);
	bindApi(hook, state);
	return hook;
}
var before_after_hook_default = {
	Singular,
	Collection
};
//#endregion
//#region node_modules/.pnpm/@octokit+endpoint@11.0.4/node_modules/@octokit/endpoint/dist-bundle/index.js
var DEFAULTS = {
	method: "GET",
	baseUrl: "https://api.github.com",
	headers: {
		accept: "application/vnd.github.v3+json",
		"user-agent": `octokit-endpoint.js/0.0.0-development ${getUserAgent()}`
	},
	mediaType: { format: "" }
};
function lowercaseKeys(object) {
	if (!object) return {};
	return Object.keys(object).reduce((newObj, key) => {
		newObj[key.toLowerCase()] = object[key];
		return newObj;
	}, {});
}
function isPlainObject$1(value) {
	if (typeof value !== "object" || value === null) return false;
	if (Object.prototype.toString.call(value) !== "[object Object]") return false;
	const proto = Object.getPrototypeOf(value);
	if (proto === null) return true;
	const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
	return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
}
__name(isPlainObject$1, "isPlainObject");
function mergeDeep(defaults, options) {
	const result = Object.assign({}, defaults);
	Object.keys(options).forEach((key) => {
		if (isPlainObject$1(options[key])) {
			if (!(key in defaults)) Object.assign(result, { [key]: options[key] });
			else result[key] = mergeDeep(defaults[key], options[key]);
		} else Object.assign(result, { [key]: options[key] });
	});
	return result;
}
function removeUndefinedProperties(obj) {
	for (const key in obj) if (obj[key] === void 0) delete obj[key];
	return obj;
}
function merge(defaults, route, options) {
	if (typeof route === "string") {
		let [method, url] = route.split(" ");
		options = Object.assign(url ? {
			method,
			url
		} : { url: method }, options);
	} else options = Object.assign({}, route);
	options.headers = lowercaseKeys(options.headers);
	removeUndefinedProperties(options);
	removeUndefinedProperties(options.headers);
	const mergedOptions = mergeDeep(defaults || {}, options);
	if (options.url === "/graphql") {
		if (defaults && defaults.mediaType.previews?.length) mergedOptions.mediaType.previews = defaults.mediaType.previews.filter((preview) => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews);
		mergedOptions.mediaType.previews = (mergedOptions.mediaType.previews || []).map((preview) => preview.replace(/-preview/, ""));
	}
	return mergedOptions;
}
function addQueryParameters(url, parameters) {
	const separator = /\?/.test(url) ? "&" : "?";
	const names = Object.keys(parameters);
	if (names.length === 0) return url;
	return url + separator + names.map((name) => {
		if (name === "q") return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
		return `${name}=${encodeURIComponent(parameters[name])}`;
	}).join("&");
}
var urlVariableRegex = /\{[^{}}]+\}/g;
function removeNonChars(variableName) {
	return variableName.replace(/(?:^\W+)|(?:(?<!\W)\W+$)/g, "").split(/,/);
}
function extractUrlVariableNames(url) {
	const matches = url.match(urlVariableRegex);
	if (!matches) return [];
	return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
}
function omit(object, keysToOmit) {
	const result = { __proto__: null };
	for (const key of Object.keys(object)) if (keysToOmit.indexOf(key) === -1) result[key] = object[key];
	return result;
}
function encodeReserved(str) {
	return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
		if (!/%[0-9A-Fa-f]/.test(part)) part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
		return part;
	}).join("");
}
function encodeUnreserved(str) {
	return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
		return "%" + c.charCodeAt(0).toString(16).toUpperCase();
	});
}
function encodeValue(operator, value, key) {
	value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
	if (key) return encodeUnreserved(key) + "=" + value;
	else return value;
}
function isDefined(value) {
	return value !== void 0 && value !== null;
}
function isKeyOperator(operator) {
	return operator === ";" || operator === "&" || operator === "?";
}
function getValues(context, operator, key, modifier) {
	var value = context[key];
	var result = [];
	if (isDefined(value) && value !== "") {
		if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
			value = value.toString();
			if (modifier && modifier !== "*") value = value.substring(0, parseInt(modifier, 10));
			result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
		} else if (modifier === "*") {
			if (Array.isArray(value)) value.filter(isDefined).forEach(function(value2) {
				result.push(encodeValue(operator, value2, isKeyOperator(operator) ? key : ""));
			});
			else Object.keys(value).forEach(function(k) {
				if (isDefined(value[k])) result.push(encodeValue(operator, value[k], k));
			});
		} else {
			const tmp = [];
			if (Array.isArray(value)) value.filter(isDefined).forEach(function(value2) {
				tmp.push(encodeValue(operator, value2));
			});
			else Object.keys(value).forEach(function(k) {
				if (isDefined(value[k])) {
					tmp.push(encodeUnreserved(k));
					tmp.push(encodeValue(operator, value[k].toString()));
				}
			});
			if (isKeyOperator(operator)) result.push(encodeUnreserved(key) + "=" + tmp.join(","));
			else if (tmp.length !== 0) result.push(tmp.join(","));
		}
	} else if (operator === ";") {
		if (isDefined(value)) result.push(encodeUnreserved(key));
	} else if (value === "" && (operator === "&" || operator === "?")) result.push(encodeUnreserved(key) + "=");
	else if (value === "") result.push("");
	return result;
}
function parseUrl(template) {
	return { expand: expand.bind(null, template) };
}
function expand(template, context) {
	var operators = [
		"+",
		"#",
		".",
		"/",
		";",
		"?",
		"&"
	];
	template = template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function(_, expression, literal) {
		if (expression) {
			let operator = "";
			const values = [];
			if (operators.indexOf(expression.charAt(0)) !== -1) {
				operator = expression.charAt(0);
				expression = expression.substr(1);
			}
			expression.split(/,/g).forEach(function(variable) {
				var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
				values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
			});
			if (operator && operator !== "+") {
				var separator = ",";
				if (operator === "?") separator = "&";
				else if (operator !== "#") separator = operator;
				return (values.length !== 0 ? operator : "") + values.join(separator);
			} else return values.join(",");
		} else return encodeReserved(literal);
	});
	if (template === "/") return template;
	else return template.replace(/\/$/, "");
}
function parse$2(options) {
	let method = options.method.toUpperCase();
	let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
	let headers = Object.assign({}, options.headers);
	let body;
	let parameters = omit(options, [
		"method",
		"baseUrl",
		"url",
		"headers",
		"request",
		"mediaType"
	]);
	const urlVariableNames = extractUrlVariableNames(url);
	url = parseUrl(url).expand(parameters);
	if (!/^http/.test(url)) url = options.baseUrl + url;
	const remainingParameters = omit(parameters, Object.keys(options).filter((option) => urlVariableNames.includes(option)).concat("baseUrl"));
	if (!/application\/octet-stream/i.test(headers.accept)) {
		if (options.mediaType.format) headers.accept = headers.accept.split(/,/).map((format) => format.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(",");
		if (url.endsWith("/graphql")) {
			if (options.mediaType.previews?.length) headers.accept = (headers.accept.match(/(?<![\w-])[\w-]+(?=-preview)/g) || []).concat(options.mediaType.previews).map((preview) => {
				return `application/vnd.github.${preview}-preview${options.mediaType.format ? `.${options.mediaType.format}` : "+json"}`;
			}).join(",");
		}
	}
	if (["GET", "HEAD"].includes(method)) url = addQueryParameters(url, remainingParameters);
	else if ("data" in remainingParameters) body = remainingParameters.data;
	else if (Object.keys(remainingParameters).length) body = remainingParameters;
	if (!headers["content-type"] && typeof body !== "undefined") headers["content-type"] = "application/json; charset=utf-8";
	if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") body = "";
	return Object.assign({
		method,
		url,
		headers
	}, typeof body !== "undefined" ? { body } : null, options.request ? { request: options.request } : null);
}
__name(parse$2, "parse");
function endpointWithDefaults(defaults, route, options) {
	return parse$2(merge(defaults, route, options));
}
function withDefaults$2(oldDefaults, newDefaults) {
	const DEFAULTS2 = merge(oldDefaults, newDefaults);
	const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2);
	return Object.assign(endpoint2, {
		DEFAULTS: DEFAULTS2,
		defaults: withDefaults$2.bind(null, DEFAULTS2),
		merge: merge.bind(null, DEFAULTS2),
		parse: parse$2
	});
}
__name(withDefaults$2, "withDefaults");
var endpoint = withDefaults$2(null, DEFAULTS);
/*!
* content-type
* Copyright(c) 2015 Douglas Christopher Wilson
* MIT Licensed
*/
//#endregion
//#region node_modules/.pnpm/json-with-bigint@3.5.10/node_modules/json-with-bigint/json-with-bigint.js
var import_dist$2 = (/* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.parse = parse;
	/**
	* Null object perf optimization. Faster than `Object.create(null)` and `{ __proto__: null }`.
	*/
	var NullObject = /* @__PURE__ */ (() => {
		const C = function() {};
		C.prototype = Object.create(null);
		return C;
	})();
	/**
	* Parse a `Content-Type` header.
	*/
	function parse(header, options) {
		const len = header.length;
		let index = skipOWS(header, 0, len);
		const valueStart = index;
		index = skipValue(header, index, len);
		const valueEnd = trailingOWS(header, valueStart, index);
		return {
			type: header.slice(valueStart, valueEnd).toLowerCase(),
			parameters: options?.parameters === false ? new NullObject() : parseParameters(header, index, len)
		};
	}
	var SP = 32;
	var HTAB = 9;
	var SEMI = 59;
	var EQ = 61;
	var DQUOTE = 34;
	var BSLASH = 92;
	/**
	* Parses the parameters of a `Content-Type` header starting at the given index.
	*/
	function parseParameters(header, index, len) {
		const parameters = new NullObject();
		parameter: while (index < len) {
			index = skipOWS(header, index + 1, len);
			const keyStart = index;
			while (index < len) {
				const code = header.charCodeAt(index);
				if (code === SEMI) continue parameter;
				if (code === EQ) {
					const keyEnd = trailingOWS(header, keyStart, index);
					const key = header.slice(keyStart, keyEnd).toLowerCase();
					index = skipOWS(header, index + 1, len);
					if (index < len && header.charCodeAt(index) === DQUOTE) {
						index++;
						let value = "";
						while (index < len) {
							const code = header.charCodeAt(index++);
							if (code === DQUOTE) {
								index = skipValue(header, index, len);
								if (parameters[key] === void 0) parameters[key] = value;
								break;
							}
							if (code === BSLASH && index < len) {
								value += header[index++];
								continue;
							}
							value += String.fromCharCode(code);
						}
						continue parameter;
					}
					const valueStart = index;
					index = skipValue(header, index, len);
					if (parameters[key] === void 0) {
						const valueEnd = trailingOWS(header, valueStart, index);
						parameters[key] = header.slice(valueStart, valueEnd);
					}
					continue parameter;
				}
				index++;
			}
		}
		return parameters;
	}
	/**
	* Skip over characters until a semicolon.
	*/
	function skipValue(str, index, len) {
		while (index < len) {
			if (str.charCodeAt(index) === SEMI) break;
			index++;
		}
		return index;
	}
	/**
	* Skip optional whitespace (OWS) in an HTTP header value.
	*
	* OWS is defined in RFC 9110 sec 5.6.3 as SP (" ") or HTAB ("\t").
	*/
	function skipOWS(header, index, len) {
		while (index < len) {
			const char = header.charCodeAt(index);
			if (char !== SP && char !== HTAB) break;
			index++;
		}
		return index;
	}
	/**
	* Trim optional whitespace (OWS) from the end of a substring.
	*
	* OWS is defined in RFC 9110 sec 5.6.3 as SP (" ") or HTAB ("\t").
	*/
	function trailingOWS(header, start, end) {
		while (end > start) {
			const char = header.charCodeAt(end - 1);
			if (char !== SP && char !== HTAB) break;
			end--;
		}
		return end;
	}
})))();
var intRegex = /^-?\d+$/;
var noiseValue = /^-?\d+n+$/;
var originalStringify = JSON.stringify;
var originalParse = JSON.parse;
var customFormat = /^-?\d+n$/;
var bigIntsStringify = /([\[:])?"(-?\d+)n"($|\s*[,\}\]])/g;
var noiseStringify = /([\[:])?("-?\d+n+)n("$|"\s*[,\}\]])/g;
/**
* @typedef {(this: any, key: string | number | undefined, value: any) => any} Replacer
* @typedef {(key: string | number | undefined, value: any, context?: { source: string }) => any} Reviver
*/
/**
* Checks if a value is unstringifiable according to native JSON.stringify rules.
*
* @param {any} val The value to check.
* @returns {boolean} True if the value is undefined, a function, or a symbol.
*/
var isUnstringifiable = (val) => val === void 0 || typeof val === "function" || typeof val === "symbol";
/**
* Checks if a value is a native JSON.rawJSON object (Node.js 22+).
*
* @param {any} val The value to check.
* @returns {boolean} True if the value is a RawJSON instance.
*/
var isRawJSON = (val) => val !== null && typeof val === "object" && val.constructor && val.constructor.name === "RawJSON";
/**
* Iteratively converts a JS value to a JSON string.
* Used as a fallback when the native JSON.stringify hits the Maximum Call Stack size.
* Fully compliant with JSON formatting (space), replacers, and toJSON behaviors.
*
* @param {any} rootValue The value to stringify.
* @param {Replacer | Array<string | number> | null} [replacer] User's custom replacer function.
* @param {string | number} [spaceParam] Indentation for pretty-printing.
* @returns {string | undefined} The generated JSON string.
*/
var stringifyIteratively = (rootValue, replacer, spaceParam) => {
	let space = "";
	if (typeof spaceParam === "number") space = " ".repeat(Math.min(10, Math.max(0, Math.floor(spaceParam))));
	else if (typeof spaceParam === "string") space = spaceParam.slice(0, 10);
	const isFunctionReplacer = typeof replacer === "function";
	const propertyList = Array.isArray(replacer) ? new Set(replacer.map(String)) : null;
	/**
	* Prepares a value for stringification by resolving toJSON, handling BigInts,
	* applying custom replacers, and unwrapping primitive objects.
	*
	* @param {object|Array} parent The parent object or array holding the value.
	* @param {string} key The key associated with the value.
	* @param {any} val The raw value to process.
	* @returns {any} The processed value ready for stringification.
	*/
	const prepareVal = (parent, key, val) => {
		if (val !== null && typeof val === "object" && typeof val.toJSON === "function") val = val.toJSON(key);
		if (typeof val === "string" && noiseValue.test(val)) return val + "n";
		if (typeof val === "bigint") {
			if ("rawJSON" in JSON) return JSON.rawJSON(val.toString());
			return val.toString() + "n";
		}
		if (isFunctionReplacer) val = replacer.call(parent, key, val);
		if (val !== null && typeof val === "object") {
			if (val instanceof Number || val instanceof String || val instanceof Boolean) val = val.valueOf();
		}
		return val;
	};
	const rootProcessed = prepareVal({ "": rootValue }, "", rootValue);
	if (isUnstringifiable(rootProcessed)) return;
	const isRootPrimitive = rootProcessed === null || typeof rootProcessed !== "object";
	const isRootNativeRawJSON = isRawJSON(rootProcessed);
	if (isRootPrimitive || isRootNativeRawJSON) return originalStringify(rootProcessed);
	const chunks = [];
	let level = 0;
	const stack = [{
		parent: { "": rootProcessed },
		key: "",
		val: rootProcessed,
		isArray: Array.isArray(rootProcessed),
		keys: Array.isArray(rootProcessed) ? null : Object.keys(rootProcessed),
		index: 0,
		first: true
	}];
	const visited = new WeakSet([rootProcessed]);
	while (stack.length > 0) {
		const node = stack[stack.length - 1];
		if (node.index === 0) {
			chunks.push(node.isArray ? "[" : "{");
			level++;
		}
		let isDone = false;
		if (node.isArray) {
			if (node.index < node.val.length) {
				if (!node.first) chunks.push(",");
				if (space) chunks.push("\n" + space.repeat(level));
				const childRaw = node.val[node.index];
				const childVal = prepareVal(node.val, String(node.index), childRaw);
				if (isUnstringifiable(childVal)) {
					chunks.push("null");
					node.first = false;
					node.index++;
				} else {
					const isComplexObject = childVal !== null && typeof childVal === "object";
					const isNativeRaw = isRawJSON(childVal);
					if (isComplexObject && !isNativeRaw) {
						if (visited.has(childVal)) throw new TypeError("Converting circular structure to JSON");
						visited.add(childVal);
						stack.push({
							parent: node.val,
							key: String(node.index),
							val: childVal,
							isArray: Array.isArray(childVal),
							keys: Array.isArray(childVal) ? null : Object.keys(childVal),
							index: 0,
							first: true
						});
						node.first = false;
						node.index++;
					} else {
						chunks.push(originalStringify(childVal));
						node.first = false;
						node.index++;
					}
				}
			} else isDone = true;
		} else {
			while (node.index < node.keys.length) {
				const k = node.keys[node.index++];
				if (propertyList && !propertyList.has(k)) continue;
				const childRaw = node.val[k];
				const childVal = prepareVal(node.val, k, childRaw);
				if (isUnstringifiable(childVal)) continue;
				if (!node.first) chunks.push(",");
				if (space) chunks.push("\n" + space.repeat(level) + originalStringify(k) + ": ");
				else chunks.push(originalStringify(k) + ":");
				const isComplexObject = childVal !== null && typeof childVal === "object";
				const isNativeRaw = isRawJSON(childVal);
				if (isComplexObject && !isNativeRaw) {
					if (visited.has(childVal)) throw new TypeError("Converting circular structure to JSON");
					visited.add(childVal);
					stack.push({
						parent: node.val,
						key: k,
						val: childVal,
						isArray: Array.isArray(childVal),
						keys: Array.isArray(childVal) ? null : Object.keys(childVal),
						index: 0,
						first: true
					});
					node.first = false;
					break;
				} else {
					chunks.push(originalStringify(childVal));
					node.first = false;
				}
			}
			if (node.index >= node.keys.length && stack[stack.length - 1] === node) isDone = true;
		}
		if (isDone) {
			level--;
			if (!node.first && space) chunks.push("\n" + space.repeat(level));
			chunks.push(node.isArray ? "]" : "}");
			visited.delete(node.val);
			stack.pop();
		}
	}
	return chunks.join("");
};
/**
* Converts a JavaScript value to a JSON string.
*
* Supports serialization of BigInt values using two strategies:
* 1. Custom format "123n" → "123" (universal fallback)
* 2. Native JSON.rawJSON() (Node.js 22+, fastest) when available
*
* All other values are serialized exactly like native JSON.stringify().
*
* @param {*} value The value to convert to a JSON string.
* @param {Replacer | Array<string | number> | null} [replacer]
* A function that alters the behavior of the stringification process,
* or an array of strings/numbers to indicate properties to exclude.
* @param {string | number} [space]
* A string or number to specify indentation or pretty-printing.
* @returns {string} The JSON string representation.
*/
var JSONStringify = (value, replacer, space) => {
	try {
		if ("rawJSON" in JSON) return originalStringify(value, (key, val) => {
			if (typeof val === "bigint") return JSON.rawJSON(val.toString());
			if (typeof replacer === "function") return replacer(key, val);
			if (Array.isArray(replacer) && replacer.includes(key)) return val;
			return val;
		}, space);
		if (!value) return originalStringify(value, replacer, space);
		return originalStringify(value, (key, val) => {
			if (typeof val === "string" && noiseValue.test(val)) return val.toString() + "n";
			if (typeof val === "bigint") return val.toString() + "n";
			if (typeof replacer === "function") return replacer(key, val);
			if (Array.isArray(replacer) && replacer.includes(key)) return val;
			return val;
		}, space).replace(bigIntsStringify, "$1$2$3").replace(noiseStringify, "$1$2$3");
	} catch (error) {
		if (error instanceof RangeError) {
			const convertedJSON = stringifyIteratively(value, replacer, space);
			if (convertedJSON === void 0) return void 0;
			if ("rawJSON" in JSON) return convertedJSON;
			return convertedJSON.replace(bigIntsStringify, "$1$2$3").replace(noiseStringify, "$1$2$3");
		}
		throw error;
	}
};
var featureCache = /* @__PURE__ */ new Map();
/**
* Detects if the current JSON.parse implementation supports the context.source feature.
*
* Uses toString() fingerprinting to cache results and automatically detect runtime
* replacements of JSON.parse (polyfills, mocks, etc.).
*
* @returns {boolean} true if context.source is supported, false otherwise.
*/
var isContextSourceSupported = () => {
	const parseFingerprint = JSON.parse.toString();
	if (featureCache.has(parseFingerprint)) return featureCache.get(parseFingerprint);
	try {
		const result = JSON.parse("1", (_, __, context) => !!context?.source && context.source === "1");
		featureCache.set(parseFingerprint, result);
		return result;
	} catch {
		featureCache.set(parseFingerprint, false);
		return false;
	}
};
/**
* Reviver function that converts custom-format BigInt strings back to BigInt values.
* Also handles "noise" strings that accidentally match the BigInt format.
*
* @param {string | number | undefined} key The object key.
* @param {*} value The value being parsed.
* @param {object} [context] Parse context (if supported by JSON.parse).
* @param {Reviver} [userReviver] User's custom reviver function.
* @returns {any} The transformed value.
*/
var convertMarkedBigIntsReviver = (key, value, context, userReviver) => {
	if (typeof value === "string" && customFormat.test(value)) return BigInt(value.slice(0, -1));
	if (typeof value === "string" && noiseValue.test(value)) return value.slice(0, -1);
	if (!(typeof userReviver === "function")) return value;
	return userReviver(key, value, context);
};
/**
* Fast JSON.parse implementation (~2x faster than classic fallback).
* Uses JSON.parse's context.source feature to detect integers and convert
* large numbers directly to BigInt without string manipulation.
*
* Does not support legacy custom format from v1 of this library.
*
* @param {string} text JSON string to parse.
* @param {Reviver} [reviver] Transform function to apply to each value.
* @returns {any} Parsed JavaScript value.
*/
var JSONParseV2 = (text, reviver) => {
	return JSON.parse(text, (key, value, context) => {
		const isNumber = typeof value === "number";
		const isOutOfBounds = value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER;
		const isBigNumber = isNumber && isOutOfBounds;
		const isInt = context && intRegex.test(context.source);
		if (isBigNumber && isInt) return BigInt(context.source);
		if (!(typeof reviver === "function")) return value;
		return reviver(key, value, context);
	});
};
var MAX_INT = Number.MAX_SAFE_INTEGER.toString();
var MAX_DIGITS = MAX_INT.length;
var stringsOrLargeNumbers = /"(?:\\.|[^"])*"|-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/g;
var noiseValueWithQuotes = /^"-?\d+n+"$/;
/**
* Iteratively traverses the parsed object bottom-up (post-order),
* emulating the native JSON.parse reviver behavior.
* This avoids Call Stack overflows (RangeError) on deeply nested structures.
*
* @param {any} parsed The natively parsed JSON object.
* @param {Reviver} [userReviver] User's custom reviver function.
* @returns {any} The fully processed object.
*/
var applyReviverIteratively = (parsed, userReviver) => {
	const rootHolder = { "": parsed };
	const stack = [{
		parent: rootHolder,
		key: "",
		visited: false
	}];
	while (stack.length > 0) {
		const node = stack[stack.length - 1];
		if (!node.visited) {
			node.visited = true;
			const value = node.parent[node.key];
			if (value !== null && typeof value === "object") {
				const keys = Object.keys(value);
				for (let i = keys.length - 1; i >= 0; i--) stack.push({
					parent: value,
					key: keys[i],
					visited: false
				});
			}
		} else {
			const { parent, key } = node;
			let value = parent[key];
			if (typeof value === "string") {
				if (customFormat.test(value)) value = BigInt(value.slice(0, -1));
				else if (noiseValue.test(value)) value = value.slice(0, -1);
			}
			if (typeof userReviver === "function") value = userReviver.call(parent, key, value);
			if (value === void 0) delete parent[key];
			else parent[key] = value;
			stack.pop();
		}
	}
	return rootHolder[""];
};
/**
* Pre-processes the JSON string to mark large numbers with an 'n' suffix.
*
* @param {string} text The raw JSON string.
* @returns {string} The serialized string with marked BigInts.
*/
var serializeBigInts = (text) => {
	return text.replace(stringsOrLargeNumbers, (match, digits, fractional, exponential) => {
		const isString = match[0] === "\"";
		if (isString && noiseValueWithQuotes.test(match)) return match.substring(0, match.length - 1) + "n\"";
		const hasFractionalOrExponential = fractional || exponential;
		const isLessThanMaxSafeInt = digits && (digits.length < MAX_DIGITS || digits.length === MAX_DIGITS && digits <= MAX_INT);
		if (isString || hasFractionalOrExponential || isLessThanMaxSafeInt) return match;
		return "\"" + match + "n\"";
	});
};
/**
* Converts a JSON string into a JavaScript value.
*
* Supports parsing of large integers using two strategies:
* 1. Classic fallback: Marks large numbers with "123n" format, then converts to BigInt
* 2. Fast path (JSONParseV2): Uses context.source feature (~2x faster) when available
*
* All other JSON values are parsed exactly like native JSON.parse().
*
* @param {string} text A valid JSON string.
* @param {Reviver} [reviver]
* A function that transforms the results. This function is called for each member
* of the object. If a member contains nested objects, the nested objects are
* transformed before the parent object is.
* @returns {any} The parsed JavaScript value.
* @throws {SyntaxError} If text is not valid JSON.
*/
var JSONParse = (text, reviver) => {
	if (!text) return originalParse(text, reviver);
	try {
		if (isContextSourceSupported()) return JSONParseV2(text, reviver);
		return originalParse(serializeBigInts(text), (key, value, context) => convertMarkedBigIntsReviver(key, value, context, reviver));
	} catch (error) {
		if (error instanceof RangeError) return applyReviverIteratively(originalParse(serializeBigInts(text)), reviver);
		throw error;
	}
};
//#endregion
//#region node_modules/.pnpm/@octokit+request-error@7.1.1/node_modules/@octokit/request-error/dist-src/index.js
var RequestError = class extends Error {
	name;
	/**
	* http status code
	*/
	status;
	/**
	* Request options that lead to the error.
	*/
	request;
	/**
	* Response object if a response was received
	*/
	response;
	constructor(message, statusCode, options) {
		super(message, { cause: options.cause });
		this.name = "HttpError";
		this.status = Number.parseInt(statusCode);
		if (Number.isNaN(this.status)) this.status = 0;
		/* v8 ignore else -- @preserve -- Bug with vitest coverage where it sees an else branch that doesn't exist */
		if ("response" in options) this.response = options.response;
		const requestCopy = Object.assign({}, options.request);
		if (options.request.headers.authorization) requestCopy.headers = Object.assign({}, options.request.headers, { authorization: options.request.headers.authorization.replace(/(?<! ) .*$/, " [REDACTED]") });
		requestCopy.url = requestCopy.url.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]").replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
		this.request = requestCopy;
	}
};
//#endregion
//#region node_modules/.pnpm/@octokit+request@10.0.13/node_modules/@octokit/request/dist-bundle/index.js
var defaults_default = { headers: { "user-agent": `octokit-request.js/10.0.13 ${getUserAgent()}` } };
function isPlainObject(value) {
	if (typeof value !== "object" || value === null) return false;
	if (Object.prototype.toString.call(value) !== "[object Object]") return false;
	const proto = Object.getPrototypeOf(value);
	if (proto === null) return true;
	const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
	return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
}
var noop$1 = /* @__PURE__ */ __name(() => "", "noop");
async function fetchWrapper(requestOptions) {
	const fetch = requestOptions.request?.fetch || globalThis.fetch;
	if (!fetch) throw new Error("fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing");
	const log = requestOptions.request?.log || console;
	const parseSuccessResponseBody = requestOptions.request?.parseSuccessResponseBody !== false;
	const body = isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body) ? JSONStringify(requestOptions.body) : requestOptions.body;
	const requestHeaders = Object.fromEntries(Object.entries(requestOptions.headers).map(([name, value]) => [name, String(value)]));
	let fetchResponse;
	try {
		fetchResponse = await fetch(requestOptions.url, {
			method: requestOptions.method,
			body,
			redirect: requestOptions.request?.redirect,
			headers: requestHeaders,
			signal: requestOptions.request?.signal,
			...requestOptions.body && { duplex: "half" }
		});
	} catch (error) {
		let message = "Unknown Error";
		if (error instanceof Error) {
			if (error.name === "AbortError") {
				error.status = 500;
				throw error;
			}
			message = error.message;
			if (error.name === "TypeError" && "cause" in error) {
				if (error.cause instanceof Error) message = error.cause.message;
				else if (typeof error.cause === "string") message = error.cause;
			}
		}
		const requestError = new RequestError(message, 500, { request: requestOptions });
		requestError.cause = error;
		throw requestError;
	}
	const status = fetchResponse.status;
	const url = fetchResponse.url;
	const responseHeaders = {};
	for (const [key, value] of fetchResponse.headers) responseHeaders[key] = value;
	const octokitResponse = {
		url,
		status,
		headers: responseHeaders,
		data: ""
	};
	if ("deprecation" in responseHeaders) {
		const matches = responseHeaders.link && responseHeaders.link.match(/<([^<>]+)>; rel="deprecation"/);
		const deprecationLink = matches && matches.pop();
		log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${responseHeaders.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`);
	}
	if (status === 204 || status === 205) return octokitResponse;
	if (requestOptions.method === "HEAD") {
		if (status < 400) return octokitResponse;
		throw new RequestError(fetchResponse.statusText, status, {
			response: octokitResponse,
			request: requestOptions
		});
	}
	if (status === 304) {
		octokitResponse.data = await getResponseData(fetchResponse);
		throw new RequestError("Not modified", status, {
			response: octokitResponse,
			request: requestOptions
		});
	}
	if (status >= 400) {
		octokitResponse.data = await getResponseData(fetchResponse);
		throw new RequestError(toErrorMessage(octokitResponse.data), status, {
			response: octokitResponse,
			request: requestOptions
		});
	}
	octokitResponse.data = parseSuccessResponseBody ? await getResponseData(fetchResponse) : fetchResponse.body;
	return octokitResponse;
}
async function getResponseData(response) {
	const contentType = response.headers.get("content-type");
	if (!contentType) return response.text().catch(noop$1);
	const mimetype = (0, import_dist$2.parse)(contentType);
	if (isJSONResponse(mimetype)) {
		let text = "";
		try {
			text = await response.text();
			return JSONParse(text);
		} catch (err) {
			return text;
		}
	} else if (mimetype.type.startsWith("text/") || mimetype.parameters.charset?.toLowerCase() === "utf-8" && mimetype.type !== "application/octet-stream") return response.text().catch(noop$1);
	else return response.arrayBuffer().catch(
		/* v8 ignore next -- @preserve */
		() => /* @__PURE__ */ new ArrayBuffer(0)
	);
}
function isJSONResponse(mimetype) {
	return mimetype.type === "application/json" || mimetype.type === "application/scim+json";
}
function toErrorMessage(data) {
	if (typeof data === "string") return data;
	if (data instanceof ArrayBuffer) return "Unknown error";
	if (typeof data === "object" && data !== null && "message" in data) {
		const objectData = data;
		const suffix = "documentation_url" in objectData ? ` - ${objectData.documentation_url}` : "";
		return Array.isArray(objectData.errors) ? `${objectData.message}: ${objectData.errors.map((v) => JSON.stringify(v)).join(", ")}${suffix}` : `${objectData.message}${suffix}`;
	}
	return `Unknown error: ${JSON.stringify(data)}`;
}
function withDefaults$1(oldEndpoint, newDefaults) {
	const endpoint2 = oldEndpoint.defaults(newDefaults);
	const newApi = function(route, parameters) {
		const endpointOptions = endpoint2.merge(route, parameters);
		if (!endpointOptions.request || !endpointOptions.request.hook) return fetchWrapper(endpoint2.parse(endpointOptions));
		const request2 = (route2, parameters2) => {
			return fetchWrapper(endpoint2.parse(endpoint2.merge(route2, parameters2)));
		};
		Object.assign(request2, {
			endpoint: endpoint2,
			defaults: withDefaults$1.bind(null, endpoint2)
		});
		return endpointOptions.request.hook(request2, endpointOptions);
	};
	return Object.assign(newApi, {
		endpoint: endpoint2,
		defaults: withDefaults$1.bind(null, endpoint2)
	});
}
__name(withDefaults$1, "withDefaults");
var request = withDefaults$1(endpoint, defaults_default);
/* v8 ignore next -- @preserve */
/* v8 ignore else -- @preserve */
//#endregion
//#region node_modules/.pnpm/@octokit+graphql@9.0.4/node_modules/@octokit/graphql/dist-bundle/index.js
var VERSION$3 = "0.0.0-development";
function _buildMessageForResponseErrors(data) {
	return `Request failed due to following response errors:
` + data.errors.map((e) => ` - ${e.message}`).join("\n");
}
var GraphqlResponseError = class extends Error {
	constructor(request2, headers, response) {
		super(_buildMessageForResponseErrors(response));
		this.request = request2;
		this.headers = headers;
		this.response = response;
		this.errors = response.errors;
		this.data = response.data;
		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
	}
	request;
	headers;
	response;
	name = "GraphqlResponseError";
	errors;
	data;
};
var NON_VARIABLE_OPTIONS = [
	"method",
	"baseUrl",
	"url",
	"headers",
	"request",
	"query",
	"mediaType",
	"operationName"
];
var FORBIDDEN_VARIABLE_OPTIONS = [
	"query",
	"method",
	"url"
];
var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
function graphql(request2, query, options) {
	if (options) {
		if (typeof query === "string" && "query" in options) return Promise.reject(/* @__PURE__ */ new Error(`[@octokit/graphql] "query" cannot be used as variable name`));
		for (const key in options) {
			if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue;
			return Promise.reject(/* @__PURE__ */ new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`));
		}
	}
	const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query;
	const requestOptions = Object.keys(parsedOptions).reduce((result, key) => {
		if (NON_VARIABLE_OPTIONS.includes(key)) {
			result[key] = parsedOptions[key];
			return result;
		}
		if (!result.variables) result.variables = {};
		result.variables[key] = parsedOptions[key];
		return result;
	}, {});
	const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl;
	if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
	return request2(requestOptions).then((response) => {
		if (response.data.errors) {
			const headers = {};
			for (const key of Object.keys(response.headers)) headers[key] = response.headers[key];
			throw new GraphqlResponseError(requestOptions, headers, response.data);
		}
		return response.data.data;
	});
}
function withDefaults(request2, newDefaults) {
	const newRequest = request2.defaults(newDefaults);
	const newApi = (query, options) => {
		return graphql(newRequest, query, options);
	};
	return Object.assign(newApi, {
		defaults: withDefaults.bind(null, newRequest),
		endpoint: newRequest.endpoint
	});
}
withDefaults(request, {
	headers: { "user-agent": `octokit-graphql.js/${VERSION$3} ${getUserAgent()}` },
	method: "POST",
	url: "/graphql"
});
function withCustomRequest(customRequest) {
	return withDefaults(customRequest, {
		method: "POST",
		url: "/graphql"
	});
}
/* v8 ignore if -- @preserve */
//#endregion
//#region node_modules/.pnpm/@octokit+auth-token@6.0.0/node_modules/@octokit/auth-token/dist-bundle/index.js
var b64url = "(?:[a-zA-Z0-9_-]+)";
var sep$1 = "\\.";
var jwtRE = new RegExp(`^${b64url}${sep$1}${b64url}${sep$1}${b64url}$`);
var isJWT = jwtRE.test.bind(jwtRE);
async function auth(token) {
	const isApp = isJWT(token);
	const isInstallation = token.startsWith("v1.") || token.startsWith("ghs_");
	const isUserToServer = token.startsWith("ghu_");
	return {
		type: "token",
		token,
		tokenType: isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth"
	};
}
function withAuthorizationPrefix(token) {
	if (token.split(/\./).length === 3) return `bearer ${token}`;
	return `token ${token}`;
}
async function hook(token, request, route, parameters) {
	const endpoint = request.endpoint.merge(route, parameters);
	endpoint.headers.authorization = withAuthorizationPrefix(token);
	return request(endpoint);
}
var createTokenAuth = function createTokenAuth2(token) {
	if (!token) throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
	if (typeof token !== "string") throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");
	token = token.replace(/^(token|bearer) +/i, "");
	return Object.assign(auth.bind(null, token), { hook: hook.bind(null, token) });
};
//#endregion
//#region node_modules/.pnpm/@octokit+core@7.0.7/node_modules/@octokit/core/dist-src/version.js
var VERSION$2 = "7.0.7";
//#endregion
//#region node_modules/.pnpm/@octokit+core@7.0.7/node_modules/@octokit/core/dist-src/index.js
var noop = () => {};
var consoleWarn = console.warn.bind(console);
var consoleError = console.error.bind(console);
function createLogger(logger = {}) {
	if (typeof logger.debug !== "function") logger.debug = noop;
	if (typeof logger.info !== "function") logger.info = noop;
	if (typeof logger.warn !== "function") logger.warn = consoleWarn;
	if (typeof logger.error !== "function") logger.error = consoleError;
	return logger;
}
var userAgentTrail = `octokit-core.js/${VERSION$2} ${getUserAgent()}`;
var Octokit = class {
	static VERSION = VERSION$2;
	static defaults(defaults) {
		const OctokitWithDefaults = class extends this {
			constructor(...args) {
				const options = args[0] || {};
				if (typeof defaults === "function") {
					super(defaults(options));
					return;
				}
				super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? { userAgent: `${options.userAgent} ${defaults.userAgent}` } : null));
			}
		};
		return OctokitWithDefaults;
	}
	static plugins = [];
	/**
	* Attach a plugin (or many) to your Octokit instance.
	*
	* @example
	* const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
	*/
	static plugin(...newPlugins) {
		const currentPlugins = this.plugins;
		const NewOctokit = class extends this {
			static plugins = currentPlugins.concat(newPlugins.filter((plugin) => !currentPlugins.includes(plugin)));
		};
		return NewOctokit;
	}
	constructor(options = {}) {
		const hook = new before_after_hook_default.Collection();
		const requestDefaults = {
			baseUrl: request.endpoint.DEFAULTS.baseUrl,
			headers: {},
			request: Object.assign({}, options.request, { hook: hook.bind(null, "request") }),
			mediaType: {
				previews: [],
				format: ""
			}
		};
		requestDefaults.headers["user-agent"] = options.userAgent ? `${options.userAgent} ${userAgentTrail}` : userAgentTrail;
		if (options.baseUrl) requestDefaults.baseUrl = options.baseUrl;
		if (options.previews) requestDefaults.mediaType.previews = options.previews;
		if (options.timeZone) requestDefaults.headers["time-zone"] = options.timeZone;
		this.request = request.defaults(requestDefaults);
		this.graphql = withCustomRequest(this.request).defaults(requestDefaults);
		this.log = createLogger(options.log);
		this.hook = hook;
		if (!options.authStrategy) {
			if (!options.auth) this.auth = async () => ({ type: "unauthenticated" });
			else {
				const auth = createTokenAuth(options.auth);
				hook.wrap("request", auth.hook);
				this.auth = auth;
			}
		} else {
			const { authStrategy, ...otherOptions } = options;
			const auth = authStrategy(Object.assign({
				request: this.request,
				log: this.log,
				octokit: this,
				octokitOptions: otherOptions
			}, options.auth));
			hook.wrap("request", auth.hook);
			this.auth = auth;
		}
		const classConstructor = this.constructor;
		for (let i = 0; i < classConstructor.plugins.length; ++i) Object.assign(this, classConstructor.plugins[i](this, options));
	}
	request;
	graphql;
	log;
	hook;
	auth;
};
//#endregion
//#region node_modules/.pnpm/@octokit+plugin-rest-endpoint-methods@17.0.0_@octokit+core@7.0.7/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/version.js
var VERSION$1 = "17.0.0";
//#endregion
//#region node_modules/.pnpm/@octokit+plugin-rest-endpoint-methods@17.0.0_@octokit+core@7.0.7/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/generated/endpoints.js
var endpoints_default = {
	actions: {
		addCustomLabelsToSelfHostedRunnerForOrg: ["POST /orgs/{org}/actions/runners/{runner_id}/labels"],
		addCustomLabelsToSelfHostedRunnerForRepo: ["POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],
		addRepoAccessToSelfHostedRunnerGroupInOrg: ["PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories/{repository_id}"],
		addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],
		addSelectedRepoToOrgVariable: ["PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"],
		approveWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"],
		cancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"],
		createEnvironmentVariable: ["POST /repos/{owner}/{repo}/environments/{environment_name}/variables"],
		createHostedRunnerForOrg: ["POST /orgs/{org}/actions/hosted-runners"],
		createOrUpdateEnvironmentSecret: ["PUT /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"],
		createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"],
		createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
		createOrgVariable: ["POST /orgs/{org}/actions/variables"],
		createRegistrationTokenForOrg: ["POST /orgs/{org}/actions/runners/registration-token"],
		createRegistrationTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/registration-token"],
		createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"],
		createRemoveTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/remove-token"],
		createRepoVariable: ["POST /repos/{owner}/{repo}/actions/variables"],
		createWorkflowDispatch: ["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"],
		deleteActionsCacheById: ["DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}"],
		deleteActionsCacheByKey: ["DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}"],
		deleteArtifact: ["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
		deleteCustomImageFromOrg: ["DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"],
		deleteCustomImageVersionFromOrg: ["DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"],
		deleteEnvironmentSecret: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"],
		deleteEnvironmentVariable: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"],
		deleteHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"],
		deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"],
		deleteOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}"],
		deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
		deleteRepoVariable: ["DELETE /repos/{owner}/{repo}/actions/variables/{name}"],
		deleteSelfHostedRunnerFromOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}"],
		deleteSelfHostedRunnerFromRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"],
		deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"],
		deleteWorkflowRunLogs: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],
		disableSelectedRepositoryGithubActionsOrganization: ["DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"],
		disableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"],
		downloadArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"],
		downloadJobLogsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"],
		downloadWorkflowRunAttemptLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs"],
		downloadWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],
		enableSelectedRepositoryGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"],
		enableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"],
		forceCancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel"],
		generateRunnerJitconfigForOrg: ["POST /orgs/{org}/actions/runners/generate-jitconfig"],
		generateRunnerJitconfigForRepo: ["POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig"],
		getActionsCacheList: ["GET /repos/{owner}/{repo}/actions/caches"],
		getActionsCacheUsage: ["GET /repos/{owner}/{repo}/actions/cache/usage"],
		getActionsCacheUsageByRepoForOrg: ["GET /orgs/{org}/actions/cache/usage-by-repository"],
		getActionsCacheUsageForOrg: ["GET /orgs/{org}/actions/cache/usage"],
		getAllowedActionsOrganization: ["GET /orgs/{org}/actions/permissions/selected-actions"],
		getAllowedActionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/selected-actions"],
		getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
		getCustomImageForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"],
		getCustomImageVersionForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"],
		getCustomOidcSubClaimForRepo: ["GET /repos/{owner}/{repo}/actions/oidc/customization/sub"],
		getEnvironmentPublicKey: ["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/public-key"],
		getEnvironmentSecret: ["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"],
		getEnvironmentVariable: ["GET /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"],
		getGithubActionsDefaultWorkflowPermissionsOrganization: ["GET /orgs/{org}/actions/permissions/workflow"],
		getGithubActionsDefaultWorkflowPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/workflow"],
		getGithubActionsPermissionsOrganization: ["GET /orgs/{org}/actions/permissions"],
		getGithubActionsPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions"],
		getHostedRunnerForOrg: ["GET /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"],
		getHostedRunnersGithubOwnedImagesForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/github-owned"],
		getHostedRunnersLimitsForOrg: ["GET /orgs/{org}/actions/hosted-runners/limits"],
		getHostedRunnersMachineSpecsForOrg: ["GET /orgs/{org}/actions/hosted-runners/machine-sizes"],
		getHostedRunnersPartnerImagesForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/partner"],
		getHostedRunnersPlatformsForOrg: ["GET /orgs/{org}/actions/hosted-runners/platforms"],
		getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"],
		getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"],
		getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"],
		getOrgVariable: ["GET /orgs/{org}/actions/variables/{name}"],
		getPendingDeploymentsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"],
		getRepoPermissions: [
			"GET /repos/{owner}/{repo}/actions/permissions",
			{},
			{ renamed: ["actions", "getGithubActionsPermissionsRepository"] }
		],
		getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"],
		getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
		getRepoVariable: ["GET /repos/{owner}/{repo}/actions/variables/{name}"],
		getReviewsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals"],
		getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"],
		getSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"],
		getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"],
		getWorkflowAccessToRepository: ["GET /repos/{owner}/{repo}/actions/permissions/access"],
		getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"],
		getWorkflowRunAttempt: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}"],
		getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"],
		getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"],
		listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"],
		listCustomImageVersionsForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions"],
		listCustomImagesForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/custom"],
		listEnvironmentSecrets: ["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets"],
		listEnvironmentVariables: ["GET /repos/{owner}/{repo}/environments/{environment_name}/variables"],
		listGithubHostedRunnersInGroupForOrg: ["GET /orgs/{org}/actions/runner-groups/{runner_group_id}/hosted-runners"],
		listHostedRunnersForOrg: ["GET /orgs/{org}/actions/hosted-runners"],
		listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"],
		listJobsForWorkflowRunAttempt: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs"],
		listLabelsForSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}/labels"],
		listLabelsForSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],
		listOrgSecrets: ["GET /orgs/{org}/actions/secrets"],
		listOrgVariables: ["GET /orgs/{org}/actions/variables"],
		listRepoOrganizationSecrets: ["GET /repos/{owner}/{repo}/actions/organization-secrets"],
		listRepoOrganizationVariables: ["GET /repos/{owner}/{repo}/actions/organization-variables"],
		listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"],
		listRepoVariables: ["GET /repos/{owner}/{repo}/actions/variables"],
		listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"],
		listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"],
		listRunnerApplicationsForRepo: ["GET /repos/{owner}/{repo}/actions/runners/downloads"],
		listSelectedReposForOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"],
		listSelectedReposForOrgVariable: ["GET /orgs/{org}/actions/variables/{name}/repositories"],
		listSelectedRepositoriesEnabledGithubActionsOrganization: ["GET /orgs/{org}/actions/permissions/repositories"],
		listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"],
		listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"],
		listWorkflowRunArtifacts: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"],
		listWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"],
		listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"],
		reRunJobForWorkflowRun: ["POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun"],
		reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"],
		reRunWorkflowFailedJobs: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs"],
		removeAllCustomLabelsFromSelfHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}/labels"],
		removeAllCustomLabelsFromSelfHostedRunnerForRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],
		removeCustomLabelFromSelfHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}"],
		removeCustomLabelFromSelfHostedRunnerForRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}"],
		removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],
		removeSelectedRepoFromOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"],
		reviewCustomGatesForRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/deployment_protection_rule"],
		reviewPendingDeploymentsForRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"],
		setAllowedActionsOrganization: ["PUT /orgs/{org}/actions/permissions/selected-actions"],
		setAllowedActionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"],
		setCustomLabelsForSelfHostedRunnerForOrg: ["PUT /orgs/{org}/actions/runners/{runner_id}/labels"],
		setCustomLabelsForSelfHostedRunnerForRepo: ["PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],
		setCustomOidcSubClaimForRepo: ["PUT /repos/{owner}/{repo}/actions/oidc/customization/sub"],
		setGithubActionsDefaultWorkflowPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions/workflow"],
		setGithubActionsDefaultWorkflowPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/workflow"],
		setGithubActionsPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions"],
		setGithubActionsPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions"],
		setSelectedReposForOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"],
		setSelectedReposForOrgVariable: ["PUT /orgs/{org}/actions/variables/{name}/repositories"],
		setSelectedRepositoriesEnabledGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories"],
		setWorkflowAccessToRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/access"],
		updateEnvironmentVariable: ["PATCH /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"],
		updateHostedRunnerForOrg: ["PATCH /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"],
		updateOrgVariable: ["PATCH /orgs/{org}/actions/variables/{name}"],
		updateRepoVariable: ["PATCH /repos/{owner}/{repo}/actions/variables/{name}"]
	},
	activity: {
		checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"],
		deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"],
		deleteThreadSubscription: ["DELETE /notifications/threads/{thread_id}/subscription"],
		getFeeds: ["GET /feeds"],
		getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"],
		getThread: ["GET /notifications/threads/{thread_id}"],
		getThreadSubscriptionForAuthenticatedUser: ["GET /notifications/threads/{thread_id}/subscription"],
		listEventsForAuthenticatedUser: ["GET /users/{username}/events"],
		listNotificationsForAuthenticatedUser: ["GET /notifications"],
		listOrgEventsForAuthenticatedUser: ["GET /users/{username}/events/orgs/{org}"],
		listPublicEvents: ["GET /events"],
		listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"],
		listPublicEventsForUser: ["GET /users/{username}/events/public"],
		listPublicOrgEvents: ["GET /orgs/{org}/events"],
		listReceivedEventsForUser: ["GET /users/{username}/received_events"],
		listReceivedPublicEventsForUser: ["GET /users/{username}/received_events/public"],
		listRepoEvents: ["GET /repos/{owner}/{repo}/events"],
		listRepoNotificationsForAuthenticatedUser: ["GET /repos/{owner}/{repo}/notifications"],
		listReposStarredByAuthenticatedUser: ["GET /user/starred"],
		listReposStarredByUser: ["GET /users/{username}/starred"],
		listReposWatchedByUser: ["GET /users/{username}/subscriptions"],
		listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"],
		listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"],
		listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"],
		markNotificationsAsRead: ["PUT /notifications"],
		markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"],
		markThreadAsDone: ["DELETE /notifications/threads/{thread_id}"],
		markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"],
		setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"],
		setThreadSubscription: ["PUT /notifications/threads/{thread_id}/subscription"],
		starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"],
		unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"]
	},
	apps: {
		addRepoToInstallation: [
			"PUT /user/installations/{installation_id}/repositories/{repository_id}",
			{},
			{ renamed: ["apps", "addRepoToInstallationForAuthenticatedUser"] }
		],
		addRepoToInstallationForAuthenticatedUser: ["PUT /user/installations/{installation_id}/repositories/{repository_id}"],
		checkToken: ["POST /applications/{client_id}/token"],
		createFromManifest: ["POST /app-manifests/{code}/conversions"],
		createInstallationAccessToken: ["POST /app/installations/{installation_id}/access_tokens"],
		deleteAuthorization: ["DELETE /applications/{client_id}/grant"],
		deleteInstallation: ["DELETE /app/installations/{installation_id}"],
		deleteToken: ["DELETE /applications/{client_id}/token"],
		getAuthenticated: ["GET /app"],
		getBySlug: ["GET /apps/{app_slug}"],
		getInstallation: ["GET /app/installations/{installation_id}"],
		getOrgInstallation: ["GET /orgs/{org}/installation"],
		getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"],
		getSubscriptionPlanForAccount: ["GET /marketplace_listing/accounts/{account_id}"],
		getSubscriptionPlanForAccountStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}"],
		getUserInstallation: ["GET /users/{username}/installation"],
		getWebhookConfigForApp: ["GET /app/hook/config"],
		getWebhookDelivery: ["GET /app/hook/deliveries/{delivery_id}"],
		listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"],
		listAccountsForPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"],
		listInstallationReposForAuthenticatedUser: ["GET /user/installations/{installation_id}/repositories"],
		listInstallationRequestsForAuthenticatedApp: ["GET /app/installation-requests"],
		listInstallations: ["GET /app/installations"],
		listInstallationsForAuthenticatedUser: ["GET /user/installations"],
		listPlans: ["GET /marketplace_listing/plans"],
		listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"],
		listReposAccessibleToInstallation: ["GET /installation/repositories"],
		listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"],
		listSubscriptionsForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed"],
		listWebhookDeliveries: ["GET /app/hook/deliveries"],
		redeliverWebhookDelivery: ["POST /app/hook/deliveries/{delivery_id}/attempts"],
		removeRepoFromInstallation: [
			"DELETE /user/installations/{installation_id}/repositories/{repository_id}",
			{},
			{ renamed: ["apps", "removeRepoFromInstallationForAuthenticatedUser"] }
		],
		removeRepoFromInstallationForAuthenticatedUser: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}"],
		resetToken: ["PATCH /applications/{client_id}/token"],
		revokeInstallationAccessToken: ["DELETE /installation/token"],
		scopeToken: ["POST /applications/{client_id}/token/scoped"],
		suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"],
		unsuspendInstallation: ["DELETE /app/installations/{installation_id}/suspended"],
		updateWebhookConfigForApp: ["PATCH /app/hook/config"]
	},
	billing: {
		getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"],
		getGithubActionsBillingUser: ["GET /users/{username}/settings/billing/actions"],
		getGithubBillingPremiumRequestUsageReportOrg: ["GET /organizations/{org}/settings/billing/premium_request/usage"],
		getGithubBillingPremiumRequestUsageReportUser: ["GET /users/{username}/settings/billing/premium_request/usage"],
		getGithubBillingUsageReportOrg: ["GET /organizations/{org}/settings/billing/usage"],
		getGithubBillingUsageReportUser: ["GET /users/{username}/settings/billing/usage"],
		getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"],
		getGithubPackagesBillingUser: ["GET /users/{username}/settings/billing/packages"],
		getSharedStorageBillingOrg: ["GET /orgs/{org}/settings/billing/shared-storage"],
		getSharedStorageBillingUser: ["GET /users/{username}/settings/billing/shared-storage"]
	},
	campaigns: {
		createCampaign: ["POST /orgs/{org}/campaigns"],
		deleteCampaign: ["DELETE /orgs/{org}/campaigns/{campaign_number}"],
		getCampaignSummary: ["GET /orgs/{org}/campaigns/{campaign_number}"],
		listOrgCampaigns: ["GET /orgs/{org}/campaigns"],
		updateCampaign: ["PATCH /orgs/{org}/campaigns/{campaign_number}"]
	},
	checks: {
		create: ["POST /repos/{owner}/{repo}/check-runs"],
		createSuite: ["POST /repos/{owner}/{repo}/check-suites"],
		get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"],
		getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"],
		listAnnotations: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"],
		listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"],
		listForSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"],
		listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"],
		rerequestRun: ["POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest"],
		rerequestSuite: ["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"],
		setSuitesPreferences: ["PATCH /repos/{owner}/{repo}/check-suites/preferences"],
		update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"]
	},
	codeScanning: {
		commitAutofix: ["POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix/commits"],
		createAutofix: ["POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"],
		createVariantAnalysis: ["POST /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses"],
		deleteAnalysis: ["DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}"],
		deleteCodeqlDatabase: ["DELETE /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"],
		getAlert: [
			"GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}",
			{},
			{ renamedParameters: { alert_id: "alert_number" } }
		],
		getAnalysis: ["GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}"],
		getAutofix: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"],
		getCodeqlDatabase: ["GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"],
		getDefaultSetup: ["GET /repos/{owner}/{repo}/code-scanning/default-setup"],
		getSarif: ["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"],
		getVariantAnalysis: ["GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}"],
		getVariantAnalysisRepoTask: ["GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}/repos/{repo_owner}/{repo_name}"],
		listAlertInstances: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances"],
		listAlertsForOrg: ["GET /orgs/{org}/code-scanning/alerts"],
		listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"],
		listAlertsInstances: [
			"GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances",
			{},
			{ renamed: ["codeScanning", "listAlertInstances"] }
		],
		listCodeqlDatabases: ["GET /repos/{owner}/{repo}/code-scanning/codeql/databases"],
		listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"],
		updateAlert: ["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"],
		updateDefaultSetup: ["PATCH /repos/{owner}/{repo}/code-scanning/default-setup"],
		uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"]
	},
	codeSecurity: {
		attachConfiguration: ["POST /orgs/{org}/code-security/configurations/{configuration_id}/attach"],
		attachEnterpriseConfiguration: ["POST /enterprises/{enterprise}/code-security/configurations/{configuration_id}/attach"],
		createConfiguration: ["POST /orgs/{org}/code-security/configurations"],
		createConfigurationForEnterprise: ["POST /enterprises/{enterprise}/code-security/configurations"],
		deleteConfiguration: ["DELETE /orgs/{org}/code-security/configurations/{configuration_id}"],
		deleteConfigurationForEnterprise: ["DELETE /enterprises/{enterprise}/code-security/configurations/{configuration_id}"],
		detachConfiguration: ["DELETE /orgs/{org}/code-security/configurations/detach"],
		getConfiguration: ["GET /orgs/{org}/code-security/configurations/{configuration_id}"],
		getConfigurationForRepository: ["GET /repos/{owner}/{repo}/code-security-configuration"],
		getConfigurationsForEnterprise: ["GET /enterprises/{enterprise}/code-security/configurations"],
		getConfigurationsForOrg: ["GET /orgs/{org}/code-security/configurations"],
		getDefaultConfigurations: ["GET /orgs/{org}/code-security/configurations/defaults"],
		getDefaultConfigurationsForEnterprise: ["GET /enterprises/{enterprise}/code-security/configurations/defaults"],
		getRepositoriesForConfiguration: ["GET /orgs/{org}/code-security/configurations/{configuration_id}/repositories"],
		getRepositoriesForEnterpriseConfiguration: ["GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}/repositories"],
		getSingleConfigurationForEnterprise: ["GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}"],
		setConfigurationAsDefault: ["PUT /orgs/{org}/code-security/configurations/{configuration_id}/defaults"],
		setConfigurationAsDefaultForEnterprise: ["PUT /enterprises/{enterprise}/code-security/configurations/{configuration_id}/defaults"],
		updateConfiguration: ["PATCH /orgs/{org}/code-security/configurations/{configuration_id}"],
		updateEnterpriseConfiguration: ["PATCH /enterprises/{enterprise}/code-security/configurations/{configuration_id}"]
	},
	codesOfConduct: {
		getAllCodesOfConduct: ["GET /codes_of_conduct"],
		getConductCode: ["GET /codes_of_conduct/{key}"]
	},
	codespaces: {
		addRepositoryForSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"],
		addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"],
		checkPermissionsForDevcontainer: ["GET /repos/{owner}/{repo}/codespaces/permissions_check"],
		codespaceMachinesForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}/machines"],
		createForAuthenticatedUser: ["POST /user/codespaces"],
		createOrUpdateOrgSecret: ["PUT /orgs/{org}/codespaces/secrets/{secret_name}"],
		createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"],
		createOrUpdateSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}"],
		createWithPrForAuthenticatedUser: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces"],
		createWithRepoForAuthenticatedUser: ["POST /repos/{owner}/{repo}/codespaces"],
		deleteForAuthenticatedUser: ["DELETE /user/codespaces/{codespace_name}"],
		deleteFromOrganization: ["DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}"],
		deleteOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}"],
		deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"],
		deleteSecretForAuthenticatedUser: ["DELETE /user/codespaces/secrets/{secret_name}"],
		exportForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/exports"],
		getCodespacesForUserInOrg: ["GET /orgs/{org}/members/{username}/codespaces"],
		getExportDetailsForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}/exports/{export_id}"],
		getForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}"],
		getOrgPublicKey: ["GET /orgs/{org}/codespaces/secrets/public-key"],
		getOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}"],
		getPublicKeyForAuthenticatedUser: ["GET /user/codespaces/secrets/public-key"],
		getRepoPublicKey: ["GET /repos/{owner}/{repo}/codespaces/secrets/public-key"],
		getRepoSecret: ["GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"],
		getSecretForAuthenticatedUser: ["GET /user/codespaces/secrets/{secret_name}"],
		listDevcontainersInRepositoryForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/devcontainers"],
		listForAuthenticatedUser: ["GET /user/codespaces"],
		listInOrganization: [
			"GET /orgs/{org}/codespaces",
			{},
			{ renamedParameters: { org_id: "org" } }
		],
		listInRepositoryForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces"],
		listOrgSecrets: ["GET /orgs/{org}/codespaces/secrets"],
		listRepoSecrets: ["GET /repos/{owner}/{repo}/codespaces/secrets"],
		listRepositoriesForSecretForAuthenticatedUser: ["GET /user/codespaces/secrets/{secret_name}/repositories"],
		listSecretsForAuthenticatedUser: ["GET /user/codespaces/secrets"],
		listSelectedReposForOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories"],
		preFlightWithRepoForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/new"],
		publishForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/publish"],
		removeRepositoryForSecretForAuthenticatedUser: ["DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"],
		removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"],
		repoMachinesForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/machines"],
		setRepositoriesForSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}/repositories"],
		setSelectedReposForOrgSecret: ["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories"],
		startForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/start"],
		stopForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/stop"],
		stopInOrganization: ["POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop"],
		updateForAuthenticatedUser: ["PATCH /user/codespaces/{codespace_name}"]
	},
	copilot: {
		addCopilotSeatsForTeams: ["POST /orgs/{org}/copilot/billing/selected_teams"],
		addCopilotSeatsForUsers: ["POST /orgs/{org}/copilot/billing/selected_users"],
		cancelCopilotSeatAssignmentForTeams: ["DELETE /orgs/{org}/copilot/billing/selected_teams"],
		cancelCopilotSeatAssignmentForUsers: ["DELETE /orgs/{org}/copilot/billing/selected_users"],
		copilotMetricsForOrganization: ["GET /orgs/{org}/copilot/metrics"],
		copilotMetricsForTeam: ["GET /orgs/{org}/team/{team_slug}/copilot/metrics"],
		getCopilotOrganizationDetails: ["GET /orgs/{org}/copilot/billing"],
		getCopilotSeatDetailsForUser: ["GET /orgs/{org}/members/{username}/copilot"],
		listCopilotSeats: ["GET /orgs/{org}/copilot/billing/seats"]
	},
	credentials: { revoke: ["POST /credentials/revoke"] },
	dependabot: {
		addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"],
		createOrUpdateOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}"],
		createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"],
		deleteOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"],
		deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"],
		getAlert: ["GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"],
		getOrgPublicKey: ["GET /orgs/{org}/dependabot/secrets/public-key"],
		getOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}"],
		getRepoPublicKey: ["GET /repos/{owner}/{repo}/dependabot/secrets/public-key"],
		getRepoSecret: ["GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"],
		listAlertsForEnterprise: ["GET /enterprises/{enterprise}/dependabot/alerts"],
		listAlertsForOrg: ["GET /orgs/{org}/dependabot/alerts"],
		listAlertsForRepo: ["GET /repos/{owner}/{repo}/dependabot/alerts"],
		listOrgSecrets: ["GET /orgs/{org}/dependabot/secrets"],
		listRepoSecrets: ["GET /repos/{owner}/{repo}/dependabot/secrets"],
		listSelectedReposForOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories"],
		removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"],
		repositoryAccessForOrg: ["GET /organizations/{org}/dependabot/repository-access"],
		setRepositoryAccessDefaultLevel: ["PUT /organizations/{org}/dependabot/repository-access/default-level"],
		setSelectedReposForOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories"],
		updateAlert: ["PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"],
		updateRepositoryAccessForOrg: ["PATCH /organizations/{org}/dependabot/repository-access"]
	},
	dependencyGraph: {
		createRepositorySnapshot: ["POST /repos/{owner}/{repo}/dependency-graph/snapshots"],
		diffRange: ["GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}"],
		exportSbom: ["GET /repos/{owner}/{repo}/dependency-graph/sbom"]
	},
	emojis: { get: ["GET /emojis"] },
	enterpriseTeamMemberships: {
		add: ["PUT /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"],
		bulkAdd: ["POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/add"],
		bulkRemove: ["POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/remove"],
		get: ["GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"],
		list: ["GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships"],
		remove: ["DELETE /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"]
	},
	enterpriseTeamOrganizations: {
		add: ["PUT /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"],
		bulkAdd: ["POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/add"],
		bulkRemove: ["POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/remove"],
		delete: ["DELETE /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"],
		getAssignment: ["GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"],
		getAssignments: ["GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations"]
	},
	enterpriseTeams: {
		create: ["POST /enterprises/{enterprise}/teams"],
		delete: ["DELETE /enterprises/{enterprise}/teams/{team_slug}"],
		get: ["GET /enterprises/{enterprise}/teams/{team_slug}"],
		list: ["GET /enterprises/{enterprise}/teams"],
		update: ["PATCH /enterprises/{enterprise}/teams/{team_slug}"]
	},
	gists: {
		checkIsStarred: ["GET /gists/{gist_id}/star"],
		create: ["POST /gists"],
		createComment: ["POST /gists/{gist_id}/comments"],
		delete: ["DELETE /gists/{gist_id}"],
		deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"],
		fork: ["POST /gists/{gist_id}/forks"],
		get: ["GET /gists/{gist_id}"],
		getComment: ["GET /gists/{gist_id}/comments/{comment_id}"],
		getRevision: ["GET /gists/{gist_id}/{sha}"],
		list: ["GET /gists"],
		listComments: ["GET /gists/{gist_id}/comments"],
		listCommits: ["GET /gists/{gist_id}/commits"],
		listForUser: ["GET /users/{username}/gists"],
		listForks: ["GET /gists/{gist_id}/forks"],
		listPublic: ["GET /gists/public"],
		listStarred: ["GET /gists/starred"],
		star: ["PUT /gists/{gist_id}/star"],
		unstar: ["DELETE /gists/{gist_id}/star"],
		update: ["PATCH /gists/{gist_id}"],
		updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"]
	},
	git: {
		createBlob: ["POST /repos/{owner}/{repo}/git/blobs"],
		createCommit: ["POST /repos/{owner}/{repo}/git/commits"],
		createRef: ["POST /repos/{owner}/{repo}/git/refs"],
		createTag: ["POST /repos/{owner}/{repo}/git/tags"],
		createTree: ["POST /repos/{owner}/{repo}/git/trees"],
		deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"],
		getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"],
		getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"],
		getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"],
		getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"],
		getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"],
		listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"],
		updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"]
	},
	gitignore: {
		getAllTemplates: ["GET /gitignore/templates"],
		getTemplate: ["GET /gitignore/templates/{name}"]
	},
	hostedCompute: {
		createNetworkConfigurationForOrg: ["POST /orgs/{org}/settings/network-configurations"],
		deleteNetworkConfigurationFromOrg: ["DELETE /orgs/{org}/settings/network-configurations/{network_configuration_id}"],
		getNetworkConfigurationForOrg: ["GET /orgs/{org}/settings/network-configurations/{network_configuration_id}"],
		getNetworkSettingsForOrg: ["GET /orgs/{org}/settings/network-settings/{network_settings_id}"],
		listNetworkConfigurationsForOrg: ["GET /orgs/{org}/settings/network-configurations"],
		updateNetworkConfigurationForOrg: ["PATCH /orgs/{org}/settings/network-configurations/{network_configuration_id}"]
	},
	interactions: {
		getRestrictionsForAuthenticatedUser: ["GET /user/interaction-limits"],
		getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"],
		getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"],
		getRestrictionsForYourPublicRepos: [
			"GET /user/interaction-limits",
			{},
			{ renamed: ["interactions", "getRestrictionsForAuthenticatedUser"] }
		],
		removeRestrictionsForAuthenticatedUser: ["DELETE /user/interaction-limits"],
		removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"],
		removeRestrictionsForRepo: ["DELETE /repos/{owner}/{repo}/interaction-limits"],
		removeRestrictionsForYourPublicRepos: [
			"DELETE /user/interaction-limits",
			{},
			{ renamed: ["interactions", "removeRestrictionsForAuthenticatedUser"] }
		],
		setRestrictionsForAuthenticatedUser: ["PUT /user/interaction-limits"],
		setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"],
		setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"],
		setRestrictionsForYourPublicRepos: [
			"PUT /user/interaction-limits",
			{},
			{ renamed: ["interactions", "setRestrictionsForAuthenticatedUser"] }
		]
	},
	issues: {
		addAssignees: ["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"],
		addBlockedByDependency: ["POST /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"],
		addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"],
		addSubIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"],
		checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"],
		checkUserCanBeAssignedToIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/assignees/{assignee}"],
		create: ["POST /repos/{owner}/{repo}/issues"],
		createComment: ["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"],
		createLabel: ["POST /repos/{owner}/{repo}/labels"],
		createMilestone: ["POST /repos/{owner}/{repo}/milestones"],
		deleteComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"],
		deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"],
		deleteMilestone: ["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"],
		get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"],
		getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"],
		getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"],
		getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"],
		getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"],
		getParent: ["GET /repos/{owner}/{repo}/issues/{issue_number}/parent"],
		list: ["GET /issues"],
		listAssignees: ["GET /repos/{owner}/{repo}/assignees"],
		listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"],
		listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"],
		listDependenciesBlockedBy: ["GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"],
		listDependenciesBlocking: ["GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocking"],
		listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"],
		listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"],
		listEventsForTimeline: ["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline"],
		listForAuthenticatedUser: ["GET /user/issues"],
		listForOrg: ["GET /orgs/{org}/issues"],
		listForRepo: ["GET /repos/{owner}/{repo}/issues"],
		listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"],
		listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"],
		listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"],
		listMilestones: ["GET /repos/{owner}/{repo}/milestones"],
		listSubIssues: ["GET /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"],
		lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"],
		removeAllLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"],
		removeAssignees: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"],
		removeDependencyBlockedBy: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by/{issue_id}"],
		removeLabel: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"],
		removeSubIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/sub_issue"],
		reprioritizeSubIssue: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}/sub_issues/priority"],
		setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"],
		unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"],
		update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"],
		updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"],
		updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"],
		updateMilestone: ["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"]
	},
	licenses: {
		get: ["GET /licenses/{license}"],
		getAllCommonlyUsed: ["GET /licenses"],
		getForRepo: ["GET /repos/{owner}/{repo}/license"]
	},
	markdown: {
		render: ["POST /markdown"],
		renderRaw: ["POST /markdown/raw", { headers: { "content-type": "text/plain; charset=utf-8" } }]
	},
	meta: {
		get: ["GET /meta"],
		getAllVersions: ["GET /versions"],
		getOctocat: ["GET /octocat"],
		getZen: ["GET /zen"],
		root: ["GET /"]
	},
	migrations: {
		deleteArchiveForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/archive"],
		deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive"],
		downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive"],
		getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive"],
		getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}"],
		getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}"],
		listForAuthenticatedUser: ["GET /user/migrations"],
		listForOrg: ["GET /orgs/{org}/migrations"],
		listReposForAuthenticatedUser: ["GET /user/migrations/{migration_id}/repositories"],
		listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories"],
		listReposForUser: [
			"GET /user/migrations/{migration_id}/repositories",
			{},
			{ renamed: ["migrations", "listReposForAuthenticatedUser"] }
		],
		startForAuthenticatedUser: ["POST /user/migrations"],
		startForOrg: ["POST /orgs/{org}/migrations"],
		unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock"],
		unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock"]
	},
	oidc: {
		getOidcCustomSubTemplateForOrg: ["GET /orgs/{org}/actions/oidc/customization/sub"],
		updateOidcCustomSubTemplateForOrg: ["PUT /orgs/{org}/actions/oidc/customization/sub"]
	},
	orgs: {
		addSecurityManagerTeam: [
			"PUT /orgs/{org}/security-managers/teams/{team_slug}",
			{},
			{ deprecated: "octokit.rest.orgs.addSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#add-a-security-manager-team" }
		],
		assignTeamToOrgRole: ["PUT /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"],
		assignUserToOrgRole: ["PUT /orgs/{org}/organization-roles/users/{username}/{role_id}"],
		blockUser: ["PUT /orgs/{org}/blocks/{username}"],
		cancelInvitation: ["DELETE /orgs/{org}/invitations/{invitation_id}"],
		checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"],
		checkMembershipForUser: ["GET /orgs/{org}/members/{username}"],
		checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"],
		convertMemberToOutsideCollaborator: ["PUT /orgs/{org}/outside_collaborators/{username}"],
		createArtifactStorageRecord: ["POST /orgs/{org}/artifacts/metadata/storage-record"],
		createInvitation: ["POST /orgs/{org}/invitations"],
		createIssueType: ["POST /orgs/{org}/issue-types"],
		createWebhook: ["POST /orgs/{org}/hooks"],
		customPropertiesForOrgsCreateOrUpdateOrganizationValues: ["PATCH /organizations/{org}/org-properties/values"],
		customPropertiesForOrgsGetOrganizationValues: ["GET /organizations/{org}/org-properties/values"],
		customPropertiesForReposCreateOrUpdateOrganizationDefinition: ["PUT /orgs/{org}/properties/schema/{custom_property_name}"],
		customPropertiesForReposCreateOrUpdateOrganizationDefinitions: ["PATCH /orgs/{org}/properties/schema"],
		customPropertiesForReposCreateOrUpdateOrganizationValues: ["PATCH /orgs/{org}/properties/values"],
		customPropertiesForReposDeleteOrganizationDefinition: ["DELETE /orgs/{org}/properties/schema/{custom_property_name}"],
		customPropertiesForReposGetOrganizationDefinition: ["GET /orgs/{org}/properties/schema/{custom_property_name}"],
		customPropertiesForReposGetOrganizationDefinitions: ["GET /orgs/{org}/properties/schema"],
		customPropertiesForReposGetOrganizationValues: ["GET /orgs/{org}/properties/values"],
		delete: ["DELETE /orgs/{org}"],
		deleteAttestationsBulk: ["POST /orgs/{org}/attestations/delete-request"],
		deleteAttestationsById: ["DELETE /orgs/{org}/attestations/{attestation_id}"],
		deleteAttestationsBySubjectDigest: ["DELETE /orgs/{org}/attestations/digest/{subject_digest}"],
		deleteIssueType: ["DELETE /orgs/{org}/issue-types/{issue_type_id}"],
		deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"],
		disableSelectedRepositoryImmutableReleasesOrganization: ["DELETE /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"],
		enableSelectedRepositoryImmutableReleasesOrganization: ["PUT /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"],
		get: ["GET /orgs/{org}"],
		getImmutableReleasesSettings: ["GET /orgs/{org}/settings/immutable-releases"],
		getImmutableReleasesSettingsRepositories: ["GET /orgs/{org}/settings/immutable-releases/repositories"],
		getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"],
		getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"],
		getOrgRole: ["GET /orgs/{org}/organization-roles/{role_id}"],
		getOrgRulesetHistory: ["GET /orgs/{org}/rulesets/{ruleset_id}/history"],
		getOrgRulesetVersion: ["GET /orgs/{org}/rulesets/{ruleset_id}/history/{version_id}"],
		getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"],
		getWebhookConfigForOrg: ["GET /orgs/{org}/hooks/{hook_id}/config"],
		getWebhookDelivery: ["GET /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}"],
		list: ["GET /organizations"],
		listAppInstallations: ["GET /orgs/{org}/installations"],
		listArtifactStorageRecords: ["GET /orgs/{org}/artifacts/{subject_digest}/metadata/storage-records"],
		listAttestationRepositories: ["GET /orgs/{org}/attestations/repositories"],
		listAttestations: ["GET /orgs/{org}/attestations/{subject_digest}"],
		listAttestationsBulk: ["POST /orgs/{org}/attestations/bulk-list{?per_page,before,after}"],
		listBlockedUsers: ["GET /orgs/{org}/blocks"],
		listFailedInvitations: ["GET /orgs/{org}/failed_invitations"],
		listForAuthenticatedUser: ["GET /user/orgs"],
		listForUser: ["GET /users/{username}/orgs"],
		listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"],
		listIssueTypes: ["GET /orgs/{org}/issue-types"],
		listMembers: ["GET /orgs/{org}/members"],
		listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"],
		listOrgRoleTeams: ["GET /orgs/{org}/organization-roles/{role_id}/teams"],
		listOrgRoleUsers: ["GET /orgs/{org}/organization-roles/{role_id}/users"],
		listOrgRoles: ["GET /orgs/{org}/organization-roles"],
		listOrganizationFineGrainedPermissions: ["GET /orgs/{org}/organization-fine-grained-permissions"],
		listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"],
		listPatGrantRepositories: ["GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories"],
		listPatGrantRequestRepositories: ["GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories"],
		listPatGrantRequests: ["GET /orgs/{org}/personal-access-token-requests"],
		listPatGrants: ["GET /orgs/{org}/personal-access-tokens"],
		listPendingInvitations: ["GET /orgs/{org}/invitations"],
		listPublicMembers: ["GET /orgs/{org}/public_members"],
		listSecurityManagerTeams: [
			"GET /orgs/{org}/security-managers",
			{},
			{ deprecated: "octokit.rest.orgs.listSecurityManagerTeams() is deprecated, see https://docs.github.com/rest/orgs/security-managers#list-security-manager-teams" }
		],
		listWebhookDeliveries: ["GET /orgs/{org}/hooks/{hook_id}/deliveries"],
		listWebhooks: ["GET /orgs/{org}/hooks"],
		pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"],
		redeliverWebhookDelivery: ["POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"],
		removeMember: ["DELETE /orgs/{org}/members/{username}"],
		removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"],
		removeOutsideCollaborator: ["DELETE /orgs/{org}/outside_collaborators/{username}"],
		removePublicMembershipForAuthenticatedUser: ["DELETE /orgs/{org}/public_members/{username}"],
		removeSecurityManagerTeam: [
			"DELETE /orgs/{org}/security-managers/teams/{team_slug}",
			{},
			{ deprecated: "octokit.rest.orgs.removeSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#remove-a-security-manager-team" }
		],
		reviewPatGrantRequest: ["POST /orgs/{org}/personal-access-token-requests/{pat_request_id}"],
		reviewPatGrantRequestsInBulk: ["POST /orgs/{org}/personal-access-token-requests"],
		revokeAllOrgRolesTeam: ["DELETE /orgs/{org}/organization-roles/teams/{team_slug}"],
		revokeAllOrgRolesUser: ["DELETE /orgs/{org}/organization-roles/users/{username}"],
		revokeOrgRoleTeam: ["DELETE /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"],
		revokeOrgRoleUser: ["DELETE /orgs/{org}/organization-roles/users/{username}/{role_id}"],
		setImmutableReleasesSettings: ["PUT /orgs/{org}/settings/immutable-releases"],
		setImmutableReleasesSettingsRepositories: ["PUT /orgs/{org}/settings/immutable-releases/repositories"],
		setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"],
		setPublicMembershipForAuthenticatedUser: ["PUT /orgs/{org}/public_members/{username}"],
		unblockUser: ["DELETE /orgs/{org}/blocks/{username}"],
		update: ["PATCH /orgs/{org}"],
		updateIssueType: ["PUT /orgs/{org}/issue-types/{issue_type_id}"],
		updateMembershipForAuthenticatedUser: ["PATCH /user/memberships/orgs/{org}"],
		updatePatAccess: ["POST /orgs/{org}/personal-access-tokens/{pat_id}"],
		updatePatAccesses: ["POST /orgs/{org}/personal-access-tokens"],
		updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"],
		updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"]
	},
	packages: {
		deletePackageForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}"],
		deletePackageForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}"],
		deletePackageForUser: ["DELETE /users/{username}/packages/{package_type}/{package_name}"],
		deletePackageVersionForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}"],
		deletePackageVersionForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"],
		deletePackageVersionForUser: ["DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"],
		getAllPackageVersionsForAPackageOwnedByAnOrg: [
			"GET /orgs/{org}/packages/{package_type}/{package_name}/versions",
			{},
			{ renamed: ["packages", "getAllPackageVersionsForPackageOwnedByOrg"] }
		],
		getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: [
			"GET /user/packages/{package_type}/{package_name}/versions",
			{},
			{ renamed: ["packages", "getAllPackageVersionsForPackageOwnedByAuthenticatedUser"] }
		],
		getAllPackageVersionsForPackageOwnedByAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions"],
		getAllPackageVersionsForPackageOwnedByOrg: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions"],
		getAllPackageVersionsForPackageOwnedByUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions"],
		getPackageForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}"],
		getPackageForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}"],
		getPackageForUser: ["GET /users/{username}/packages/{package_type}/{package_name}"],
		getPackageVersionForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}"],
		getPackageVersionForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"],
		getPackageVersionForUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"],
		listDockerMigrationConflictingPackagesForAuthenticatedUser: ["GET /user/docker/conflicts"],
		listDockerMigrationConflictingPackagesForOrganization: ["GET /orgs/{org}/docker/conflicts"],
		listDockerMigrationConflictingPackagesForUser: ["GET /users/{username}/docker/conflicts"],
		listPackagesForAuthenticatedUser: ["GET /user/packages"],
		listPackagesForOrganization: ["GET /orgs/{org}/packages"],
		listPackagesForUser: ["GET /users/{username}/packages"],
		restorePackageForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/restore{?token}"],
		restorePackageForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}"],
		restorePackageForUser: ["POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}"],
		restorePackageVersionForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"],
		restorePackageVersionForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"],
		restorePackageVersionForUser: ["POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"]
	},
	privateRegistries: {
		createOrgPrivateRegistry: ["POST /orgs/{org}/private-registries"],
		deleteOrgPrivateRegistry: ["DELETE /orgs/{org}/private-registries/{secret_name}"],
		getOrgPrivateRegistry: ["GET /orgs/{org}/private-registries/{secret_name}"],
		getOrgPublicKey: ["GET /orgs/{org}/private-registries/public-key"],
		listOrgPrivateRegistries: ["GET /orgs/{org}/private-registries"],
		updateOrgPrivateRegistry: ["PATCH /orgs/{org}/private-registries/{secret_name}"]
	},
	projects: {
		addItemForOrg: ["POST /orgs/{org}/projectsV2/{project_number}/items"],
		addItemForUser: ["POST /users/{username}/projectsV2/{project_number}/items"],
		deleteItemForOrg: ["DELETE /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],
		deleteItemForUser: ["DELETE /users/{username}/projectsV2/{project_number}/items/{item_id}"],
		getFieldForOrg: ["GET /orgs/{org}/projectsV2/{project_number}/fields/{field_id}"],
		getFieldForUser: ["GET /users/{username}/projectsV2/{project_number}/fields/{field_id}"],
		getForOrg: ["GET /orgs/{org}/projectsV2/{project_number}"],
		getForUser: ["GET /users/{username}/projectsV2/{project_number}"],
		getOrgItem: ["GET /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],
		getUserItem: ["GET /users/{username}/projectsV2/{project_number}/items/{item_id}"],
		listFieldsForOrg: ["GET /orgs/{org}/projectsV2/{project_number}/fields"],
		listFieldsForUser: ["GET /users/{username}/projectsV2/{project_number}/fields"],
		listForOrg: ["GET /orgs/{org}/projectsV2"],
		listForUser: ["GET /users/{username}/projectsV2"],
		listItemsForOrg: ["GET /orgs/{org}/projectsV2/{project_number}/items"],
		listItemsForUser: ["GET /users/{username}/projectsV2/{project_number}/items"],
		updateItemForOrg: ["PATCH /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],
		updateItemForUser: ["PATCH /users/{username}/projectsV2/{project_number}/items/{item_id}"]
	},
	pulls: {
		checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
		create: ["POST /repos/{owner}/{repo}/pulls"],
		createReplyForReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"],
		createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
		createReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"],
		deletePendingReview: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
		deleteReviewComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
		dismissReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"],
		get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"],
		getReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
		getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
		list: ["GET /repos/{owner}/{repo}/pulls"],
		listCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"],
		listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"],
		listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"],
		listRequestedReviewers: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
		listReviewComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"],
		listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"],
		listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
		merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
		removeRequestedReviewers: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
		requestReviewers: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
		submitReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"],
		update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"],
		updateBranch: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch"],
		updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
		updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"]
	},
	rateLimit: { get: ["GET /rate_limit"] },
	reactions: {
		createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions"],
		createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions"],
		createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"],
		createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"],
		createForRelease: ["POST /repos/{owner}/{repo}/releases/{release_id}/reactions"],
		createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"],
		createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"],
		deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}"],
		deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}"],
		deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}"],
		deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}"],
		deleteForRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}"],
		deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}"],
		deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}"],
		listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions"],
		listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"],
		listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"],
		listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"],
		listForRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}/reactions"],
		listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"],
		listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"]
	},
	repos: {
		acceptInvitation: [
			"PATCH /user/repository_invitations/{invitation_id}",
			{},
			{ renamed: ["repos", "acceptInvitationForAuthenticatedUser"] }
		],
		acceptInvitationForAuthenticatedUser: ["PATCH /user/repository_invitations/{invitation_id}"],
		addAppAccessRestrictions: [
			"POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",
			{},
			{ mapToData: "apps" }
		],
		addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"],
		addStatusCheckContexts: [
			"POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",
			{},
			{ mapToData: "contexts" }
		],
		addTeamAccessRestrictions: [
			"POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",
			{},
			{ mapToData: "teams" }
		],
		addUserAccessRestrictions: [
			"POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",
			{},
			{ mapToData: "users" }
		],
		cancelPagesDeployment: ["POST /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}/cancel"],
		checkAutomatedSecurityFixes: ["GET /repos/{owner}/{repo}/automated-security-fixes"],
		checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"],
		checkImmutableReleases: ["GET /repos/{owner}/{repo}/immutable-releases"],
		checkPrivateVulnerabilityReporting: ["GET /repos/{owner}/{repo}/private-vulnerability-reporting"],
		checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts"],
		codeownersErrors: ["GET /repos/{owner}/{repo}/codeowners/errors"],
		compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"],
		compareCommitsWithBasehead: ["GET /repos/{owner}/{repo}/compare/{basehead}"],
		createAttestation: ["POST /repos/{owner}/{repo}/attestations"],
		createAutolink: ["POST /repos/{owner}/{repo}/autolinks"],
		createCommitComment: ["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"],
		createCommitSignatureProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"],
		createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"],
		createDeployKey: ["POST /repos/{owner}/{repo}/keys"],
		createDeployment: ["POST /repos/{owner}/{repo}/deployments"],
		createDeploymentBranchPolicy: ["POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"],
		createDeploymentProtectionRule: ["POST /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"],
		createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],
		createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"],
		createForAuthenticatedUser: ["POST /user/repos"],
		createFork: ["POST /repos/{owner}/{repo}/forks"],
		createInOrg: ["POST /orgs/{org}/repos"],
		createOrUpdateEnvironment: ["PUT /repos/{owner}/{repo}/environments/{environment_name}"],
		createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"],
		createOrgRuleset: ["POST /orgs/{org}/rulesets"],
		createPagesDeployment: ["POST /repos/{owner}/{repo}/pages/deployments"],
		createPagesSite: ["POST /repos/{owner}/{repo}/pages"],
		createRelease: ["POST /repos/{owner}/{repo}/releases"],
		createRepoRuleset: ["POST /repos/{owner}/{repo}/rulesets"],
		createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate"],
		createWebhook: ["POST /repos/{owner}/{repo}/hooks"],
		customPropertiesForReposCreateOrUpdateRepositoryValues: ["PATCH /repos/{owner}/{repo}/properties/values"],
		customPropertiesForReposGetRepositoryValues: ["GET /repos/{owner}/{repo}/properties/values"],
		declineInvitation: [
			"DELETE /user/repository_invitations/{invitation_id}",
			{},
			{ renamed: ["repos", "declineInvitationForAuthenticatedUser"] }
		],
		declineInvitationForAuthenticatedUser: ["DELETE /user/repository_invitations/{invitation_id}"],
		delete: ["DELETE /repos/{owner}/{repo}"],
		deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],
		deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
		deleteAnEnvironment: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}"],
		deleteAutolink: ["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"],
		deleteBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"],
		deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"],
		deleteCommitSignatureProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"],
		deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"],
		deleteDeployment: ["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"],
		deleteDeploymentBranchPolicy: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"],
		deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"],
		deleteInvitation: ["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"],
		deleteOrgRuleset: ["DELETE /orgs/{org}/rulesets/{ruleset_id}"],
		deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages"],
		deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
		deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"],
		deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"],
		deleteRepoRuleset: ["DELETE /repos/{owner}/{repo}/rulesets/{ruleset_id}"],
		deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"],
		disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes"],
		disableDeploymentProtectionRule: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"],
		disableImmutableReleases: ["DELETE /repos/{owner}/{repo}/immutable-releases"],
		disablePrivateVulnerabilityReporting: ["DELETE /repos/{owner}/{repo}/private-vulnerability-reporting"],
		disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts"],
		downloadArchive: [
			"GET /repos/{owner}/{repo}/zipball/{ref}",
			{},
			{ renamed: ["repos", "downloadZipballArchive"] }
		],
		downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"],
		downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"],
		enableAutomatedSecurityFixes: ["PUT /repos/{owner}/{repo}/automated-security-fixes"],
		enableImmutableReleases: ["PUT /repos/{owner}/{repo}/immutable-releases"],
		enablePrivateVulnerabilityReporting: ["PUT /repos/{owner}/{repo}/private-vulnerability-reporting"],
		enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts"],
		generateReleaseNotes: ["POST /repos/{owner}/{repo}/releases/generate-notes"],
		get: ["GET /repos/{owner}/{repo}"],
		getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],
		getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
		getAllDeploymentProtectionRules: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"],
		getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"],
		getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"],
		getAllTopics: ["GET /repos/{owner}/{repo}/topics"],
		getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"],
		getAutolink: ["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"],
		getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"],
		getBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection"],
		getBranchRules: ["GET /repos/{owner}/{repo}/rules/branches/{branch}"],
		getClones: ["GET /repos/{owner}/{repo}/traffic/clones"],
		getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"],
		getCollaboratorPermissionLevel: ["GET /repos/{owner}/{repo}/collaborators/{username}/permission"],
		getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"],
		getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"],
		getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"],
		getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"],
		getCommitSignatureProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"],
		getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"],
		getContent: ["GET /repos/{owner}/{repo}/contents/{path}"],
		getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"],
		getCustomDeploymentProtectionRule: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"],
		getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"],
		getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"],
		getDeploymentBranchPolicy: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"],
		getDeploymentStatus: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"],
		getEnvironment: ["GET /repos/{owner}/{repo}/environments/{environment_name}"],
		getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"],
		getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"],
		getOrgRuleSuite: ["GET /orgs/{org}/rulesets/rule-suites/{rule_suite_id}"],
		getOrgRuleSuites: ["GET /orgs/{org}/rulesets/rule-suites"],
		getOrgRuleset: ["GET /orgs/{org}/rulesets/{ruleset_id}"],
		getOrgRulesets: ["GET /orgs/{org}/rulesets"],
		getPages: ["GET /repos/{owner}/{repo}/pages"],
		getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"],
		getPagesDeployment: ["GET /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}"],
		getPagesHealthCheck: ["GET /repos/{owner}/{repo}/pages/health"],
		getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"],
		getPullRequestReviewProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
		getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"],
		getReadme: ["GET /repos/{owner}/{repo}/readme"],
		getReadmeInDirectory: ["GET /repos/{owner}/{repo}/readme/{dir}"],
		getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"],
		getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"],
		getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"],
		getRepoRuleSuite: ["GET /repos/{owner}/{repo}/rulesets/rule-suites/{rule_suite_id}"],
		getRepoRuleSuites: ["GET /repos/{owner}/{repo}/rulesets/rule-suites"],
		getRepoRuleset: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}"],
		getRepoRulesetHistory: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history"],
		getRepoRulesetVersion: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history/{version_id}"],
		getRepoRulesets: ["GET /repos/{owner}/{repo}/rulesets"],
		getStatusChecksProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
		getTeamsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"],
		getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"],
		getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"],
		getUsersWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"],
		getViews: ["GET /repos/{owner}/{repo}/traffic/views"],
		getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"],
		getWebhookConfigForRepo: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/config"],
		getWebhookDelivery: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}"],
		listActivities: ["GET /repos/{owner}/{repo}/activity"],
		listAttestations: ["GET /repos/{owner}/{repo}/attestations/{subject_digest}"],
		listAutolinks: ["GET /repos/{owner}/{repo}/autolinks"],
		listBranches: ["GET /repos/{owner}/{repo}/branches"],
		listBranchesForHeadCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head"],
		listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"],
		listCommentsForCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"],
		listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"],
		listCommitStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses"],
		listCommits: ["GET /repos/{owner}/{repo}/commits"],
		listContributors: ["GET /repos/{owner}/{repo}/contributors"],
		listCustomDeploymentRuleIntegrations: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps"],
		listDeployKeys: ["GET /repos/{owner}/{repo}/keys"],
		listDeploymentBranchPolicies: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"],
		listDeploymentStatuses: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],
		listDeployments: ["GET /repos/{owner}/{repo}/deployments"],
		listForAuthenticatedUser: ["GET /user/repos"],
		listForOrg: ["GET /orgs/{org}/repos"],
		listForUser: ["GET /users/{username}/repos"],
		listForks: ["GET /repos/{owner}/{repo}/forks"],
		listInvitations: ["GET /repos/{owner}/{repo}/invitations"],
		listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"],
		listLanguages: ["GET /repos/{owner}/{repo}/languages"],
		listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"],
		listPublic: ["GET /repositories"],
		listPullRequestsAssociatedWithCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls"],
		listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"],
		listReleases: ["GET /repos/{owner}/{repo}/releases"],
		listTags: ["GET /repos/{owner}/{repo}/tags"],
		listTeams: ["GET /repos/{owner}/{repo}/teams"],
		listWebhookDeliveries: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries"],
		listWebhooks: ["GET /repos/{owner}/{repo}/hooks"],
		merge: ["POST /repos/{owner}/{repo}/merges"],
		mergeUpstream: ["POST /repos/{owner}/{repo}/merge-upstream"],
		pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"],
		redeliverWebhookDelivery: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"],
		removeAppAccessRestrictions: [
			"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",
			{},
			{ mapToData: "apps" }
		],
		removeCollaborator: ["DELETE /repos/{owner}/{repo}/collaborators/{username}"],
		removeStatusCheckContexts: [
			"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",
			{},
			{ mapToData: "contexts" }
		],
		removeStatusCheckProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
		removeTeamAccessRestrictions: [
			"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",
			{},
			{ mapToData: "teams" }
		],
		removeUserAccessRestrictions: [
			"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",
			{},
			{ mapToData: "users" }
		],
		renameBranch: ["POST /repos/{owner}/{repo}/branches/{branch}/rename"],
		replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics"],
		requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"],
		setAdminBranchProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
		setAppAccessRestrictions: [
			"PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",
			{},
			{ mapToData: "apps" }
		],
		setStatusCheckContexts: [
			"PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",
			{},
			{ mapToData: "contexts" }
		],
		setTeamAccessRestrictions: [
			"PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",
			{},
			{ mapToData: "teams" }
		],
		setUserAccessRestrictions: [
			"PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",
			{},
			{ mapToData: "users" }
		],
		testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"],
		transfer: ["POST /repos/{owner}/{repo}/transfer"],
		update: ["PATCH /repos/{owner}/{repo}"],
		updateBranchProtection: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection"],
		updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"],
		updateDeploymentBranchPolicy: ["PUT /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"],
		updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"],
		updateInvitation: ["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"],
		updateOrgRuleset: ["PUT /orgs/{org}/rulesets/{ruleset_id}"],
		updatePullRequestReviewProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
		updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"],
		updateReleaseAsset: ["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"],
		updateRepoRuleset: ["PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}"],
		updateStatusCheckPotection: [
			"PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks",
			{},
			{ renamed: ["repos", "updateStatusCheckProtection"] }
		],
		updateStatusCheckProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
		updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"],
		updateWebhookConfigForRepo: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"],
		uploadReleaseAsset: ["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", { baseUrl: "https://uploads.github.com" }]
	},
	search: {
		code: ["GET /search/code"],
		commits: ["GET /search/commits"],
		issuesAndPullRequests: ["GET /search/issues"],
		labels: ["GET /search/labels"],
		repos: ["GET /search/repositories"],
		topics: ["GET /search/topics"],
		users: ["GET /search/users"]
	},
	secretScanning: {
		createPushProtectionBypass: ["POST /repos/{owner}/{repo}/secret-scanning/push-protection-bypasses"],
		getAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"],
		getScanHistory: ["GET /repos/{owner}/{repo}/secret-scanning/scan-history"],
		listAlertsForOrg: ["GET /orgs/{org}/secret-scanning/alerts"],
		listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"],
		listLocationsForAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations"],
		listOrgPatternConfigs: ["GET /orgs/{org}/secret-scanning/pattern-configurations"],
		updateAlert: ["PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"],
		updateOrgPatternConfigs: ["PATCH /orgs/{org}/secret-scanning/pattern-configurations"]
	},
	securityAdvisories: {
		createFork: ["POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/forks"],
		createPrivateVulnerabilityReport: ["POST /repos/{owner}/{repo}/security-advisories/reports"],
		createRepositoryAdvisory: ["POST /repos/{owner}/{repo}/security-advisories"],
		createRepositoryAdvisoryCveRequest: ["POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/cve"],
		getGlobalAdvisory: ["GET /advisories/{ghsa_id}"],
		getRepositoryAdvisory: ["GET /repos/{owner}/{repo}/security-advisories/{ghsa_id}"],
		listGlobalAdvisories: ["GET /advisories"],
		listOrgRepositoryAdvisories: ["GET /orgs/{org}/security-advisories"],
		listRepositoryAdvisories: ["GET /repos/{owner}/{repo}/security-advisories"],
		updateRepositoryAdvisory: ["PATCH /repos/{owner}/{repo}/security-advisories/{ghsa_id}"]
	},
	teams: {
		addOrUpdateMembershipForUserInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"],
		addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
		checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
		create: ["POST /orgs/{org}/teams"],
		createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],
		createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"],
		deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
		deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
		deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"],
		getByName: ["GET /orgs/{org}/teams/{team_slug}"],
		getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
		getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
		getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"],
		list: ["GET /orgs/{org}/teams"],
		listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"],
		listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],
		listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"],
		listForAuthenticatedUser: ["GET /user/teams"],
		listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"],
		listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"],
		listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"],
		removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"],
		removeRepoInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
		updateDiscussionCommentInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
		updateDiscussionInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
		updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"]
	},
	users: {
		addEmailForAuthenticated: [
			"POST /user/emails",
			{},
			{ renamed: ["users", "addEmailForAuthenticatedUser"] }
		],
		addEmailForAuthenticatedUser: ["POST /user/emails"],
		addSocialAccountForAuthenticatedUser: ["POST /user/social_accounts"],
		block: ["PUT /user/blocks/{username}"],
		checkBlocked: ["GET /user/blocks/{username}"],
		checkFollowingForUser: ["GET /users/{username}/following/{target_user}"],
		checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"],
		createGpgKeyForAuthenticated: [
			"POST /user/gpg_keys",
			{},
			{ renamed: ["users", "createGpgKeyForAuthenticatedUser"] }
		],
		createGpgKeyForAuthenticatedUser: ["POST /user/gpg_keys"],
		createPublicSshKeyForAuthenticated: [
			"POST /user/keys",
			{},
			{ renamed: ["users", "createPublicSshKeyForAuthenticatedUser"] }
		],
		createPublicSshKeyForAuthenticatedUser: ["POST /user/keys"],
		createSshSigningKeyForAuthenticatedUser: ["POST /user/ssh_signing_keys"],
		deleteAttestationsBulk: ["POST /users/{username}/attestations/delete-request"],
		deleteAttestationsById: ["DELETE /users/{username}/attestations/{attestation_id}"],
		deleteAttestationsBySubjectDigest: ["DELETE /users/{username}/attestations/digest/{subject_digest}"],
		deleteEmailForAuthenticated: [
			"DELETE /user/emails",
			{},
			{ renamed: ["users", "deleteEmailForAuthenticatedUser"] }
		],
		deleteEmailForAuthenticatedUser: ["DELETE /user/emails"],
		deleteGpgKeyForAuthenticated: [
			"DELETE /user/gpg_keys/{gpg_key_id}",
			{},
			{ renamed: ["users", "deleteGpgKeyForAuthenticatedUser"] }
		],
		deleteGpgKeyForAuthenticatedUser: ["DELETE /user/gpg_keys/{gpg_key_id}"],
		deletePublicSshKeyForAuthenticated: [
			"DELETE /user/keys/{key_id}",
			{},
			{ renamed: ["users", "deletePublicSshKeyForAuthenticatedUser"] }
		],
		deletePublicSshKeyForAuthenticatedUser: ["DELETE /user/keys/{key_id}"],
		deleteSocialAccountForAuthenticatedUser: ["DELETE /user/social_accounts"],
		deleteSshSigningKeyForAuthenticatedUser: ["DELETE /user/ssh_signing_keys/{ssh_signing_key_id}"],
		follow: ["PUT /user/following/{username}"],
		getAuthenticated: ["GET /user"],
		getById: ["GET /user/{account_id}"],
		getByUsername: ["GET /users/{username}"],
		getContextForUser: ["GET /users/{username}/hovercard"],
		getGpgKeyForAuthenticated: [
			"GET /user/gpg_keys/{gpg_key_id}",
			{},
			{ renamed: ["users", "getGpgKeyForAuthenticatedUser"] }
		],
		getGpgKeyForAuthenticatedUser: ["GET /user/gpg_keys/{gpg_key_id}"],
		getPublicSshKeyForAuthenticated: [
			"GET /user/keys/{key_id}",
			{},
			{ renamed: ["users", "getPublicSshKeyForAuthenticatedUser"] }
		],
		getPublicSshKeyForAuthenticatedUser: ["GET /user/keys/{key_id}"],
		getSshSigningKeyForAuthenticatedUser: ["GET /user/ssh_signing_keys/{ssh_signing_key_id}"],
		list: ["GET /users"],
		listAttestations: ["GET /users/{username}/attestations/{subject_digest}"],
		listAttestationsBulk: ["POST /users/{username}/attestations/bulk-list{?per_page,before,after}"],
		listBlockedByAuthenticated: [
			"GET /user/blocks",
			{},
			{ renamed: ["users", "listBlockedByAuthenticatedUser"] }
		],
		listBlockedByAuthenticatedUser: ["GET /user/blocks"],
		listEmailsForAuthenticated: [
			"GET /user/emails",
			{},
			{ renamed: ["users", "listEmailsForAuthenticatedUser"] }
		],
		listEmailsForAuthenticatedUser: ["GET /user/emails"],
		listFollowedByAuthenticated: [
			"GET /user/following",
			{},
			{ renamed: ["users", "listFollowedByAuthenticatedUser"] }
		],
		listFollowedByAuthenticatedUser: ["GET /user/following"],
		listFollowersForAuthenticatedUser: ["GET /user/followers"],
		listFollowersForUser: ["GET /users/{username}/followers"],
		listFollowingForUser: ["GET /users/{username}/following"],
		listGpgKeysForAuthenticated: [
			"GET /user/gpg_keys",
			{},
			{ renamed: ["users", "listGpgKeysForAuthenticatedUser"] }
		],
		listGpgKeysForAuthenticatedUser: ["GET /user/gpg_keys"],
		listGpgKeysForUser: ["GET /users/{username}/gpg_keys"],
		listPublicEmailsForAuthenticated: [
			"GET /user/public_emails",
			{},
			{ renamed: ["users", "listPublicEmailsForAuthenticatedUser"] }
		],
		listPublicEmailsForAuthenticatedUser: ["GET /user/public_emails"],
		listPublicKeysForUser: ["GET /users/{username}/keys"],
		listPublicSshKeysForAuthenticated: [
			"GET /user/keys",
			{},
			{ renamed: ["users", "listPublicSshKeysForAuthenticatedUser"] }
		],
		listPublicSshKeysForAuthenticatedUser: ["GET /user/keys"],
		listSocialAccountsForAuthenticatedUser: ["GET /user/social_accounts"],
		listSocialAccountsForUser: ["GET /users/{username}/social_accounts"],
		listSshSigningKeysForAuthenticatedUser: ["GET /user/ssh_signing_keys"],
		listSshSigningKeysForUser: ["GET /users/{username}/ssh_signing_keys"],
		setPrimaryEmailVisibilityForAuthenticated: [
			"PATCH /user/email/visibility",
			{},
			{ renamed: ["users", "setPrimaryEmailVisibilityForAuthenticatedUser"] }
		],
		setPrimaryEmailVisibilityForAuthenticatedUser: ["PATCH /user/email/visibility"],
		unblock: ["DELETE /user/blocks/{username}"],
		unfollow: ["DELETE /user/following/{username}"],
		updateAuthenticated: ["PATCH /user"]
	}
};
//#endregion
//#region node_modules/.pnpm/@octokit+plugin-rest-endpoint-methods@17.0.0_@octokit+core@7.0.7/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/endpoints-to-methods.js
var endpointMethodsMap = /* @__PURE__ */ new Map();
for (const [scope, endpoints] of Object.entries(endpoints_default)) for (const [methodName, endpoint] of Object.entries(endpoints)) {
	const [route, defaults, decorations] = endpoint;
	const [method, url] = route.split(/ /);
	const endpointDefaults = Object.assign({
		method,
		url
	}, defaults);
	if (!endpointMethodsMap.has(scope)) endpointMethodsMap.set(scope, /* @__PURE__ */ new Map());
	endpointMethodsMap.get(scope).set(methodName, {
		scope,
		methodName,
		endpointDefaults,
		decorations
	});
}
var handler = {
	has({ scope }, methodName) {
		return endpointMethodsMap.get(scope).has(methodName);
	},
	getOwnPropertyDescriptor(target, methodName) {
		return {
			value: this.get(target, methodName),
			configurable: true,
			writable: true,
			enumerable: true
		};
	},
	defineProperty(target, methodName, descriptor) {
		Object.defineProperty(target.cache, methodName, descriptor);
		return true;
	},
	deleteProperty(target, methodName) {
		delete target.cache[methodName];
		return true;
	},
	ownKeys({ scope }) {
		return [...endpointMethodsMap.get(scope).keys()];
	},
	set(target, methodName, value) {
		return target.cache[methodName] = value;
	},
	get({ octokit, scope, cache }, methodName) {
		if (cache[methodName]) return cache[methodName];
		const method = endpointMethodsMap.get(scope).get(methodName);
		if (!method) return;
		const { endpointDefaults, decorations } = method;
		if (decorations) cache[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations);
		else cache[methodName] = octokit.request.defaults(endpointDefaults);
		return cache[methodName];
	}
};
function endpointsToMethods(octokit) {
	const newMethods = {};
	for (const scope of endpointMethodsMap.keys()) newMethods[scope] = new Proxy({
		octokit,
		scope,
		cache: {}
	}, handler);
	return newMethods;
}
function decorate(octokit, scope, methodName, defaults, decorations) {
	const requestWithDefaults = octokit.request.defaults(defaults);
	function withDecorations(...args) {
		let options = requestWithDefaults.endpoint.merge(...args);
		if (decorations.mapToData) {
			options = Object.assign({}, options, {
				data: options[decorations.mapToData],
				[decorations.mapToData]: void 0
			});
			return requestWithDefaults(options);
		}
		if (decorations.renamed) {
			const [newScope, newMethodName] = decorations.renamed;
			octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`);
		}
		if (decorations.deprecated) octokit.log.warn(decorations.deprecated);
		if (decorations.renamedParameters) {
			const options2 = requestWithDefaults.endpoint.merge(...args);
			for (const [name, alias] of Object.entries(decorations.renamedParameters)) if (name in options2) {
				octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`);
				if (!(alias in options2)) options2[alias] = options2[name];
				delete options2[name];
			}
			return requestWithDefaults(options2);
		}
		return requestWithDefaults(...args);
	}
	return Object.assign(withDecorations, requestWithDefaults);
}
//#endregion
//#region node_modules/.pnpm/@octokit+plugin-rest-endpoint-methods@17.0.0_@octokit+core@7.0.7/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/index.js
function restEndpointMethods(octokit) {
	return { rest: endpointsToMethods(octokit) };
}
restEndpointMethods.VERSION = VERSION$1;
function legacyRestEndpointMethods(octokit) {
	const api = endpointsToMethods(octokit);
	return {
		...api,
		rest: api
	};
}
legacyRestEndpointMethods.VERSION = VERSION$1;
//#endregion
//#region node_modules/.pnpm/@octokit+plugin-paginate-rest@14.0.0_@octokit+core@7.0.7/node_modules/@octokit/plugin-paginate-rest/dist-bundle/index.js
var VERSION = "0.0.0-development";
function normalizePaginatedListResponse(response) {
	if (!response.data) return {
		...response,
		data: []
	};
	if (!(("total_count" in response.data || "total_commits" in response.data) && !("url" in response.data))) return response;
	const incompleteResults = response.data.incomplete_results;
	const repositorySelection = response.data.repository_selection;
	const totalCount = response.data.total_count;
	const totalCommits = response.data.total_commits;
	delete response.data.incomplete_results;
	delete response.data.repository_selection;
	delete response.data.total_count;
	delete response.data.total_commits;
	const namespaceKey = Object.keys(response.data)[0];
	response.data = response.data[namespaceKey];
	if (typeof incompleteResults !== "undefined") response.data.incomplete_results = incompleteResults;
	if (typeof repositorySelection !== "undefined") response.data.repository_selection = repositorySelection;
	response.data.total_count = totalCount;
	response.data.total_commits = totalCommits;
	return response;
}
function iterator(octokit, route, parameters) {
	const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters);
	const requestMethod = typeof route === "function" ? route : octokit.request;
	const method = options.method;
	const headers = options.headers;
	let url = options.url;
	return { [Symbol.asyncIterator]: () => ({ async next() {
		if (!url) return { done: true };
		try {
			const normalizedResponse = normalizePaginatedListResponse(await requestMethod({
				method,
				url,
				headers
			}));
			url = ((normalizedResponse.headers.link || "").match(/<([^<>]+)>;\s*rel="next"/) || [])[1];
			if (!url && "total_commits" in normalizedResponse.data) {
				const parsedUrl = new URL(normalizedResponse.url);
				const params = parsedUrl.searchParams;
				const page = parseInt(params.get("page") || "1", 10);
				if (page * parseInt(params.get("per_page") || "250", 10) < normalizedResponse.data.total_commits) {
					params.set("page", String(page + 1));
					url = parsedUrl.toString();
				}
			}
			return { value: normalizedResponse };
		} catch (error) {
			if (error.status !== 409) throw error;
			url = "";
			return { value: {
				status: 200,
				headers: {},
				data: []
			} };
		}
	} }) };
}
function paginate(octokit, route, parameters, mapFn) {
	if (typeof parameters === "function") {
		mapFn = parameters;
		parameters = void 0;
	}
	return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn);
}
function gather(octokit, results, iterator2, mapFn) {
	return iterator2.next().then((result) => {
		if (result.done) return results;
		let earlyExit = false;
		function done() {
			earlyExit = true;
		}
		results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data);
		if (earlyExit) return results;
		return gather(octokit, results, iterator2, mapFn);
	});
}
Object.assign(paginate, { iterator });
function paginateRest(octokit) {
	return { paginate: Object.assign(paginate.bind(null, octokit), { iterator: iterator.bind(null, octokit) }) };
}
paginateRest.VERSION = VERSION;
new Context();
var baseUrl = getApiBaseUrl();
var defaults = {
	baseUrl,
	request: {
		agent: getProxyAgent(baseUrl),
		fetch: getProxyFetch(baseUrl)
	}
};
Octokit.plugin(restEndpointMethods, paginateRest).defaults(defaults);
new Context();
//#endregion
//#region node_modules/.pnpm/@actions-rs-plus+core@0.10.0_supports-color@7.2.0/node_modules/@actions-rs-plus/core/dist/commands/base-program.js
var BaseProgram = class {
	path;
	constructor(path) {
		this.path = path;
	}
	call(arguments_, options) {
		return exec(this.path, arguments_, options);
	}
};
//#endregion
//#region node_modules/.pnpm/@actions-rs-plus+core@0.10.0_supports-color@7.2.0/node_modules/@actions-rs-plus/core/dist/commands/crates.js
async function resolveVersion(crate) {
	const url = `https://crates.io/api/v1/crates/${crate}`;
	const response = await new HttpClient("@actions-rs-plus (https://github.com/actions-rs-plus/)").getJson(url);
	if (response.result === null) throw new Error(`Unable to fetch latest crate version of "${crate}"`);
	if ("errors" in response.result) throw new Error(`Unable to fetch latest crate version of "${crate}", server returned ${JSON.stringify(response.result, null, 2)}`);
	if (response.result.crate?.newest_version === void 0) throw new Error(`Unable to fetch latest crate version of "${crate}"`);
	return response.result.crate.newest_version;
}
//#endregion
//#region node_modules/.pnpm/@actions+glob@0.6.1/node_modules/@actions/glob/lib/internal-glob-options-helper.js
/**
* Returns a copy with defaults filled in.
*/
function getOptions(copy) {
	const result = {
		followSymbolicLinks: true,
		implicitDescendants: true,
		matchDirectories: true,
		omitBrokenSymbolicLinks: true,
		excludeHiddenFiles: false
	};
	if (copy) {
		if (typeof copy.followSymbolicLinks === "boolean") {
			result.followSymbolicLinks = copy.followSymbolicLinks;
			debug(`followSymbolicLinks '${result.followSymbolicLinks}'`);
		}
		if (typeof copy.implicitDescendants === "boolean") {
			result.implicitDescendants = copy.implicitDescendants;
			debug(`implicitDescendants '${result.implicitDescendants}'`);
		}
		if (typeof copy.matchDirectories === "boolean") {
			result.matchDirectories = copy.matchDirectories;
			debug(`matchDirectories '${result.matchDirectories}'`);
		}
		if (typeof copy.omitBrokenSymbolicLinks === "boolean") {
			result.omitBrokenSymbolicLinks = copy.omitBrokenSymbolicLinks;
			debug(`omitBrokenSymbolicLinks '${result.omitBrokenSymbolicLinks}'`);
		}
		if (typeof copy.excludeHiddenFiles === "boolean") {
			result.excludeHiddenFiles = copy.excludeHiddenFiles;
			debug(`excludeHiddenFiles '${result.excludeHiddenFiles}'`);
		}
	}
	return result;
}
//#endregion
//#region node_modules/.pnpm/@actions+glob@0.6.1/node_modules/@actions/glob/lib/internal-path-helper.js
var IS_WINDOWS$6 = process.platform === "win32";
/**
* Similar to path.dirname except normalizes the path separators and slightly better handling for Windows UNC paths.
*
* For example, on Linux/macOS:
* - `/               => /`
* - `/hello          => /`
*
* For example, on Windows:
* - `C:\             => C:\`
* - `C:\hello        => C:\`
* - `C:              => C:`
* - `C:hello         => C:`
* - `\               => \`
* - `\hello          => \`
* - `\\hello         => \\hello`
* - `\\hello\world   => \\hello\world`
*/
function dirname(p) {
	p = safeTrimTrailingSeparator(p);
	if (IS_WINDOWS$6 && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p)) return p;
	let result = path$2.dirname(p);
	if (IS_WINDOWS$6 && /^\\\\[^\\]+\\[^\\]+\\$/.test(result)) result = safeTrimTrailingSeparator(result);
	return result;
}
/**
* Roots the path if not already rooted. On Windows, relative roots like `\`
* or `C:` are expanded based on the current working directory.
*/
function ensureAbsoluteRoot(root, itemPath) {
	assert(root, `ensureAbsoluteRoot parameter 'root' must not be empty`);
	assert(itemPath, `ensureAbsoluteRoot parameter 'itemPath' must not be empty`);
	if (hasAbsoluteRoot(itemPath)) return itemPath;
	if (IS_WINDOWS$6) {
		if (itemPath.match(/^[A-Z]:[^\\/]|^[A-Z]:$/i)) {
			let cwd = process.cwd();
			assert(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`);
			if (itemPath[0].toUpperCase() === cwd[0].toUpperCase()) {
				if (itemPath.length === 2) return `${itemPath[0]}:\\${cwd.substr(3)}`;
				else {
					if (!cwd.endsWith("\\")) cwd += "\\";
					return `${itemPath[0]}:\\${cwd.substr(3)}${itemPath.substr(2)}`;
				}
			} else return `${itemPath[0]}:\\${itemPath.substr(2)}`;
		} else if (normalizeSeparators(itemPath).match(/^\\$|^\\[^\\]/)) {
			const cwd = process.cwd();
			assert(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`);
			return `${cwd[0]}:\\${itemPath.substr(1)}`;
		}
	}
	assert(hasAbsoluteRoot(root), `ensureAbsoluteRoot parameter 'root' must have an absolute root`);
	if (root.endsWith("/") || IS_WINDOWS$6 && root.endsWith("\\")) {} else root += path$2.sep;
	return root + itemPath;
}
/**
* On Linux/macOS, true if path starts with `/`. On Windows, true for paths like:
* `\\hello\share` and `C:\hello` (and using alternate separator).
*/
function hasAbsoluteRoot(itemPath) {
	assert(itemPath, `hasAbsoluteRoot parameter 'itemPath' must not be empty`);
	itemPath = normalizeSeparators(itemPath);
	if (IS_WINDOWS$6) return itemPath.startsWith("\\\\") || /^[A-Z]:\\/i.test(itemPath);
	return itemPath.startsWith("/");
}
/**
* On Linux/macOS, true if path starts with `/`. On Windows, true for paths like:
* `\`, `\hello`, `\\hello\share`, `C:`, and `C:\hello` (and using alternate separator).
*/
function hasRoot(itemPath) {
	assert(itemPath, `isRooted parameter 'itemPath' must not be empty`);
	itemPath = normalizeSeparators(itemPath);
	if (IS_WINDOWS$6) return itemPath.startsWith("\\") || /^[A-Z]:/i.test(itemPath);
	return itemPath.startsWith("/");
}
/**
* Removes redundant slashes and converts `/` to `\` on Windows
*/
function normalizeSeparators(p) {
	p = p || "";
	if (IS_WINDOWS$6) {
		p = p.replace(/\//g, "\\");
		return (/^\\\\+[^\\]/.test(p) ? "\\" : "") + p.replace(/\\\\+/g, "\\");
	}
	return p.replace(/\/\/+/g, "/");
}
/**
* Normalizes the path separators and trims the trailing separator (when safe).
* For example, `/foo/ => /foo` but `/ => /`
*/
function safeTrimTrailingSeparator(p) {
	if (!p) return "";
	p = normalizeSeparators(p);
	if (!p.endsWith(path$2.sep)) return p;
	if (p === path$2.sep) return p;
	if (IS_WINDOWS$6 && /^[A-Z]:\\$/i.test(p)) return p;
	return p.substr(0, p.length - 1);
}
//#endregion
//#region node_modules/.pnpm/@actions+glob@0.6.1/node_modules/@actions/glob/lib/internal-match-kind.js
/**
* Indicates whether a pattern matches a path
*/
var MatchKind;
(function(MatchKind) {
	/** Not matched */
	MatchKind[MatchKind["None"] = 0] = "None";
	/** Matched if the path is a directory */
	MatchKind[MatchKind["Directory"] = 1] = "Directory";
	/** Matched if the path is a regular file */
	MatchKind[MatchKind["File"] = 2] = "File";
	/** Matched */
	MatchKind[MatchKind["All"] = 3] = "All";
})(MatchKind || (MatchKind = {}));
//#endregion
//#region node_modules/.pnpm/@actions+glob@0.6.1/node_modules/@actions/glob/lib/internal-pattern-helper.js
var IS_WINDOWS$5 = process.platform === "win32";
/**
* Given an array of patterns, returns an array of paths to search.
* Duplicates and paths under other included paths are filtered out.
*/
function getSearchPaths(patterns) {
	patterns = patterns.filter((x) => !x.negate);
	const searchPathMap = {};
	for (const pattern of patterns) {
		const key = IS_WINDOWS$5 ? pattern.searchPath.toUpperCase() : pattern.searchPath;
		searchPathMap[key] = "candidate";
	}
	const result = [];
	for (const pattern of patterns) {
		const key = IS_WINDOWS$5 ? pattern.searchPath.toUpperCase() : pattern.searchPath;
		if (searchPathMap[key] === "included") continue;
		let foundAncestor = false;
		let tempKey = key;
		let parent = dirname(tempKey);
		while (parent !== tempKey) {
			if (searchPathMap[parent]) {
				foundAncestor = true;
				break;
			}
			tempKey = parent;
			parent = dirname(tempKey);
		}
		if (!foundAncestor) {
			result.push(pattern.searchPath);
			searchPathMap[key] = "included";
		}
	}
	return result;
}
/**
* Matches the patterns against the path
*/
function match(patterns, itemPath) {
	let result = MatchKind.None;
	for (const pattern of patterns) if (pattern.negate) result &= ~pattern.match(itemPath);
	else result |= pattern.match(itemPath);
	return result;
}
/**
* Checks whether to descend further into the directory
*/
function partialMatch(patterns, itemPath) {
	return patterns.some((x) => !x.negate && x.partialMatch(itemPath));
}
//#endregion
//#region node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js
var require_concat_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = function(xs, fn) {
		var res = [];
		for (var i = 0; i < xs.length; i++) {
			var x = fn(xs[i], i);
			if (isArray(x)) res.push.apply(res, x);
			else res.push(x);
		}
		return res;
	};
	var isArray = Array.isArray || function(xs) {
		return Object.prototype.toString.call(xs) === "[object Array]";
	};
}));
//#endregion
//#region node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
var require_balanced_match = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = balanced;
	function balanced(a, b, str) {
		if (a instanceof RegExp) a = maybeMatch(a, str);
		if (b instanceof RegExp) b = maybeMatch(b, str);
		var r = range(a, b, str);
		return r && {
			start: r[0],
			end: r[1],
			pre: str.slice(0, r[0]),
			body: str.slice(r[0] + a.length, r[1]),
			post: str.slice(r[1] + b.length)
		};
	}
	function maybeMatch(reg, str) {
		var m = str.match(reg);
		return m ? m[0] : null;
	}
	balanced.range = range;
	function range(a, b, str) {
		var begs;
		var beg;
		var left;
		var right;
		var result;
		var ai = str.indexOf(a);
		var bi = str.indexOf(b, ai + 1);
		var i = ai;
		if (ai >= 0 && bi > 0) {
			if (a === b) return [ai, bi];
			begs = [];
			left = str.length;
			while (i >= 0 && !result) {
				if (i == ai) {
					begs.push(i);
					ai = str.indexOf(a, i + 1);
				} else if (begs.length == 1) result = [begs.pop(), bi];
				else {
					beg = begs.pop();
					if (beg < left) {
						left = beg;
						right = bi;
					}
					bi = str.indexOf(b, i + 1);
				}
				i = ai < bi && ai >= 0 ? ai : bi;
			}
			if (begs.length) result = [left, right];
		}
		return result;
	}
}));
//#endregion
//#region node_modules/.pnpm/brace-expansion@1.1.18/node_modules/brace-expansion/index.js
var require_brace_expansion = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	require_concat_map();
	var balanced = require_balanced_match();
	module.exports = expandTop;
	var escSlash = "\0SLASH" + Math.random() + "\0";
	var escOpen = "\0OPEN" + Math.random() + "\0";
	var escClose = "\0CLOSE" + Math.random() + "\0";
	var escComma = "\0COMMA" + Math.random() + "\0";
	var escPeriod = "\0PERIOD" + Math.random() + "\0";
	var EXPANSION_MAX = 1e5;
	var EXPANSION_MAX_LENGTH = 4e6;
	function numeric(str) {
		return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
	}
	function escapeBraces(str) {
		return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
	}
	function unescapeBraces(str) {
		return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
	}
	function parseCommaParts(str) {
		if (!str) return [""];
		var parts = [];
		var m = balanced("{", "}", str);
		if (!m) return str.split(",");
		var pre = m.pre;
		var body = m.body;
		var post = m.post;
		var p = pre.split(",");
		p[p.length - 1] += "{" + body + "}";
		var postParts = parseCommaParts(post);
		if (post.length) {
			p[p.length - 1] += postParts.shift();
			p.push.apply(p, postParts);
		}
		parts.push.apply(parts, p);
		return parts;
	}
	function expandTop(str, options) {
		if (!str) return [];
		options = options || {};
		var max = options.max == null ? EXPANSION_MAX : options.max;
		var maxLength = options.maxLength == null ? EXPANSION_MAX_LENGTH : options.maxLength;
		if (str.substr(0, 2) === "{}") str = "\\{\\}" + str.substr(2);
		return expand(escapeBraces(str), max, maxLength, true).map(unescapeBraces);
	}
	function embrace(str) {
		return "{" + str + "}";
	}
	function isPadded(el) {
		return /^-?0\d/.test(el);
	}
	function lte(i, y) {
		return i <= y;
	}
	function gte(i, y) {
		return i >= y;
	}
	function combine(acc, base, pre, values, max, maxLength, dropEmpties, outBase) {
		var out = [];
		var length = 0;
		for (var a = 0; a < acc.length; a++) for (var v = 0; v < values.length; v++) {
			if (out.length >= max) return out;
			var expansion = acc[a] + pre + values[v];
			if (dropEmpties && expansion.length === base[a]) continue;
			if (length + expansion.length > maxLength) return out;
			out.push(expansion);
			outBase.push(base[a]);
			length += expansion.length;
		}
		return out;
	}
	function expandSequence(body, isAlphaSequence, max, maxLength) {
		var n = body.split(/\.\./);
		var N = [];
		/* c8 ignore start */
		if (n[0] === void 0 || n[1] === void 0) return N;
		/* c8 ignore stop */
		var x = numeric(n[0]);
		var y = numeric(n[1]);
		var width = Math.max(n[0].length, n[1].length);
		var incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
		var test = lte;
		if (y < x) {
			incr *= -1;
			test = gte;
		}
		var pad = n.some(isPadded);
		var length = 0;
		for (var i = x; test(i, y) && N.length < max; i += incr) {
			var c;
			if (isAlphaSequence) {
				c = String.fromCharCode(i);
				if (c === "\\") c = "";
			} else {
				c = String(i);
				if (pad) {
					var need = width - c.length;
					if (need > 0) {
						var z = new Array(need + 1).join("0");
						if (i < 0) c = "-" + z + c.slice(1);
						else c = z + c;
					}
				}
			}
			if (length + c.length > maxLength) break;
			N.push(c);
			length += c.length;
		}
		return N;
	}
	function expand(str, max, maxLength, isTop) {
		var acc = [""];
		var accBase = [0];
		var dropEmpties = false;
		var firstGroup = true;
		var nextBase;
		for (;;) {
			var m = balanced("{", "}", str);
			if (!m) return combine(acc, accBase, str, [""], max, maxLength, dropEmpties, []);
			var pre = m.pre;
			if (/\$$/.test(pre)) return combine(acc, accBase, str, [""], max, maxLength, dropEmpties, []);
			var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
			var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
			var isSequence = isNumericSequence || isAlphaSequence;
			var isOptions = m.body.indexOf(",") >= 0;
			if (!isSequence && !isOptions) {
				if (m.post.match(/,(?!,).*\}/)) {
					str = m.pre + "{" + m.body + escClose + m.post;
					isTop = true;
					firstGroup = true;
					dropEmpties = false;
					accBase = [];
					for (var b = 0; b < acc.length; b++) accBase.push(acc[b].length);
					continue;
				}
				return combine(acc, accBase, pre + "{" + m.body + "}" + m.post, [""], max, maxLength, dropEmpties, []);
			}
			if (firstGroup) {
				dropEmpties = isTop && !isSequence;
				firstGroup = false;
			}
			var values;
			if (isSequence) values = expandSequence(m.body, isAlphaSequence, max, maxLength);
			else {
				var n = parseCommaParts(m.body);
				if (n.length === 1 && n[0] !== void 0) {
					n = expand(n[0], max, maxLength, false).map(embrace);
					/* c8 ignore start */
					if (n.length === 1) {
						nextBase = [];
						acc = combine(acc, accBase, pre + n[0], [""], max, maxLength, dropEmpties && !m.post.length, nextBase);
						accBase = nextBase;
						if (!m.post.length) break;
						str = m.post;
						continue;
					}
				}
				var dropsEmpties = dropEmpties && !m.post.length && !pre;
				for (var d = 0; dropsEmpties && d < acc.length; d++) if (acc[d].length !== accBase[d]) dropsEmpties = false;
				values = [];
				var valuesLength = 0;
				outer: for (var j = 0; j < n.length; j++) {
					var expanded = expand(n[j], max, maxLength, false);
					for (var k = 0; k < expanded.length; k++) {
						var v = expanded[k];
						if (dropsEmpties && !v) continue;
						if (values.length >= max || valuesLength + v.length > maxLength) break outer;
						values.push(v);
						valuesLength += v.length;
					}
				}
			}
			nextBase = [];
			acc = combine(acc, accBase, pre, values, max, maxLength, dropEmpties && !m.post.length, nextBase);
			accBase = nextBase;
			if (!m.post.length) break;
			str = m.post;
		}
		return acc;
	}
}));
//#endregion
//#region node_modules/.pnpm/@actions+glob@0.6.1/node_modules/@actions/glob/lib/internal-path.js
var import_minimatch = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = minimatch;
	minimatch.Minimatch = Minimatch;
	var path$1 = function() {
		try {
			return __require("path");
		} catch (e) {}
	}() || { sep: "/" };
	minimatch.sep = path$1.sep;
	var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
	var expand = require_brace_expansion();
	var plTypes = {
		"!": {
			open: "(?:(?!(?:",
			close: "))[^/]*?)"
		},
		"?": {
			open: "(?:",
			close: ")?"
		},
		"+": {
			open: "(?:",
			close: ")+"
		},
		"*": {
			open: "(?:",
			close: ")*"
		},
		"@": {
			open: "(?:",
			close: ")"
		}
	};
	var qmark = "[^/]";
	var star = qmark + "*?";
	var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
	var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
	var reSpecials = charSet("().*{}+?[]^$\\!");
	function charSet(s) {
		return s.split("").reduce(function(set, c) {
			set[c] = true;
			return set;
		}, {});
	}
	var slashSplit = /\/+/;
	minimatch.filter = filter;
	function filter(pattern, options) {
		options = options || {};
		return function(p, i, list) {
			return minimatch(p, pattern, options);
		};
	}
	function ext(a, b) {
		b = b || {};
		var t = {};
		Object.keys(a).forEach(function(k) {
			t[k] = a[k];
		});
		Object.keys(b).forEach(function(k) {
			t[k] = b[k];
		});
		return t;
	}
	minimatch.defaults = function(def) {
		if (!def || typeof def !== "object" || !Object.keys(def).length) return minimatch;
		var orig = minimatch;
		var m = function minimatch(p, pattern, options) {
			return orig(p, pattern, ext(def, options));
		};
		m.Minimatch = function Minimatch(pattern, options) {
			return new orig.Minimatch(pattern, ext(def, options));
		};
		m.Minimatch.defaults = function defaults(options) {
			return orig.defaults(ext(def, options)).Minimatch;
		};
		m.filter = function filter(pattern, options) {
			return orig.filter(pattern, ext(def, options));
		};
		m.defaults = function defaults(options) {
			return orig.defaults(ext(def, options));
		};
		m.makeRe = function makeRe(pattern, options) {
			return orig.makeRe(pattern, ext(def, options));
		};
		m.braceExpand = function braceExpand(pattern, options) {
			return orig.braceExpand(pattern, ext(def, options));
		};
		m.match = function(list, pattern, options) {
			return orig.match(list, pattern, ext(def, options));
		};
		return m;
	};
	Minimatch.defaults = function(def) {
		return minimatch.defaults(def).Minimatch;
	};
	function minimatch(p, pattern, options) {
		assertValidPattern(pattern);
		if (!options) options = {};
		if (!options.nocomment && pattern.charAt(0) === "#") return false;
		return new Minimatch(pattern, options).match(p);
	}
	function Minimatch(pattern, options) {
		if (!(this instanceof Minimatch)) return new Minimatch(pattern, options);
		assertValidPattern(pattern);
		if (!options) options = {};
		pattern = pattern.trim();
		if (!options.allowWindowsEscape && path$1.sep !== "/") pattern = pattern.split(path$1.sep).join("/");
		this.options = options;
		this.maxGlobstarRecursion = options.maxGlobstarRecursion !== void 0 ? options.maxGlobstarRecursion : 200;
		this.set = [];
		this.pattern = pattern;
		this.regexp = null;
		this.negate = false;
		this.comment = false;
		this.empty = false;
		this.partial = !!options.partial;
		this.make();
	}
	Minimatch.prototype.debug = function() {};
	Minimatch.prototype.make = make;
	function make() {
		var pattern = this.pattern;
		var options = this.options;
		if (!options.nocomment && pattern.charAt(0) === "#") {
			this.comment = true;
			return;
		}
		if (!pattern) {
			this.empty = true;
			return;
		}
		this.parseNegate();
		var set = this.globSet = this.braceExpand();
		if (options.debug) this.debug = function debug() {
			console.error.apply(console, arguments);
		};
		this.debug(this.pattern, set);
		set = this.globParts = set.map(function(s) {
			return s.split(slashSplit);
		});
		this.debug(this.pattern, set);
		set = set.map(function(s, si, set) {
			return s.map(this.parse, this);
		}, this);
		this.debug(this.pattern, set);
		set = set.filter(function(s) {
			return s.indexOf(false) === -1;
		});
		this.debug(this.pattern, set);
		this.set = set;
	}
	Minimatch.prototype.parseNegate = parseNegate;
	function parseNegate() {
		var pattern = this.pattern;
		var negate = false;
		var options = this.options;
		var negateOffset = 0;
		if (options.nonegate) return;
		for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) {
			negate = !negate;
			negateOffset++;
		}
		if (negateOffset) this.pattern = pattern.substr(negateOffset);
		this.negate = negate;
	}
	minimatch.braceExpand = function(pattern, options) {
		return braceExpand(pattern, options);
	};
	Minimatch.prototype.braceExpand = braceExpand;
	function braceExpand(pattern, options) {
		if (!options) {
			if (this instanceof Minimatch) options = this.options;
			else options = {};
		}
		pattern = typeof pattern === "undefined" ? this.pattern : pattern;
		assertValidPattern(pattern);
		if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) return [pattern];
		return expand(pattern);
	}
	var MAX_PATTERN_LENGTH = 65536;
	var assertValidPattern = function(pattern) {
		if (typeof pattern !== "string") throw new TypeError("invalid pattern");
		if (pattern.length > MAX_PATTERN_LENGTH) throw new TypeError("pattern is too long");
	};
	Minimatch.prototype.parse = parse;
	var SUBPARSE = {};
	function parse(pattern, isSub) {
		assertValidPattern(pattern);
		var options = this.options;
		if (pattern === "**") {
			if (!options.noglobstar) return GLOBSTAR;
			else pattern = "*";
		}
		if (pattern === "") return "";
		var re = "";
		var hasMagic = !!options.nocase;
		var escaping = false;
		var patternListStack = [];
		var negativeLists = [];
		var stateChar;
		var inClass = false;
		var reClassStart = -1;
		var classStart = -1;
		var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
		var self = this;
		function clearStateChar() {
			if (stateChar) {
				switch (stateChar) {
					case "*":
						re += star;
						hasMagic = true;
						break;
					case "?":
						re += qmark;
						hasMagic = true;
						break;
					default: re += "\\" + stateChar;
				}
				self.debug("clearStateChar %j %j", stateChar, re);
				stateChar = false;
			}
		}
		for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
			this.debug("%s	%s %s %j", pattern, i, re, c);
			if (escaping && reSpecials[c]) {
				re += "\\" + c;
				escaping = false;
				continue;
			}
			switch (c) {
				/* istanbul ignore next */
				case "/": return false;
				case "\\":
					clearStateChar();
					escaping = true;
					continue;
				case "?":
				case "*":
				case "+":
				case "@":
				case "!":
					this.debug("%s	%s %s %j <-- stateChar", pattern, i, re, c);
					if (inClass) {
						this.debug("  in class");
						if (c === "!" && i === classStart + 1) c = "^";
						re += c;
						continue;
					}
					if (c === "*" && stateChar === "*") continue;
					self.debug("call clearStateChar %j", stateChar);
					clearStateChar();
					stateChar = c;
					if (options.noext) clearStateChar();
					continue;
				case "(":
					if (inClass) {
						re += "(";
						continue;
					}
					if (!stateChar) {
						re += "\\(";
						continue;
					}
					patternListStack.push({
						type: stateChar,
						start: i - 1,
						reStart: re.length,
						open: plTypes[stateChar].open,
						close: plTypes[stateChar].close
					});
					re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
					this.debug("plType %j %j", stateChar, re);
					stateChar = false;
					continue;
				case ")":
					if (inClass || !patternListStack.length) {
						re += "\\)";
						continue;
					}
					clearStateChar();
					hasMagic = true;
					var pl = patternListStack.pop();
					re += pl.close;
					if (pl.type === "!") negativeLists.push(pl);
					pl.reEnd = re.length;
					continue;
				case "|":
					if (inClass || !patternListStack.length || escaping) {
						re += "\\|";
						escaping = false;
						continue;
					}
					clearStateChar();
					re += "|";
					continue;
				case "[":
					clearStateChar();
					if (inClass) {
						re += "\\" + c;
						continue;
					}
					inClass = true;
					classStart = i;
					reClassStart = re.length;
					re += c;
					continue;
				case "]":
					if (i === classStart + 1 || !inClass) {
						re += "\\" + c;
						escaping = false;
						continue;
					}
					var cs = pattern.substring(classStart + 1, i);
					try {
						RegExp("[" + cs + "]");
					} catch (er) {
						var sp = this.parse(cs, SUBPARSE);
						re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
						hasMagic = hasMagic || sp[1];
						inClass = false;
						continue;
					}
					hasMagic = true;
					inClass = false;
					re += c;
					continue;
				default:
					clearStateChar();
					if (escaping) escaping = false;
					else if (reSpecials[c] && !(c === "^" && inClass)) re += "\\";
					re += c;
			}
		}
		if (inClass) {
			cs = pattern.substr(classStart + 1);
			sp = this.parse(cs, SUBPARSE);
			re = re.substr(0, reClassStart) + "\\[" + sp[0];
			hasMagic = hasMagic || sp[1];
		}
		for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
			var tail = re.slice(pl.reStart + pl.open.length);
			this.debug("setting tail", re, pl);
			tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function(_, $1, $2) {
				if (!$2) $2 = "\\";
				return $1 + $1 + $2 + "|";
			});
			this.debug("tail=%j\n   %s", tail, tail, pl, re);
			var t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
			hasMagic = true;
			re = re.slice(0, pl.reStart) + t + "\\(" + tail;
		}
		clearStateChar();
		if (escaping) re += "\\\\";
		var addPatternStart = false;
		switch (re.charAt(0)) {
			case "[":
			case ".":
			case "(": addPatternStart = true;
		}
		for (var n = negativeLists.length - 1; n > -1; n--) {
			var nl = negativeLists[n];
			var nlBefore = re.slice(0, nl.reStart);
			var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
			var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
			var nlAfter = re.slice(nl.reEnd);
			nlLast += nlAfter;
			var openParensBefore = nlBefore.split("(").length - 1;
			var cleanAfter = nlAfter;
			for (i = 0; i < openParensBefore; i++) cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
			nlAfter = cleanAfter;
			var dollar = "";
			if (nlAfter === "" && isSub !== SUBPARSE) dollar = "$";
			re = nlBefore + nlFirst + nlAfter + dollar + nlLast;
		}
		if (re !== "" && hasMagic) re = "(?=.)" + re;
		if (addPatternStart) re = patternStart + re;
		if (isSub === SUBPARSE) return [re, hasMagic];
		if (!hasMagic) return globUnescape(pattern);
		var flags = options.nocase ? "i" : "";
		try {
			var regExp = new RegExp("^" + re + "$", flags);
		} catch (er) /* istanbul ignore next - should be impossible */ {
			return /* @__PURE__ */ new RegExp("$.");
		}
		regExp._glob = pattern;
		regExp._src = re;
		return regExp;
	}
	minimatch.makeRe = function(pattern, options) {
		return new Minimatch(pattern, options || {}).makeRe();
	};
	Minimatch.prototype.makeRe = makeRe;
	function makeRe() {
		if (this.regexp || this.regexp === false) return this.regexp;
		var set = this.set;
		if (!set.length) {
			this.regexp = false;
			return this.regexp;
		}
		var options = this.options;
		var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
		var flags = options.nocase ? "i" : "";
		var re = set.map(function(pattern) {
			return pattern.map(function(p) {
				return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
			}).join("\\/");
		}).join("|");
		re = "^(?:" + re + ")$";
		if (this.negate) re = "^(?!" + re + ").*$";
		try {
			this.regexp = new RegExp(re, flags);
		} catch (ex) /* istanbul ignore next - should be impossible */ {
			this.regexp = false;
		}
		return this.regexp;
	}
	minimatch.match = function(list, pattern, options) {
		options = options || {};
		var mm = new Minimatch(pattern, options);
		list = list.filter(function(f) {
			return mm.match(f);
		});
		if (mm.options.nonull && !list.length) list.push(pattern);
		return list;
	};
	Minimatch.prototype.match = function match(f, partial) {
		if (typeof partial === "undefined") partial = this.partial;
		this.debug("match", f, this.pattern);
		if (this.comment) return false;
		if (this.empty) return f === "";
		if (f === "/" && partial) return true;
		var options = this.options;
		if (path$1.sep !== "/") f = f.split(path$1.sep).join("/");
		f = f.split(slashSplit);
		this.debug(this.pattern, "split", f);
		var set = this.set;
		this.debug(this.pattern, "set", set);
		var filename;
		var i;
		for (i = f.length - 1; i >= 0; i--) {
			filename = f[i];
			if (filename) break;
		}
		for (i = 0; i < set.length; i++) {
			var pattern = set[i];
			var file = f;
			if (options.matchBase && pattern.length === 1) file = [filename];
			if (this.matchOne(file, pattern, partial)) {
				if (options.flipNegate) return true;
				return !this.negate;
			}
		}
		if (options.flipNegate) return false;
		return this.negate;
	};
	Minimatch.prototype.matchOne = function(file, pattern, partial) {
		if (pattern.indexOf(GLOBSTAR) !== -1) return this._matchGlobstar(file, pattern, partial, 0, 0);
		return this._matchOne(file, pattern, partial, 0, 0);
	};
	Minimatch.prototype._matchGlobstar = function(file, pattern, partial, fileIndex, patternIndex) {
		var i;
		var firstgs = -1;
		for (i = patternIndex; i < pattern.length; i++) if (pattern[i] === GLOBSTAR) {
			firstgs = i;
			break;
		}
		var lastgs = -1;
		for (i = pattern.length - 1; i >= 0; i--) if (pattern[i] === GLOBSTAR) {
			lastgs = i;
			break;
		}
		var head = pattern.slice(patternIndex, firstgs);
		var body = partial ? pattern.slice(firstgs + 1) : pattern.slice(firstgs + 1, lastgs);
		var tail = partial ? [] : pattern.slice(lastgs + 1);
		if (head.length) {
			var fileHead = file.slice(fileIndex, fileIndex + head.length);
			if (!this._matchOne(fileHead, head, partial, 0, 0)) return false;
			fileIndex += head.length;
		}
		var fileTailMatch = 0;
		if (tail.length) {
			if (tail.length + fileIndex > file.length) return false;
			var tailStart = file.length - tail.length;
			if (this._matchOne(file, tail, partial, tailStart, 0)) fileTailMatch = tail.length;
			else {
				if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) return false;
				tailStart--;
				if (!this._matchOne(file, tail, partial, tailStart, 0)) return false;
				fileTailMatch = tail.length + 1;
			}
		}
		if (!body.length) {
			var sawSome = !!fileTailMatch;
			for (i = fileIndex; i < file.length - fileTailMatch; i++) {
				var f = String(file[i]);
				sawSome = true;
				if (f === "." || f === ".." || !this.options.dot && f.charAt(0) === ".") return false;
			}
			return partial || sawSome;
		}
		var bodySegments = [[[], 0]];
		var currentBody = bodySegments[0];
		var nonGsParts = 0;
		var nonGsPartsSums = [0];
		for (var bi = 0; bi < body.length; bi++) {
			var b = body[bi];
			if (b === GLOBSTAR) {
				nonGsPartsSums.push(nonGsParts);
				currentBody = [[], 0];
				bodySegments.push(currentBody);
			} else {
				currentBody[0].push(b);
				nonGsParts++;
			}
		}
		var idx = bodySegments.length - 1;
		var fileLength = file.length - fileTailMatch;
		for (var si = 0; si < bodySegments.length; si++) bodySegments[si][1] = fileLength - (nonGsPartsSums[idx--] + bodySegments[si][0].length);
		return !!this._matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
	};
	Minimatch.prototype._matchGlobStarBodySections = function(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
		var bs = bodySegments[bodyIndex];
		if (!bs) {
			for (var i = fileIndex; i < file.length; i++) {
				sawTail = true;
				var f = file[i];
				if (f === "." || f === ".." || !this.options.dot && f.charAt(0) === ".") return false;
			}
			return sawTail;
		}
		var body = bs[0];
		var after = bs[1];
		while (fileIndex <= after) {
			if (this._matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0) && globStarDepth < this.maxGlobstarRecursion) {
				var sub = this._matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
				if (sub !== false) return sub;
			}
			var f = file[fileIndex];
			if (f === "." || f === ".." || !this.options.dot && f.charAt(0) === ".") return false;
			fileIndex++;
		}
		return partial || null;
	};
	Minimatch.prototype._matchOne = function(file, pattern, partial, fileIndex, patternIndex) {
		var fi;
		var pi;
		var fl;
		var pl;
		for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
			this.debug("matchOne loop");
			var p = pattern[pi];
			var f = file[fi];
			this.debug(pattern, p, f);
			/* istanbul ignore if */
			if (p === false || p === GLOBSTAR) return false;
			var hit;
			if (typeof p === "string") {
				hit = f === p;
				this.debug("string match", p, f, hit);
			} else {
				hit = f.match(p);
				this.debug("pattern match", p, f, hit);
			}
			if (!hit) return false;
		}
		if (fi === fl && pi === pl) return true;
		else if (fi === fl) return partial;
		else if (pi === pl) return fi === fl - 1 && file[fi] === "";
		/* istanbul ignore next */
		throw new Error("wtf?");
	};
	function globUnescape(s) {
		return s.replace(/\\(.)/g, "$1");
	}
	function regExpEscape(s) {
		return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
	}
})))(), 1);
var IS_WINDOWS$4 = process.platform === "win32";
/**
* Helper class for parsing paths into segments
*/
var Path = class {
	/**
	* Constructs a Path
	* @param itemPath Path or array of segments
	*/
	constructor(itemPath) {
		this.segments = [];
		if (typeof itemPath === "string") {
			assert(itemPath, `Parameter 'itemPath' must not be empty`);
			itemPath = safeTrimTrailingSeparator(itemPath);
			if (!hasRoot(itemPath)) this.segments = itemPath.split(path$2.sep);
			else {
				let remaining = itemPath;
				let dir = dirname(remaining);
				while (dir !== remaining) {
					const basename = path$2.basename(remaining);
					this.segments.unshift(basename);
					remaining = dir;
					dir = dirname(remaining);
				}
				this.segments.unshift(remaining);
			}
		} else {
			assert(itemPath.length > 0, `Parameter 'itemPath' must not be an empty array`);
			for (let i = 0; i < itemPath.length; i++) {
				let segment = itemPath[i];
				assert(segment, `Parameter 'itemPath' must not contain any empty segments`);
				segment = normalizeSeparators(itemPath[i]);
				if (i === 0 && hasRoot(segment)) {
					segment = safeTrimTrailingSeparator(segment);
					assert(segment === dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`);
					this.segments.push(segment);
				} else {
					assert(!segment.includes(path$2.sep), `Parameter 'itemPath' contains unexpected path separators`);
					this.segments.push(segment);
				}
			}
		}
	}
	/**
	* Converts the path to it's string representation
	*/
	toString() {
		let result = this.segments[0];
		let skipSlash = result.endsWith(path$2.sep) || IS_WINDOWS$4 && /^[A-Z]:$/i.test(result);
		for (let i = 1; i < this.segments.length; i++) {
			if (skipSlash) skipSlash = false;
			else result += path$2.sep;
			result += this.segments[i];
		}
		return result;
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+glob@0.6.1/node_modules/@actions/glob/lib/internal-pattern.js
var { Minimatch } = import_minimatch.default;
var IS_WINDOWS$3 = process.platform === "win32";
var Pattern = class Pattern {
	constructor(patternOrNegate, isImplicitPattern = false, segments, homedir) {
		/**
		* Indicates whether matches should be excluded from the result set
		*/
		this.negate = false;
		let pattern;
		if (typeof patternOrNegate === "string") pattern = patternOrNegate.trim();
		else {
			segments = segments || [];
			assert(segments.length, `Parameter 'segments' must not empty`);
			const root = Pattern.getLiteral(segments[0]);
			assert(root && hasAbsoluteRoot(root), `Parameter 'segments' first element must be a root path`);
			pattern = new Path(segments).toString().trim();
			if (patternOrNegate) pattern = `!${pattern}`;
		}
		while (pattern.startsWith("!")) {
			this.negate = !this.negate;
			pattern = pattern.substr(1).trim();
		}
		pattern = Pattern.fixupPattern(pattern, homedir);
		this.segments = new Path(pattern).segments;
		this.trailingSeparator = normalizeSeparators(pattern).endsWith(path$2.sep);
		pattern = safeTrimTrailingSeparator(pattern);
		let foundGlob = false;
		const searchSegments = this.segments.map((x) => Pattern.getLiteral(x)).filter((x) => !foundGlob && !(foundGlob = x === ""));
		this.searchPath = new Path(searchSegments).toString();
		this.rootRegExp = new RegExp(Pattern.regExpEscape(searchSegments[0]), IS_WINDOWS$3 ? "i" : "");
		this.isImplicitPattern = isImplicitPattern;
		const minimatchOptions = {
			dot: true,
			nobrace: true,
			nocase: IS_WINDOWS$3,
			nocomment: true,
			noext: true,
			nonegate: true
		};
		pattern = IS_WINDOWS$3 ? pattern.replace(/\\/g, "/") : pattern;
		this.minimatch = new Minimatch(pattern, minimatchOptions);
	}
	/**
	* Matches the pattern against the specified path
	*/
	match(itemPath) {
		if (this.segments[this.segments.length - 1] === "**") {
			itemPath = normalizeSeparators(itemPath);
			if (!itemPath.endsWith(path$2.sep) && this.isImplicitPattern === false) itemPath = `${itemPath}${path$2.sep}`;
		} else itemPath = safeTrimTrailingSeparator(itemPath);
		if (this.minimatch.match(itemPath)) return this.trailingSeparator ? MatchKind.Directory : MatchKind.All;
		return MatchKind.None;
	}
	/**
	* Indicates whether the pattern may match descendants of the specified path
	*/
	partialMatch(itemPath) {
		itemPath = safeTrimTrailingSeparator(itemPath);
		if (dirname(itemPath) === itemPath) return this.rootRegExp.test(itemPath);
		return this.minimatch.matchOne(itemPath.split(IS_WINDOWS$3 ? /\\+/ : /\/+/), this.minimatch.set[0], true);
	}
	/**
	* Escapes glob patterns within a path
	*/
	static globEscape(s) {
		return (IS_WINDOWS$3 ? s : s.replace(/\\/g, "\\\\")).replace(/(\[)(?=[^/]+\])/g, "[[]").replace(/\?/g, "[?]").replace(/\*/g, "[*]");
	}
	/**
	* Normalizes slashes and ensures absolute root
	*/
	static fixupPattern(pattern, homedir) {
		assert(pattern, "pattern cannot be empty");
		const literalSegments = new Path(pattern).segments.map((x) => Pattern.getLiteral(x));
		assert(literalSegments.every((x, i) => (x !== "." || i === 0) && x !== ".."), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`);
		assert(!hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`);
		pattern = normalizeSeparators(pattern);
		if (pattern === "." || pattern.startsWith(`.${path$2.sep}`)) pattern = Pattern.globEscape(process.cwd()) + pattern.substr(1);
		else if (pattern === "~" || pattern.startsWith(`~${path$2.sep}`)) {
			homedir = homedir || os$4.homedir();
			assert(homedir, "Unable to determine HOME directory");
			assert(hasAbsoluteRoot(homedir), `Expected HOME directory to be a rooted path. Actual '${homedir}'`);
			pattern = Pattern.globEscape(homedir) + pattern.substr(1);
		} else if (IS_WINDOWS$3 && (pattern.match(/^[A-Z]:$/i) || pattern.match(/^[A-Z]:[^\\]/i))) {
			let root = ensureAbsoluteRoot("C:\\dummy-root", pattern.substr(0, 2));
			if (pattern.length > 2 && !root.endsWith("\\")) root += "\\";
			pattern = Pattern.globEscape(root) + pattern.substr(2);
		} else if (IS_WINDOWS$3 && (pattern === "\\" || pattern.match(/^\\[^\\]/))) {
			let root = ensureAbsoluteRoot("C:\\dummy-root", "\\");
			if (!root.endsWith("\\")) root += "\\";
			pattern = Pattern.globEscape(root) + pattern.substr(1);
		} else pattern = ensureAbsoluteRoot(Pattern.globEscape(process.cwd()), pattern);
		return normalizeSeparators(pattern);
	}
	/**
	* Attempts to unescape a pattern segment to create a literal path segment.
	* Otherwise returns empty string.
	*/
	static getLiteral(segment) {
		let literal = "";
		for (let i = 0; i < segment.length; i++) {
			const c = segment[i];
			if (c === "\\" && !IS_WINDOWS$3 && i + 1 < segment.length) {
				literal += segment[++i];
				continue;
			} else if (c === "*" || c === "?") return "";
			else if (c === "[" && i + 1 < segment.length) {
				let set = "";
				let closed = -1;
				for (let i2 = i + 1; i2 < segment.length; i2++) {
					const c2 = segment[i2];
					if (c2 === "\\" && !IS_WINDOWS$3 && i2 + 1 < segment.length) {
						set += segment[++i2];
						continue;
					} else if (c2 === "]") {
						closed = i2;
						break;
					} else set += c2;
				}
				if (closed >= 0) {
					if (set.length > 1) return "";
					if (set) {
						literal += set;
						i = closed;
						continue;
					}
				}
			}
			literal += c;
		}
		return literal;
	}
	/**
	* Escapes regexp special characters
	* https://javascript.info/regexp-escaping
	*/
	static regExpEscape(s) {
		return s.replace(/[[\\^$.|?*+()]/g, "\\$&");
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+glob@0.6.1/node_modules/@actions/glob/lib/internal-search-state.js
var SearchState = class {
	constructor(path, level) {
		this.path = path;
		this.level = level;
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+glob@0.6.1/node_modules/@actions/glob/lib/internal-globber.js
var __awaiter$13 = 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 __asyncValues$2 = function(o) {
	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
	var m = o[Symbol.asyncIterator];
	var i;
	return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
		return this;
	}, i);
	function verb(n) {
		i[n] = o[n] && function(v) {
			return new Promise(function(resolve, reject) {
				v = o[n](v), settle(resolve, reject, v.done, v.value);
			});
		};
	}
	function settle(resolve, reject, d, v) {
		Promise.resolve(v).then(function(v) {
			resolve({
				value: v,
				done: d
			});
		}, reject);
	}
};
var __await = function(v) {
	return this instanceof __await ? (this.v = v, this) : new __await(v);
};
var __asyncGenerator = function(thisArg, _arguments, generator) {
	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
	var g = generator.apply(thisArg, _arguments || []);
	var i;
	var q = [];
	return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
		return this;
	}, i;
	function awaitReturn(f) {
		return function(v) {
			return Promise.resolve(v).then(f, reject);
		};
	}
	function verb(n, f) {
		if (g[n]) {
			i[n] = function(v) {
				return new Promise(function(a, b) {
					q.push([
						n,
						v,
						a,
						b
					]) > 1 || resume(n, v);
				});
			};
			if (f) i[n] = f(i[n]);
		}
	}
	function resume(n, v) {
		try {
			step(g[n](v));
		} catch (e) {
			settle(q[0][3], e);
		}
	}
	function step(r) {
		r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
	}
	function fulfill(value) {
		resume("next", value);
	}
	function reject(value) {
		resume("throw", value);
	}
	function settle(f, v) {
		if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
	}
};
var IS_WINDOWS$2 = process.platform === "win32";
var DefaultGlobber = class DefaultGlobber {
	constructor(options) {
		this.patterns = [];
		this.searchPaths = [];
		this.options = getOptions(options);
	}
	getSearchPaths() {
		return this.searchPaths.slice();
	}
	glob() {
		return __awaiter$13(this, void 0, void 0, function* () {
			var _a;
			var e_1;
			var _b;
			var _c;
			const result = [];
			try {
				for (var _d = true, _e = __asyncValues$2(this.globGenerator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
					_c = _f.value;
					_d = false;
					const itemPath = _c;
					result.push(itemPath);
				}
			} catch (e_1_1) {
				e_1 = { error: e_1_1 };
			} finally {
				try {
					if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
				} finally {
					if (e_1) throw e_1.error;
				}
			}
			return result;
		});
	}
	globGenerator() {
		return __asyncGenerator(this, arguments, function* globGenerator_1() {
			const options = getOptions(this.options);
			const patterns = [];
			for (const pattern of this.patterns) {
				patterns.push(pattern);
				if (options.implicitDescendants && (pattern.trailingSeparator || pattern.segments[pattern.segments.length - 1] !== "**")) patterns.push(new Pattern(pattern.negate, true, pattern.segments.concat("**")));
			}
			const stack = [];
			for (const searchPath of getSearchPaths(patterns)) {
				debug(`Search path '${searchPath}'`);
				try {
					yield __await(fs$1.promises.lstat(searchPath));
				} catch (err) {
					if (err.code === "ENOENT") continue;
					throw err;
				}
				stack.unshift(new SearchState(searchPath, 1));
			}
			const traversalChain = [];
			while (stack.length) {
				const item = stack.pop();
				const match$1 = match(patterns, item.path);
				const partialMatch$1 = !!match$1 || partialMatch(patterns, item.path);
				if (!match$1 && !partialMatch$1) continue;
				const stats = yield __await(DefaultGlobber.stat(item, options, traversalChain));
				if (!stats) continue;
				if (options.excludeHiddenFiles && path$2.basename(item.path).match(/^\./)) continue;
				if (stats.isDirectory()) {
					if (match$1 & MatchKind.Directory && options.matchDirectories) yield yield __await(item.path);
					else if (!partialMatch$1) continue;
					const childLevel = item.level + 1;
					const childItems = (yield __await(fs$1.promises.readdir(item.path))).map((x) => new SearchState(path$2.join(item.path, x), childLevel));
					stack.push(...childItems.reverse());
				} else if (match$1 & MatchKind.File) yield yield __await(item.path);
			}
		});
	}
	/**
	* Constructs a DefaultGlobber
	*/
	static create(patterns, options) {
		return __awaiter$13(this, void 0, void 0, function* () {
			const result = new DefaultGlobber(options);
			if (IS_WINDOWS$2) {
				patterns = patterns.replace(/\r\n/g, "\n");
				patterns = patterns.replace(/\r/g, "\n");
			}
			const lines = patterns.split("\n").map((x) => x.trim());
			for (const line of lines) if (!line || line.startsWith("#")) continue;
			else result.patterns.push(new Pattern(line));
			result.searchPaths.push(...getSearchPaths(result.patterns));
			return result;
		});
	}
	static stat(item, options, traversalChain) {
		return __awaiter$13(this, void 0, void 0, function* () {
			let stats;
			if (options.followSymbolicLinks) try {
				stats = yield fs$1.promises.stat(item.path);
			} catch (err) {
				if (err.code === "ENOENT") {
					if (options.omitBrokenSymbolicLinks) {
						debug(`Broken symlink '${item.path}'`);
						return;
					}
					throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`);
				}
				throw err;
			}
			else stats = yield fs$1.promises.lstat(item.path);
			if (stats.isDirectory() && options.followSymbolicLinks) {
				const realPath = yield fs$1.promises.realpath(item.path);
				while (traversalChain.length >= item.level) traversalChain.pop();
				if (traversalChain.some((x) => x === realPath)) {
					debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
					return;
				}
				traversalChain.push(realPath);
			}
			return stats;
		});
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+glob@0.6.1/node_modules/@actions/glob/lib/glob.js
var __awaiter$11 = 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());
	});
};
/**
* Constructs a globber
*
* @param patterns  Patterns separated by newlines
* @param options   Glob options
*/
function create(patterns, options) {
	return __awaiter$11(this, void 0, void 0, function* () {
		return yield DefaultGlobber.create(patterns, options);
	});
}
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = {
		MAX_LENGTH: 256,
		MAX_SAFE_COMPONENT_LENGTH: 16,
		MAX_SAFE_BUILD_LENGTH: 250,
		MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER || 
		/* istanbul ignore next */ 9007199254740991,
		RELEASE_TYPES: [
			"major",
			"premajor",
			"minor",
			"preminor",
			"patch",
			"prepatch",
			"prerelease"
		],
		SEMVER_SPEC_VERSION: "2.0.0",
		FLAG_INCLUDE_PRERELEASE: 1,
		FLAG_LOOSE: 2
	};
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js
var require_debug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js
var require_re = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH } = require_constants();
	var debug = require_debug();
	exports = module.exports = {};
	var re = exports.re = [];
	var safeRe = exports.safeRe = [];
	var src = exports.src = [];
	var safeSrc = exports.safeSrc = [];
	var t = exports.t = {};
	var R = 0;
	var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
	var safeRegexReplacements = [
		["\\s", 1],
		["\\d", MAX_LENGTH],
		[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
	];
	var makeSafeRegex = (value) => {
		for (const [token, max] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
		return value;
	};
	var createToken = (name, value, isGlobal) => {
		const safe = makeSafeRegex(value);
		const index = R++;
		debug(name, index, value);
		t[name] = index;
		src[index] = value;
		safeSrc[index] = safe;
		re[index] = new RegExp(value, isGlobal ? "g" : void 0);
		safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
	};
	createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
	createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
	createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
	createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
	createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
	createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
	createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
	createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
	createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
	createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
	createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
	createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
	createToken("FULL", `^${src[t.FULLPLAIN]}$`);
	createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
	createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
	createToken("GTLT", "((?:<|>)?=?)");
	createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
	createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
	createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
	createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
	createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
	createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
	createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
	createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
	createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
	createToken("COERCERTL", src[t.COERCE], true);
	createToken("COERCERTLFULL", src[t.COERCEFULL], true);
	createToken("LONETILDE", "(?:~>?)");
	createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
	exports.tildeTrimReplace = "$1~";
	createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
	createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
	createToken("LONECARET", "(?:\\^)");
	createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
	exports.caretTrimReplace = "$1^";
	createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
	createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
	createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
	createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
	createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
	exports.comparatorTrimReplace = "$1$2$3";
	createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
	createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
	createToken("STAR", "(<|>)?=?\\s*\\*");
	createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
	createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js
var require_parse_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var looseOption = Object.freeze({ loose: true });
	var emptyOpts = Object.freeze({});
	var parseOptions = (options) => {
		if (!options) return emptyOpts;
		if (typeof options !== "object") return looseOption;
		return options;
	};
	module.exports = parseOptions;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js
var require_identifiers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var numeric = /^[0-9]+$/;
	var compareIdentifiers = (a, b) => {
		if (typeof a === "number" && typeof b === "number") return a === b ? 0 : a < b ? -1 : 1;
		const anum = numeric.test(a);
		const bnum = numeric.test(b);
		if (anum && bnum) {
			a = +a;
			b = +b;
		}
		return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
	};
	var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
	module.exports = {
		compareIdentifiers,
		rcompareIdentifiers
	};
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js
var require_semver$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var debug = require_debug();
	var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
	var { safeRe: re, t } = require_re();
	var parseOptions = require_parse_options();
	var { compareIdentifiers } = require_identifiers();
	var isPrereleaseIdentifier = (prerelease, identifier) => {
		const identifiers = identifier.split(".");
		if (identifiers.length > prerelease.length) return false;
		for (let i = 0; i < identifiers.length; i++) if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) return false;
		return true;
	};
	module.exports = class SemVer {
		constructor(version, options) {
			options = parseOptions(options);
			if (version instanceof SemVer) {
				if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
				else version = version.version;
			} else if (typeof version !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
			if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
			debug("SemVer", version, options);
			this.options = options;
			this.loose = !!options.loose;
			this.includePrerelease = !!options.includePrerelease;
			const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
			if (!m) throw new TypeError(`Invalid Version: ${version}`);
			this.raw = version;
			this.major = +m[1];
			this.minor = +m[2];
			this.patch = +m[3];
			if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError("Invalid major version");
			if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError("Invalid minor version");
			if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError("Invalid patch version");
			if (!m[4]) this.prerelease = [];
			else this.prerelease = m[4].split(".").map((id) => {
				if (/^[0-9]+$/.test(id)) {
					const num = +id;
					if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
				}
				return id;
			});
			this.build = m[5] ? m[5].split(".") : [];
			this.format();
		}
		format() {
			this.version = `${this.major}.${this.minor}.${this.patch}`;
			if (this.prerelease.length) this.version += `-${this.prerelease.join(".")}`;
			return this.version;
		}
		toString() {
			return this.version;
		}
		compare(other) {
			debug("SemVer.compare", this.version, this.options, other);
			if (!(other instanceof SemVer)) {
				if (typeof other === "string" && other === this.version) return 0;
				other = new SemVer(other, this.options);
			}
			if (other.version === this.version) return 0;
			return this.compareMain(other) || this.comparePre(other);
		}
		compareMain(other) {
			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
			if (this.major < other.major) return -1;
			if (this.major > other.major) return 1;
			if (this.minor < other.minor) return -1;
			if (this.minor > other.minor) return 1;
			if (this.patch < other.patch) return -1;
			if (this.patch > other.patch) return 1;
			return 0;
		}
		comparePre(other) {
			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
			if (this.prerelease.length && !other.prerelease.length) return -1;
			else if (!this.prerelease.length && other.prerelease.length) return 1;
			else if (!this.prerelease.length && !other.prerelease.length) return 0;
			let i = 0;
			do {
				const a = this.prerelease[i];
				const b = other.prerelease[i];
				debug("prerelease compare", i, a, b);
				if (a === void 0 && b === void 0) return 0;
				else if (b === void 0) return 1;
				else if (a === void 0) return -1;
				else if (a === b) continue;
				else return compareIdentifiers(a, b);
			} while (++i);
		}
		compareBuild(other) {
			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
			let i = 0;
			do {
				const a = this.build[i];
				const b = other.build[i];
				debug("build compare", i, a, b);
				if (a === void 0 && b === void 0) return 0;
				else if (b === void 0) return 1;
				else if (a === void 0) return -1;
				else if (a === b) continue;
				else return compareIdentifiers(a, b);
			} while (++i);
		}
		inc(release, identifier, identifierBase) {
			if (release.startsWith("pre")) {
				if (!identifier && identifierBase === false) throw new Error("invalid increment argument: identifier is empty");
				if (identifier) {
					const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
					if (!match || match[1] !== identifier) throw new Error(`invalid identifier: ${identifier}`);
				}
			}
			switch (release) {
				case "premajor":
					this.prerelease.length = 0;
					this.patch = 0;
					this.minor = 0;
					this.major++;
					this.inc("pre", identifier, identifierBase);
					break;
				case "preminor":
					this.prerelease.length = 0;
					this.patch = 0;
					this.minor++;
					this.inc("pre", identifier, identifierBase);
					break;
				case "prepatch":
					this.prerelease.length = 0;
					this.inc("patch", identifier, identifierBase);
					this.inc("pre", identifier, identifierBase);
					break;
				case "prerelease":
					if (this.prerelease.length === 0) this.inc("patch", identifier, identifierBase);
					this.inc("pre", identifier, identifierBase);
					break;
				case "release":
					if (this.prerelease.length === 0) throw new Error(`version ${this.raw} is not a prerelease`);
					this.prerelease.length = 0;
					break;
				case "major":
					if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;
					this.minor = 0;
					this.patch = 0;
					this.prerelease = [];
					break;
				case "minor":
					if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;
					this.patch = 0;
					this.prerelease = [];
					break;
				case "patch":
					if (this.prerelease.length === 0) this.patch++;
					this.prerelease = [];
					break;
				case "pre": {
					const base = Number(identifierBase) ? 1 : 0;
					if (this.prerelease.length === 0) this.prerelease = [base];
					else {
						let i = this.prerelease.length;
						while (--i >= 0) if (typeof this.prerelease[i] === "number") {
							this.prerelease[i]++;
							i = -2;
						}
						if (i === -1) {
							if (identifier === this.prerelease.join(".") && identifierBase === false) throw new Error("invalid increment argument: identifier already exists");
							this.prerelease.push(base);
						}
					}
					if (identifier) {
						let prerelease = [identifier, base];
						if (identifierBase === false) prerelease = [identifier];
						if (isPrereleaseIdentifier(this.prerelease, identifier)) {
							const prereleaseBase = this.prerelease[identifier.split(".").length];
							if (isNaN(prereleaseBase)) this.prerelease = prerelease;
						} else this.prerelease = prerelease;
					}
					break;
				}
				default: throw new Error(`invalid increment argument: ${release}`);
			}
			this.raw = this.format();
			if (this.build.length) this.raw += `+${this.build.join(".")}`;
			return this;
		}
	};
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js
var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var parse = (version, options, throwErrors = false) => {
		if (version instanceof SemVer) return version;
		try {
			return new SemVer(version, options);
		} catch (er) {
			if (!throwErrors) return null;
			throw er;
		}
	};
	module.exports = parse;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js
var require_valid$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var parse = require_parse();
	var valid = (version, options) => {
		const v = parse(version, options);
		return v ? v.version : null;
	};
	module.exports = valid;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/clean.js
var require_clean = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var parse = require_parse();
	var clean = (version, options) => {
		const s = parse(version.trim().replace(/^[=v]+/, ""), options);
		return s ? s.version : null;
	};
	module.exports = clean;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/inc.js
var require_inc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var inc = (version, release, options, identifier, identifierBase) => {
		if (typeof options === "string") {
			identifierBase = identifier;
			identifier = options;
			options = void 0;
		}
		try {
			return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier, identifierBase).version;
		} catch (er) {
			return null;
		}
	};
	module.exports = inc;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/diff.js
var require_diff = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var parse = require_parse();
	var diff = (version1, version2) => {
		const v1 = parse(version1, null, true);
		const v2 = parse(version2, null, true);
		const comparison = v1.compare(v2);
		if (comparison === 0) return null;
		const v1Higher = comparison > 0;
		const highVersion = v1Higher ? v1 : v2;
		const lowVersion = v1Higher ? v2 : v1;
		const highHasPre = !!highVersion.prerelease.length;
		if (!!lowVersion.prerelease.length && !highHasPre) {
			if (!lowVersion.patch && !lowVersion.minor) return "major";
			if (lowVersion.compareMain(highVersion) === 0) {
				if (lowVersion.minor && !lowVersion.patch) return "minor";
				return "patch";
			}
		}
		const prefix = highHasPre ? "pre" : "";
		if (v1.major !== v2.major) return prefix + "major";
		if (v1.minor !== v2.minor) return prefix + "minor";
		if (v1.patch !== v2.patch) return prefix + "patch";
		return "prerelease";
	};
	module.exports = diff;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/major.js
var require_major = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var major = (a, loose) => new SemVer(a, loose).major;
	module.exports = major;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/minor.js
var require_minor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var minor = (a, loose) => new SemVer(a, loose).minor;
	module.exports = minor;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/patch.js
var require_patch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var patch = (a, loose) => new SemVer(a, loose).patch;
	module.exports = patch;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/prerelease.js
var require_prerelease = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var parse = require_parse();
	var prerelease = (version, options) => {
		const parsed = parse(version, options);
		return parsed && parsed.prerelease.length ? parsed.prerelease : null;
	};
	module.exports = prerelease;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js
var require_compare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
	module.exports = compare;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rcompare.js
var require_rcompare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compare = require_compare();
	var rcompare = (a, b, loose) => compare(b, a, loose);
	module.exports = rcompare;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-loose.js
var require_compare_loose = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compare = require_compare();
	var compareLoose = (a, b) => compare(a, b, true);
	module.exports = compareLoose;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-build.js
var require_compare_build = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var compareBuild = (a, b, loose) => {
		const versionA = new SemVer(a, loose);
		const versionB = new SemVer(b, loose);
		return versionA.compare(versionB) || versionA.compareBuild(versionB);
	};
	module.exports = compareBuild;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/sort.js
var require_sort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compareBuild = require_compare_build();
	var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
	module.exports = sort;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rsort.js
var require_rsort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compareBuild = require_compare_build();
	var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
	module.exports = rsort;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gt.js
var require_gt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compare = require_compare();
	var gt = (a, b, loose) => compare(a, b, loose) > 0;
	module.exports = gt;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lt.js
var require_lt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compare = require_compare();
	var lt = (a, b, loose) => compare(a, b, loose) < 0;
	module.exports = lt;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/eq.js
var require_eq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compare = require_compare();
	var eq = (a, b, loose) => compare(a, b, loose) === 0;
	module.exports = eq;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/neq.js
var require_neq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compare = require_compare();
	var neq = (a, b, loose) => compare(a, b, loose) !== 0;
	module.exports = neq;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gte.js
var require_gte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compare = require_compare();
	var gte = (a, b, loose) => compare(a, b, loose) >= 0;
	module.exports = gte;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lte.js
var require_lte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var compare = require_compare();
	var lte = (a, b, loose) => compare(a, b, loose) <= 0;
	module.exports = lte;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/cmp.js
var require_cmp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var eq = require_eq();
	var neq = require_neq();
	var gt = require_gt();
	var gte = require_gte();
	var lt = require_lt();
	var lte = require_lte();
	var cmp = (a, op, b, loose) => {
		switch (op) {
			case "===":
				if (typeof a === "object") a = a.version;
				if (typeof b === "object") b = b.version;
				return a === b;
			case "!==":
				if (typeof a === "object") a = a.version;
				if (typeof b === "object") b = b.version;
				return a !== b;
			case "":
			case "=":
			case "==": return eq(a, b, loose);
			case "!=": return neq(a, b, loose);
			case ">": return gt(a, b, loose);
			case ">=": return gte(a, b, loose);
			case "<": return lt(a, b, loose);
			case "<=": return lte(a, b, loose);
			default: throw new TypeError(`Invalid operator: ${op}`);
		}
	};
	module.exports = cmp;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/coerce.js
var require_coerce = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var parse = require_parse();
	var { safeRe: re, t } = require_re();
	var coerce = (version, options) => {
		if (version instanceof SemVer) return version;
		if (typeof version === "number") version = String(version);
		if (typeof version !== "string") return null;
		options = options || {};
		let match = null;
		if (!options.rtl) match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
		else {
			const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
			let next;
			while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
				if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
				coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
			}
			coerceRtlRegex.lastIndex = -1;
		}
		if (match === null) return null;
		const major = match[2];
		return parse(`${major}.${match[3] || "0"}.${match[4] || "0"}${options.includePrerelease && match[5] ? `-${match[5]}` : ""}${options.includePrerelease && match[6] ? `+${match[6]}` : ""}`, options);
	};
	module.exports = coerce;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/truncate.js
var require_truncate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var parse = require_parse();
	var constants = require_constants();
	var SemVer = require_semver$1();
	var truncate = (version, truncation, options) => {
		if (!constants.RELEASE_TYPES.includes(truncation)) return null;
		const clonedVersion = cloneInputVersion(version, options);
		return clonedVersion && doTruncation(clonedVersion, truncation);
	};
	var cloneInputVersion = (version, options) => {
		return parse(version instanceof SemVer ? version.version : version, options);
	};
	var doTruncation = (version, truncation) => {
		if (isPrerelease(truncation)) return version.version;
		version.prerelease = [];
		switch (truncation) {
			case "major":
				version.minor = 0;
				version.patch = 0;
				break;
			case "minor": version.patch = 0;
		}
		return version.format();
	};
	var isPrerelease = (type) => {
		return type.startsWith("pre");
	};
	module.exports = truncate;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/lrucache.js
var require_lrucache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var LRUCache = class {
		constructor() {
			this.max = 1e3;
			this.map = /* @__PURE__ */ new Map();
		}
		get(key) {
			const value = this.map.get(key);
			if (value === void 0) return;
			else {
				this.map.delete(key);
				this.map.set(key, value);
				return value;
			}
		}
		delete(key) {
			return this.map.delete(key);
		}
		set(key, value) {
			if (!this.delete(key) && value !== void 0) {
				if (this.map.size >= this.max) {
					const firstKey = this.map.keys().next().value;
					this.delete(firstKey);
				}
				this.map.set(key, value);
			}
			return this;
		}
	};
	module.exports = LRUCache;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/range.js
var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SPACE_CHARACTERS = /\s+/g;
	module.exports = class Range {
		constructor(range, options) {
			options = parseOptions(options);
			if (range instanceof Range) {
				if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
				else return new Range(range.raw, options);
			}
			if (range instanceof Comparator) {
				this.raw = range.value;
				this.set = [[range]];
				this.formatted = void 0;
				return this;
			}
			this.options = options;
			this.loose = !!options.loose;
			this.includePrerelease = !!options.includePrerelease;
			this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
			this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
			if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
			if (this.set.length > 1) {
				const first = this.set[0];
				this.set = this.set.filter((c) => !isNullSet(c[0]));
				if (this.set.length === 0) this.set = [first];
				else if (this.set.length > 1) {
					for (const c of this.set) if (c.length === 1 && isAny(c[0])) {
						this.set = [c];
						break;
					}
				}
			}
			this.formatted = void 0;
		}
		get range() {
			if (this.formatted === void 0) {
				this.formatted = "";
				for (let i = 0; i < this.set.length; i++) {
					if (i > 0) this.formatted += "||";
					const comps = this.set[i];
					for (let k = 0; k < comps.length; k++) {
						if (k > 0) this.formatted += " ";
						this.formatted += comps[k].toString().trim();
					}
				}
			}
			return this.formatted;
		}
		format() {
			return this.range;
		}
		toString() {
			return this.range;
		}
		parseRange(range) {
			range = range.replace(BUILDSTRIPRE, "");
			const memoKey = ((this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE)) + ":" + range;
			const cached = cache.get(memoKey);
			if (cached) return cached;
			const loose = this.options.loose;
			const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
			range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
			debug("hyphen replace", range);
			range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
			debug("comparator trim", range);
			range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
			debug("tilde trim", range);
			range = range.replace(re[t.CARETTRIM], caretTrimReplace);
			debug("caret trim", range);
			let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
			if (loose) rangeList = rangeList.filter((comp) => {
				debug("loose invalid filter", comp, this.options);
				return !!comp.match(re[t.COMPARATORLOOSE]);
			});
			debug("range list", rangeList);
			const rangeMap = /* @__PURE__ */ new Map();
			const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
			for (const comp of comparators) {
				if (isNullSet(comp)) return [comp];
				rangeMap.set(comp.value, comp);
			}
			if (rangeMap.size > 1 && rangeMap.has("")) rangeMap.delete("");
			const result = [...rangeMap.values()];
			cache.set(memoKey, result);
			return result;
		}
		intersects(range, options) {
			if (!(range instanceof Range)) throw new TypeError("a Range is required");
			return this.set.some((thisComparators) => {
				return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
					return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
						return rangeComparators.every((rangeComparator) => {
							return thisComparator.intersects(rangeComparator, options);
						});
					});
				});
			});
		}
		test(version) {
			if (!version) return false;
			if (typeof version === "string") try {
				version = new SemVer(version, this.options);
			} catch (er) {
				return false;
			}
			for (let i = 0; i < this.set.length; i++) if (testSet(this.set[i], version, this.options)) return true;
			return false;
		}
	};
	var cache = new (require_lrucache())();
	var parseOptions = require_parse_options();
	var Comparator = require_comparator();
	var debug = require_debug();
	var SemVer = require_semver$1();
	var { safeRe: re, src, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = require_re();
	var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
	var BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
	var isNullSet = (c) => c.value === "<0.0.0-0";
	var isAny = (c) => c.value === "";
	var isSatisfiable = (comparators, options) => {
		let result = true;
		const remainingComparators = comparators.slice();
		let testComparator = remainingComparators.pop();
		while (result && remainingComparators.length) {
			result = remainingComparators.every((otherComparator) => {
				return testComparator.intersects(otherComparator, options);
			});
			testComparator = remainingComparators.pop();
		}
		return result;
	};
	var parseComparator = (comp, options) => {
		comp = comp.replace(re[t.BUILD], "");
		debug("comp", comp, options);
		comp = replaceCarets(comp, options);
		debug("caret", comp);
		comp = replaceTildes(comp, options);
		debug("tildes", comp);
		comp = replaceXRanges(comp, options);
		debug("xrange", comp);
		comp = replaceStars(comp, options);
		debug("stars", comp);
		return comp;
	};
	var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
	var invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
	var replaceTildes = (comp, options) => {
		return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
	};
	var replaceTilde = (comp, options) => {
		const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
		const z = options.includePrerelease ? "-0" : "";
		return comp.replace(r, (_, M, m, p, pr) => {
			debug("tilde", comp, _, M, m, p, pr);
			let ret;
			if (isX(M)) ret = "";
			else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
			else if (isX(p)) ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
			else if (pr) {
				debug("replaceTilde pr", pr);
				ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
			} else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
			debug("tilde return", ret);
			return ret;
		});
	};
	var replaceCarets = (comp, options) => {
		return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
	};
	var replaceCaret = (comp, options) => {
		debug("caret", comp, options);
		const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
		const z = options.includePrerelease ? "-0" : "";
		return comp.replace(r, (_, M, m, p, pr) => {
			debug("caret", comp, _, M, m, p, pr);
			let ret;
			if (isX(M)) ret = "";
			else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
			else if (isX(p)) {
				if (M === "0") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
				else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
			} else if (pr) {
				debug("replaceCaret pr", pr);
				if (M === "0") {
					if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
					else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
				} else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
			} else {
				debug("no pr");
				if (M === "0") {
					if (m === "0") ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
					else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
				} else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
			}
			debug("caret return", ret);
			return ret;
		});
	};
	var replaceXRanges = (comp, options) => {
		debug("replaceXRanges", comp, options);
		return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
	};
	var replaceXRange = (comp, options) => {
		comp = comp.trim();
		const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
		return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
			debug("xRange", comp, ret, gtlt, M, m, p, pr);
			if (invalidXRangeOrder(M, m, p)) return comp;
			const xM = isX(M);
			const xm = xM || isX(m);
			const xp = xm || isX(p);
			const anyX = xp;
			if (gtlt === "=" && anyX) gtlt = "";
			pr = options.includePrerelease ? "-0" : "";
			if (xM) {
				if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
				else ret = "*";
			} else if (gtlt && anyX) {
				if (xm) m = 0;
				p = 0;
				if (gtlt === ">") {
					gtlt = ">=";
					if (xm) {
						M = +M + 1;
						m = 0;
						p = 0;
					} else {
						m = +m + 1;
						p = 0;
					}
				} else if (gtlt === "<=") {
					gtlt = "<";
					if (xm) M = +M + 1;
					else m = +m + 1;
				}
				if (gtlt === "<") pr = "-0";
				ret = `${gtlt + M}.${m}.${p}${pr}`;
			} else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
			else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
			debug("xRange return", ret);
			return ret;
		});
	};
	var replaceStars = (comp, options) => {
		debug("replaceStars", comp, options);
		return comp.trim().replace(re[t.STAR], "");
	};
	var replaceGTE0 = (comp, options) => {
		debug("replaceGTE0", comp, options);
		return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
	};
	var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
		if (isX(fM)) from = "";
		else if (isX(fm)) from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
		else if (isX(fp)) from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
		else if (fpr) from = `>=${from}`;
		else from = `>=${from}${incPr ? "-0" : ""}`;
		if (isX(tM)) to = "";
		else if (isX(tm)) to = `<${+tM + 1}.0.0-0`;
		else if (isX(tp)) to = `<${tM}.${+tm + 1}.0-0`;
		else if (tpr) to = `<=${tM}.${tm}.${tp}-${tpr}`;
		else if (incPr) to = `<${tM}.${tm}.${+tp + 1}-0`;
		else to = `<=${to}`;
		return `${from} ${to}`.trim();
	};
	var testSet = (set, version, options) => {
		for (let i = 0; i < set.length; i++) if (!set[i].test(version)) return false;
		if (version.prerelease.length && !options.includePrerelease) {
			for (let i = 0; i < set.length; i++) {
				debug(set[i].semver);
				if (set[i].semver === Comparator.ANY) continue;
				if (set[i].semver.prerelease.length > 0) {
					const allowed = set[i].semver;
					if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;
				}
			}
			return false;
		}
		return true;
	};
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/comparator.js
var require_comparator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var ANY = Symbol("SemVer ANY");
	module.exports = class Comparator {
		static get ANY() {
			return ANY;
		}
		constructor(comp, options) {
			options = parseOptions(options);
			if (comp instanceof Comparator) {
				if (comp.loose === !!options.loose) return comp;
				else comp = comp.value;
			}
			comp = comp.trim().split(/\s+/).join(" ");
			debug("comparator", comp, options);
			this.options = options;
			this.loose = !!options.loose;
			this.parse(comp);
			if (this.semver === ANY) this.value = "";
			else this.value = this.operator + this.semver.version;
			debug("comp", this);
		}
		parse(comp) {
			const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
			const m = comp.match(r);
			if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
			this.operator = m[1] !== void 0 ? m[1] : "";
			if (this.operator === "=") this.operator = "";
			if (!m[2]) this.semver = ANY;
			else this.semver = new SemVer(m[2], this.options.loose);
		}
		toString() {
			return this.value;
		}
		test(version) {
			debug("Comparator.test", version, this.options.loose);
			if (this.semver === ANY || version === ANY) return true;
			if (typeof version === "string") try {
				version = new SemVer(version, this.options);
			} catch (er) {
				return false;
			}
			return cmp(version, this.operator, this.semver, this.options);
		}
		intersects(comp, options) {
			if (!(comp instanceof Comparator)) throw new TypeError("a Comparator is required");
			if (this.operator === "") {
				if (this.value === "") return true;
				return new Range(comp.value, options).test(this.value);
			} else if (comp.operator === "") {
				if (comp.value === "") return true;
				return new Range(this.value, options).test(comp.semver);
			}
			options = parseOptions(options);
			if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) return false;
			if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) return false;
			if (this.operator.startsWith(">") && comp.operator.startsWith(">")) return true;
			if (this.operator.startsWith("<") && comp.operator.startsWith("<")) return true;
			if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) return true;
			if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) return true;
			if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) return true;
			return false;
		}
	};
	var parseOptions = require_parse_options();
	var { safeRe: re, t } = require_re();
	var cmp = require_cmp();
	var debug = require_debug();
	var SemVer = require_semver$1();
	var Range = require_range();
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/satisfies.js
var require_satisfies = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var Range = require_range();
	var satisfies = (version, range, options) => {
		try {
			range = new Range(range, options);
		} catch (er) {
			return false;
		}
		return range.test(version);
	};
	module.exports = satisfies;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/to-comparators.js
var require_to_comparators = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var Range = require_range();
	var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
	module.exports = toComparators;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var Range = require_range();
	var maxSatisfying = (versions, range, options) => {
		let max = null;
		let maxSV = null;
		let rangeObj = null;
		try {
			rangeObj = new Range(range, options);
		} catch (er) {
			return null;
		}
		versions.forEach((v) => {
			if (rangeObj.test(v)) {
				if (!max || maxSV.compare(v) === -1) {
					max = v;
					maxSV = new SemVer(max, options);
				}
			}
		});
		return max;
	};
	module.exports = maxSatisfying;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var Range = require_range();
	var minSatisfying = (versions, range, options) => {
		let min = null;
		let minSV = null;
		let rangeObj = null;
		try {
			rangeObj = new Range(range, options);
		} catch (er) {
			return null;
		}
		versions.forEach((v) => {
			if (rangeObj.test(v)) {
				if (!min || minSV.compare(v) === 1) {
					min = v;
					minSV = new SemVer(min, options);
				}
			}
		});
		return min;
	};
	module.exports = minSatisfying;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-version.js
var require_min_version = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var Range = require_range();
	var gt = require_gt();
	var minVersion = (range, loose) => {
		range = new Range(range, loose);
		let minver = new SemVer("0.0.0");
		if (range.test(minver)) return minver;
		minver = new SemVer("0.0.0-0");
		if (range.test(minver)) return minver;
		minver = null;
		for (let i = 0; i < range.set.length; ++i) {
			const comparators = range.set[i];
			let setMin = null;
			comparators.forEach((comparator) => {
				const compver = new SemVer(comparator.semver.version);
				switch (comparator.operator) {
					case ">":
						if (compver.prerelease.length === 0) compver.patch++;
						else compver.prerelease.push(0);
						compver.raw = compver.format();
					case "":
					case ">=":
						if (!setMin || gt(compver, setMin)) setMin = compver;
						break;
					case "<":
					case "<=": break;
					/* istanbul ignore next */
					default: throw new Error(`Unexpected operation: ${comparator.operator}`);
				}
			});
			if (setMin && (!minver || gt(minver, setMin))) minver = setMin;
		}
		if (minver && range.test(minver)) return minver;
		return null;
	};
	module.exports = minVersion;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/valid.js
var require_valid = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var Range = require_range();
	var validRange = (range, options) => {
		try {
			return new Range(range, options).range || "*";
		} catch (er) {
			return null;
		}
	};
	module.exports = validRange;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/outside.js
var require_outside = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var SemVer = require_semver$1();
	var Comparator = require_comparator();
	var { ANY } = Comparator;
	var Range = require_range();
	var satisfies = require_satisfies();
	var gt = require_gt();
	var lt = require_lt();
	var lte = require_lte();
	var gte = require_gte();
	var outside = (version, range, hilo, options) => {
		version = new SemVer(version, options);
		range = new Range(range, options);
		let gtfn;
		let ltefn;
		let ltfn;
		let comp;
		let ecomp;
		switch (hilo) {
			case ">":
				gtfn = gt;
				ltefn = lte;
				ltfn = lt;
				comp = ">";
				ecomp = ">=";
				break;
			case "<":
				gtfn = lt;
				ltefn = gte;
				ltfn = gt;
				comp = "<";
				ecomp = "<=";
				break;
			default: throw new TypeError("Must provide a hilo val of \"<\" or \">\"");
		}
		if (satisfies(version, range, options)) return false;
		for (let i = 0; i < range.set.length; ++i) {
			const comparators = range.set[i];
			let high = null;
			let low = null;
			comparators.forEach((comparator) => {
				if (comparator.semver === ANY) comparator = new Comparator(">=0.0.0");
				high = high || comparator;
				low = low || comparator;
				if (gtfn(comparator.semver, high.semver, options)) high = comparator;
				else if (ltfn(comparator.semver, low.semver, options)) low = comparator;
			});
			if (high.operator === comp || high.operator === ecomp) return false;
			if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) return false;
			else if (low.operator === ecomp && ltfn(version, low.semver)) return false;
		}
		return true;
	};
	module.exports = outside;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/gtr.js
var require_gtr = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var outside = require_outside();
	var gtr = (version, range, options) => outside(version, range, ">", options);
	module.exports = gtr;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/ltr.js
var require_ltr = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var outside = require_outside();
	var ltr = (version, range, options) => outside(version, range, "<", options);
	module.exports = ltr;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/intersects.js
var require_intersects = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var Range = require_range();
	var intersects = (r1, r2, options) => {
		r1 = new Range(r1, options);
		r2 = new Range(r2, options);
		return r1.intersects(r2, options);
	};
	module.exports = intersects;
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/simplify.js
var require_simplify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var satisfies = require_satisfies();
	var compare = require_compare();
	module.exports = (versions, range, options) => {
		const set = [];
		let first = null;
		let prev = null;
		const v = versions.sort((a, b) => compare(a, b, options));
		for (const version of v) if (satisfies(version, range, options)) {
			prev = version;
			if (!first) first = version;
		} else {
			if (prev) set.push([first, prev]);
			prev = null;
			first = null;
		}
		if (first) set.push([first, null]);
		const ranges = [];
		for (const [min, max] of set) if (min === max) ranges.push(min);
		else if (!max && min === v[0]) ranges.push("*");
		else if (!max) ranges.push(`>=${min}`);
		else if (min === v[0]) ranges.push(`<=${max}`);
		else ranges.push(`${min} - ${max}`);
		const simplified = ranges.join(" || ");
		const original = typeof range.raw === "string" ? range.raw : String(range);
		return simplified.length < original.length ? simplified : range;
	};
}));
//#endregion
//#region node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/subset.js
var require_subset = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var Range = require_range();
	var Comparator = require_comparator();
	var { ANY } = Comparator;
	var satisfies = require_satisfies();
	var compare = require_compare();
	var subset = (sub, dom, options = {}) => {
		if (sub === dom) return true;
		sub = new Range(sub, options);
		dom = new Range(dom, options);
		let sawNonNull = false;
		OUTER: for (const simpleSub of sub.set) {
			for (const simpleDom of dom.set) {
				const isSub = simpleSubset(simpleSub, simpleDom, options);
				sawNonNull = sawNonNull || isSub !== null;
				if (isSub) continue OUTER;
			}
			if (sawNonNull) return false;
		}
		return true;
	};
	var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
	var minimumVersion = [new Comparator(">=0.0.0")];
	var simpleSubset = (sub, dom, options) => {
		if (sub === dom) return true;
		if (sub.length === 1 && sub[0].semver === ANY) {
			if (dom.length === 1 && dom[0].semver === ANY) return true;
			else if (options.includePrerelease) sub = minimumVersionWithPreRelease;
			else sub = minimumVersion;
		}
		if (dom.length === 1 && dom[0].semver === ANY) {
			if (options.includePrerelease) return true;
			else dom = minimumVersion;
		}
		const eqSet = /* @__PURE__ */ new Set();
		let gt;
		let lt;
		for (const c of sub) if (c.operator === ">" || c.operator === ">=") gt = higherGT(gt, c, options);
		else if (c.operator === "<" || c.operator === "<=") lt = lowerLT(lt, c, options);
		else eqSet.add(c.semver);
		if (eqSet.size > 1) return null;
		let gtltComp;
		if (gt && lt) {
			gtltComp = compare(gt.semver, lt.semver, options);
			if (gtltComp > 0) return null;
			else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) return null;
		}
		for (const eq of eqSet) {
			if (gt && !satisfies(eq, String(gt), options)) return null;
			if (lt && !satisfies(eq, String(lt), options)) return null;
			for (const c of dom) if (!satisfies(eq, String(c), options)) return false;
			return true;
		}
		let higher;
		let lower;
		let hasDomLT;
		let hasDomGT;
		let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
		let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
		if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) needDomLTPre = false;
		for (const c of dom) {
			hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
			hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
			if (gt) {
				if (needDomGTPre) {
					if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) needDomGTPre = false;
				}
				if (c.operator === ">" || c.operator === ">=") {
					higher = higherGT(gt, c, options);
					if (higher === c && higher !== gt) return false;
				} else if (gt.operator === ">=" && !c.test(gt.semver)) return false;
			}
			if (lt) {
				if (needDomLTPre) {
					if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) needDomLTPre = false;
				}
				if (c.operator === "<" || c.operator === "<=") {
					lower = lowerLT(lt, c, options);
					if (lower === c && lower !== lt) return false;
				} else if (lt.operator === "<=" && !c.test(lt.semver)) return false;
			}
			if (!c.operator && (lt || gt) && gtltComp !== 0) return false;
		}
		if (gt && hasDomLT && !lt && gtltComp !== 0) return false;
		if (lt && hasDomGT && !gt && gtltComp !== 0) return false;
		if (needDomGTPre || needDomLTPre) return false;
		return true;
	};
	var higherGT = (a, b, options) => {
		if (!a) return b;
		const comp = compare(a.semver, b.semver, options);
		return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
	};
	var lowerLT = (a, b, options) => {
		if (!a) return b;
		const comp = compare(a.semver, b.semver, options);
		return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
	};
	module.exports = subset;
}));
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/constants.js
var import_semver = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
	var internalRe = require_re();
	var constants = require_constants();
	var SemVer = require_semver$1();
	var identifiers = require_identifiers();
	module.exports = {
		parse: require_parse(),
		valid: require_valid$1(),
		clean: require_clean(),
		inc: require_inc(),
		diff: require_diff(),
		major: require_major(),
		minor: require_minor(),
		patch: require_patch(),
		prerelease: require_prerelease(),
		compare: require_compare(),
		rcompare: require_rcompare(),
		compareLoose: require_compare_loose(),
		compareBuild: require_compare_build(),
		sort: require_sort(),
		rsort: require_rsort(),
		gt: require_gt(),
		lt: require_lt(),
		eq: require_eq(),
		neq: require_neq(),
		gte: require_gte(),
		lte: require_lte(),
		cmp: require_cmp(),
		coerce: require_coerce(),
		truncate: require_truncate(),
		Comparator: require_comparator(),
		Range: require_range(),
		satisfies: require_satisfies(),
		toComparators: require_to_comparators(),
		maxSatisfying: require_max_satisfying(),
		minSatisfying: require_min_satisfying(),
		minVersion: require_min_version(),
		validRange: require_valid(),
		outside: require_outside(),
		gtr: require_gtr(),
		ltr: require_ltr(),
		intersects: require_intersects(),
		simplifyRange: require_simplify(),
		subset: require_subset(),
		SemVer,
		re: internalRe.re,
		src: internalRe.src,
		tokens: internalRe.t,
		SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
		RELEASE_TYPES: constants.RELEASE_TYPES,
		compareIdentifiers: identifiers.compareIdentifiers,
		rcompareIdentifiers: identifiers.rcompareIdentifiers
	};
})))(), 1);
var CacheFilename;
(function(CacheFilename) {
	CacheFilename["Gzip"] = "cache.tgz";
	CacheFilename["Zstd"] = "cache.tzst";
})(CacheFilename || (CacheFilename = {}));
var CompressionMethod;
(function(CompressionMethod) {
	CompressionMethod["Gzip"] = "gzip";
	CompressionMethod["ZstdWithoutLong"] = "zstd-without-long";
	CompressionMethod["Zstd"] = "zstd";
})(CompressionMethod || (CompressionMethod = {}));
var ArchiveToolType;
(function(ArchiveToolType) {
	ArchiveToolType["GNU"] = "gnu";
	ArchiveToolType["BSD"] = "bsd";
})(ArchiveToolType || (ArchiveToolType = {}));
var DefaultRetryDelay = 5e3;
var SocketTimeout = 5e3;
var GnuTarPathOnWindows = `${process.env["PROGRAMFILES"]}\\Git\\usr\\bin\\tar.exe`;
var SystemTarPathOnWindows = `${process.env["SYSTEMDRIVE"]}\\Windows\\System32\\tar.exe`;
var TarFilename = "cache.tar";
var ManifestFilename = "manifest.txt";
10 * Math.pow(1024, 3);
var CacheReadDeniedMessagePrefix = "cache read denied:";
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/cacheUtils.js
var __awaiter$10 = 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 __asyncValues = function(o) {
	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
	var m = o[Symbol.asyncIterator];
	var i;
	return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
		return this;
	}, i);
	function verb(n) {
		i[n] = o[n] && function(v) {
			return new Promise(function(resolve, reject) {
				v = o[n](v), settle(resolve, reject, v.done, v.value);
			});
		};
	}
	function settle(resolve, reject, d, v) {
		Promise.resolve(v).then(function(v) {
			resolve({
				value: v,
				done: d
			});
		}, reject);
	}
};
var versionSalt = "1.0";
function createTempDirectory() {
	return __awaiter$10(this, void 0, void 0, function* () {
		const IS_WINDOWS = process.platform === "win32";
		let tempDirectory = process.env["RUNNER_TEMP"] || "";
		if (!tempDirectory) {
			let baseLocation;
			if (IS_WINDOWS) baseLocation = process.env["USERPROFILE"] || "C:\\";
			else if (process.platform === "darwin") baseLocation = "/Users";
			else baseLocation = "/home";
			tempDirectory = path$2.join(baseLocation, "actions", "temp");
		}
		const dest = path$2.join(tempDirectory, crypto.randomUUID());
		yield mkdirP(dest);
		return dest;
	});
}
function getArchiveFileSizeInBytes(filePath) {
	return fs$1.statSync(filePath).size;
}
function resolvePaths(patterns) {
	return __awaiter$10(this, void 0, void 0, function* () {
		var _a;
		var e_1;
		var _b;
		var _c;
		var _d;
		const paths = [];
		const workspace = (_d = process.env["GITHUB_WORKSPACE"]) !== null && _d !== void 0 ? _d : process.cwd();
		const globber = yield create(patterns.join("\n"), { implicitDescendants: false });
		try {
			for (var _e = true, _f = __asyncValues(globber.globGenerator()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
				_c = _g.value;
				_e = false;
				const file = _c;
				const relativeFile = path$2.relative(workspace, file).replace(new RegExp(`\\${path$2.sep}`, "g"), "/");
				debug(`Matched: ${relativeFile}`);
				if (relativeFile === "") paths.push(".");
				else paths.push(`${relativeFile}`);
			}
		} catch (e_1_1) {
			e_1 = { error: e_1_1 };
		} finally {
			try {
				if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
			} finally {
				if (e_1) throw e_1.error;
			}
		}
		return paths;
	});
}
function unlinkFile(filePath) {
	return __awaiter$10(this, void 0, void 0, function* () {
		return util$2.promisify(fs$1.unlink)(filePath);
	});
}
function getVersion(app_1) {
	return __awaiter$10(this, arguments, void 0, function* (app, additionalArgs = []) {
		let versionOutput = "";
		additionalArgs.push("--version");
		debug(`Checking ${app} ${additionalArgs.join(" ")}`);
		try {
			yield exec(`${app}`, additionalArgs, {
				ignoreReturnCode: true,
				silent: true,
				listeners: {
					stdout: (data) => versionOutput += data.toString(),
					stderr: (data) => versionOutput += data.toString()
				}
			});
		} catch (err) {
			debug(err.message);
		}
		versionOutput = versionOutput.trim();
		debug(versionOutput);
		return versionOutput;
	});
}
function getCompressionMethod() {
	return __awaiter$10(this, void 0, void 0, function* () {
		const versionOutput = yield getVersion("zstd", ["--quiet"]);
		debug(`zstd version: ${import_semver.clean(versionOutput)}`);
		if (versionOutput === "") return CompressionMethod.Gzip;
		else return CompressionMethod.ZstdWithoutLong;
	});
}
function getCacheFileName(compressionMethod) {
	return compressionMethod === CompressionMethod.Gzip ? CacheFilename.Gzip : CacheFilename.Zstd;
}
function getGnuTarPathOnWindows() {
	return __awaiter$10(this, void 0, void 0, function* () {
		if (fs$1.existsSync(GnuTarPathOnWindows)) return GnuTarPathOnWindows;
		return (yield getVersion("tar")).toLowerCase().includes("gnu tar") ? which("tar") : "";
	});
}
function assertDefined(name, value) {
	if (value === void 0) throw Error(`Expected ${name} but value was undefiend`);
	return value;
}
function getCacheVersion(paths, compressionMethod, enableCrossOsArchive = false) {
	const components = paths.slice();
	if (compressionMethod) components.push(compressionMethod);
	if (process.platform === "win32" && !enableCrossOsArchive) components.push("windows-only");
	components.push(versionSalt);
	return crypto.createHash("sha256").update(components.join("|")).digest("hex");
}
function getRuntimeToken() {
	const token = process.env["ACTIONS_RUNTIME_TOKEN"];
	if (!token) throw new Error("Unable to get the ACTIONS_RUNTIME_TOKEN env variable");
	return token;
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/abort-controller/AbortError.js
/**
* This error is thrown when an asynchronous operation has been aborted.
* Check for this error by testing the `name` that the name property of the
* error matches `"AbortError"`.
*
* @example
* ```ts snippet:ReadmeSampleAbortError
* import { AbortError } from "@typespec/ts-http-runtime";
*
* async function doAsyncWork(options: { abortSignal: AbortSignal }): Promise<void> {
*   if (options.abortSignal.aborted) {
*     throw new AbortError();
*   }
*
*   // do async work
* }
*
* const controller = new AbortController();
* controller.abort();
*
* try {
*   doAsyncWork({ abortSignal: controller.signal });
* } catch (e) {
*   if (e instanceof Error && e.name === "AbortError") {
*     // handle abort error here.
*   }
* }
* ```
*/
var AbortError$1 = class extends Error {
	static {
		__name(this, "AbortError");
	}
	constructor(message) {
		super(message);
		this.name = "AbortError";
	}
};
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/logger/log.js
function log(message, ...args) {
	process$1.stderr.write(`${util.format(message, ...args)}${EOL$1}`);
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/env.js
/**
* Returns the value of the specified environment variable.
*
* @internal
*/
function getEnvironmentVariable(name) {
	return process$1.env[name];
}
typeof process$1.versions.deno === "string" && process$1.versions.deno.length;
typeof process$1.versions.bun === "string" && process$1.versions.bun.length;
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/logger/debug.js
var debugEnvVariable = getEnvironmentVariable("DEBUG");
var enabledString;
var enabledNamespaces = [];
var skippedNamespaces = [];
var debuggers = [];
if (debugEnvVariable) enable(debugEnvVariable);
var debugObj = Object.assign((namespace) => {
	return createDebugger(namespace);
}, {
	enable,
	enabled,
	disable,
	log
});
function enable(namespaces) {
	enabledString = namespaces;
	enabledNamespaces = [];
	skippedNamespaces = [];
	const namespaceList = namespaces.split(",").map((ns) => ns.trim());
	for (const ns of namespaceList) if (ns.startsWith("-")) skippedNamespaces.push(ns.substring(1));
	else enabledNamespaces.push(ns);
	for (const instance of debuggers) instance.enabled = enabled(instance.namespace);
}
function enabled(namespace) {
	if (namespace.endsWith("*")) return true;
	for (const skipped of skippedNamespaces) if (namespaceMatches(namespace, skipped)) return false;
	for (const enabledNamespace of enabledNamespaces) if (namespaceMatches(namespace, enabledNamespace)) return true;
	return false;
}
/**
* Given a namespace, check if it matches a pattern.
* Patterns only have a single wildcard character which is *.
* The behavior of * is that it matches zero or more other characters.
*/
function namespaceMatches(namespace, patternToMatch) {
	if (patternToMatch.indexOf("*") === -1) return namespace === patternToMatch;
	let pattern = patternToMatch;
	if (patternToMatch.indexOf("**") !== -1) {
		const patternParts = [];
		let lastCharacter = "";
		for (const character of patternToMatch) if (character === "*" && lastCharacter === "*") continue;
		else {
			lastCharacter = character;
			patternParts.push(character);
		}
		pattern = patternParts.join("");
	}
	let namespaceIndex = 0;
	let patternIndex = 0;
	const patternLength = pattern.length;
	const namespaceLength = namespace.length;
	let lastWildcard = -1;
	let lastWildcardNamespace = -1;
	while (namespaceIndex < namespaceLength && patternIndex < patternLength) if (pattern[patternIndex] === "*") {
		lastWildcard = patternIndex;
		patternIndex++;
		if (patternIndex === patternLength) return true;
		while (namespace[namespaceIndex] !== pattern[patternIndex]) {
			namespaceIndex++;
			if (namespaceIndex === namespaceLength) return false;
		}
		lastWildcardNamespace = namespaceIndex;
		namespaceIndex++;
		patternIndex++;
		continue;
	} else if (pattern[patternIndex] === namespace[namespaceIndex]) {
		patternIndex++;
		namespaceIndex++;
	} else if (lastWildcard >= 0) {
		patternIndex = lastWildcard + 1;
		namespaceIndex = lastWildcardNamespace + 1;
		if (namespaceIndex === namespaceLength) return false;
		while (namespace[namespaceIndex] !== pattern[patternIndex]) {
			namespaceIndex++;
			if (namespaceIndex === namespaceLength) return false;
		}
		lastWildcardNamespace = namespaceIndex;
		namespaceIndex++;
		patternIndex++;
		continue;
	} else return false;
	const namespaceDone = namespaceIndex === namespace.length;
	const patternDone = patternIndex === pattern.length;
	const trailingWildCard = patternIndex === pattern.length - 1 && pattern[patternIndex] === "*";
	return namespaceDone && (patternDone || trailingWildCard);
}
function disable() {
	const result = enabledString || "";
	enable("");
	return result;
}
function createDebugger(namespace) {
	const newDebugger = Object.assign(debug, {
		enabled: enabled(namespace),
		destroy,
		log: debugObj.log,
		namespace,
		extend
	});
	function debug(...args) {
		if (!newDebugger.enabled) return;
		if (args.length > 0) args[0] = `${namespace} ${args[0]}`;
		newDebugger.log(...args);
	}
	debuggers.push(newDebugger);
	return newDebugger;
}
function destroy() {
	const index = debuggers.indexOf(this);
	if (index >= 0) {
		debuggers.splice(index, 1);
		return true;
	}
	return false;
}
function extend(namespace) {
	const newDebugger = createDebugger(`${this.namespace}:${namespace}`);
	newDebugger.log = this.log;
	return newDebugger;
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/logger/logger.js
var TYPESPEC_RUNTIME_LOG_LEVELS = [
	"verbose",
	"info",
	"warning",
	"error"
];
var levelMap = {
	verbose: 400,
	info: 300,
	warning: 200,
	error: 100
};
function patchLogMethod(parent, child) {
	child.log = (...args) => {
		parent.log(...args);
	};
}
function isTypeSpecRuntimeLogLevel(level) {
	return TYPESPEC_RUNTIME_LOG_LEVELS.includes(level);
}
/**
* Creates a logger context base on the provided options.
* @param options - The options for creating a logger context.
* @returns The logger context.
*/
function createLoggerContext(options) {
	const registeredLoggers = /* @__PURE__ */ new Set();
	const logLevelFromEnv = getEnvironmentVariable(options.logLevelEnvVarName);
	let logLevel;
	const clientLogger = debugObj(options.namespace);
	clientLogger.log = (...args) => {
		debugObj.log(...args);
	};
	function contextSetLogLevel(level) {
		if (level && !isTypeSpecRuntimeLogLevel(level)) throw new Error(`Unknown log level '${level}'. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(",")}`);
		logLevel = level;
		const enabledNamespaces = [];
		for (const logger of registeredLoggers) if (shouldEnable(logger)) enabledNamespaces.push(logger.namespace);
		debugObj.enable(enabledNamespaces.join(","));
	}
	if (logLevelFromEnv) {
		if (isTypeSpecRuntimeLogLevel(logLevelFromEnv)) contextSetLogLevel(logLevelFromEnv);
		else console.error(`${options.logLevelEnvVarName} set to unknown log level '${logLevelFromEnv}'; logging is not enabled. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(", ")}.`);
	}
	function shouldEnable(logger) {
		return Boolean(logLevel && levelMap[logger.level] <= levelMap[logLevel]);
	}
	function createLogger(parent, level) {
		const logger = Object.assign(parent.extend(level), { level });
		patchLogMethod(parent, logger);
		if (shouldEnable(logger)) {
			const enabledNamespaces = debugObj.disable();
			debugObj.enable(enabledNamespaces + "," + logger.namespace);
		}
		registeredLoggers.add(logger);
		return logger;
	}
	function contextGetLogLevel() {
		return logLevel;
	}
	function contextCreateClientLogger(namespace) {
		const clientRootLogger = clientLogger.extend(namespace);
		patchLogMethod(clientLogger, clientRootLogger);
		return {
			error: createLogger(clientRootLogger, "error"),
			warning: createLogger(clientRootLogger, "warning"),
			info: createLogger(clientRootLogger, "info"),
			verbose: createLogger(clientRootLogger, "verbose")
		};
	}
	return {
		setLogLevel: contextSetLogLevel,
		getLogLevel: contextGetLogLevel,
		createClientLogger: contextCreateClientLogger,
		logger: clientLogger
	};
}
var context$1 = createLoggerContext({
	logLevelEnvVarName: "TYPESPEC_RUNTIME_LOG_LEVEL",
	namespace: "typeSpecRuntime"
});
context$1.logger;
/**
* Creates a logger for use by the SDKs that inherits from `TypeSpecRuntimeLogger`.
* @param namespace - The name of the SDK package.
* @hidden
*/
function createClientLogger$1(namespace) {
	return context$1.createClientLogger(namespace);
}
__name(createClientLogger$1, "createClientLogger");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/httpHeaders.js
function normalizeName(name) {
	return name.toLowerCase();
}
/**
* Removes CR and LF characters from a header value to prevent obs-fold
* (line folding) sequences, as forbidden by RFC 7230 §3.2.4.
* @param value - The header value to sanitize.
*/
function normalizeValue(value) {
	return String(value).trim().replace(/[\r\n]/g, "");
}
function* headerIterator(map) {
	for (const entry of map.values()) yield [entry.name, entry.value];
}
var HttpHeadersImpl = class {
	_headersMap;
	constructor(rawHeaders) {
		this._headersMap = /* @__PURE__ */ new Map();
		if (rawHeaders) for (const headerName of Object.keys(rawHeaders)) this.set(headerName, rawHeaders[headerName]);
	}
	/**
	* Set a header in this collection with the provided name and value. The name is
	* case-insensitive.
	* @param name - The name of the header to set. This value is case-insensitive.
	* @param value - The value of the header to set.
	*/
	set(name, value) {
		this._headersMap.set(normalizeName(name), {
			name,
			value: normalizeValue(value)
		});
	}
	/**
	* Get the header value for the provided header name, or undefined if no header exists in this
	* collection with the provided name.
	* @param name - The name of the header. This value is case-insensitive.
	*/
	get(name) {
		return this._headersMap.get(normalizeName(name))?.value;
	}
	/**
	* Get whether or not this header collection contains a header entry for the provided header name.
	* @param name - The name of the header to set. This value is case-insensitive.
	*/
	has(name) {
		return this._headersMap.has(normalizeName(name));
	}
	/**
	* Remove the header with the provided headerName.
	* @param name - The name of the header to remove.
	*/
	delete(name) {
		this._headersMap.delete(normalizeName(name));
	}
	/**
	* Get the JSON object representation of this HTTP header collection.
	*/
	toJSON(options = {}) {
		const result = {};
		if (options.preserveCase) for (const entry of this._headersMap.values()) result[entry.name] = entry.value;
		else for (const [normalizedName, entry] of this._headersMap) result[normalizedName] = entry.value;
		return result;
	}
	/**
	* Get the string representation of this HTTP header collection.
	*/
	toString() {
		return JSON.stringify(this.toJSON({ preserveCase: true }));
	}
	/**
	* Iterate over tuples of header [name, value] pairs.
	*/
	[Symbol.iterator]() {
		return headerIterator(this._headersMap);
	}
};
/**
* Creates an object that satisfies the `HttpHeaders` interface.
* @param rawHeaders - A simple object representing initial headers
*/
function createHttpHeaders$1(rawHeaders) {
	return new HttpHeadersImpl(rawHeaders);
}
__name(createHttpHeaders$1, "createHttpHeaders");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/uuidUtils.js
/**
* Generated Universally Unique Identifier
*
* @returns RFC4122 v4 UUID.
*/
function randomUUID$1() {
	return globalThis.crypto.randomUUID();
}
__name(randomUUID$1, "randomUUID");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/pipelineRequest.js
var PipelineRequestImpl = class {
	url;
	method;
	headers;
	timeout;
	withCredentials;
	body;
	multipartBody;
	formData;
	streamResponseStatusCodes;
	enableBrowserStreams;
	proxySettings;
	disableKeepAlive;
	abortSignal;
	requestId;
	allowInsecureConnection;
	onUploadProgress;
	onDownloadProgress;
	requestOverrides;
	authSchemes;
	constructor(options) {
		this.url = options.url;
		this.body = options.body;
		this.headers = options.headers ?? createHttpHeaders$1();
		this.method = options.method ?? "GET";
		this.timeout = options.timeout ?? 0;
		this.multipartBody = options.multipartBody;
		this.formData = options.formData;
		this.disableKeepAlive = options.disableKeepAlive ?? false;
		this.proxySettings = options.proxySettings;
		this.streamResponseStatusCodes = options.streamResponseStatusCodes;
		this.withCredentials = options.withCredentials ?? false;
		this.abortSignal = options.abortSignal;
		this.onUploadProgress = options.onUploadProgress;
		this.onDownloadProgress = options.onDownloadProgress;
		this.requestId = options.requestId || randomUUID$1();
		this.allowInsecureConnection = options.allowInsecureConnection ?? false;
		this.enableBrowserStreams = options.enableBrowserStreams ?? false;
		this.requestOverrides = options.requestOverrides;
		this.authSchemes = options.authSchemes;
	}
};
/**
* Creates a new pipeline request with the given options.
* This method is to allow for the easy setting of default values and not required.
* @param options - The options to create the request with.
*/
function createPipelineRequest$1(options) {
	return new PipelineRequestImpl(options);
}
__name(createPipelineRequest$1, "createPipelineRequest");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/pipeline.js
var ValidPhaseNames = /* @__PURE__ */ new Set([
	"Deserialize",
	"Serialize",
	"Retry",
	"Sign"
]);
/**
* A private implementation of Pipeline.
* Do not export this class from the package.
* @internal
*/
var HttpPipeline = class HttpPipeline {
	_policies = [];
	_orderedPolicies;
	constructor(policies) {
		this._policies = policies?.slice(0) ?? [];
		this._orderedPolicies = void 0;
	}
	addPolicy(policy, options = {}) {
		if (options.phase && options.afterPhase) throw new Error("Policies inside a phase cannot specify afterPhase.");
		if (options.phase && !ValidPhaseNames.has(options.phase)) throw new Error(`Invalid phase name: ${options.phase}`);
		if (options.afterPhase && !ValidPhaseNames.has(options.afterPhase)) throw new Error(`Invalid afterPhase name: ${options.afterPhase}`);
		this._policies.push({
			policy,
			options
		});
		this._orderedPolicies = void 0;
	}
	removePolicy(options) {
		const removedPolicies = [];
		this._policies = this._policies.filter((policyDescriptor) => {
			if (options.name && policyDescriptor.policy.name === options.name || options.phase && policyDescriptor.options.phase === options.phase) {
				removedPolicies.push(policyDescriptor.policy);
				return false;
			} else return true;
		});
		this._orderedPolicies = void 0;
		return removedPolicies;
	}
	sendRequest(httpClient, request) {
		return this.getOrderedPolicies().reduceRight((next, policy) => {
			return (req) => {
				return policy.sendRequest(req, next);
			};
		}, (req) => httpClient.sendRequest(req))(request);
	}
	getOrderedPolicies() {
		if (!this._orderedPolicies) this._orderedPolicies = this.orderPolicies();
		return this._orderedPolicies;
	}
	clone() {
		return new HttpPipeline(this._policies);
	}
	static create() {
		return new HttpPipeline();
	}
	orderPolicies() {
		/**
		* The goal of this method is to reliably order pipeline policies
		* based on their declared requirements when they were added.
		*
		* Order is first determined by phase:
		*
		* 1. Serialize Phase
		* 2. Policies not in a phase
		* 3. Deserialize Phase
		* 4. Retry Phase
		* 5. Sign Phase
		*
		* Within each phase, policies are executed in the order
		* they were added unless they were specified to execute
		* before/after other policies or after a particular phase.
		*
		* To determine the final order, we will walk the policy list
		* in phase order multiple times until all dependencies are
		* satisfied.
		*
		* `afterPolicies` are the set of policies that must be
		* executed before a given policy. This requirement is
		* considered satisfied when each of the listed policies
		* have been scheduled.
		*
		* `beforePolicies` are the set of policies that must be
		* executed after a given policy. Since this dependency
		* can be expressed by converting it into a equivalent
		* `afterPolicies` declarations, they are normalized
		* into that form for simplicity.
		*
		* An `afterPhase` dependency is considered satisfied when all
		* policies in that phase have scheduled.
		*
		*/
		const result = [];
		const policyMap = /* @__PURE__ */ new Map();
		function createPhase(name) {
			return {
				name,
				policies: /* @__PURE__ */ new Set(),
				hasRun: false,
				hasAfterPolicies: false
			};
		}
		const serializePhase = createPhase("Serialize");
		const noPhase = createPhase("None");
		const deserializePhase = createPhase("Deserialize");
		const retryPhase = createPhase("Retry");
		const signPhase = createPhase("Sign");
		const orderedPhases = [
			serializePhase,
			noPhase,
			deserializePhase,
			retryPhase,
			signPhase
		];
		function getPhase(phase) {
			if (phase === "Retry") return retryPhase;
			else if (phase === "Serialize") return serializePhase;
			else if (phase === "Deserialize") return deserializePhase;
			else if (phase === "Sign") return signPhase;
			else return noPhase;
		}
		for (const descriptor of this._policies) {
			const policy = descriptor.policy;
			const options = descriptor.options;
			const policyName = policy.name;
			if (policyMap.has(policyName)) throw new Error("Duplicate policy names not allowed in pipeline");
			const node = {
				policy,
				dependsOn: /* @__PURE__ */ new Set(),
				dependants: /* @__PURE__ */ new Set()
			};
			if (options.afterPhase) {
				node.afterPhase = getPhase(options.afterPhase);
				node.afterPhase.hasAfterPolicies = true;
			}
			policyMap.set(policyName, node);
			getPhase(options.phase).policies.add(node);
		}
		for (const descriptor of this._policies) {
			const { policy, options } = descriptor;
			const policyName = policy.name;
			const node = policyMap.get(policyName);
			if (!node) throw new Error(`Missing node for policy ${policyName}`);
			if (options.afterPolicies) for (const afterPolicyName of options.afterPolicies) {
				const afterNode = policyMap.get(afterPolicyName);
				if (afterNode) {
					node.dependsOn.add(afterNode);
					afterNode.dependants.add(node);
				}
			}
			if (options.beforePolicies) for (const beforePolicyName of options.beforePolicies) {
				const beforeNode = policyMap.get(beforePolicyName);
				if (beforeNode) {
					beforeNode.dependsOn.add(node);
					node.dependants.add(beforeNode);
				}
			}
		}
		function walkPhase(phase) {
			phase.hasRun = true;
			for (const node of phase.policies) {
				if (node.afterPhase && (!node.afterPhase.hasRun || node.afterPhase.policies.size)) continue;
				if (node.dependsOn.size === 0) {
					result.push(node.policy);
					for (const dependant of node.dependants) dependant.dependsOn.delete(node);
					policyMap.delete(node.policy.name);
					phase.policies.delete(node);
				}
			}
		}
		function walkPhases() {
			for (const phase of orderedPhases) {
				walkPhase(phase);
				if (phase.policies.size > 0 && phase !== noPhase) {
					if (!noPhase.hasRun) walkPhase(noPhase);
					return;
				}
				if (phase.hasAfterPolicies) walkPhase(noPhase);
			}
		}
		let iteration = 0;
		while (policyMap.size > 0) {
			iteration++;
			const initialResultLength = result.length;
			walkPhases();
			if (result.length <= initialResultLength && iteration > 1) throw new Error("Cannot satisfy policy dependencies due to requirements cycle.");
		}
		return result;
	}
};
/**
* Creates a totally empty pipeline.
* Useful for testing or creating a custom one.
*/
function createEmptyPipeline$1() {
	return HttpPipeline.create();
}
__name(createEmptyPipeline$1, "createEmptyPipeline");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/object.js
/**
* Helper to determine when an input is a generic JS object.
* @returns true when input is an object type that is not null, Array, RegExp, or Date.
*/
function isObject(input) {
	return typeof input === "object" && input !== null && !Array.isArray(input) && !(input instanceof RegExp) && !(input instanceof Date);
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/error.js
/**
* Typeguard for an error object shape (has name and message)
* @param e - Something caught by a catch clause.
*/
function isError$1(e) {
	if (isObject(e)) {
		const hasName = typeof e.name === "string";
		const hasMessage = typeof e.message === "string";
		return hasName && hasMessage;
	}
	return false;
}
__name(isError$1, "isError");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/inspect.js
var custom = inspect.custom;
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/sanitizer.js
var RedactedString = "REDACTED";
var defaultAllowedHeaderNames = [
	"x-ms-client-request-id",
	"x-ms-return-client-request-id",
	"x-ms-useragent",
	"x-ms-correlation-request-id",
	"x-ms-request-id",
	"client-request-id",
	"ms-cv",
	"return-client-request-id",
	"traceparent",
	"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",
	"Origin",
	"Accept",
	"Accept-Encoding",
	"Cache-Control",
	"Connection",
	"Content-Length",
	"Content-Type",
	"Date",
	"ETag",
	"Expires",
	"If-Match",
	"If-Modified-Since",
	"If-None-Match",
	"If-Unmodified-Since",
	"Last-Modified",
	"Pragma",
	"Request-Id",
	"Retry-After",
	"Server",
	"Transfer-Encoding",
	"User-Agent",
	"WWW-Authenticate"
];
var defaultAllowedQueryParameters = ["api-version"];
/**
* A utility class to sanitize objects for logging.
*/
var Sanitizer = class {
	allowedHeaderNames;
	allowedQueryParameters;
	constructor({ additionalAllowedHeaderNames: allowedHeaderNames = [], additionalAllowedQueryParameters: allowedQueryParameters = [] } = {}) {
		allowedHeaderNames = defaultAllowedHeaderNames.concat(allowedHeaderNames);
		allowedQueryParameters = defaultAllowedQueryParameters.concat(allowedQueryParameters);
		this.allowedHeaderNames = new Set(allowedHeaderNames.map((n) => n.toLowerCase()));
		this.allowedQueryParameters = new Set(allowedQueryParameters.map((p) => p.toLowerCase()));
	}
	/**
	* Sanitizes an object for logging.
	* @param obj - The object to sanitize
	* @returns - The sanitized object as a string
	*/
	sanitize(obj) {
		const seen = /* @__PURE__ */ new Set();
		return JSON.stringify(obj, (key, value) => {
			if (value instanceof Error) return {
				...value,
				name: value.name,
				message: value.message
			};
			if (key === "headers" && isObject(value)) return this.sanitizeHeaders(value);
			else if (key === "url" && typeof value === "string") return this.sanitizeUrl(value);
			else if (key === "query" && isObject(value)) return this.sanitizeQuery(value);
			else if (key === "body") return;
			else if (key === "response") return;
			else if (key === "operationSpec") return;
			else if (Array.isArray(value) || isObject(value)) {
				if (seen.has(value)) return "[Circular]";
				seen.add(value);
			}
			return value;
		}, 2);
	}
	/**
	* Sanitizes a URL for logging.
	* @param value - The URL to sanitize
	* @returns - The sanitized URL as a string
	*/
	sanitizeUrl(value) {
		if (typeof value !== "string" || value === null || value === "") return value;
		const url = new URL(value);
		if (!url.search) return value;
		for (const [key] of url.searchParams) if (!this.allowedQueryParameters.has(key.toLowerCase())) url.searchParams.set(key, RedactedString);
		return url.toString();
	}
	sanitizeHeaders(obj) {
		const sanitized = {};
		for (const key of Object.keys(obj)) if (this.allowedHeaderNames.has(key.toLowerCase())) sanitized[key] = obj[key];
		else sanitized[key] = RedactedString;
		return sanitized;
	}
	sanitizeQuery(value) {
		if (typeof value !== "object" || value === null) return value;
		const sanitized = {};
		for (const k of Object.keys(value)) if (this.allowedQueryParameters.has(k.toLowerCase())) sanitized[k] = value[k];
		else sanitized[k] = RedactedString;
		return sanitized;
	}
};
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/restError.js
var errorSanitizer = new Sanitizer();
/**
* A custom error type for failed pipeline requests.
*/
var RestError$1 = class RestError$1 extends Error {
	static {
		__name(this, "RestError");
	}
	/**
	* Something went wrong when making the request.
	* This means the actual request failed for some reason,
	* such as a DNS issue or the connection being lost.
	*/
	static REQUEST_SEND_ERROR = "REQUEST_SEND_ERROR";
	/**
	* This means that parsing the response from the server failed.
	* It may have been malformed.
	*/
	static PARSE_ERROR = "PARSE_ERROR";
	/**
	* The code of the error itself (use statics on RestError if possible.)
	*/
	code;
	/**
	* The HTTP status code of the request (if applicable.)
	*/
	statusCode;
	/**
	* The request that was made.
	* This property is non-enumerable.
	*/
	request;
	/**
	* The response received (if any.)
	* This property is non-enumerable.
	*/
	response;
	/**
	* Bonus property set by the throw site.
	*/
	details;
	constructor(message, options = {}) {
		super(message);
		this.name = "RestError";
		this.code = options.code;
		this.statusCode = options.statusCode;
		Object.defineProperty(this, "request", {
			value: options.request,
			enumerable: false
		});
		Object.defineProperty(this, "response", {
			value: options.response,
			enumerable: false
		});
		const agent = this.request?.agent ? {
			maxFreeSockets: this.request.agent.maxFreeSockets,
			maxSockets: this.request.agent.maxSockets
		} : void 0;
		Object.defineProperty(this, custom, {
			value: () => {
				return `RestError: ${this.message} \n ${errorSanitizer.sanitize({
					...this,
					request: {
						...this.request,
						agent
					},
					response: this.response
				})}`;
			},
			enumerable: false
		});
		Object.setPrototypeOf(this, RestError$1.prototype);
	}
};
/**
* Typeguard for RestError
* @param e - Something caught by a catch clause.
*/
function isRestError$1(e) {
	if (e instanceof RestError$1) return true;
	return isError$1(e) && e.name === "RestError";
}
__name(isRestError$1, "isRestError");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/bytesEncoding.js
/**
* The helper that transforms bytes with specific character encoding into string
* @param bytes - the uint8array bytes
* @param format - the format we use to encode the byte
* @returns a string of the encoded string
*/
function uint8ArrayToString$1(bytes, format) {
	return Buffer.from(bytes).toString(format);
}
__name(uint8ArrayToString$1, "uint8ArrayToString");
/**
* The helper that transforms string to specific character encoded bytes array.
* @param value - the string to be converted
* @param format - the format we use to decode the value
* @returns a uint8array
*/
function stringToUint8Array$1(value, format) {
	return Buffer.from(value, format);
}
__name(stringToUint8Array$1, "stringToUint8Array");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/log.js
var logger$4 = createClientLogger$1("ts-http-runtime");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/nodeHttpClient.js
var DEFAULT_TLS_SETTINGS = {};
function isReadableStream(body) {
	return body && typeof body.pipe === "function";
}
function isStreamComplete(stream) {
	if (stream.readable === false) return Promise.resolve();
	return new Promise((resolve) => {
		const handler = () => {
			resolve();
			stream.removeListener("close", handler);
			stream.removeListener("end", handler);
			stream.removeListener("error", handler);
		};
		stream.on("close", handler);
		stream.on("end", handler);
		stream.on("error", handler);
	});
}
function isArrayBuffer(body) {
	return body && typeof body.byteLength === "number";
}
var ReportTransform = class extends Transform {
	loadedBytes = 0;
	progressCallback;
	_transform(chunk, _encoding, callback) {
		this.push(chunk);
		this.loadedBytes += chunk.length;
		try {
			this.progressCallback({ loadedBytes: this.loadedBytes });
			callback();
		} catch (e) {
			callback(e);
		}
	}
	constructor(progressCallback) {
		super();
		this.progressCallback = progressCallback;
	}
};
/**
* A HttpClient implementation that uses Node's "https" module to send HTTPS requests.
* @internal
*/
var NodeHttpClient = class {
	cachedHttpAgent;
	cachedHttpsAgents = /* @__PURE__ */ new WeakMap();
	/**
	* Makes a request over an underlying transport layer and returns the response.
	* @param request - The request to be made.
	*/
	async sendRequest(request) {
		const abortController = new AbortController();
		let abortListener;
		if (request.abortSignal) {
			if (request.abortSignal.aborted) throw new AbortError$1("The operation was aborted. Request has already been canceled.");
			abortListener = (event) => {
				if (event.type === "abort") abortController.abort();
			};
			request.abortSignal.addEventListener("abort", abortListener);
		}
		let timeoutId;
		if (request.timeout > 0) timeoutId = setTimeout(() => {
			const sanitizer = new Sanitizer();
			logger$4.info(`request to '${sanitizer.sanitizeUrl(request.url)}' timed out. canceling...`);
			abortController.abort();
		}, request.timeout);
		const acceptEncoding = request.headers.get("Accept-Encoding");
		const shouldDecompress = acceptEncoding?.includes("gzip") || acceptEncoding?.includes("deflate");
		let body = typeof request.body === "function" ? request.body() : request.body;
		if (body && !request.headers.has("Content-Length")) {
			const bodyLength = getBodyLength(body);
			if (bodyLength !== null) request.headers.set("Content-Length", bodyLength);
		}
		let responseStream;
		try {
			if (body && request.onUploadProgress) {
				const onUploadProgress = request.onUploadProgress;
				const uploadReportStream = new ReportTransform(onUploadProgress);
				uploadReportStream.on("error", (e) => {
					logger$4.error("Error in upload progress", e);
				});
				if (isReadableStream(body)) body.pipe(uploadReportStream);
				else uploadReportStream.end(body);
				body = uploadReportStream;
			}
			const res = await this.makeRequest(request, abortController, body);
			if (timeoutId !== void 0) clearTimeout(timeoutId);
			const headers = getResponseHeaders(res);
			const response = {
				status: res.statusCode ?? 0,
				headers,
				request
			};
			if (request.method === "HEAD") {
				res.resume();
				return response;
			}
			responseStream = shouldDecompress ? getDecodedResponseStream(res, headers) : res;
			const onDownloadProgress = request.onDownloadProgress;
			if (onDownloadProgress) {
				const downloadReportStream = new ReportTransform(onDownloadProgress);
				downloadReportStream.on("error", (e) => {
					logger$4.error("Error in download progress", e);
				});
				responseStream.pipe(downloadReportStream);
				responseStream = downloadReportStream;
			}
			if (request.streamResponseStatusCodes?.has(Number.POSITIVE_INFINITY) || request.streamResponseStatusCodes?.has(response.status)) response.readableStreamBody = responseStream;
			else response.bodyAsText = await streamToText(responseStream);
			return response;
		} finally {
			if (request.abortSignal && abortListener) {
				let uploadStreamDone = Promise.resolve();
				if (isReadableStream(body)) uploadStreamDone = isStreamComplete(body);
				let downloadStreamDone = Promise.resolve();
				if (isReadableStream(responseStream)) downloadStreamDone = isStreamComplete(responseStream);
				Promise.all([uploadStreamDone, downloadStreamDone]).then(() => {
					if (abortListener) request.abortSignal?.removeEventListener("abort", abortListener);
				}).catch((e) => {
					logger$4.warning("Error when cleaning up abortListener on httpRequest", e);
				});
			}
		}
	}
	makeRequest(request, abortController, body) {
		const url = new URL(request.url);
		const isInsecure = url.protocol !== "https:";
		if (isInsecure && !request.allowInsecureConnection) throw new Error(`Cannot connect to ${request.url} while allowInsecureConnection is false.`);
		const options = {
			agent: request.agent ?? this.getOrCreateAgent(request, isInsecure),
			hostname: url.hostname,
			path: `${url.pathname}${url.search}`,
			port: url.port,
			method: request.method,
			headers: request.headers.toJSON({ preserveCase: true }),
			...request.requestOverrides
		};
		return new Promise((resolve, reject) => {
			const req = isInsecure ? http.request(options, resolve) : https.request(options, resolve);
			req.once("error", (err) => {
				reject(new RestError$1(err.message, {
					code: err.code ?? RestError$1.REQUEST_SEND_ERROR,
					request
				}));
			});
			abortController.signal.addEventListener("abort", () => {
				const abortError = new AbortError$1("The operation was aborted. Rejecting from abort signal callback while making request.");
				req.destroy(abortError);
				reject(abortError);
			});
			if (body && isReadableStream(body)) body.pipe(req);
			else if (body) {
				if (typeof body === "string" || Buffer.isBuffer(body)) req.end(body);
				else if (isArrayBuffer(body)) req.end(ArrayBuffer.isView(body) ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : Buffer.from(body));
				else {
					logger$4.error("Unrecognized body type", body);
					reject(new RestError$1("Unrecognized body type"));
				}
			} else req.end();
		});
	}
	getOrCreateAgent(request, isInsecure) {
		const disableKeepAlive = request.disableKeepAlive;
		if (isInsecure) {
			if (disableKeepAlive) return http.globalAgent;
			if (!this.cachedHttpAgent) this.cachedHttpAgent = new http.Agent({ keepAlive: true });
			return this.cachedHttpAgent;
		} else {
			if (disableKeepAlive && !request.tlsSettings) return https.globalAgent;
			const tlsSettings = request.tlsSettings ?? DEFAULT_TLS_SETTINGS;
			let agent = this.cachedHttpsAgents.get(tlsSettings);
			if (agent && agent.options.keepAlive === !disableKeepAlive) return agent;
			logger$4.info("No cached TLS Agent exist, creating a new Agent");
			agent = new https.Agent({
				keepAlive: !disableKeepAlive,
				...tlsSettings
			});
			this.cachedHttpsAgents.set(tlsSettings, agent);
			return agent;
		}
	}
};
function getResponseHeaders(res) {
	const headers = createHttpHeaders$1();
	for (const header of Object.keys(res.headers)) {
		const value = res.headers[header];
		if (Array.isArray(value)) {
			if (value.length > 0) headers.set(header, value[0]);
		} else if (value) headers.set(header, value);
	}
	return headers;
}
function getDecodedResponseStream(stream, headers) {
	const contentEncoding = headers.get("Content-Encoding");
	if (contentEncoding === "gzip") {
		const unzip = zlib.createGunzip();
		stream.pipe(unzip);
		return unzip;
	} else if (contentEncoding === "deflate") {
		const inflate = zlib.createInflate();
		stream.pipe(inflate);
		return inflate;
	}
	return stream;
}
function streamToText(stream) {
	return new Promise((resolve, reject) => {
		const buffer = [];
		stream.on("data", (chunk) => {
			if (Buffer.isBuffer(chunk)) buffer.push(chunk);
			else buffer.push(Buffer.from(chunk));
		});
		stream.on("end", () => {
			resolve(Buffer.concat(buffer).toString("utf8"));
		});
		stream.on("error", (e) => {
			if (e && e?.name === "AbortError") reject(e);
			else reject(new RestError$1(`Error reading response as text: ${e.message}`, { code: RestError$1.PARSE_ERROR }));
		});
	});
}
/** @internal */
function getBodyLength(body) {
	if (!body) return 0;
	else if (Buffer.isBuffer(body)) return body.length;
	else if (isReadableStream(body)) return null;
	else if (isArrayBuffer(body)) return body.byteLength;
	else if (typeof body === "string") return Buffer.from(body).length;
	else return null;
}
/**
* Create a new HttpClient instance for the NodeJS environment.
* @internal
*/
function createNodeHttpClient() {
	return new NodeHttpClient();
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/defaultHttpClient.js
/**
* Create the correct HttpClient for the current environment.
*/
function createDefaultHttpClient$1() {
	return createNodeHttpClient();
}
__name(createDefaultHttpClient$1, "createDefaultHttpClient");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/logPolicy.js
/**
* The programmatic identifier of the logPolicy.
*/
var logPolicyName = "logPolicy";
/**
* A policy that logs all requests and responses.
* @param options - Options to configure logPolicy.
*/
function logPolicy$1(options = {}) {
	const logger = options.logger ?? logger$4.info;
	const sanitizer = new Sanitizer({
		additionalAllowedHeaderNames: options.additionalAllowedHeaderNames,
		additionalAllowedQueryParameters: options.additionalAllowedQueryParameters
	});
	return {
		name: logPolicyName,
		async sendRequest(request, next) {
			if (!logger.enabled) return next(request);
			logger(`Request: ${sanitizer.sanitize(request)}`);
			const response = await next(request);
			logger(`Response status code: ${response.status}`);
			logger(`Headers: ${sanitizer.sanitize({ headers: response.headers })}`);
			return response;
		}
	};
}
__name(logPolicy$1, "logPolicy");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/random.js
/**
* Returns a random integer value between a lower and upper bound,
* inclusive of both bounds.
* Note that this uses Math.random and isn't secure. If you need to use
* this for any kind of security purpose, find a better source of random.
* @param min - The smallest integer value allowed.
* @param max - The largest integer value allowed.
*/
function getRandomIntegerInclusive(min, max) {
	min = Math.ceil(min);
	max = Math.floor(max);
	return Math.floor(Math.random() * (max - min + 1)) + min;
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/delay.js
/**
* Calculates the delay interval for retry attempts using exponential delay with jitter.
* @param retryAttempt - The current retry attempt number.
* @param config - The exponential retry configuration.
* @returns An object containing the calculated retry delay.
*/
function calculateRetryDelay(retryAttempt, config) {
	const exponentialDelay = config.retryDelayInMs * Math.pow(2, retryAttempt);
	const clampedDelay = Math.min(config.maxRetryDelayInMs, exponentialDelay);
	return { retryAfterInMs: clampedDelay / 2 + getRandomIntegerInclusive(0, clampedDelay / 2) };
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/helpers.js
var StandardAbortMessage$1 = "The operation was aborted.";
/**
* A wrapper for setTimeout that resolves a promise after delayInMs milliseconds.
* @param delayInMs - The number of milliseconds to be delayed.
* @param value - The value to be resolved with after a timeout of t milliseconds.
* @param options - The options for delay - currently abort options
*                  - abortSignal - The abortSignal associated with containing operation.
*                  - abortErrorMsg - The abort error message associated with containing operation.
* @returns Resolved promise
*/
function delay$2(delayInMs, value, options) {
	return new Promise((resolve, reject) => {
		let timer = void 0;
		let onAborted = void 0;
		const rejectOnAbort = () => {
			return reject(new AbortError$1(options?.abortErrorMsg ? options?.abortErrorMsg : StandardAbortMessage$1));
		};
		const removeListeners = () => {
			if (options?.abortSignal && onAborted) options.abortSignal.removeEventListener("abort", onAborted);
		};
		onAborted = () => {
			if (timer) clearTimeout(timer);
			removeListeners();
			return rejectOnAbort();
		};
		if (options?.abortSignal && options.abortSignal.aborted) return rejectOnAbort();
		timer = setTimeout(() => {
			removeListeners();
			resolve(value);
		}, delayInMs);
		if (options?.abortSignal) options.abortSignal.addEventListener("abort", onAborted);
	});
}
__name(delay$2, "delay");
/**
* @internal
* @returns the parsed value or undefined if the parsed value is invalid.
*/
function parseHeaderValueAsNumber(response, headerName) {
	const value = response.headers.get(headerName);
	if (!value) return;
	const valueAsNum = Number(value);
	if (Number.isNaN(valueAsNum)) return;
	return valueAsNum;
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/retryStrategies/throttlingRetryStrategy.js
/**
* The header that comes back from services representing
* the amount of time (minimum) to wait to retry (in seconds or timestamp after which we can retry).
*/
var RetryAfterHeader = "Retry-After";
/**
* The headers that come back from services representing
* the amount of time (minimum) to wait to retry.
*
* "retry-after-ms", "x-ms-retry-after-ms" : milliseconds
* "Retry-After" : seconds or timestamp
*/
var AllRetryAfterHeaders = [
	"retry-after-ms",
	"x-ms-retry-after-ms",
	RetryAfterHeader
];
/**
* A response is a throttling retry response if it has a throttling status code (429 or 503),
* as long as one of the [ "Retry-After" or "retry-after-ms" or "x-ms-retry-after-ms" ] headers has a valid value.
*
* Returns the `retryAfterInMs` value if the response is a throttling retry response.
* If not throttling retry response, returns `undefined`.
*
* @internal
*/
function getRetryAfterInMs(response) {
	if (!(response && [429, 503].includes(response.status))) return void 0;
	try {
		for (const header of AllRetryAfterHeaders) {
			const retryAfterValue = parseHeaderValueAsNumber(response, header);
			if (retryAfterValue === 0 || retryAfterValue) return retryAfterValue * (header === RetryAfterHeader ? 1e3 : 1);
		}
		const retryAfterHeader = response.headers.get(RetryAfterHeader);
		if (!retryAfterHeader) return;
		const diff = Date.parse(retryAfterHeader) - Date.now();
		return Number.isFinite(diff) ? Math.max(0, diff) : void 0;
	} catch {
		return;
	}
}
/**
* A response is a retry response if it has a throttling status code (429 or 503),
* as long as one of the [ "Retry-After" or "retry-after-ms" or "x-ms-retry-after-ms" ] headers has a valid value.
*/
function isThrottlingRetryResponse(response) {
	return Number.isFinite(getRetryAfterInMs(response));
}
function throttlingRetryStrategy() {
	return {
		name: "throttlingRetryStrategy",
		retry({ response }) {
			const retryAfterInMs = getRetryAfterInMs(response);
			if (!Number.isFinite(retryAfterInMs)) return { skipStrategy: true };
			return { retryAfterInMs };
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/retryStrategies/exponentialRetryStrategy.js
var DEFAULT_CLIENT_RETRY_INTERVAL = 1e3;
var DEFAULT_CLIENT_MAX_RETRY_INTERVAL = 64e3;
/**
* A retry strategy that retries with an exponentially increasing delay in these two cases:
* - When there are errors in the underlying transport layer (e.g. DNS lookup failures).
* - Or otherwise if the outgoing request fails (408, greater or equal than 500, except for 501 and 505).
*/
function exponentialRetryStrategy(options = {}) {
	const retryInterval = options.retryDelayInMs ?? DEFAULT_CLIENT_RETRY_INTERVAL;
	const maxRetryInterval = options.maxRetryDelayInMs ?? DEFAULT_CLIENT_MAX_RETRY_INTERVAL;
	return {
		name: "exponentialRetryStrategy",
		retry({ retryCount, response, responseError }) {
			const matchedSystemError = isSystemError(responseError);
			const ignoreSystemErrors = matchedSystemError && options.ignoreSystemErrors;
			const isExponential = isExponentialRetryResponse(response);
			const ignoreExponentialResponse = isExponential && options.ignoreHttpStatusCodes;
			if (response && (isThrottlingRetryResponse(response) || !isExponential) || ignoreExponentialResponse || ignoreSystemErrors) return { skipStrategy: true };
			if (responseError && !matchedSystemError && !isExponential) return { errorToThrow: responseError };
			return calculateRetryDelay(retryCount, {
				retryDelayInMs: retryInterval,
				maxRetryDelayInMs: maxRetryInterval
			});
		}
	};
}
/**
* A response is a retry response if it has status codes:
* - 408, or
* - Greater or equal than 500, except for 501 and 505.
*/
function isExponentialRetryResponse(response) {
	return Boolean(response && response.status !== void 0 && (response.status >= 500 || response.status === 408) && response.status !== 501 && response.status !== 505);
}
/**
* Determines whether an error from a pipeline response was triggered in the network layer.
*/
function isSystemError(err) {
	if (!err) return false;
	return err.code === "ETIMEDOUT" || err.code === "ESOCKETTIMEDOUT" || err.code === "ECONNREFUSED" || err.code === "ECONNRESET" || err.code === "ENOENT" || err.code === "ENOTFOUND";
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/retryPolicy.js
var retryPolicyLogger = createClientLogger$1("ts-http-runtime retryPolicy");
/**
* The programmatic identifier of the retryPolicy.
*/
var retryPolicyName = "retryPolicy";
/**
* retryPolicy is a generic policy to enable retrying requests when certain conditions are met
*/
function retryPolicy(strategies, options = { maxRetries: 3 }) {
	const logger = options.logger || retryPolicyLogger;
	return {
		name: retryPolicyName,
		async sendRequest(request, next) {
			let response;
			let responseError;
			let retryCount = -1;
			retryRequest: while (true) {
				retryCount += 1;
				response = void 0;
				responseError = void 0;
				try {
					logger.info(`Retry ${retryCount}: Attempting to send request`, request.requestId);
					response = await next(request);
					logger.info(`Retry ${retryCount}: Received a response from request`, request.requestId);
				} catch (e) {
					logger.error(`Retry ${retryCount}: Received an error from request`, request.requestId);
					if (!isRestError$1(e)) throw e;
					responseError = e;
					response = e.response;
				}
				if (request.abortSignal?.aborted) {
					logger.error(`Retry ${retryCount}: Request aborted.`);
					throw new AbortError$1();
				}
				if (retryCount >= (options.maxRetries ?? 3)) {
					logger.info(`Retry ${retryCount}: Maximum retries reached. Returning the last received response, or throwing the last received error.`);
					if (responseError) throw responseError;
					else if (response) return response;
					else throw new Error("Maximum retries reached with no response or error to throw");
				}
				logger.info(`Retry ${retryCount}: Processing ${strategies.length} retry strategies.`);
				strategiesLoop: for (const strategy of strategies) {
					const strategyLogger = strategy.logger || logger;
					strategyLogger.info(`Retry ${retryCount}: Processing retry strategy ${strategy.name}.`);
					const modifiers = strategy.retry({
						retryCount,
						response,
						responseError
					});
					if (modifiers.skipStrategy) {
						strategyLogger.info(`Retry ${retryCount}: Skipped.`);
						continue strategiesLoop;
					}
					const { errorToThrow, retryAfterInMs, redirectTo } = modifiers;
					if (errorToThrow) {
						strategyLogger.error(`Retry ${retryCount}: Retry strategy ${strategy.name} throws error:`, errorToThrow);
						throw errorToThrow;
					}
					if (retryAfterInMs || retryAfterInMs === 0) {
						strategyLogger.info(`Retry ${retryCount}: Retry strategy ${strategy.name} retries after ${retryAfterInMs}`);
						await delay$2(retryAfterInMs, void 0, { abortSignal: request.abortSignal });
						continue retryRequest;
					}
					if (redirectTo) {
						strategyLogger.info(`Retry ${retryCount}: Retry strategy ${strategy.name} redirects to ${redirectTo}`);
						request.url = redirectTo;
						continue retryRequest;
					}
				}
				if (responseError) {
					logger.info(`None of the retry strategies could work with the received error. Throwing it.`);
					throw responseError;
				}
				if (response) {
					logger.info(`None of the retry strategies could work with the received response. Returning it.`);
					return response;
				}
			}
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/defaultRetryPolicy.js
/**
* Name of the {@link defaultRetryPolicy}
*/
var defaultRetryPolicyName = "defaultRetryPolicy";
/**
* A policy that retries according to three strategies:
* - When the server sends a 429 response with a Retry-After header.
* - When there are errors in the underlying transport layer (e.g. DNS lookup failures).
* - Or otherwise if the outgoing request fails, it will retry with an exponentially increasing delay.
*/
function defaultRetryPolicy$1(options = {}) {
	return {
		name: defaultRetryPolicyName,
		sendRequest: retryPolicy([throttlingRetryStrategy(), exponentialRetryStrategy(options)], { maxRetries: options.maxRetries ?? 3 }).sendRequest
	};
}
__name(defaultRetryPolicy$1, "defaultRetryPolicy");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/formData.js
/**
* If the request body is a native FormData, convert it to our FormDataMap
* representation and clear the body. Node.js's HTTP stack doesn't handle
* FormData natively, so the pipeline must serialize it later.
*
* @internal
*/
function convertBodyToFormDataMap(body) {
	if (typeof FormData !== "undefined" && body instanceof FormData) {
		const formDataMap = {};
		for (const [key, value] of body.entries()) {
			const existing = formDataMap[key];
			if (Array.isArray(existing)) existing.push(value);
			else formDataMap[key] = existing !== void 0 ? [existing, value] : [value];
		}
		return formDataMap;
	}
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/formDataPolicy.js
/**
* The programmatic identifier of the formDataPolicy.
*/
var formDataPolicyName = "formDataPolicy";
/**
* A policy that encodes FormData on the request into the body.
*/
function formDataPolicy$1() {
	return {
		name: formDataPolicyName,
		async sendRequest(request, next) {
			const converted = convertBodyToFormDataMap(request.body);
			if (converted) {
				request.formData = converted;
				request.body = void 0;
			}
			if (request.formData) {
				const contentType = request.headers.get("Content-Type");
				if (contentType && contentType.indexOf("application/x-www-form-urlencoded") !== -1) request.body = wwwFormUrlEncode(request.formData);
				else await prepareFormData(request.formData, request);
				request.formData = void 0;
			}
			return next(request);
		}
	};
}
__name(formDataPolicy$1, "formDataPolicy");
function wwwFormUrlEncode(formData) {
	const urlSearchParams = new URLSearchParams();
	for (const [key, value] of Object.entries(formData)) if (Array.isArray(value)) for (const subValue of value) urlSearchParams.append(key, subValue.toString());
	else urlSearchParams.append(key, value.toString());
	return urlSearchParams.toString();
}
async function prepareFormData(formData, request) {
	const contentType = request.headers.get("Content-Type");
	if (contentType && !contentType.startsWith("multipart/form-data")) return;
	request.headers.set("Content-Type", contentType ?? "multipart/form-data");
	const parts = [];
	for (const [fieldName, values] of Object.entries(formData)) for (const value of Array.isArray(values) ? values : [values]) if (typeof value === "string") parts.push({
		headers: createHttpHeaders$1({ "Content-Disposition": `form-data; name="${fieldName}"` }),
		body: stringToUint8Array$1(value, "utf-8")
	});
	else if (value === void 0 || value === null || typeof value !== "object") throw new Error(`Unexpected value for key ${fieldName}: ${value}. Value should be serialized to string first.`);
	else {
		const fileName = value.name || "blob";
		const headers = createHttpHeaders$1();
		headers.set("Content-Disposition", `form-data; name="${fieldName}"; filename="${fileName}"`);
		headers.set("Content-Type", value.type || "application/octet-stream");
		parts.push({
			headers,
			body: value
		});
	}
	request.multipartBody = { parts };
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/agentPolicy.js
/**
* Name of the Agent Policy
*/
var agentPolicyName = "agentPolicy";
/**
* Gets a pipeline policy that sets http.agent
*/
function agentPolicy$1(agent) {
	return {
		name: agentPolicyName,
		sendRequest: async (req, next) => {
			if (!req.agent) req.agent = agent;
			return next(req);
		}
	};
}
__name(agentPolicy$1, "agentPolicy");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/tlsPolicy.js
/**
* Name of the TLS Policy
*/
var tlsPolicyName = "tlsPolicy";
/**
* Gets a pipeline policy that adds the client certificate to the HttpClient agent for authentication.
*/
function tlsPolicy$1(tlsSettings) {
	return {
		name: tlsPolicyName,
		sendRequest: async (req, next) => {
			if (!req.tlsSettings) req.tlsSettings = tlsSettings;
			return next(req);
		}
	};
}
__name(tlsPolicy$1, "tlsPolicy");
//#endregion
//#region node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js
var require_ms = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/**
	* Helpers.
	*/
	var s = 1e3;
	var m = s * 60;
	var h = m * 60;
	var d = h * 24;
	var w = d * 7;
	var y = d * 365.25;
	/**
	* Parse or format the given `val`.
	*
	* Options:
	*
	*  - `long` verbose formatting [false]
	*
	* @param {String|Number} val
	* @param {Object} [options]
	* @throws {Error} throw an error if val is not a non-empty string or a number
	* @return {String|Number}
	* @api public
	*/
	module.exports = function(val, options) {
		options = options || {};
		var type = typeof val;
		if (type === "string" && val.length > 0) return parse(val);
		else if (type === "number" && isFinite(val)) return options.long ? fmtLong(val) : fmtShort(val);
		throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
	};
	/**
	* Parse the given `str` and return milliseconds.
	*
	* @param {String} str
	* @return {Number}
	* @api private
	*/
	function parse(str) {
		str = String(str);
		if (str.length > 100) return;
		var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
		if (!match) return;
		var n = parseFloat(match[1]);
		switch ((match[2] || "ms").toLowerCase()) {
			case "years":
			case "year":
			case "yrs":
			case "yr":
			case "y": return n * y;
			case "weeks":
			case "week":
			case "w": return n * w;
			case "days":
			case "day":
			case "d": return n * d;
			case "hours":
			case "hour":
			case "hrs":
			case "hr":
			case "h": return n * h;
			case "minutes":
			case "minute":
			case "mins":
			case "min":
			case "m": return n * m;
			case "seconds":
			case "second":
			case "secs":
			case "sec":
			case "s": return n * s;
			case "milliseconds":
			case "millisecond":
			case "msecs":
			case "msec":
			case "ms": return n;
			default: return;
		}
	}
	/**
	* Short format for `ms`.
	*
	* @param {Number} ms
	* @return {String}
	* @api private
	*/
	function fmtShort(ms) {
		var msAbs = Math.abs(ms);
		if (msAbs >= d) return Math.round(ms / d) + "d";
		if (msAbs >= h) return Math.round(ms / h) + "h";
		if (msAbs >= m) return Math.round(ms / m) + "m";
		if (msAbs >= s) return Math.round(ms / s) + "s";
		return ms + "ms";
	}
	/**
	* Long format for `ms`.
	*
	* @param {Number} ms
	* @return {String}
	* @api private
	*/
	function fmtLong(ms) {
		var msAbs = Math.abs(ms);
		if (msAbs >= d) return plural(ms, msAbs, d, "day");
		if (msAbs >= h) return plural(ms, msAbs, h, "hour");
		if (msAbs >= m) return plural(ms, msAbs, m, "minute");
		if (msAbs >= s) return plural(ms, msAbs, s, "second");
		return ms + " ms";
	}
	/**
	* Pluralization helper.
	*/
	function plural(ms, msAbs, n, name) {
		var isPlural = msAbs >= n * 1.5;
		return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
	}
}));
//#endregion
//#region node_modules/.pnpm/debug@4.4.3_supports-color@7.2.0/node_modules/debug/src/common.js
var require_common = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/**
	* This is the common logic for both the Node.js and web browser
	* implementations of `debug()`.
	*/
	function setup(env) {
		createDebug.debug = createDebug;
		createDebug.default = createDebug;
		createDebug.coerce = coerce;
		createDebug.disable = disable;
		createDebug.enable = enable;
		createDebug.enabled = enabled;
		createDebug.humanize = require_ms();
		createDebug.destroy = destroy;
		Object.keys(env).forEach((key) => {
			createDebug[key] = env[key];
		});
		/**
		* The currently active debug mode names, and names to skip.
		*/
		createDebug.names = [];
		createDebug.skips = [];
		/**
		* Map of special "%n" handling functions, for the debug "format" argument.
		*
		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
		*/
		createDebug.formatters = {};
		/**
		* Selects a color for a debug namespace
		* @param {String} namespace The namespace string for the debug instance to be colored
		* @return {Number|String} An ANSI color code for the given namespace
		* @api private
		*/
		function selectColor(namespace) {
			let hash = 0;
			for (let i = 0; i < namespace.length; i++) {
				hash = (hash << 5) - hash + namespace.charCodeAt(i);
				hash |= 0;
			}
			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
		}
		createDebug.selectColor = selectColor;
		/**
		* Create a debugger with the given `namespace`.
		*
		* @param {String} namespace
		* @return {Function}
		* @api public
		*/
		function createDebug(namespace) {
			let prevTime;
			let enableOverride = null;
			let namespacesCache;
			let enabledCache;
			function debug(...args) {
				if (!debug.enabled) return;
				const self = debug;
				const curr = Number(/* @__PURE__ */ new Date());
				self.diff = curr - (prevTime || curr);
				self.prev = prevTime;
				self.curr = curr;
				prevTime = curr;
				args[0] = createDebug.coerce(args[0]);
				if (typeof args[0] !== "string") args.unshift("%O");
				let index = 0;
				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
					if (match === "%%") return "%";
					index++;
					const formatter = createDebug.formatters[format];
					if (typeof formatter === "function") {
						const val = args[index];
						match = formatter.call(self, val);
						args.splice(index, 1);
						index--;
					}
					return match;
				});
				createDebug.formatArgs.call(self, args);
				(self.log || createDebug.log).apply(self, args);
			}
			debug.namespace = namespace;
			debug.useColors = createDebug.useColors();
			debug.color = createDebug.selectColor(namespace);
			debug.extend = extend;
			debug.destroy = createDebug.destroy;
			Object.defineProperty(debug, "enabled", {
				enumerable: true,
				configurable: false,
				get: () => {
					if (enableOverride !== null) return enableOverride;
					if (namespacesCache !== createDebug.namespaces) {
						namespacesCache = createDebug.namespaces;
						enabledCache = createDebug.enabled(namespace);
					}
					return enabledCache;
				},
				set: (v) => {
					enableOverride = v;
				}
			});
			if (typeof createDebug.init === "function") createDebug.init(debug);
			return debug;
		}
		function extend(namespace, delimiter) {
			const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
			newDebug.log = this.log;
			return newDebug;
		}
		/**
		* Enables a debug mode by namespaces. This can include modes
		* separated by a colon and wildcards.
		*
		* @param {String} namespaces
		* @api public
		*/
		function enable(namespaces) {
			createDebug.save(namespaces);
			createDebug.namespaces = namespaces;
			createDebug.names = [];
			createDebug.skips = [];
			const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
			for (const ns of split) if (ns[0] === "-") createDebug.skips.push(ns.slice(1));
			else createDebug.names.push(ns);
		}
		/**
		* Checks if the given string matches a namespace template, honoring
		* asterisks as wildcards.
		*
		* @param {String} search
		* @param {String} template
		* @return {Boolean}
		*/
		function matchesTemplate(search, template) {
			let searchIndex = 0;
			let templateIndex = 0;
			let starIndex = -1;
			let matchIndex = 0;
			while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
				if (template[templateIndex] === "*") {
					starIndex = templateIndex;
					matchIndex = searchIndex;
					templateIndex++;
				} else {
					searchIndex++;
					templateIndex++;
				}
			} else if (starIndex !== -1) {
				templateIndex = starIndex + 1;
				matchIndex++;
				searchIndex = matchIndex;
			} else return false;
			while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++;
			return templateIndex === template.length;
		}
		/**
		* Disable debug output.
		*
		* @return {String} namespaces
		* @api public
		*/
		function disable() {
			const namespaces = [...createDebug.names, ...createDebug.skips.map((namespace) => "-" + namespace)].join(",");
			createDebug.enable("");
			return namespaces;
		}
		/**
		* Returns true if the given mode name is enabled, false otherwise.
		*
		* @param {String} name
		* @return {Boolean}
		* @api public
		*/
		function enabled(name) {
			for (const skip of createDebug.skips) if (matchesTemplate(name, skip)) return false;
			for (const ns of createDebug.names) if (matchesTemplate(name, ns)) return true;
			return false;
		}
		/**
		* Coerce `val`.
		*
		* @param {Mixed} val
		* @return {Mixed}
		* @api private
		*/
		function coerce(val) {
			if (val instanceof Error) return val.stack || val.message;
			return val;
		}
		/**
		* XXX DO NOT USE. This is a temporary stub function.
		* XXX It WILL be removed in the next major release.
		*/
		function destroy() {
			console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
		}
		createDebug.enable(createDebug.load());
		return createDebug;
	}
	module.exports = setup;
}));
//#endregion
//#region node_modules/.pnpm/debug@4.4.3_supports-color@7.2.0/node_modules/debug/src/browser.js
var require_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/**
	* This is the web browser implementation of `debug()`.
	*/
	exports.formatArgs = formatArgs;
	exports.save = save;
	exports.load = load;
	exports.useColors = useColors;
	exports.storage = localstorage();
	exports.destroy = (() => {
		let warned = false;
		return () => {
			if (!warned) {
				warned = true;
				console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
			}
		};
	})();
	/**
	* Colors.
	*/
	exports.colors = [
		"#0000CC",
		"#0000FF",
		"#0033CC",
		"#0033FF",
		"#0066CC",
		"#0066FF",
		"#0099CC",
		"#0099FF",
		"#00CC00",
		"#00CC33",
		"#00CC66",
		"#00CC99",
		"#00CCCC",
		"#00CCFF",
		"#3300CC",
		"#3300FF",
		"#3333CC",
		"#3333FF",
		"#3366CC",
		"#3366FF",
		"#3399CC",
		"#3399FF",
		"#33CC00",
		"#33CC33",
		"#33CC66",
		"#33CC99",
		"#33CCCC",
		"#33CCFF",
		"#6600CC",
		"#6600FF",
		"#6633CC",
		"#6633FF",
		"#66CC00",
		"#66CC33",
		"#9900CC",
		"#9900FF",
		"#9933CC",
		"#9933FF",
		"#99CC00",
		"#99CC33",
		"#CC0000",
		"#CC0033",
		"#CC0066",
		"#CC0099",
		"#CC00CC",
		"#CC00FF",
		"#CC3300",
		"#CC3333",
		"#CC3366",
		"#CC3399",
		"#CC33CC",
		"#CC33FF",
		"#CC6600",
		"#CC6633",
		"#CC9900",
		"#CC9933",
		"#CCCC00",
		"#CCCC33",
		"#FF0000",
		"#FF0033",
		"#FF0066",
		"#FF0099",
		"#FF00CC",
		"#FF00FF",
		"#FF3300",
		"#FF3333",
		"#FF3366",
		"#FF3399",
		"#FF33CC",
		"#FF33FF",
		"#FF6600",
		"#FF6633",
		"#FF9900",
		"#FF9933",
		"#FFCC00",
		"#FFCC33"
	];
	/**
	* Currently only WebKit-based Web Inspectors, Firefox >= v31,
	* and the Firebug extension (any Firefox version) are known
	* to support "%c" CSS customizations.
	*
	* TODO: add a `localStorage` variable to explicitly enable/disable colors
	*/
	function useColors() {
		if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) return true;
		if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) return false;
		let m;
		return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
	}
	/**
	* Colorize log arguments if enabled.
	*
	* @api public
	*/
	function formatArgs(args) {
		args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
		if (!this.useColors) return;
		const c = "color: " + this.color;
		args.splice(1, 0, c, "color: inherit");
		let index = 0;
		let lastC = 0;
		args[0].replace(/%[a-zA-Z%]/g, (match) => {
			if (match === "%%") return;
			index++;
			if (match === "%c") lastC = index;
		});
		args.splice(lastC, 0, c);
	}
	/**
	* Invokes `console.debug()` when available.
	* No-op when `console.debug` is not a "function".
	* If `console.debug` is not available, falls back
	* to `console.log`.
	*
	* @api public
	*/
	exports.log = console.debug || console.log || (() => {});
	/**
	* Save `namespaces`.
	*
	* @param {String} namespaces
	* @api private
	*/
	function save(namespaces) {
		try {
			if (namespaces) exports.storage.setItem("debug", namespaces);
			else exports.storage.removeItem("debug");
		} catch (error) {}
	}
	/**
	* Load `namespaces`.
	*
	* @return {String} returns the previously persisted debug modes
	* @api private
	*/
	function load() {
		let r;
		try {
			r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
		} catch (error) {}
		if (!r && typeof process !== "undefined" && "env" in process) r = process.env.DEBUG;
		return r;
	}
	/**
	* Localstorage attempts to return the localstorage.
	*
	* This is necessary because safari throws
	* when a user disables cookies/localstorage
	* and you attempt to access it.
	*
	* @return {LocalStorage}
	* @api private
	*/
	function localstorage() {
		try {
			return localStorage;
		} catch (error) {}
	}
	module.exports = require_common()(exports);
	var { formatters } = module.exports;
	/**
	* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
	*/
	formatters.j = function(v) {
		try {
			return JSON.stringify(v);
		} catch (error) {
			return "[UnexpectedJSONParseError]: " + error.message;
		}
	};
}));
//#endregion
//#region node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
var require_has_flag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = (flag, argv = process.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);
	};
}));
//#endregion
//#region node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js
var require_supports_color = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var os$3 = __require("os");
	var tty$1 = __require("tty");
	var hasFlag = require_has_flag();
	var { env } = process;
	var forceColor;
	if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) forceColor = 0;
	else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) forceColor = 1;
	if ("FORCE_COLOR" in env) {
		if (env.FORCE_COLOR === "true") forceColor = 1;
		else if (env.FORCE_COLOR === "false") forceColor = 0;
		else forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(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) {
		if (forceColor === 0) return 0;
		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
		if (hasFlag("color=256")) return 2;
		if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
		const min = forceColor || 0;
		if (env.TERM === "dumb") return min;
		if (process.platform === "win32") {
			const osRelease = os$3.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 ([
				"TRAVIS",
				"CIRCLECI",
				"APPVEYOR",
				"GITLAB_CI",
				"GITHUB_ACTIONS",
				"BUILDKITE"
			].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 ("TERM_PROGRAM" in env) {
			const version = 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 getSupportLevel(stream) {
		return translateLevel(supportsColor(stream, stream && stream.isTTY));
	}
	module.exports = {
		supportsColor: getSupportLevel,
		stdout: translateLevel(supportsColor(true, tty$1.isatty(1))),
		stderr: translateLevel(supportsColor(true, tty$1.isatty(2)))
	};
}));
//#endregion
//#region node_modules/.pnpm/debug@4.4.3_supports-color@7.2.0/node_modules/debug/src/node.js
var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/**
	* Module dependencies.
	*/
	var tty = __require("tty");
	var util$1 = __require("util");
	/**
	* This is the Node.js implementation of `debug()`.
	*/
	exports.init = init;
	exports.log = log;
	exports.formatArgs = formatArgs;
	exports.save = save;
	exports.load = load;
	exports.useColors = useColors;
	exports.destroy = util$1.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
	/**
	* Colors.
	*/
	exports.colors = [
		6,
		2,
		3,
		4,
		5,
		1
	];
	try {
		const supportsColor = require_supports_color();
		if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) exports.colors = [
			20,
			21,
			26,
			27,
			32,
			33,
			38,
			39,
			40,
			41,
			42,
			43,
			44,
			45,
			56,
			57,
			62,
			63,
			68,
			69,
			74,
			75,
			76,
			77,
			78,
			79,
			80,
			81,
			92,
			93,
			98,
			99,
			112,
			113,
			128,
			129,
			134,
			135,
			148,
			149,
			160,
			161,
			162,
			163,
			164,
			165,
			166,
			167,
			168,
			169,
			170,
			171,
			172,
			173,
			178,
			179,
			184,
			185,
			196,
			197,
			198,
			199,
			200,
			201,
			202,
			203,
			204,
			205,
			206,
			207,
			208,
			209,
			214,
			215,
			220,
			221
		];
	} catch (error) {}
	/**
	* Build up the default `inspectOpts` object from the environment variables.
	*
	*   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
	*/
	exports.inspectOpts = Object.keys(process.env).filter((key) => {
		return /^debug_/i.test(key);
	}).reduce((obj, key) => {
		const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
			return k.toUpperCase();
		});
		let val = process.env[key];
		if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
		else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
		else if (val === "null") val = null;
		else val = Number(val);
		obj[prop] = val;
		return obj;
	}, {});
	/**
	* Is stdout a TTY? Colored output is enabled when `true`.
	*/
	function useColors() {
		return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
	}
	/**
	* Adds ANSI color escape codes if enabled.
	*
	* @api public
	*/
	function formatArgs(args) {
		const { namespace: name, useColors } = this;
		if (useColors) {
			const c = this.color;
			const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
			const prefix = `  ${colorCode};1m${name} \u001B[0m`;
			args[0] = prefix + args[0].split("\n").join("\n" + prefix);
			args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
		} else args[0] = getDate() + name + " " + args[0];
	}
	function getDate() {
		if (exports.inspectOpts.hideDate) return "";
		return (/* @__PURE__ */ new Date()).toISOString() + " ";
	}
	/**
	* Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
	*/
	function log(...args) {
		return process.stderr.write(util$1.formatWithOptions(exports.inspectOpts, ...args) + "\n");
	}
	/**
	* Save `namespaces`.
	*
	* @param {String} namespaces
	* @api private
	*/
	function save(namespaces) {
		if (namespaces) process.env.DEBUG = namespaces;
		else delete process.env.DEBUG;
	}
	/**
	* Load `namespaces`.
	*
	* @return {String} returns the previously persisted debug modes
	* @api private
	*/
	function load() {
		return process.env.DEBUG;
	}
	/**
	* Init logic for `debug` instances.
	*
	* Create a new `inspectOpts` object in case `useColors` is set
	* differently for a particular `debug` instance.
	*/
	function init(debug) {
		debug.inspectOpts = {};
		const keys = Object.keys(exports.inspectOpts);
		for (let i = 0; i < keys.length; i++) debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
	}
	module.exports = require_common()(exports);
	var { formatters } = module.exports;
	/**
	* Map %o to `util.inspect()`, all on a single line.
	*/
	formatters.o = function(v) {
		this.inspectOpts.colors = this.useColors;
		return util$1.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
	};
	/**
	* Map %O to `util.inspect()`, allowing multiple lines if needed.
	*/
	formatters.O = function(v) {
		this.inspectOpts.colors = this.useColors;
		return util$1.inspect(v, this.inspectOpts);
	};
}));
//#endregion
//#region node_modules/.pnpm/debug@4.4.3_supports-color@7.2.0/node_modules/debug/src/index.js
var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/**
	* Detect Electron renderer / nwjs process, which is node, but we should
	* treat as a browser.
	*/
	if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) module.exports = require_browser();
	else module.exports = require_node();
}));
//#endregion
//#region node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/helpers.js
var require_helpers = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	});
	var __importStar = exports && exports.__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;
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.req = exports.json = exports.toBuffer = void 0;
	var http$2 = __importStar(__require("http"));
	var https$1 = __importStar(__require("https"));
	async function toBuffer(stream) {
		let length = 0;
		const chunks = [];
		for await (const chunk of stream) {
			length += chunk.length;
			chunks.push(chunk);
		}
		return Buffer.concat(chunks, length);
	}
	exports.toBuffer = toBuffer;
	async function json(stream) {
		const str = (await toBuffer(stream)).toString("utf8");
		try {
			return JSON.parse(str);
		} catch (_err) {
			const err = _err;
			err.message += ` (input: ${str})`;
			throw err;
		}
	}
	exports.json = json;
	function req(url, opts = {}) {
		const req = ((typeof url === "string" ? url : url.href).startsWith("https:") ? https$1 : http$2).request(url, opts);
		const promise = new Promise((resolve, reject) => {
			req.once("response", resolve).once("error", reject).end();
		});
		req.then = promise.then.bind(promise);
		return req;
	}
	exports.req = req;
}));
//#endregion
//#region node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/index.js
var require_dist$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	});
	var __importStar = exports && exports.__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 = exports && exports.__exportStar || function(m, exports$2) {
		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$2, p)) __createBinding(exports$2, m, p);
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.Agent = void 0;
	var net$2 = __importStar(__require("net"));
	var http$1 = __importStar(__require("http"));
	var https_1 = __require("https");
	__exportStar(require_helpers(), exports);
	var INTERNAL = Symbol("AgentBaseInternalState");
	var Agent = class extends http$1.Agent {
		constructor(opts) {
			super(opts);
			this[INTERNAL] = {};
		}
		/**
		* Determine whether this is an `http` or `https` request.
		*/
		isSecureEndpoint(options) {
			if (options) {
				if (typeof options.secureEndpoint === "boolean") return options.secureEndpoint;
				if (typeof options.protocol === "string") return options.protocol === "https:";
			}
			const { stack } = /* @__PURE__ */ new Error();
			if (typeof stack !== "string") return false;
			return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
		}
		incrementSockets(name) {
			if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) return null;
			if (!this.sockets[name]) this.sockets[name] = [];
			const fakeSocket = new net$2.Socket({ writable: false });
			this.sockets[name].push(fakeSocket);
			this.totalSocketCount++;
			return fakeSocket;
		}
		decrementSockets(name, socket) {
			if (!this.sockets[name] || socket === null) return;
			const sockets = this.sockets[name];
			const index = sockets.indexOf(socket);
			if (index !== -1) {
				sockets.splice(index, 1);
				this.totalSocketCount--;
				if (sockets.length === 0) delete this.sockets[name];
			}
		}
		getName(options) {
			if (this.isSecureEndpoint(options)) return https_1.Agent.prototype.getName.call(this, options);
			return super.getName(options);
		}
		createSocket(req, options, cb) {
			const connectOpts = {
				...options,
				secureEndpoint: this.isSecureEndpoint(options)
			};
			const name = this.getName(connectOpts);
			const fakeSocket = this.incrementSockets(name);
			Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
				this.decrementSockets(name, fakeSocket);
				if (socket instanceof http$1.Agent) try {
					return socket.addRequest(req, connectOpts);
				} catch (err) {
					return cb(err);
				}
				this[INTERNAL].currentSocket = socket;
				super.createSocket(req, options, cb);
			}, (err) => {
				this.decrementSockets(name, fakeSocket);
				cb(err);
			});
		}
		createConnection() {
			const socket = this[INTERNAL].currentSocket;
			this[INTERNAL].currentSocket = void 0;
			if (!socket) throw new Error("No socket was returned in the `connect()` function");
			return socket;
		}
		get defaultPort() {
			return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
		}
		set defaultPort(v) {
			if (this[INTERNAL]) this[INTERNAL].defaultPort = v;
		}
		get protocol() {
			return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
		}
		set protocol(v) {
			if (this[INTERNAL]) this[INTERNAL].protocol = v;
		}
	};
	exports.Agent = Agent;
}));
//#endregion
//#region node_modules/.pnpm/https-proxy-agent@7.0.6_supports-color@7.2.0/node_modules/https-proxy-agent/dist/parse-proxy-response.js
var require_parse_proxy_response = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.parseProxyResponse = void 0;
	var debug = (0, __importDefault(require_src()).default)("https-proxy-agent:parse-proxy-response");
	function parseProxyResponse(socket) {
		return new Promise((resolve, reject) => {
			let buffersLength = 0;
			const buffers = [];
			function read() {
				const b = socket.read();
				if (b) ondata(b);
				else socket.once("readable", read);
			}
			function cleanup() {
				socket.removeListener("end", onend);
				socket.removeListener("error", onerror);
				socket.removeListener("readable", read);
			}
			function onend() {
				cleanup();
				debug("onend");
				reject(/* @__PURE__ */ new Error("Proxy connection ended before receiving CONNECT response"));
			}
			function onerror(err) {
				cleanup();
				debug("onerror %o", err);
				reject(err);
			}
			function ondata(b) {
				buffers.push(b);
				buffersLength += b.length;
				const buffered = Buffer.concat(buffers, buffersLength);
				const endOfHeaders = buffered.indexOf("\r\n\r\n");
				if (endOfHeaders === -1) {
					debug("have not received end of HTTP headers yet...");
					read();
					return;
				}
				const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n");
				const firstLine = headerParts.shift();
				if (!firstLine) {
					socket.destroy();
					return reject(/* @__PURE__ */ new Error("No header received from proxy CONNECT response"));
				}
				const firstLineParts = firstLine.split(" ");
				const statusCode = +firstLineParts[1];
				const statusText = firstLineParts.slice(2).join(" ");
				const headers = {};
				for (const header of headerParts) {
					if (!header) continue;
					const firstColon = header.indexOf(":");
					if (firstColon === -1) {
						socket.destroy();
						return reject(/* @__PURE__ */ new Error(`Invalid header from proxy CONNECT response: "${header}"`));
					}
					const key = header.slice(0, firstColon).toLowerCase();
					const value = header.slice(firstColon + 1).trimStart();
					const current = headers[key];
					if (typeof current === "string") headers[key] = [current, value];
					else if (Array.isArray(current)) current.push(value);
					else headers[key] = value;
				}
				debug("got proxy server response: %o %o", firstLine, headers);
				cleanup();
				resolve({
					connect: {
						statusCode,
						statusText,
						headers
					},
					buffered
				});
			}
			socket.on("error", onerror);
			socket.on("end", onend);
			read();
		});
	}
	exports.parseProxyResponse = parseProxyResponse;
}));
//#endregion
//#region node_modules/.pnpm/https-proxy-agent@7.0.6_supports-color@7.2.0/node_modules/https-proxy-agent/dist/index.js
var require_dist$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	});
	var __importStar = exports && exports.__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 __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.HttpsProxyAgent = void 0;
	var net$1 = __importStar(__require("net"));
	var tls$1 = __importStar(__require("tls"));
	var assert_1 = __importDefault(__require("assert"));
	var debug_1 = __importDefault(require_src());
	var agent_base_1 = require_dist$2();
	var url_1$1 = __require("url");
	var parse_proxy_response_1 = require_parse_proxy_response();
	var debug = (0, debug_1.default)("https-proxy-agent");
	var setServernameFromNonIpHost = (options) => {
		if (options.servername === void 0 && options.host && !net$1.isIP(options.host)) return {
			...options,
			servername: options.host
		};
		return options;
	};
	/**
	* The `HttpsProxyAgent` implements an HTTP Agent subclass that connects to
	* the specified "HTTP(s) proxy server" in order to proxy HTTPS requests.
	*
	* Outgoing HTTP requests are first tunneled through the proxy server using the
	* `CONNECT` HTTP request method to establish a connection to the proxy server,
	* and then the proxy server connects to the destination target and issues the
	* HTTP request from the proxy server.
	*
	* `https:` requests have their socket connection upgraded to TLS once
	* the connection to the proxy server has been established.
	*/
	var HttpsProxyAgent = class extends agent_base_1.Agent {
		constructor(proxy, opts) {
			super(opts);
			this.options = { path: void 0 };
			this.proxy = typeof proxy === "string" ? new url_1$1.URL(proxy) : proxy;
			this.proxyHeaders = opts?.headers ?? {};
			debug("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
			const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
			const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
			this.connectOpts = {
				ALPNProtocols: ["http/1.1"],
				...opts ? omit(opts, "headers") : null,
				host,
				port
			};
		}
		/**
		* Called when the node-core HTTP client library is creating a
		* new HTTP request.
		*/
		async connect(req, opts) {
			const { proxy } = this;
			if (!opts.host) throw new TypeError("No \"host\" provided");
			let socket;
			if (proxy.protocol === "https:") {
				debug("Creating `tls.Socket`: %o", this.connectOpts);
				socket = tls$1.connect(setServernameFromNonIpHost(this.connectOpts));
			} else {
				debug("Creating `net.Socket`: %o", this.connectOpts);
				socket = net$1.connect(this.connectOpts);
			}
			const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
			const host = net$1.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
			let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r\n`;
			if (proxy.username || proxy.password) {
				const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
				headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
			}
			headers.Host = `${host}:${opts.port}`;
			if (!headers["Proxy-Connection"]) headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
			for (const name of Object.keys(headers)) payload += `${name}: ${headers[name]}\r\n`;
			const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
			socket.write(`${payload}\r\n`);
			const { connect, buffered } = await proxyResponsePromise;
			req.emit("proxyConnect", connect);
			this.emit("proxyConnect", connect, req);
			if (connect.statusCode === 200) {
				req.once("socket", resume);
				if (opts.secureEndpoint) {
					debug("Upgrading socket connection to TLS");
					return tls$1.connect({
						...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
						socket
					});
				}
				return socket;
			}
			socket.destroy();
			const fakeSocket = new net$1.Socket({ writable: false });
			fakeSocket.readable = true;
			req.once("socket", (s) => {
				debug("Replaying proxy buffer for failed request");
				(0, assert_1.default)(s.listenerCount("data") > 0);
				s.push(buffered);
				s.push(null);
			});
			return fakeSocket;
		}
	};
	HttpsProxyAgent.protocols = ["http", "https"];
	exports.HttpsProxyAgent = HttpsProxyAgent;
	function resume(socket) {
		socket.resume();
	}
	function omit(obj, ...keys) {
		const ret = {};
		let key;
		for (key in obj) if (!keys.includes(key)) ret[key] = obj[key];
		return ret;
	}
}));
//#endregion
//#region node_modules/.pnpm/http-proxy-agent@7.0.2_supports-color@7.2.0/node_modules/http-proxy-agent/dist/index.js
var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	});
	var __importStar = exports && exports.__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 __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.HttpProxyAgent = void 0;
	var net = __importStar(__require("net"));
	var tls = __importStar(__require("tls"));
	var debug_1 = __importDefault(require_src());
	var events_1 = __require("events");
	var agent_base_1 = require_dist$2();
	var url_1 = __require("url");
	var debug = (0, debug_1.default)("http-proxy-agent");
	/**
	* The `HttpProxyAgent` implements an HTTP Agent subclass that connects
	* to the specified "HTTP proxy server" in order to proxy HTTP requests.
	*/
	var HttpProxyAgent = class extends agent_base_1.Agent {
		constructor(proxy, opts) {
			super(opts);
			this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
			this.proxyHeaders = opts?.headers ?? {};
			debug("Creating new HttpProxyAgent instance: %o", this.proxy.href);
			const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
			const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
			this.connectOpts = {
				...opts ? omit(opts, "headers") : null,
				host,
				port
			};
		}
		addRequest(req, opts) {
			req._header = null;
			this.setRequestProps(req, opts);
			super.addRequest(req, opts);
		}
		setRequestProps(req, opts) {
			const { proxy } = this;
			const base = `${opts.secureEndpoint ? "https:" : "http:"}//${req.getHeader("host") || "localhost"}`;
			const url = new url_1.URL(req.path, base);
			if (opts.port !== 80) url.port = String(opts.port);
			req.path = String(url);
			const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
			if (proxy.username || proxy.password) {
				const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
				headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
			}
			if (!headers["Proxy-Connection"]) headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
			for (const name of Object.keys(headers)) {
				const value = headers[name];
				if (value) req.setHeader(name, value);
			}
		}
		async connect(req, opts) {
			req._header = null;
			if (!req.path.includes("://")) this.setRequestProps(req, opts);
			let first;
			let endOfHeaders;
			debug("Regenerating stored HTTP header string for request");
			req._implicitHeader();
			if (req.outputData && req.outputData.length > 0) {
				debug("Patching connection write() output buffer with updated header");
				first = req.outputData[0].data;
				endOfHeaders = first.indexOf("\r\n\r\n") + 4;
				req.outputData[0].data = req._header + first.substring(endOfHeaders);
				debug("Output buffer: %o", req.outputData[0].data);
			}
			let socket;
			if (this.proxy.protocol === "https:") {
				debug("Creating `tls.Socket`: %o", this.connectOpts);
				socket = tls.connect(this.connectOpts);
			} else {
				debug("Creating `net.Socket`: %o", this.connectOpts);
				socket = net.connect(this.connectOpts);
			}
			await (0, events_1.once)(socket, "connect");
			return socket;
		}
	};
	HttpProxyAgent.protocols = ["http", "https"];
	exports.HttpProxyAgent = HttpProxyAgent;
	function omit(obj, ...keys) {
		const ret = {};
		let key;
		for (key in obj) if (!keys.includes(key)) ret[key] = obj[key];
		return ret;
	}
}));
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/proxyPolicy.js
var import_dist = require_dist$1();
var import_dist$1 = require_dist();
var HTTPS_PROXY = "HTTPS_PROXY";
var HTTP_PROXY = "HTTP_PROXY";
var ALL_PROXY = "ALL_PROXY";
var NO_PROXY = "NO_PROXY";
/**
* The programmatic identifier of the proxyPolicy.
*/
var proxyPolicyName = "proxyPolicy";
/**
* Stores the patterns specified in NO_PROXY environment variable.
* @internal
*/
var globalNoProxyList = [];
var noProxyListLoaded = false;
/** A cache of whether a host should bypass the proxy. */
var globalBypassedMap = /* @__PURE__ */ new Map();
function getEnvironmentValue(name) {
	if (process.env[name]) return process.env[name];
	else if (process.env[name.toLowerCase()]) return process.env[name.toLowerCase()];
}
function loadEnvironmentProxyValue() {
	if (!process) return;
	const httpsProxy = getEnvironmentValue(HTTPS_PROXY);
	const allProxy = getEnvironmentValue(ALL_PROXY);
	const httpProxy = getEnvironmentValue(HTTP_PROXY);
	return httpsProxy || allProxy || httpProxy;
}
/**
* Check whether the host of a given `uri` matches any pattern in the no proxy list.
* If there's a match, any request sent to the same host shouldn't have the proxy settings set.
* This implementation is a port of https://github.com/Azure/azure-sdk-for-net/blob/8cca811371159e527159c7eb65602477898683e2/sdk/core/Azure.Core/src/Pipeline/Internal/HttpEnvironmentProxy.cs#L210
*/
function isBypassed(uri, noProxyList, bypassedMap) {
	if (noProxyList.length === 0) return false;
	const host = new URL(uri).hostname;
	if (bypassedMap?.has(host)) return bypassedMap.get(host);
	let isBypassedFlag = false;
	for (const pattern of noProxyList) if (pattern[0] === ".") {
		if (host.endsWith(pattern)) isBypassedFlag = true;
		else if (host.length === pattern.length - 1 && host === pattern.slice(1)) isBypassedFlag = true;
	} else if (host === pattern) isBypassedFlag = true;
	bypassedMap?.set(host, isBypassedFlag);
	return isBypassedFlag;
}
function loadNoProxy() {
	const noProxy = getEnvironmentValue(NO_PROXY);
	noProxyListLoaded = true;
	if (noProxy) return noProxy.split(",").map((item) => item.trim()).filter((item) => item.length);
	return [];
}
/**
* This method converts a proxy url into `ProxySettings` for use with ProxyPolicy.
* If no argument is given, it attempts to parse a proxy URL from the environment
* variables `HTTPS_PROXY` or `HTTP_PROXY`.
* @param proxyUrl - The url of the proxy to use. May contain authentication information.
* @deprecated - Internally this method is no longer necessary when setting proxy information.
*/
function getDefaultProxySettings$1(proxyUrl) {
	if (!proxyUrl) {
		proxyUrl = loadEnvironmentProxyValue();
		if (!proxyUrl) return;
	}
	const parsedUrl = new URL(proxyUrl);
	return {
		host: (parsedUrl.protocol ? parsedUrl.protocol + "//" : "") + parsedUrl.hostname,
		port: Number.parseInt(parsedUrl.port || "80"),
		username: parsedUrl.username,
		password: parsedUrl.password
	};
}
__name(getDefaultProxySettings$1, "getDefaultProxySettings");
/**
* This method attempts to parse a proxy URL from the environment
* variables `HTTPS_PROXY` or `HTTP_PROXY`.
*/
function getDefaultProxySettingsInternal() {
	const envProxy = loadEnvironmentProxyValue();
	return envProxy ? new URL(envProxy) : void 0;
}
function getUrlFromProxySettings(settings) {
	let parsedProxyUrl;
	try {
		parsedProxyUrl = new URL(settings.host);
	} catch {
		throw new Error(`Expecting a valid host string in proxy settings, but found "${settings.host}".`);
	}
	parsedProxyUrl.port = String(settings.port);
	if (settings.username) parsedProxyUrl.username = settings.username;
	if (settings.password) parsedProxyUrl.password = settings.password;
	return parsedProxyUrl;
}
function setProxyAgentOnRequest(request, cachedAgents, proxyUrl) {
	if (request.agent) return;
	const isInsecure = new URL(request.url).protocol !== "https:";
	if (request.tlsSettings) logger$4.warning("TLS settings are not supported in combination with custom Proxy, certificates provided to the client will be ignored.");
	if (isInsecure) {
		if (!cachedAgents.httpProxyAgent) cachedAgents.httpProxyAgent = new import_dist$1.HttpProxyAgent(proxyUrl);
		request.agent = cachedAgents.httpProxyAgent;
	} else {
		if (!cachedAgents.httpsProxyAgent) cachedAgents.httpsProxyAgent = new import_dist.HttpsProxyAgent(proxyUrl);
		request.agent = cachedAgents.httpsProxyAgent;
	}
}
/**
* A policy that allows one to apply proxy settings to all requests.
* If not passed static settings, they will be retrieved from the HTTPS_PROXY
* or HTTP_PROXY environment variables.
* @param proxySettings - ProxySettings to use on each request.
* @param options - additional settings, for example, custom NO_PROXY patterns
*/
function proxyPolicy$1(proxySettings, options) {
	if (!noProxyListLoaded) globalNoProxyList.push(...loadNoProxy());
	const defaultProxy = proxySettings ? getUrlFromProxySettings(proxySettings) : getDefaultProxySettingsInternal();
	const cachedAgents = {};
	return {
		name: proxyPolicyName,
		async sendRequest(request, next) {
			if (!request.proxySettings && defaultProxy && !isBypassed(request.url, options?.customNoProxyList ?? globalNoProxyList, options?.customNoProxyList ? void 0 : globalBypassedMap)) setProxyAgentOnRequest(request, cachedAgents, defaultProxy);
			else if (request.proxySettings) setProxyAgentOnRequest(request, cachedAgents, getUrlFromProxySettings(request.proxySettings));
			return next(request);
		}
	};
}
__name(proxyPolicy$1, "proxyPolicy");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/decompressResponsePolicy.js
/**
* The programmatic identifier of the decompressResponsePolicy.
*/
var decompressResponsePolicyName$1 = "decompressResponsePolicy";
/**
* A policy to enable response decompression according to Accept-Encoding header
* https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding
*/
function decompressResponsePolicy$1() {
	return {
		name: decompressResponsePolicyName$1,
		async sendRequest(request, next) {
			if (request.method !== "HEAD") request.headers.set("Accept-Encoding", "gzip,deflate");
			return next(request);
		}
	};
}
__name(decompressResponsePolicy$1, "decompressResponsePolicy");
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/redirectPolicy.js
/**
* The programmatic identifier of the redirectPolicy.
*/
var redirectPolicyName$1 = "redirectPolicy";
/**
* Methods that are allowed to follow redirects 301 and 302
*/
var allowedRedirect = ["GET", "HEAD"];
/**
* A policy to follow Location headers from the server in order
* to support server-side redirection.
* In the browser, this policy is not used.
* @param options - Options to control policy behavior.
*/
function redirectPolicy$1(options = {}) {
	const { maxRetries = 20, allowCrossOriginRedirects = false } = options;
	return {
		name: redirectPolicyName$1,
		async sendRequest(request, next) {
			return handleRedirect(next, await next(request), maxRetries, allowCrossOriginRedirects);
		}
	};
}
__name(redirectPolicy$1, "redirectPolicy");
async function handleRedirect(next, response, maxRetries, allowCrossOriginRedirects, currentRetries = 0) {
	const { request, status, headers } = response;
	const locationHeader = headers.get("location");
	if (locationHeader && (status === 300 || status === 301 && allowedRedirect.includes(request.method) || status === 302 && allowedRedirect.includes(request.method) || status === 303 && request.method === "POST" || status === 307) && currentRetries < maxRetries) {
		const url = new URL(locationHeader, request.url);
		if (!allowCrossOriginRedirects) {
			const originalUrl = new URL(request.url);
			if (url.origin !== originalUrl.origin) {
				logger$4.verbose(`Skipping cross-origin redirect from ${originalUrl.origin} to ${url.origin}.`);
				return response;
			}
		}
		request.url = url.toString();
		if (status === 303) {
			request.method = "GET";
			request.headers.delete("Content-Length");
			delete request.body;
		}
		request.headers.delete("Authorization");
		return handleRedirect(next, await next(request), maxRetries, allowCrossOriginRedirects, currentRetries + 1);
	}
	return response;
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/typeGuards.js
function isBlob(x) {
	return x instanceof Blob;
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/util/concat.js
async function* streamAsyncIterator() {
	const reader = this.getReader();
	try {
		while (true) {
			const { done, value } = await reader.read();
			if (done) return;
			yield value;
		}
	} finally {
		reader.releaseLock();
	}
}
function makeAsyncIterable(webStream) {
	if (!webStream[Symbol.asyncIterator]) webStream[Symbol.asyncIterator] = streamAsyncIterator.bind(webStream);
	if (!webStream.values) webStream.values = streamAsyncIterator.bind(webStream);
}
function ensureNodeStream(stream) {
	if (stream instanceof ReadableStream) {
		makeAsyncIterable(stream);
		return Readable$1.fromWeb(stream);
	} else return stream;
}
function toStream(source) {
	if (source instanceof Uint8Array) return Readable$1.from(Buffer.from(source));
	else if (isBlob(source)) return ensureNodeStream(source.stream());
	else return ensureNodeStream(source);
}
/**
* Utility function that concatenates a set of binary inputs into one combined output.
*
* @param sources - array of sources for the concatenation
* @returns - in Node, a (() =\> NodeJS.ReadableStream) which, when read, produces a concatenation of all the inputs.
*           In browser, returns a `Blob` representing all the concatenated inputs.
*
* @internal
*/
async function concat(sources) {
	return function() {
		const streams = sources.map((x) => typeof x === "function" ? x() : x).map(toStream);
		return Readable$1.from((async function* () {
			for (const stream of streams) for await (const chunk of stream) yield chunk;
		})());
	};
}
//#endregion
//#region node_modules/.pnpm/@typespec+ts-http-runtime@0.3.8_supports-color@7.2.0/node_modules/@typespec/ts-http-runtime/dist/esm/policies/multipartPolicy.js
function generateBoundary() {
	return `----AzSDKFormBoundary${randomUUID$1()}`;
}
function encodeHeaders(headers) {
	let result = "";
	for (const [key, value] of headers) result += `${key}: ${value}\r\n`;
	return result;
}
function getLength(source) {
	if (source instanceof Uint8Array) return source.byteLength;
	else if (isBlob(source)) return source.size === -1 ? void 0 : source.size;
	else return;
}
function getTotalLength(sources) {
	let total = 0;
	for (const source of sources) {
		const partLength = getLength(source);
		if (partLength === void 0) return;
		else total += partLength;
	}
	return total;
}
async function buildRequestBody(request, parts, boundary) {
	const sources = [
		stringToUint8Array$1(`--${boundary}`, "utf-8"),
		...parts.flatMap((part) => [
			stringToUint8Array$1("\r\n", "utf-8"),
			stringToUint8Array$1(encodeHeaders(part.headers), "utf-8"),
			stringToUint8Array$1("\r\n", "utf-8"),
			part.body,
			stringToUint8Array$1(`\r\n--${boundary}`, "utf-8")
		]),
		stringToUint8Array$1("--\r\n\r\n", "utf-8")
	];
	const contentLength = getTotalLength(sources);
	if (contentLength) request.headers.set("Content-Length", contentLength);
	request.body = await concat(sources);
}
/**
* Name of multipart policy
*/
var multipartPolicyName$1 = "multipartPolicy";
var maxBoundaryLength = 70;
var validBoundaryCharacters = /* @__PURE__ */ new Set(`abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'()+,-./:=?`);
function assertValidBoundary(boundary) {
	if (boundary.length > maxBoundaryLength) throw new Error(`Multipart boundary "${boundary}" exceeds maximum length of 70 characters`);
	if (Array.from(boundary).some((x) => !validBoundaryCharacters.has(x))) throw new Error(`Multipart boundary "${boundary}" contains invalid characters`);
}
/**
* Pipeline policy for multipart requests
*/
function multipartPolicy$1() {
	return {
		name: multipartPolicyName$1,
		async sendRequest(request, next) {
			if (!request.multipartBody) return next(request);
			if (request.body) throw new Error("multipartBody and regular body cannot be set at the same time");
			let boundary = request.multipartBody.boundary;
			const contentTypeHeader = request.headers.get("Content-Type") ?? "multipart/mixed";
			const parsedHeader = contentTypeHeader.match(/^(multipart\/[^ ;]+)(?:; *boundary=(.+))?$/);
			if (!parsedHeader) throw new Error(`Got multipart request body, but content-type header was not multipart: ${contentTypeHeader}`);
			const [, contentType, parsedBoundary] = parsedHeader;
			if (parsedBoundary && boundary && parsedBoundary !== boundary) throw new Error(`Multipart boundary was specified as ${parsedBoundary} in the header, but got ${boundary} in the request body`);
			boundary ??= parsedBoundary;
			if (boundary) assertValidBoundary(boundary);
			else boundary = generateBoundary();
			request.headers.set("Content-Type", `${contentType}; boundary=${boundary}`);
			await buildRequestBody(request, request.multipartBody.parts, boundary);
			request.multipartBody = void 0;
			return next(request);
		}
	};
}
__name(multipartPolicy$1, "multipartPolicy");
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/pipeline.js
/**
* Creates a totally empty pipeline.
* Useful for testing or creating a custom one.
*/
function createEmptyPipeline() {
	return createEmptyPipeline$1();
}
//#endregion
//#region node_modules/.pnpm/@azure+logger@1.4.0_supports-color@7.2.0/node_modules/@azure/logger/dist/esm/index.js
var context = createLoggerContext({
	logLevelEnvVarName: "AZURE_LOG_LEVEL",
	namespace: "azure"
});
context.logger;
/**
* Creates a logger for use by the Azure SDKs that inherits from `AzureLogger`.
* @param namespace - The name of the SDK package.
* @hidden
*/
function createClientLogger(namespace) {
	return context.createClientLogger(namespace);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/log.js
var logger$3 = createClientLogger("core-rest-pipeline");
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/logPolicy.js
/**
* A policy that logs all requests and responses.
* @param options - Options to configure logPolicy.
*/
function logPolicy(options = {}) {
	return logPolicy$1({
		logger: logger$3.info,
		...options
	});
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/redirectPolicy.js
/**
* The programmatic identifier of the redirectPolicy.
*/
var redirectPolicyName = redirectPolicyName$1;
/**
* A policy to follow Location headers from the server in order
* to support server-side redirection.
* In the browser, this policy is not used.
* @param options - Options to control policy behavior.
*/
function redirectPolicy(options = {}) {
	return redirectPolicy$1(options);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/util/userAgentPlatform.js
/**
* @internal
*/
function getHeaderName() {
	return "User-Agent";
}
/**
* @internal
*/
async function setPlatformSpecificData(map) {
	if (process$1 && process$1.versions) {
		const osInfo = `${os$1.type()} ${os$1.release()}; ${os$1.arch()}`;
		if (process$1.versions.bun) map.set("Bun", `${process$1.versions.bun} (${osInfo})`);
		else if (process$1.versions.deno) map.set("Deno", `${process$1.versions.deno} (${osInfo})`);
		else if (process$1.versions.node) map.set("Node", `${process$1.versions.node} (${osInfo})`);
	}
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/constants.js
var SDK_VERSION$1 = "1.25.0";
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/util/userAgent.js
function getUserAgentString$1(telemetryInfo) {
	const parts = [];
	for (const [key, value] of telemetryInfo) {
		const token = value ? `${key}/${value}` : key;
		parts.push(token);
	}
	return parts.join(" ");
}
__name(getUserAgentString$1, "getUserAgentString");
/**
* @internal
*/
function getUserAgentHeaderName() {
	return getHeaderName();
}
/**
* @internal
*/
async function getUserAgentValue(prefix) {
	const runtimeInfo = /* @__PURE__ */ new Map();
	runtimeInfo.set("core-rest-pipeline", SDK_VERSION$1);
	await setPlatformSpecificData(runtimeInfo);
	const defaultAgent = getUserAgentString$1(runtimeInfo);
	return prefix ? `${prefix} ${defaultAgent}` : defaultAgent;
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/userAgentPolicy.js
var UserAgentHeaderName = getUserAgentHeaderName();
/**
* The programmatic identifier of the userAgentPolicy.
*/
var userAgentPolicyName = "userAgentPolicy";
/**
* A policy that sets the User-Agent header (or equivalent) to reflect
* the library version.
* @param options - Options to customize the user agent value.
*/
function userAgentPolicy(options = {}) {
	const userAgentValue = getUserAgentValue(options.userAgentPrefix);
	return {
		name: userAgentPolicyName,
		async sendRequest(request, next) {
			if (!request.headers.has(UserAgentHeaderName)) request.headers.set(UserAgentHeaderName, await userAgentValue);
			return next(request);
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/util/file.js
/**
* Private symbol used as key on objects created using createFile containing the
* original source of the file object.
*
* This is used in Node to access the original Node stream without using Blob#stream, which
* returns a web stream. This is done to avoid a couple of bugs to do with Blob#stream and
* Readable#to/fromWeb in Node versions we support:
* - https://github.com/nodejs/node/issues/42694 (fixed in Node 18.14)
* - https://github.com/nodejs/node/issues/48916 (fixed in Node 20.6)
*
* Once these versions are no longer supported, we may be able to stop doing this.
*
* @internal
*/
var rawContent = Symbol("rawContent");
/**
* Type guard to check if a given object is a blob-like object with a raw content property.
*/
function hasRawContent(x) {
	return typeof x[rawContent] === "function";
}
/**
* Extract the raw content from a given blob-like object. If the input was created using createFile
* or createFileFromStream, the exact content passed into createFile/createFileFromStream will be used.
* For true instances of Blob and File, returns the actual blob.
*
* @internal
*/
function getRawContent$1(blob) {
	if (hasRawContent(blob)) return blob[rawContent]();
	else return blob;
}
__name(getRawContent$1, "getRawContent");
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/multipartPolicy.js
/**
* Name of multipart policy
*/
var multipartPolicyName = multipartPolicyName$1;
/**
* Pipeline policy for multipart requests
*/
function multipartPolicy() {
	const tspPolicy = multipartPolicy$1();
	return {
		name: multipartPolicyName,
		sendRequest: async (request, next) => {
			if (request.multipartBody) {
				for (const part of request.multipartBody.parts) if (hasRawContent(part.body)) part.body = getRawContent$1(part.body);
			}
			return tspPolicy.sendRequest(request, next);
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/decompressResponsePolicy.js
/**
* The programmatic identifier of the decompressResponsePolicy.
*/
var decompressResponsePolicyName = decompressResponsePolicyName$1;
/**
* A policy to enable response decompression according to Accept-Encoding header
* https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding
*/
function decompressResponsePolicy() {
	return decompressResponsePolicy$1();
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/defaultRetryPolicy.js
/**
* A policy that retries according to three strategies:
* - When the server sends a 429 response with a Retry-After header.
* - When there are errors in the underlying transport layer (e.g. DNS lookup failures).
* - Or otherwise if the outgoing request fails, it will retry with an exponentially increasing delay.
*/
function defaultRetryPolicy(options = {}) {
	return defaultRetryPolicy$1(options);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/formDataPolicy.js
/**
* A policy that encodes FormData on the request into the body.
*/
function formDataPolicy() {
	return formDataPolicy$1();
}
//#endregion
//#region node_modules/.pnpm/@azure+abort-controller@2.2.0/node_modules/@azure/abort-controller/dist/esm/AbortError.js
/**
* This error is thrown when an asynchronous operation has been aborted.
* Check for this error by testing the `name` that the name property of the
* error matches `"AbortError"`.
*
* @example
* ```ts snippet:AbortErrorSample
* import { AbortError } from "@azure/abort-controller";
*
* async function doAsyncWork(options: { abortSignal: AbortSignal }): Promise<void> {
*   if (options.abortSignal.aborted) {
*     throw new AbortError();
*   }
*
*   // do async work
* }
*
* const controller = new AbortController();
* controller.abort();
* try {
*   doAsyncWork({ abortSignal: controller.signal });
* } catch (e) {
*   if (e instanceof Error && e.name === "AbortError") {
*     // handle abort error here.
*   }
* }
* ```
*/
var AbortError = class extends Error {
	constructor(message) {
		super(message);
		this.name = "AbortError";
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+core-util@1.14.0_supports-color@7.2.0/node_modules/@azure/core-util/dist/esm/createAbortablePromise.js
/**
* Creates an abortable promise.
* @param buildPromise - A function that takes the resolve and reject functions as parameters.
* @param options - The options for the abortable promise.
* @returns A promise that can be aborted.
*/
function createAbortablePromise(buildPromise, options) {
	const { cleanupBeforeAbort, abortSignal, abortErrorMsg } = options ?? {};
	return new Promise((resolve, reject) => {
		function rejectOnAbort() {
			reject(new AbortError(abortErrorMsg ?? "The operation was aborted."));
		}
		function removeListeners() {
			abortSignal?.removeEventListener("abort", onAbort);
		}
		function onAbort() {
			cleanupBeforeAbort?.();
			removeListeners();
			rejectOnAbort();
		}
		if (abortSignal?.aborted) return rejectOnAbort();
		try {
			buildPromise((x) => {
				removeListeners();
				resolve(x);
			}, (x) => {
				removeListeners();
				reject(x);
			});
		} catch (err) {
			reject(err);
		}
		abortSignal?.addEventListener("abort", onAbort);
	});
}
//#endregion
//#region node_modules/.pnpm/@azure+core-util@1.14.0_supports-color@7.2.0/node_modules/@azure/core-util/dist/esm/delay.js
var StandardAbortMessage = "The delay was aborted.";
/**
* A wrapper for setTimeout that resolves a promise after timeInMs milliseconds.
* @param timeInMs - The number of milliseconds to be delayed.
* @param options - The options for delay - currently abort options
* @returns Promise that is resolved after timeInMs
*/
function delay$1(timeInMs, options) {
	let token;
	const { abortSignal, abortErrorMsg } = options ?? {};
	return createAbortablePromise((resolve) => {
		token = setTimeout(resolve, timeInMs);
	}, {
		cleanupBeforeAbort: () => clearTimeout(token),
		abortSignal,
		abortErrorMsg: abortErrorMsg ?? StandardAbortMessage
	});
}
__name(delay$1, "delay");
//#endregion
//#region node_modules/.pnpm/@azure+core-util@1.14.0_supports-color@7.2.0/node_modules/@azure/core-util/dist/esm/error.js
/**
* Given what is thought to be an error object, return the message if possible.
* If the message is missing, returns a stringified version of the input.
* @param e - Something thrown from a try block
* @returns The error message or a string of the input
*/
function getErrorMessage(e) {
	if (isError$1(e)) return e.message;
	else {
		let stringified;
		try {
			if (typeof e === "object" && e) stringified = JSON.stringify(e);
			else stringified = String(e);
		} catch (err) {
			stringified = "[unable to stringify input]";
		}
		return `Unknown error ${stringified}`;
	}
}
//#endregion
//#region node_modules/.pnpm/@azure+core-util@1.14.0_supports-color@7.2.0/node_modules/@azure/core-util/dist/esm/index.js
/**
* Typeguard for an error object shape (has name and message)
*
* @param e - Something caught by a catch clause.
*/
function isError(e) {
	return isError$1(e);
}
/**
* Generated Universally Unique Identifier
*
* @returns RFC4122 v4 UUID.
*/
function randomUUID() {
	return randomUUID$1();
}
/**
* A constant that indicates whether the environment the code is running is a Node.js compatible environment.
*/
var isNodeLike = true;
/**
* The helper that transforms bytes with specific character encoding into string
* @param bytes - the uint8array bytes
* @param format - the format we use to encode the byte
* @returns a string of the encoded string
*/
function uint8ArrayToString(bytes, format) {
	return uint8ArrayToString$1(bytes, format);
}
/**
* The helper that transforms string to specific character encoded bytes array.
* @param value - the string to be converted
* @param format - the format we use to decode the value
* @returns a uint8array
*/
function stringToUint8Array(value, format) {
	return stringToUint8Array$1(value, format);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/proxyPolicy.js
/**
* This method converts a proxy url into `ProxySettings` for use with ProxyPolicy.
* If no argument is given, it attempts to parse a proxy URL from the environment
* variables `HTTPS_PROXY` or `HTTP_PROXY`.
* @param proxyUrl - The url of the proxy to use. May contain authentication information.
* @deprecated - Internally this method is no longer necessary when setting proxy information.
*/
function getDefaultProxySettings(proxyUrl) {
	return getDefaultProxySettings$1(proxyUrl);
}
/**
* A policy that allows one to apply proxy settings to all requests.
* If not passed static settings, they will be retrieved from the HTTPS_PROXY
* or HTTP_PROXY environment variables.
* @param proxySettings - ProxySettings to use on each request.
* @param options - additional settings, for example, custom NO_PROXY patterns
*/
function proxyPolicy(proxySettings, options) {
	return proxyPolicy$1(proxySettings, options);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/setClientRequestIdPolicy.js
/**
* The programmatic identifier of the setClientRequestIdPolicy.
*/
var setClientRequestIdPolicyName = "setClientRequestIdPolicy";
/**
* Each PipelineRequest gets a unique id upon creation.
* This policy passes that unique id along via an HTTP header to enable better
* telemetry and tracing.
* @param requestIdHeaderName - The name of the header to pass the request ID to.
*/
function setClientRequestIdPolicy(requestIdHeaderName = "x-ms-client-request-id") {
	return {
		name: setClientRequestIdPolicyName,
		async sendRequest(request, next) {
			if (!request.headers.has(requestIdHeaderName)) request.headers.set(requestIdHeaderName, request.requestId);
			return next(request);
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/agentPolicy.js
/**
* Gets a pipeline policy that sets http.agent
*/
function agentPolicy(agent) {
	return agentPolicy$1(agent);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/tlsPolicy.js
/**
* Gets a pipeline policy that adds the client certificate to the HttpClient agent for authentication.
*/
function tlsPolicy(tlsSettings) {
	return tlsPolicy$1(tlsSettings);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-tracing@1.4.0/node_modules/@azure/core-tracing/dist/esm/tracingContext.js
/** @internal */
var knownContextKeys = {
	span: Symbol.for("@azure/core-tracing span"),
	namespace: Symbol.for("@azure/core-tracing namespace")
};
/**
* Creates a new {@link TracingContext} with the given options.
* @param options - A set of known keys that may be set on the context.
* @returns A new {@link TracingContext} with the given options.
*
* @internal
*/
function createTracingContext(options = {}) {
	let context = new TracingContextImpl(options.parentContext);
	if (options.span) context = context.setValue(knownContextKeys.span, options.span);
	if (options.namespace) context = context.setValue(knownContextKeys.namespace, options.namespace);
	return context;
}
/** @internal */
var TracingContextImpl = class TracingContextImpl {
	_contextMap;
	constructor(initialContext) {
		this._contextMap = initialContext instanceof TracingContextImpl ? new Map(initialContext._contextMap) : /* @__PURE__ */ new Map();
	}
	setValue(key, value) {
		const newContext = new TracingContextImpl(this);
		newContext._contextMap.set(key, value);
		return newContext;
	}
	getValue(key) {
		return this._contextMap.get(key);
	}
	deleteValue(key) {
		const newContext = new TracingContextImpl(this);
		newContext._contextMap.delete(key);
		return newContext;
	}
};
/**
* Defines the shared state between CJS and ESM by re-exporting the CJS state.
*/
var state$1 = (/* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.state = void 0;
	/**
	* @internal
	*
	* Holds the singleton instrumenter, to be shared across CJS and ESM imports.
	*/
	exports.state = { instrumenterImplementation: void 0 };
})))().state;
//#endregion
//#region node_modules/.pnpm/@azure+core-tracing@1.4.0/node_modules/@azure/core-tracing/dist/esm/instrumenter.js
function createDefaultTracingSpan() {
	return {
		end: () => {},
		isRecording: () => false,
		recordException: () => {},
		setAttribute: () => {},
		setStatus: () => {},
		addEvent: () => {}
	};
}
function createDefaultInstrumenter() {
	return {
		createRequestHeaders: () => {
			return {};
		},
		parseTraceparentHeader: () => {},
		startSpan: (_name, spanOptions) => {
			return {
				span: createDefaultTracingSpan(),
				tracingContext: createTracingContext({ parentContext: spanOptions.tracingContext })
			};
		},
		withContext(_context, callback, ...callbackArgs) {
			return callback(...callbackArgs);
		}
	};
}
/**
* Gets the currently set instrumenter, a No-Op instrumenter by default.
*
* @returns The currently set instrumenter
*/
function getInstrumenter() {
	if (!state$1.instrumenterImplementation) state$1.instrumenterImplementation = createDefaultInstrumenter();
	return state$1.instrumenterImplementation;
}
//#endregion
//#region node_modules/.pnpm/@azure+core-tracing@1.4.0/node_modules/@azure/core-tracing/dist/esm/tracingClient.js
/**
* Creates a new tracing client.
*
* @param options - Options used to configure the tracing client.
* @returns - An instance of {@link TracingClient}.
*/
function createTracingClient(options) {
	const { namespace, packageName, packageVersion } = options;
	function startSpan(name, operationOptions, spanOptions) {
		const startSpanResult = getInstrumenter().startSpan(name, {
			...spanOptions,
			packageName,
			packageVersion,
			tracingContext: operationOptions?.tracingOptions?.tracingContext
		});
		let tracingContext = startSpanResult.tracingContext;
		const span = startSpanResult.span;
		if (!tracingContext.getValue(knownContextKeys.namespace)) tracingContext = tracingContext.setValue(knownContextKeys.namespace, namespace);
		span.setAttribute("az.namespace", tracingContext.getValue(knownContextKeys.namespace));
		return {
			span,
			updatedOptions: Object.assign({}, operationOptions, { tracingOptions: {
				...operationOptions?.tracingOptions,
				tracingContext
			} })
		};
	}
	async function withSpan(name, operationOptions, callback, spanOptions) {
		const { span, updatedOptions } = startSpan(name, operationOptions, spanOptions);
		try {
			const result = await withContext(updatedOptions.tracingOptions.tracingContext, () => callback(updatedOptions, span));
			span.setStatus({ status: "success" });
			return result;
		} catch (err) {
			span.setStatus({
				status: "error",
				error: err
			});
			throw err;
		} finally {
			span.end();
		}
	}
	function withContext(context, callback, ...callbackArgs) {
		return getInstrumenter().withContext(context, callback, ...callbackArgs);
	}
	/**
	* Parses a traceparent header value into a span identifier.
	*
	* @param traceparentHeader - The traceparent header to parse.
	* @returns An implementation-specific identifier for the span.
	*/
	function parseTraceparentHeader(traceparentHeader) {
		return getInstrumenter().parseTraceparentHeader(traceparentHeader);
	}
	/**
	* Creates a set of request headers to propagate tracing information to a backend.
	*
	* @param tracingContext - The context containing the span to serialize.
	* @returns The set of headers to add to a request.
	*/
	function createRequestHeaders(tracingContext) {
		return getInstrumenter().createRequestHeaders(tracingContext);
	}
	return {
		startSpan,
		withSpan,
		withContext,
		parseTraceparentHeader,
		createRequestHeaders
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/restError.js
/**
* A custom error type for failed pipeline requests.
*/
var RestError = RestError$1;
/**
* Typeguard for RestError
* @param e - Something caught by a catch clause.
*/
function isRestError(e) {
	return isRestError$1(e);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/tracingPolicy.js
/**
* The programmatic identifier of the tracingPolicy.
*/
var tracingPolicyName = "tracingPolicy";
/**
* A simple policy to create OpenTelemetry Spans for each request made by the pipeline
* that has SpanOptions with a parent.
* Requests made without a parent Span will not be recorded.
* @param options - Options to configure the telemetry logged by the tracing policy.
*/
function tracingPolicy(options = {}) {
	const userAgentPromise = getUserAgentValue(options.userAgentPrefix);
	const sanitizer = new Sanitizer({ additionalAllowedQueryParameters: options.additionalAllowedQueryParameters });
	const tracingClient = tryCreateTracingClient();
	return {
		name: tracingPolicyName,
		async sendRequest(request, next) {
			if (!tracingClient) return next(request);
			const userAgent = await userAgentPromise;
			const spanAttributes = {
				"http.url": sanitizer.sanitizeUrl(request.url),
				"http.method": request.method,
				"http.user_agent": userAgent,
				requestId: request.requestId
			};
			if (userAgent) spanAttributes["http.user_agent"] = userAgent;
			const { span, tracingContext } = tryCreateSpan(tracingClient, request, spanAttributes) ?? {};
			if (!span || !tracingContext) return next(request);
			try {
				const response = await tracingClient.withContext(tracingContext, next, request);
				tryProcessResponse(span, response);
				return response;
			} catch (err) {
				tryProcessError(span, err);
				throw err;
			}
		}
	};
}
function tryCreateTracingClient() {
	try {
		return createTracingClient({
			namespace: "",
			packageName: "@azure/core-rest-pipeline",
			packageVersion: SDK_VERSION$1
		});
	} catch (e) {
		logger$3.warning(`Error when creating the TracingClient: ${getErrorMessage(e)}`);
		return;
	}
}
function tryCreateSpan(tracingClient, request, spanAttributes) {
	try {
		const { span, updatedOptions } = tracingClient.startSpan(`HTTP ${request.method}`, { tracingOptions: request.tracingOptions }, {
			spanKind: "client",
			spanAttributes
		});
		if (!span.isRecording()) {
			span.end();
			return;
		}
		const headers = tracingClient.createRequestHeaders(updatedOptions.tracingOptions.tracingContext);
		for (const [key, value] of Object.entries(headers)) request.headers.set(key, value);
		return {
			span,
			tracingContext: updatedOptions.tracingOptions.tracingContext
		};
	} catch (e) {
		logger$3.warning(`Skipping creating a tracing span due to an error: ${getErrorMessage(e)}`);
		return;
	}
}
function tryProcessError(span, error) {
	try {
		span.setStatus({
			status: "error",
			error: isError(error) ? error : void 0
		});
		if (isRestError(error) && error.statusCode) span.setAttribute("http.status_code", error.statusCode);
		span.end();
	} catch (e) {
		logger$3.warning(`Skipping tracing span processing due to an error: ${getErrorMessage(e)}`);
	}
}
function tryProcessResponse(span, response) {
	try {
		span.setAttribute("http.status_code", response.status);
		const serviceRequestId = response.headers.get("x-ms-request-id");
		if (serviceRequestId) span.setAttribute("serviceRequestId", serviceRequestId);
		if (response.status >= 400) span.setStatus({ status: "error" });
		span.end();
	} catch (e) {
		logger$3.warning(`Skipping tracing span processing due to an error: ${getErrorMessage(e)}`);
	}
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/util/wrapAbortSignal.js
/**
* Creates a native AbortSignal which reflects the state of the provided AbortSignalLike.
* If the AbortSignalLike is already a native AbortSignal, it is returned as is.
* @param abortSignalLike - The AbortSignalLike to wrap.
* @returns - An object containing the native AbortSignal and an optional cleanup function. The cleanup function should be called when the AbortSignal is no longer needed.
*/
function wrapAbortSignalLike(abortSignalLike) {
	if (abortSignalLike instanceof AbortSignal) return { abortSignal: abortSignalLike };
	if (abortSignalLike.aborted) return { abortSignal: AbortSignal.abort("reason" in abortSignalLike ? abortSignalLike.reason : void 0) };
	const controller = new AbortController();
	let needsCleanup = true;
	function cleanup() {
		if (needsCleanup) {
			abortSignalLike.removeEventListener("abort", listener);
			needsCleanup = false;
		}
	}
	function listener() {
		controller.abort("reason" in abortSignalLike ? abortSignalLike.reason : void 0);
		cleanup();
	}
	abortSignalLike.addEventListener("abort", listener);
	return {
		abortSignal: controller.signal,
		cleanup
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/wrapAbortSignalLikePolicy.js
var wrapAbortSignalLikePolicyName = "wrapAbortSignalLikePolicy";
/**
* Policy that ensure that any AbortSignalLike is wrapped in a native AbortSignal for processing by the pipeline.
* Since the ts-http-runtime expects a native AbortSignal, this policy is used to ensure that any AbortSignalLike is wrapped in a native AbortSignal.
*
* @returns - created policy
*/
function wrapAbortSignalLikePolicy() {
	return {
		name: wrapAbortSignalLikePolicyName,
		sendRequest: async (request, next) => {
			if (!request.abortSignal) return next(request);
			const { abortSignal, cleanup } = wrapAbortSignalLike(request.abortSignal);
			request.abortSignal = abortSignal;
			try {
				return await next(request);
			} finally {
				cleanup?.();
			}
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/createPipelineFromOptions.js
/**
* Create a new pipeline with a default set of customizable policies.
* @param options - Options to configure a custom pipeline.
*/
function createPipelineFromOptions(options) {
	const pipeline = createEmptyPipeline();
	if (isNodeLike) {
		if (options.agent) pipeline.addPolicy(agentPolicy(options.agent));
		if (options.tlsOptions) pipeline.addPolicy(tlsPolicy(options.tlsOptions));
		pipeline.addPolicy(proxyPolicy(options.proxyOptions));
		pipeline.addPolicy(decompressResponsePolicy());
	}
	pipeline.addPolicy(wrapAbortSignalLikePolicy());
	pipeline.addPolicy(formDataPolicy(), { beforePolicies: [multipartPolicyName] });
	pipeline.addPolicy(userAgentPolicy(options.userAgentOptions));
	pipeline.addPolicy(setClientRequestIdPolicy(options.telemetryOptions?.clientRequestIdHeaderName));
	pipeline.addPolicy(multipartPolicy(), { afterPhase: "Deserialize" });
	pipeline.addPolicy(defaultRetryPolicy(options.retryOptions), { phase: "Retry" });
	pipeline.addPolicy(tracingPolicy({
		...options.userAgentOptions,
		...options.loggingOptions
	}), { afterPhase: "Retry" });
	if (isNodeLike) pipeline.addPolicy(redirectPolicy(options.redirectOptions), { afterPhase: "Retry" });
	pipeline.addPolicy(logPolicy(options.loggingOptions), { afterPhase: "Sign" });
	return pipeline;
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/defaultHttpClient.js
/**
* Create the correct HttpClient for the current environment.
*/
function createDefaultHttpClient() {
	const client = createDefaultHttpClient$1();
	return { async sendRequest(request) {
		const { abortSignal, cleanup } = request.abortSignal ? wrapAbortSignalLike(request.abortSignal) : {};
		try {
			request.abortSignal = abortSignal;
			return await client.sendRequest(request);
		} finally {
			cleanup?.();
		}
	} };
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/httpHeaders.js
/**
* Creates an object that satisfies the `HttpHeaders` interface.
* @param rawHeaders - A simple object representing initial headers
*/
function createHttpHeaders(rawHeaders) {
	return createHttpHeaders$1(rawHeaders);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/pipelineRequest.js
/**
* Creates a new pipeline request with the given options.
* This method is to allow for the easy setting of default values and not required.
* @param options - The options to create the request with.
*/
function createPipelineRequest(options) {
	return createPipelineRequest$1(options);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/util/tokenCycler.js
var DEFAULT_CYCLER_OPTIONS = {
	forcedRefreshWindowInMs: 1e3,
	retryIntervalInMs: 3e3,
	refreshWindowInMs: 12e4
};
/**
* Converts an an unreliable access token getter (which may resolve with null)
* into an AccessTokenGetter by retrying the unreliable getter in a regular
* interval.
*
* @param getAccessToken - A function that produces a promise of an access token that may fail by returning null.
* @param retryIntervalInMs - The time (in milliseconds) to wait between retry attempts.
* @param refreshTimeout - The timestamp after which the refresh attempt will fail, throwing an exception.
* @returns - A promise that, if it resolves, will resolve with an access token.
*/
async function beginRefresh(getAccessToken, retryIntervalInMs, refreshTimeout) {
	async function tryGetAccessToken() {
		if (Date.now() < refreshTimeout) try {
			return await getAccessToken();
		} catch {
			return null;
		}
		else {
			const finalToken = await getAccessToken();
			if (finalToken === null) throw new Error("Failed to refresh access token.");
			return finalToken;
		}
	}
	let token = await tryGetAccessToken();
	while (token === null) {
		await delay$1(retryIntervalInMs);
		token = await tryGetAccessToken();
	}
	return token;
}
/**
* Creates a token cycler from a credential, scopes, and optional settings.
*
* A token cycler represents a way to reliably retrieve a valid access token
* from a TokenCredential. It will handle initializing the token, refreshing it
* when it nears expiration, and synchronizes refresh attempts to avoid
* concurrency hazards.
*
* @param credential - the underlying TokenCredential that provides the access
* token
* @param tokenCyclerOptions - optionally override default settings for the cycler
*
* @returns - a function that reliably produces a valid access token
*/
function createTokenCycler(credential, tokenCyclerOptions) {
	let refreshWorker = null;
	let token = null;
	let tenantId;
	const options = {
		...DEFAULT_CYCLER_OPTIONS,
		...tokenCyclerOptions
	};
	/**
	* This little holder defines several predicates that we use to construct
	* the rules of refreshing the token.
	*/
	const cycler = {
		/**
		* Produces true if a refresh job is currently in progress.
		*/
		get isRefreshing() {
			return refreshWorker !== null;
		},
		/**
		* Produces true if the cycler SHOULD refresh (we are within the refresh
		* window and not already refreshing)
		*/
		get shouldRefresh() {
			if (token === null) return true;
			if (cycler.isRefreshing) return false;
			if (token.refreshAfterTimestamp && token.refreshAfterTimestamp < Date.now()) return true;
			return token.expiresOnTimestamp - options.refreshWindowInMs < Date.now();
		},
		/**
		* Produces true if the cycler MUST refresh (null or nearly-expired
		* token).
		*/
		get mustRefresh() {
			return token === null || token.expiresOnTimestamp - options.forcedRefreshWindowInMs < Date.now();
		}
	};
	/**
	* Starts a refresh job or returns the existing job if one is already
	* running.
	*/
	function refresh(scopes, getTokenOptions) {
		if (!cycler.isRefreshing) {
			const tryGetAccessToken = () => credential.getToken(scopes, getTokenOptions);
			refreshWorker = beginRefresh(tryGetAccessToken, options.retryIntervalInMs, token?.expiresOnTimestamp ?? Date.now()).then((_token) => {
				refreshWorker = null;
				token = _token;
				tenantId = getTokenOptions.tenantId;
				return token;
			}).catch((reason) => {
				refreshWorker = null;
				token = null;
				tenantId = void 0;
				throw reason;
			});
		}
		return refreshWorker;
	}
	return async (scopes, tokenOptions) => {
		const hasClaimChallenge = Boolean(tokenOptions.claims);
		const tenantIdChanged = tenantId !== tokenOptions.tenantId;
		if (hasClaimChallenge) token = null;
		if (tenantIdChanged || hasClaimChallenge || cycler.mustRefresh) return refresh(scopes, tokenOptions);
		if (cycler.shouldRefresh) refresh(scopes, tokenOptions);
		return token;
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-rest-pipeline@1.25.0_supports-color@7.2.0/node_modules/@azure/core-rest-pipeline/dist/esm/policies/bearerTokenAuthenticationPolicy.js
/**
* The programmatic identifier of the bearerTokenAuthenticationPolicy.
*/
var bearerTokenAuthenticationPolicyName = "bearerTokenAuthenticationPolicy";
/**
* Try to send the given request.
*
* When a response is received, returns a tuple of the response received and, if the response was received
* inside a thrown RestError, the RestError that was thrown.
*
* Otherwise, if an error was thrown while sending the request that did not provide an underlying response, it
* will be rethrown.
*/
async function trySendRequest(request, next) {
	try {
		return [await next(request), void 0];
	} catch (e) {
		if (isRestError(e) && e.response) return [e.response, e];
		else throw e;
	}
}
/**
* Default authorize request handler
*/
async function defaultAuthorizeRequest(options) {
	const { scopes, getAccessToken, request } = options;
	const accessToken = await getAccessToken(scopes, {
		abortSignal: request.abortSignal,
		tracingOptions: request.tracingOptions,
		enableCae: true
	});
	if (accessToken) options.request.headers.set("Authorization", `Bearer ${accessToken.token}`);
}
/**
* We will retrieve the challenge only if the response status code was 401,
* and if the response contained the header "WWW-Authenticate" with a non-empty value.
*/
function isChallengeResponse(response) {
	return response.status === 401 && response.headers.has("WWW-Authenticate");
}
/**
* Re-authorize the request for CAE challenge.
* The response containing the challenge is `options.response`.
* If this method returns true, the underlying request will be sent once again.
*/
async function authorizeRequestOnCaeChallenge(onChallengeOptions, caeClaims) {
	const { scopes } = onChallengeOptions;
	const accessToken = await onChallengeOptions.getAccessToken(scopes, {
		enableCae: true,
		claims: caeClaims
	});
	if (!accessToken) return false;
	onChallengeOptions.request.headers.set("Authorization", `${accessToken.tokenType ?? "Bearer"} ${accessToken.token}`);
	return true;
}
/**
* A policy that can request a token from a TokenCredential implementation and
* then apply it to the Authorization header of a request as a Bearer token.
*/
function bearerTokenAuthenticationPolicy(options) {
	const { credential, scopes, challengeCallbacks } = options;
	const logger = options.logger || logger$3;
	const callbacks = {
		authorizeRequest: challengeCallbacks?.authorizeRequest?.bind(challengeCallbacks) ?? defaultAuthorizeRequest,
		authorizeRequestOnChallenge: challengeCallbacks?.authorizeRequestOnChallenge?.bind(challengeCallbacks)
	};
	const getAccessToken = credential ? createTokenCycler(credential) : () => Promise.resolve(null);
	return {
		name: bearerTokenAuthenticationPolicyName,
		/**
		* If there's no challenge parameter:
		* - It will try to retrieve the token using the cache, or the credential's getToken.
		* - Then it will try the next policy with or without the retrieved token.
		*
		* It uses the challenge parameters to:
		* - Skip a first attempt to get the token from the credential if there's no cached token,
		*   since it expects the token to be retrievable only after the challenge.
		* - Prepare the outgoing request if the `prepareRequest` method has been provided.
		* - Send an initial request to receive the challenge if it fails.
		* - Process a challenge if the response contains it.
		* - Retrieve a token with the challenge information, then re-send the request.
		*/
		async sendRequest(request, next) {
			if (!request.url.toLowerCase().startsWith("https://")) throw new Error("Bearer token authentication is not permitted for non-TLS protected (non-https) URLs.");
			await callbacks.authorizeRequest({
				scopes: Array.isArray(scopes) ? scopes : [scopes],
				request,
				getAccessToken,
				logger
			});
			let response;
			let error;
			let shouldSendRequest;
			[response, error] = await trySendRequest(request, next);
			if (isChallengeResponse(response)) {
				let claims = getCaeChallengeClaims(response.headers.get("WWW-Authenticate"));
				if (claims) {
					let parsedClaim;
					try {
						parsedClaim = atob(claims);
					} catch (e) {
						logger.warning(`The WWW-Authenticate header contains "claims" that cannot be parsed. Unable to perform the Continuous Access Evaluation authentication flow. Unparsable claims: ${claims}`);
						return response;
					}
					shouldSendRequest = await authorizeRequestOnCaeChallenge({
						scopes: Array.isArray(scopes) ? scopes : [scopes],
						response,
						request,
						getAccessToken,
						logger
					}, parsedClaim);
					if (shouldSendRequest) [response, error] = await trySendRequest(request, next);
				} else if (callbacks.authorizeRequestOnChallenge) {
					shouldSendRequest = await callbacks.authorizeRequestOnChallenge({
						scopes: Array.isArray(scopes) ? scopes : [scopes],
						request,
						response,
						getAccessToken,
						logger
					});
					if (shouldSendRequest) [response, error] = await trySendRequest(request, next);
					if (isChallengeResponse(response)) {
						claims = getCaeChallengeClaims(response.headers.get("WWW-Authenticate") ?? "");
						if (claims) {
							let parsedClaim;
							try {
								parsedClaim = atob(claims);
							} catch (e) {
								logger.warning(`The WWW-Authenticate header contains "claims" that cannot be parsed. Unable to perform the Continuous Access Evaluation authentication flow. Unparsable claims: ${claims}`);
								return response;
							}
							shouldSendRequest = await authorizeRequestOnCaeChallenge({
								scopes: Array.isArray(scopes) ? scopes : [scopes],
								response,
								request,
								getAccessToken,
								logger
							}, parsedClaim);
							if (shouldSendRequest) [response, error] = await trySendRequest(request, next);
						}
					}
				}
			}
			if (error) throw error;
			else return response;
		}
	};
}
/**
* Converts: `Bearer a="b", c="d", Pop e="f", g="h"`.
* Into: `[ { scheme: 'Bearer', params: { a: 'b', c: 'd' } }, { scheme: 'Pop', params: { e: 'f', g: 'h' } } ]`.
*
* @internal
*/
function parseChallenges(challenges) {
	const challengeRegex = /(\w+)\s+((?:\w+=(?:"[^"]*"|[^,]*),?\s*)+)/g;
	const paramRegex = /(\w+)="([^"]*)"/g;
	const parsedChallenges = [];
	let match;
	while ((match = challengeRegex.exec(challenges)) !== null) {
		const scheme = match[1];
		const paramsString = match[2];
		const params = {};
		let paramMatch;
		while ((paramMatch = paramRegex.exec(paramsString)) !== null) params[paramMatch[1]] = paramMatch[2];
		parsedChallenges.push({
			scheme,
			params
		});
	}
	return parsedChallenges;
}
/**
* Parse a pipeline response and look for a CAE challenge with "Bearer" scheme
* Return the value in the header without parsing the challenge
* @internal
*/
function getCaeChallengeClaims(challenges) {
	if (!challenges) return;
	return parseChallenges(challenges).find((x) => x.scheme === "Bearer" && x.params.claims && x.params.error === "insufficient_claims")?.params.claims;
}
//#endregion
//#region node_modules/.pnpm/@azure+core-auth@1.11.0_supports-color@7.2.0/node_modules/@azure/core-auth/dist/esm/tokenCredential.js
/**
* Tests an object to determine whether it implements TokenCredential.
*
* @param credential - The assumed TokenCredential to be tested.
*/
function isTokenCredential(credential) {
	const castCredential = credential;
	return castCredential && typeof castCredential.getToken === "function" && (castCredential.signRequest === void 0 || castCredential.getToken.length > 0);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-http-compat@2.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__@azure+co_d787bc7df786cb651d567e8aaf5a6964/node_modules/@azure/core-http-compat/dist/esm/policies/disableKeepAlivePolicy.js
var disableKeepAlivePolicyName = "DisableKeepAlivePolicy";
function createDisableKeepAlivePolicy() {
	return {
		name: disableKeepAlivePolicyName,
		sendRequest(request, next) {
			request.disableKeepAlive = true;
			return next(request);
		}
	};
}
/**
* @internal
*/
function pipelineContainsDisableKeepAlivePolicy(pipeline) {
	return pipeline.getOrderedPolicies().some((policy) => policy.name === disableKeepAlivePolicyName);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/base64.js
/**
* Encodes a byte array in base64 format.
* @param value - the Uint8Array to encode
* @internal
*/
function encodeByteArray(value) {
	return uint8ArrayToString(value, "base64");
}
/**
* Decodes a base64 string into a byte array.
* @param value - the base64 string to decode
* @internal
*/
function decodeString(value) {
	return stringToUint8Array(value, "base64");
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/utils.js
/**
* A type guard for a primitive response body.
* @param value - Value to test
*
* @internal
*/
function isPrimitiveBody(value, mapperTypeName) {
	return mapperTypeName !== "Composite" && mapperTypeName !== "Dictionary" && (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || mapperTypeName?.match(/^(Date|DateTime|DateTimeRfc1123|UnixTime|ByteArray|Base64Url)$/i) !== null || value === void 0 || value === null);
}
var validateISODuration = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
/**
* Returns true if the given string is in ISO 8601 format.
* @param value - The value to be validated for ISO 8601 duration format.
* @internal
*/
function isDuration(value) {
	return validateISODuration.test(value);
}
var validUuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;
/**
* Returns true if the provided uuid is valid.
*
* @param uuid - The uuid that needs to be validated.
*
* @internal
*/
function isValidUuid(uuid) {
	return validUuidRegex.test(uuid);
}
/**
* Maps the response as follows:
* - wraps the response body if needed (typically if its type is primitive).
* - returns null if the combination of the headers and the body is empty.
* - otherwise, returns the combination of the headers and the body.
*
* @param responseObject - a representation of the parsed response
* @returns the response that will be returned to the user which can be null and/or wrapped
*
* @internal
*/
function handleNullableResponseAndWrappableBody(responseObject) {
	const combinedHeadersAndBody = {
		...responseObject.headers,
		...responseObject.body
	};
	if (responseObject.hasNullableType && Object.getOwnPropertyNames(combinedHeadersAndBody).length === 0) return responseObject.shouldWrapBody ? { body: null } : null;
	else return responseObject.shouldWrapBody ? {
		...responseObject.headers,
		body: responseObject.body
	} : combinedHeadersAndBody;
}
/**
* Take a `FullOperationResponse` and turn it into a flat
* response object to hand back to the consumer.
* @param fullResponse - The processed response from the operation request
* @param responseSpec - The response map from the OperationSpec
*
* @internal
*/
function flattenResponse(fullResponse, responseSpec) {
	const parsedHeaders = fullResponse.parsedHeaders;
	if (fullResponse.request.method === "HEAD") return {
		...parsedHeaders,
		body: fullResponse.parsedBody
	};
	const bodyMapper = responseSpec && responseSpec.bodyMapper;
	const isNullable = Boolean(bodyMapper?.nullable);
	const expectedBodyTypeName = bodyMapper?.type.name;
	/** If the body is asked for, we look at the expected body type to handle it */
	if (expectedBodyTypeName === "Stream") return {
		...parsedHeaders,
		blobBody: fullResponse.blobBody,
		readableStreamBody: fullResponse.readableStreamBody
	};
	const modelProperties = expectedBodyTypeName === "Composite" && bodyMapper.type.modelProperties || {};
	const isPageableResponse = Object.keys(modelProperties).some((k) => modelProperties[k].serializedName === "");
	if (expectedBodyTypeName === "Sequence" || isPageableResponse) {
		const arrayResponse = fullResponse.parsedBody ?? [];
		for (const key of Object.keys(modelProperties)) if (modelProperties[key].serializedName) arrayResponse[key] = fullResponse.parsedBody?.[key];
		if (parsedHeaders) for (const key of Object.keys(parsedHeaders)) arrayResponse[key] = parsedHeaders[key];
		return isNullable && !fullResponse.parsedBody && !parsedHeaders && Object.getOwnPropertyNames(modelProperties).length === 0 ? null : arrayResponse;
	}
	return handleNullableResponseAndWrappableBody({
		body: fullResponse.parsedBody,
		headers: parsedHeaders,
		hasNullableType: isNullable,
		shouldWrapBody: isPrimitiveBody(fullResponse.parsedBody, expectedBodyTypeName)
	});
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/serializer.js
var SerializerImpl = class {
	modelMappers;
	isXML;
	constructor(modelMappers = {}, isXML = false) {
		this.modelMappers = modelMappers;
		this.isXML = isXML;
	}
	/**
	* @deprecated Removing the constraints validation on client side.
	*/
	validateConstraints(mapper, value, objectName) {
		const failValidation = (constraintName, constraintValue) => {
			throw new Error(`"${objectName}" with value "${value}" should satisfy the constraint "${constraintName}": ${constraintValue}.`);
		};
		if (mapper.constraints && value !== void 0 && value !== null) {
			const { ExclusiveMaximum, ExclusiveMinimum, InclusiveMaximum, InclusiveMinimum, MaxItems, MaxLength, MinItems, MinLength, MultipleOf, Pattern, UniqueItems } = mapper.constraints;
			if (ExclusiveMaximum !== void 0 && value >= ExclusiveMaximum) failValidation("ExclusiveMaximum", ExclusiveMaximum);
			if (ExclusiveMinimum !== void 0 && value <= ExclusiveMinimum) failValidation("ExclusiveMinimum", ExclusiveMinimum);
			if (InclusiveMaximum !== void 0 && value > InclusiveMaximum) failValidation("InclusiveMaximum", InclusiveMaximum);
			if (InclusiveMinimum !== void 0 && value < InclusiveMinimum) failValidation("InclusiveMinimum", InclusiveMinimum);
			if (MaxItems !== void 0 && value.length > MaxItems) failValidation("MaxItems", MaxItems);
			if (MaxLength !== void 0 && value.length > MaxLength) failValidation("MaxLength", MaxLength);
			if (MinItems !== void 0 && value.length < MinItems) failValidation("MinItems", MinItems);
			if (MinLength !== void 0 && value.length < MinLength) failValidation("MinLength", MinLength);
			if (MultipleOf !== void 0 && value % MultipleOf !== 0) failValidation("MultipleOf", MultipleOf);
			if (Pattern) {
				const pattern = typeof Pattern === "string" ? new RegExp(Pattern) : Pattern;
				if (typeof value !== "string" || value.match(pattern) === null) failValidation("Pattern", Pattern);
			}
			if (UniqueItems && value.some((item, i, ar) => ar.indexOf(item) !== i)) failValidation("UniqueItems", UniqueItems);
		}
	}
	/**
	* Serialize the given object based on its metadata defined in the mapper
	*
	* @param mapper - The mapper which defines the metadata of the serializable object
	*
	* @param object - A valid Javascript object to be serialized
	*
	* @param objectName - Name of the serialized object
	*
	* @param options - additional options to serialization
	*
	* @returns A valid serialized Javascript object
	*/
	serialize(mapper, object, objectName, options = { xml: {} }) {
		const updatedOptions = { xml: {
			rootName: options.xml.rootName ?? "",
			includeRoot: options.xml.includeRoot ?? false,
			xmlCharKey: options.xml.xmlCharKey ?? "_"
		} };
		let payload = {};
		const mapperType = mapper.type.name;
		if (!objectName) objectName = mapper.serializedName;
		if (mapperType.match(/^Sequence$/i) !== null) payload = [];
		if (mapper.isConstant) object = mapper.defaultValue;
		const { required, nullable } = mapper;
		if (required && nullable && object === void 0) throw new Error(`${objectName} cannot be undefined.`);
		if (required && !nullable && (object === void 0 || object === null)) throw new Error(`${objectName} cannot be null or undefined.`);
		if (!required && nullable === false && object === null) throw new Error(`${objectName} cannot be null.`);
		if (object === void 0 || object === null) payload = object;
		else if (mapperType.match(/^any$/i) !== null) payload = object;
		else if (mapperType.match(/^(Number|String|Boolean|Object|Stream|Uuid)$/i) !== null) payload = serializeBasicTypes(mapperType, objectName, object);
		else if (mapperType.match(/^Enum$/i) !== null) payload = serializeEnumType(objectName, mapper.type.allowedValues, object);
		else if (mapperType.match(/^(Date|DateTime|TimeSpan|DateTimeRfc1123|UnixTime)$/i) !== null) payload = serializeDateTypes(mapperType, object, objectName);
		else if (mapperType.match(/^ByteArray$/i) !== null) payload = serializeByteArrayType(objectName, object);
		else if (mapperType.match(/^Base64Url$/i) !== null) payload = serializeBase64UrlType(objectName, object);
		else if (mapperType.match(/^Sequence$/i) !== null) payload = serializeSequenceType(this, mapper, object, objectName, Boolean(this.isXML), updatedOptions);
		else if (mapperType.match(/^Dictionary$/i) !== null) payload = serializeDictionaryType(this, mapper, object, objectName, Boolean(this.isXML), updatedOptions);
		else if (mapperType.match(/^Composite$/i) !== null) payload = serializeCompositeType(this, mapper, object, objectName, Boolean(this.isXML), updatedOptions);
		return payload;
	}
	/**
	* Deserialize the given object based on its metadata defined in the mapper
	*
	* @param mapper - The mapper which defines the metadata of the serializable object
	*
	* @param responseBody - A valid Javascript entity to be deserialized
	*
	* @param objectName - Name of the deserialized object
	*
	* @param options - Controls behavior of XML parser and builder.
	*
	* @returns A valid deserialized Javascript object
	*/
	deserialize(mapper, responseBody, objectName, options = { xml: {} }) {
		const updatedOptions = {
			xml: {
				rootName: options.xml.rootName ?? "",
				includeRoot: options.xml.includeRoot ?? false,
				xmlCharKey: options.xml.xmlCharKey ?? "_"
			},
			ignoreUnknownProperties: options.ignoreUnknownProperties ?? false
		};
		if (responseBody === void 0 || responseBody === null) {
			if (this.isXML && mapper.type.name === "Sequence" && !mapper.xmlIsWrapped) responseBody = [];
			if (mapper.defaultValue !== void 0) responseBody = mapper.defaultValue;
			return responseBody;
		}
		let payload;
		const mapperType = mapper.type.name;
		if (!objectName) objectName = mapper.serializedName;
		if (mapperType.match(/^Composite$/i) !== null) payload = deserializeCompositeType(this, mapper, responseBody, objectName, updatedOptions);
		else {
			if (this.isXML) {
				const xmlCharKey = updatedOptions.xml.xmlCharKey;
				/**
				* If the mapper specifies this as a non-composite type value but the responseBody contains
				* both header ("$" i.e., XML_ATTRKEY) and body ("#" i.e., XML_CHARKEY) properties,
				* then just reduce the responseBody value to the body ("#" i.e., XML_CHARKEY) property.
				*/
				if (responseBody["$"] !== void 0 && responseBody[xmlCharKey] !== void 0) responseBody = responseBody[xmlCharKey];
			}
			if (mapperType.match(/^Number$/i) !== null) {
				payload = parseFloat(responseBody);
				if (isNaN(payload)) payload = responseBody;
			} else if (mapperType.match(/^Boolean$/i) !== null) {
				if (responseBody === "true") payload = true;
				else if (responseBody === "false") payload = false;
				else payload = responseBody;
			} else if (mapperType.match(/^(String|Enum|Object|Stream|Uuid|TimeSpan|any)$/i) !== null) payload = responseBody;
			else if (mapperType.match(/^(Date|DateTime|DateTimeRfc1123)$/i) !== null) payload = new Date(responseBody);
			else if (mapperType.match(/^UnixTime$/i) !== null) payload = unixTimeToDate(responseBody);
			else if (mapperType.match(/^ByteArray$/i) !== null) payload = decodeString(responseBody);
			else if (mapperType.match(/^Base64Url$/i) !== null) payload = base64UrlToByteArray(responseBody);
			else if (mapperType.match(/^Sequence$/i) !== null) payload = deserializeSequenceType(this, mapper, responseBody, objectName, updatedOptions);
			else if (mapperType.match(/^Dictionary$/i) !== null) payload = deserializeDictionaryType(this, mapper, responseBody, objectName, updatedOptions);
		}
		if (mapper.isConstant) payload = mapper.defaultValue;
		return payload;
	}
};
/**
* Method that creates and returns a Serializer.
* @param modelMappers - Known models to map
* @param isXML - If XML should be supported
*/
function createSerializer(modelMappers = {}, isXML = false) {
	return new SerializerImpl(modelMappers, isXML);
}
function trimEnd(str, ch) {
	let len = str.length;
	while (len - 1 >= 0 && str[len - 1] === ch) --len;
	return str.substr(0, len);
}
function bufferToBase64Url(buffer) {
	if (!buffer) return;
	if (!(buffer instanceof Uint8Array)) throw new Error(`Please provide an input of type Uint8Array for converting to Base64Url.`);
	return trimEnd(encodeByteArray(buffer), "=").replace(/\+/g, "-").replace(/\//g, "_");
}
function base64UrlToByteArray(str) {
	if (!str) return;
	if (str && typeof str.valueOf() !== "string") throw new Error("Please provide an input of type string for converting to Uint8Array");
	str = str.replace(/-/g, "+").replace(/_/g, "/");
	return decodeString(str);
}
function splitSerializeName(prop) {
	const classes = [];
	let partialclass = "";
	if (prop) {
		const subwords = prop.split(".");
		for (const item of subwords) if (item.charAt(item.length - 1) === "\\") partialclass += item.substr(0, item.length - 1) + ".";
		else {
			partialclass += item;
			classes.push(partialclass);
			partialclass = "";
		}
	}
	return classes;
}
function dateToUnixTime(d) {
	if (!d) return;
	if (typeof d.valueOf() === "string") d = new Date(d);
	return Math.floor(d.getTime() / 1e3);
}
function unixTimeToDate(n) {
	if (!n) return;
	return /* @__PURE__ */ new Date(n * 1e3);
}
function serializeBasicTypes(typeName, objectName, value) {
	if (value !== null && value !== void 0) {
		if (typeName.match(/^Number$/i) !== null) {
			if (typeof value !== "number") throw new Error(`${objectName} with value ${value} must be of type number.`);
		} else if (typeName.match(/^String$/i) !== null) {
			if (typeof value.valueOf() !== "string") throw new Error(`${objectName} with value "${value}" must be of type string.`);
		} else if (typeName.match(/^Uuid$/i) !== null) {
			if (!(typeof value.valueOf() === "string" && isValidUuid(value))) throw new Error(`${objectName} with value "${value}" must be of type string and a valid uuid.`);
		} else if (typeName.match(/^Boolean$/i) !== null) {
			if (typeof value !== "boolean") throw new Error(`${objectName} with value ${value} must be of type boolean.`);
		} else if (typeName.match(/^Stream$/i) !== null) {
			const objectType = typeof value;
			if (objectType !== "string" && typeof value.pipe !== "function" && typeof value.tee !== "function" && !(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value) && !((typeof Blob === "function" || typeof Blob === "object") && value instanceof Blob) && objectType !== "function") throw new Error(`${objectName} must be a string, Blob, ArrayBuffer, ArrayBufferView, ReadableStream, or () => ReadableStream.`);
		}
	}
	return value;
}
function serializeEnumType(objectName, allowedValues, value) {
	if (!allowedValues) throw new Error(`Please provide a set of allowedValues to validate ${objectName} as an Enum Type.`);
	if (!allowedValues.some((item) => {
		if (typeof item.valueOf() === "string") return item.toLowerCase() === value.toLowerCase();
		return item === value;
	})) throw new Error(`${value} is not a valid value for ${objectName}. The valid values are: ${JSON.stringify(allowedValues)}.`);
	return value;
}
function serializeByteArrayType(objectName, value) {
	if (value !== void 0 && value !== null) {
		if (!(value instanceof Uint8Array)) throw new Error(`${objectName} must be of type Uint8Array.`);
		value = encodeByteArray(value);
	}
	return value;
}
function serializeBase64UrlType(objectName, value) {
	if (value !== void 0 && value !== null) {
		if (!(value instanceof Uint8Array)) throw new Error(`${objectName} must be of type Uint8Array.`);
		value = bufferToBase64Url(value);
	}
	return value;
}
function serializeDateTypes(typeName, value, objectName) {
	if (value !== void 0 && value !== null) {
		if (typeName.match(/^Date$/i) !== null) {
			if (!(value instanceof Date || typeof value.valueOf() === "string" && !isNaN(Date.parse(value)))) throw new Error(`${objectName} must be an instanceof Date or a string in ISO8601 format.`);
			value = value instanceof Date ? value.toISOString().substring(0, 10) : new Date(value).toISOString().substring(0, 10);
		} else if (typeName.match(/^DateTime$/i) !== null) {
			if (!(value instanceof Date || typeof value.valueOf() === "string" && !isNaN(Date.parse(value)))) throw new Error(`${objectName} must be an instanceof Date or a string in ISO8601 format.`);
			value = value instanceof Date ? value.toISOString() : new Date(value).toISOString();
		} else if (typeName.match(/^DateTimeRfc1123$/i) !== null) {
			if (!(value instanceof Date || typeof value.valueOf() === "string" && !isNaN(Date.parse(value)))) throw new Error(`${objectName} must be an instanceof Date or a string in RFC-1123 format.`);
			value = value instanceof Date ? value.toUTCString() : new Date(value).toUTCString();
		} else if (typeName.match(/^UnixTime$/i) !== null) {
			if (!(value instanceof Date || typeof value.valueOf() === "string" && !isNaN(Date.parse(value)))) throw new Error(`${objectName} must be an instanceof Date or a string in RFC-1123/ISO8601 format for it to be serialized in UnixTime/Epoch format.`);
			value = dateToUnixTime(value);
		} else if (typeName.match(/^TimeSpan$/i) !== null) {
			if (!isDuration(value)) throw new Error(`${objectName} must be a string in ISO 8601 format. Instead was "${value}".`);
		}
	}
	return value;
}
function serializeSequenceType(serializer, mapper, object, objectName, isXml, options) {
	if (!Array.isArray(object)) throw new Error(`${objectName} must be of type Array.`);
	let elementType = mapper.type.element;
	if (!elementType || typeof elementType !== "object") throw new Error(`"element" metadata for an Array must be defined in the mapper and it must be of type "object" in ${objectName}.`);
	if (elementType.type.name === "Composite" && elementType.type.className) elementType = serializer.modelMappers[elementType.type.className] ?? elementType;
	const tempArray = [];
	for (let i = 0; i < object.length; i++) {
		const serializedValue = serializer.serialize(elementType, object[i], objectName, options);
		if (isXml && elementType.xmlNamespace) {
			const xmlnsKey = elementType.xmlNamespacePrefix ? `xmlns:${elementType.xmlNamespacePrefix}` : "xmlns";
			if (elementType.type.name === "Composite") {
				tempArray[i] = { ...serializedValue };
				tempArray[i]["$"] = { [xmlnsKey]: elementType.xmlNamespace };
			} else {
				tempArray[i] = {};
				tempArray[i][options.xml.xmlCharKey] = serializedValue;
				tempArray[i]["$"] = { [xmlnsKey]: elementType.xmlNamespace };
			}
		} else tempArray[i] = serializedValue;
	}
	return tempArray;
}
function serializeDictionaryType(serializer, mapper, object, objectName, isXml, options) {
	if (typeof object !== "object") throw new Error(`${objectName} must be of type object.`);
	const valueType = mapper.type.value;
	if (!valueType || typeof valueType !== "object") throw new Error(`"value" metadata for a Dictionary must be defined in the mapper and it must of type "object" in ${objectName}.`);
	const tempDictionary = {};
	for (const key of Object.keys(object)) tempDictionary[key] = getXmlObjectValue(valueType, serializer.serialize(valueType, object[key], objectName, options), isXml, options);
	if (isXml && mapper.xmlNamespace) {
		const xmlnsKey = mapper.xmlNamespacePrefix ? `xmlns:${mapper.xmlNamespacePrefix}` : "xmlns";
		const result = tempDictionary;
		result["$"] = { [xmlnsKey]: mapper.xmlNamespace };
		return result;
	}
	return tempDictionary;
}
/**
* Resolves the additionalProperties property from a referenced mapper
* @param serializer - the serializer containing the entire set of mappers
* @param mapper - the composite mapper to resolve
* @param objectName - name of the object being serialized
*/
function resolveAdditionalProperties(serializer, mapper, objectName) {
	const additionalProperties = mapper.type.additionalProperties;
	if (!additionalProperties && mapper.type.className) return resolveReferencedMapper(serializer, mapper, objectName)?.type.additionalProperties;
	return additionalProperties;
}
/**
* Finds the mapper referenced by className
* @param serializer - the serializer containing the entire set of mappers
* @param mapper - the composite mapper to resolve
* @param objectName - name of the object being serialized
*/
function resolveReferencedMapper(serializer, mapper, objectName) {
	const className = mapper.type.className;
	if (!className) throw new Error(`Class name for model "${objectName}" is not provided in the mapper "${JSON.stringify(mapper, void 0, 2)}".`);
	return serializer.modelMappers[className];
}
/**
* Resolves a composite mapper's modelProperties.
* @param serializer - the serializer containing the entire set of mappers
* @param mapper - the composite mapper to resolve
*/
function resolveModelProperties(serializer, mapper, objectName) {
	let modelProps = mapper.type.modelProperties;
	if (!modelProps) {
		const modelMapper = resolveReferencedMapper(serializer, mapper, objectName);
		if (!modelMapper) throw new Error(`mapper() cannot be null or undefined for model "${mapper.type.className}".`);
		modelProps = modelMapper?.type.modelProperties;
		if (!modelProps) throw new Error(`modelProperties cannot be null or undefined in the mapper "${JSON.stringify(modelMapper)}" of type "${mapper.type.className}" for object "${objectName}".`);
	}
	return modelProps;
}
function serializeCompositeType(serializer, mapper, object, objectName, isXml, options) {
	if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) mapper = getPolymorphicMapper(serializer, mapper, object, "clientName");
	if (object !== void 0 && object !== null) {
		const payload = {};
		const modelProps = resolveModelProperties(serializer, mapper, objectName);
		for (const key of Object.keys(modelProps)) {
			const propertyMapper = modelProps[key];
			if (propertyMapper.readOnly) continue;
			let propName;
			let parentObject = payload;
			if (serializer.isXML) {
				if (propertyMapper.xmlIsWrapped) propName = propertyMapper.xmlName;
				else propName = propertyMapper.xmlElementName || propertyMapper.xmlName;
			} else {
				const paths = splitSerializeName(propertyMapper.serializedName);
				propName = paths.pop();
				for (const pathName of paths) {
					const childObject = parentObject[pathName];
					if ((childObject === void 0 || childObject === null) && (object[key] !== void 0 && object[key] !== null || propertyMapper.defaultValue !== void 0)) parentObject[pathName] = {};
					parentObject = parentObject[pathName];
				}
			}
			if (parentObject !== void 0 && parentObject !== null) {
				if (isXml && mapper.xmlNamespace) {
					const xmlnsKey = mapper.xmlNamespacePrefix ? `xmlns:${mapper.xmlNamespacePrefix}` : "xmlns";
					parentObject["$"] = {
						...parentObject["$"],
						[xmlnsKey]: mapper.xmlNamespace
					};
				}
				const propertyObjectName = propertyMapper.serializedName !== "" ? objectName + "." + propertyMapper.serializedName : objectName;
				let toSerialize = object[key];
				const polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
				if (polymorphicDiscriminator && polymorphicDiscriminator.clientName === key && (toSerialize === void 0 || toSerialize === null)) toSerialize = mapper.serializedName;
				const serializedValue = serializer.serialize(propertyMapper, toSerialize, propertyObjectName, options);
				if (serializedValue !== void 0 && propName !== void 0 && propName !== null) {
					const value = getXmlObjectValue(propertyMapper, serializedValue, isXml, options);
					if (isXml && propertyMapper.xmlIsAttribute) {
						parentObject["$"] = parentObject["$"] || {};
						parentObject["$"][propName] = serializedValue;
					} else if (isXml && propertyMapper.xmlIsWrapped) parentObject[propName] = { [propertyMapper.xmlElementName]: value };
					else parentObject[propName] = value;
				}
			}
		}
		const additionalPropertiesMapper = resolveAdditionalProperties(serializer, mapper, objectName);
		if (additionalPropertiesMapper) {
			const propNames = Object.keys(modelProps);
			for (const clientPropName of Object.keys(object)) if (propNames.every((pn) => pn !== clientPropName)) Object.defineProperty(payload, clientPropName, {
				value: serializer.serialize(additionalPropertiesMapper, object[clientPropName], objectName + "[\"" + clientPropName + "\"]", options),
				enumerable: true,
				configurable: true,
				writable: true
			});
		}
		return payload;
	}
	return object;
}
function getXmlObjectValue(propertyMapper, serializedValue, isXml, options) {
	if (!isXml || !propertyMapper.xmlNamespace) return serializedValue;
	const xmlNamespace = { [propertyMapper.xmlNamespacePrefix ? `xmlns:${propertyMapper.xmlNamespacePrefix}` : "xmlns"]: propertyMapper.xmlNamespace };
	if (["Composite"].includes(propertyMapper.type.name)) {
		if (serializedValue["$"]) return serializedValue;
		else {
			const result = { ...serializedValue };
			result["$"] = xmlNamespace;
			return result;
		}
	}
	const result = {};
	result[options.xml.xmlCharKey] = serializedValue;
	result["$"] = xmlNamespace;
	return result;
}
function isSpecialXmlProperty(propertyName, options) {
	return ["$", options.xml.xmlCharKey].includes(propertyName);
}
function deserializeCompositeType(serializer, mapper, responseBody, objectName, options) {
	const xmlCharKey = options.xml.xmlCharKey ?? "_";
	if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) mapper = getPolymorphicMapper(serializer, mapper, responseBody, "serializedName");
	const modelProps = resolveModelProperties(serializer, mapper, objectName);
	let instance = {};
	const handledPropertyNames = [];
	for (const key of Object.keys(modelProps)) {
		const propertyMapper = modelProps[key];
		const paths = splitSerializeName(modelProps[key].serializedName);
		handledPropertyNames.push(paths[0]);
		const { serializedName, xmlName, xmlElementName } = propertyMapper;
		let propertyObjectName = objectName;
		if (serializedName !== "" && serializedName !== void 0) propertyObjectName = objectName + "." + serializedName;
		const headerCollectionPrefix = propertyMapper.headerCollectionPrefix;
		if (headerCollectionPrefix) {
			const dictionary = {};
			for (const headerKey of Object.keys(responseBody)) {
				if (headerKey.startsWith(headerCollectionPrefix)) dictionary[headerKey.substring(headerCollectionPrefix.length)] = serializer.deserialize(propertyMapper.type.value, responseBody[headerKey], propertyObjectName, options);
				handledPropertyNames.push(headerKey);
			}
			instance[key] = dictionary;
		} else if (serializer.isXML) {
			if (propertyMapper.xmlIsAttribute && responseBody["$"]) instance[key] = serializer.deserialize(propertyMapper, responseBody["$"][xmlName], propertyObjectName, options);
			else if (propertyMapper.xmlIsMsText) {
				if (responseBody[xmlCharKey] !== void 0) instance[key] = responseBody[xmlCharKey];
				else if (typeof responseBody === "string") instance[key] = responseBody;
			} else {
				const propertyName = xmlElementName || xmlName || serializedName;
				if (propertyMapper.xmlIsWrapped) {
					const elementList = responseBody[xmlName]?.[xmlElementName] ?? [];
					Object.defineProperty(instance, key, {
						value: serializer.deserialize(propertyMapper, elementList, propertyObjectName, options),
						enumerable: true,
						configurable: true,
						writable: true
					});
					handledPropertyNames.push(xmlName);
				} else {
					const property = responseBody[propertyName];
					instance[key] = serializer.deserialize(propertyMapper, property, propertyObjectName, options);
					handledPropertyNames.push(propertyName);
				}
			}
		} else {
			let propertyInstance;
			let res = responseBody;
			let steps = 0;
			for (const item of paths) {
				if (!res) break;
				steps++;
				res = res[item];
			}
			if (res === null && steps < paths.length) res = void 0;
			propertyInstance = res;
			const polymorphicDiscriminator = mapper.type.polymorphicDiscriminator;
			if (polymorphicDiscriminator && key === polymorphicDiscriminator.clientName && (propertyInstance === void 0 || propertyInstance === null)) propertyInstance = mapper.serializedName;
			let serializedValue;
			if (Array.isArray(responseBody[key]) && modelProps[key].serializedName === "") {
				propertyInstance = responseBody[key];
				const arrayInstance = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName, options);
				for (const [k, v] of Object.entries(instance)) if (!Object.prototype.hasOwnProperty.call(arrayInstance, k)) arrayInstance[k] = v;
				instance = arrayInstance;
			} else if (propertyInstance !== void 0 || propertyMapper.defaultValue !== void 0) {
				serializedValue = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName, options);
				instance[key] = serializedValue;
			}
		}
	}
	const additionalPropertiesMapper = mapper.type.additionalProperties;
	if (additionalPropertiesMapper) {
		const isAdditionalProperty = (responsePropName) => {
			for (const clientPropName of Object.keys(modelProps)) if (splitSerializeName(modelProps[clientPropName].serializedName)[0] === responsePropName) return false;
			return true;
		};
		for (const responsePropName of Object.keys(responseBody)) if (isAdditionalProperty(responsePropName)) {
			const deserializedValue = serializer.deserialize(additionalPropertiesMapper, responseBody[responsePropName], objectName + "[\"" + responsePropName + "\"]", options);
			Object.defineProperty(instance, responsePropName, {
				value: deserializedValue,
				enumerable: true,
				configurable: true,
				writable: true
			});
		}
	} else if (responseBody && !options.ignoreUnknownProperties) {
		for (const key of Object.keys(responseBody)) if (instance[key] === void 0 && !handledPropertyNames.includes(key) && !isSpecialXmlProperty(key, options)) Object.defineProperty(instance, key, {
			value: responseBody[key],
			enumerable: true,
			configurable: true,
			writable: true
		});
	}
	return instance;
}
function deserializeDictionaryType(serializer, mapper, responseBody, objectName, options) {
	const value = mapper.type.value;
	if (!value || typeof value !== "object") throw new Error(`"value" metadata for a Dictionary must be defined in the mapper and it must of type "object" in ${objectName}`);
	if (responseBody) {
		const tempDictionary = {};
		for (const key of Object.keys(responseBody)) tempDictionary[key] = serializer.deserialize(value, responseBody[key], objectName, options);
		return tempDictionary;
	}
	return responseBody;
}
function deserializeSequenceType(serializer, mapper, responseBody, objectName, options) {
	let element = mapper.type.element;
	if (!element || typeof element !== "object") throw new Error(`"element" metadata for an Array must be defined in the mapper and it must be of type "object" in ${objectName}`);
	if (responseBody) {
		if (!Array.isArray(responseBody)) responseBody = [responseBody];
		if (element.type.name === "Composite" && element.type.className) element = serializer.modelMappers[element.type.className] ?? element;
		const tempArray = [];
		for (let i = 0; i < responseBody.length; i++) tempArray[i] = serializer.deserialize(element, responseBody[i], `${objectName}[${i}]`, options);
		return tempArray;
	}
	return responseBody;
}
function getIndexDiscriminator(discriminators, discriminatorValue, typeName) {
	const typeNamesToCheck = [typeName];
	while (typeNamesToCheck.length) {
		const currentName = typeNamesToCheck.shift();
		const indexDiscriminator = discriminatorValue === currentName ? discriminatorValue : currentName + "." + discriminatorValue;
		if (Object.prototype.hasOwnProperty.call(discriminators, indexDiscriminator)) return discriminators[indexDiscriminator];
		else for (const [name, mapper] of Object.entries(discriminators)) if (name.startsWith(currentName + ".") && mapper.type.uberParent === currentName && mapper.type.className) typeNamesToCheck.push(mapper.type.className);
	}
}
function getPolymorphicMapper(serializer, mapper, object, polymorphicPropertyName) {
	const polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
	if (polymorphicDiscriminator) {
		let discriminatorName = polymorphicDiscriminator[polymorphicPropertyName];
		if (discriminatorName) {
			if (polymorphicPropertyName === "serializedName") discriminatorName = discriminatorName.replace(/\\/gi, "");
			const discriminatorValue = object[discriminatorName];
			const typeName = mapper.type.uberParent ?? mapper.type.className;
			if (typeof discriminatorValue === "string" && typeName) {
				const polymorphicMapper = getIndexDiscriminator(serializer.modelMappers.discriminators, discriminatorValue, typeName);
				if (polymorphicMapper) mapper = polymorphicMapper;
			}
		}
	}
	return mapper;
}
function getPolymorphicDiscriminatorRecursively(serializer, mapper) {
	return mapper.type.polymorphicDiscriminator || getPolymorphicDiscriminatorSafely(serializer, mapper.type.uberParent) || getPolymorphicDiscriminatorSafely(serializer, mapper.type.className);
}
function getPolymorphicDiscriminatorSafely(serializer, typeName) {
	return typeName && serializer.modelMappers[typeName] && serializer.modelMappers[typeName].type.polymorphicDiscriminator;
}
/**
* Known types of Mappers
*/
var MapperTypeNames = {
	Base64Url: "Base64Url",
	Boolean: "Boolean",
	ByteArray: "ByteArray",
	Composite: "Composite",
	Date: "Date",
	DateTime: "DateTime",
	DateTimeRfc1123: "DateTimeRfc1123",
	Dictionary: "Dictionary",
	Enum: "Enum",
	Number: "Number",
	Object: "Object",
	Sequence: "Sequence",
	String: "String",
	Stream: "Stream",
	TimeSpan: "TimeSpan",
	UnixTime: "UnixTime"
};
/**
* Defines the shared state between CJS and ESM by re-exporting the CJS state.
*/
var state = (/* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.state = void 0;
	/**
	* Holds the singleton operationRequestMap, to be shared across CJS and ESM imports.
	*/
	exports.state = { operationRequestMap: /* @__PURE__ */ new WeakMap() };
})))().state;
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/operationHelpers.js
/**
* @internal
* Retrieves the value to use for a given operation argument
* @param operationArguments - The arguments passed from the generated client
* @param parameter - The parameter description
* @param fallbackObject - If something isn't found in the arguments bag, look here.
*  Generally used to look at the service client properties.
*/
function getOperationArgumentValueFromParameter(operationArguments, parameter, fallbackObject) {
	let parameterPath = parameter.parameterPath;
	const parameterMapper = parameter.mapper;
	let value;
	if (typeof parameterPath === "string") parameterPath = [parameterPath];
	if (Array.isArray(parameterPath)) {
		if (parameterPath.length > 0) {
			if (parameterMapper.isConstant) value = parameterMapper.defaultValue;
			else {
				let propertySearchResult = getPropertyFromParameterPath(operationArguments, parameterPath);
				if (!propertySearchResult.propertyFound && fallbackObject) propertySearchResult = getPropertyFromParameterPath(fallbackObject, parameterPath);
				let useDefaultValue = false;
				if (!propertySearchResult.propertyFound) useDefaultValue = parameterMapper.required || parameterPath[0] === "options" && parameterPath.length === 2;
				value = useDefaultValue ? parameterMapper.defaultValue : propertySearchResult.propertyValue;
			}
		}
	} else {
		if (parameterMapper.required) value = {};
		for (const [propertyName, propertyPath] of Object.entries(parameterPath)) {
			const propertyMapper = parameterMapper.type.modelProperties[propertyName];
			const propertyValue = getOperationArgumentValueFromParameter(operationArguments, {
				parameterPath: propertyPath,
				mapper: propertyMapper
			}, fallbackObject);
			if (propertyValue !== void 0) {
				if (!value) value = {};
				Object.defineProperty(value, propertyName, {
					value: propertyValue,
					enumerable: true,
					configurable: true,
					writable: true
				});
			}
		}
	}
	return value;
}
function getPropertyFromParameterPath(parent, parameterPath) {
	const result = { propertyFound: false };
	let i = 0;
	for (; i < parameterPath.length; ++i) {
		const parameterPathPart = parameterPath[i];
		if (parent && parameterPathPart in parent) parent = parent[parameterPathPart];
		else break;
	}
	if (i === parameterPath.length) {
		result.propertyValue = parent;
		result.propertyFound = true;
	}
	return result;
}
var originalRequestSymbol$1 = Symbol.for("@azure/core-client original request");
function hasOriginalRequest(request) {
	return originalRequestSymbol$1 in request;
}
function getOperationRequestInfo(request) {
	if (hasOriginalRequest(request)) return getOperationRequestInfo(request[originalRequestSymbol$1]);
	let info = state.operationRequestMap.get(request);
	if (!info) {
		info = {};
		state.operationRequestMap.set(request, info);
	}
	return info;
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/deserializationPolicy.js
var defaultJsonContentTypes = ["application/json", "text/json"];
var defaultXmlContentTypes = ["application/xml", "application/atom+xml"];
/**
* The programmatic identifier of the deserializationPolicy.
*/
var deserializationPolicyName = "deserializationPolicy";
/**
* This policy handles parsing out responses according to OperationSpecs on the request.
*/
function deserializationPolicy(options = {}) {
	const jsonContentTypes = options.expectedContentTypes?.json ?? defaultJsonContentTypes;
	const xmlContentTypes = options.expectedContentTypes?.xml ?? defaultXmlContentTypes;
	const parseXML = options.parseXML;
	const serializerOptions = options.serializerOptions;
	const updatedOptions = { xml: {
		rootName: serializerOptions?.xml.rootName ?? "",
		includeRoot: serializerOptions?.xml.includeRoot ?? false,
		xmlCharKey: serializerOptions?.xml.xmlCharKey ?? "_"
	} };
	return {
		name: deserializationPolicyName,
		async sendRequest(request, next) {
			const response = await next(request);
			return deserializeResponseBody(jsonContentTypes, xmlContentTypes, response, updatedOptions, parseXML);
		}
	};
}
function getOperationResponseMap(parsedResponse) {
	let result;
	const request = parsedResponse.request;
	const operationInfo = getOperationRequestInfo(request);
	const operationSpec = operationInfo?.operationSpec;
	if (operationSpec) {
		if (!operationInfo?.operationResponseGetter) result = operationSpec.responses[parsedResponse.status];
		else result = operationInfo?.operationResponseGetter(operationSpec, parsedResponse);
	}
	return result;
}
function shouldDeserializeResponse(parsedResponse) {
	const request = parsedResponse.request;
	const shouldDeserialize = getOperationRequestInfo(request)?.shouldDeserialize;
	let result;
	if (shouldDeserialize === void 0) result = true;
	else if (typeof shouldDeserialize === "boolean") result = shouldDeserialize;
	else result = shouldDeserialize(parsedResponse);
	return result;
}
async function deserializeResponseBody(jsonContentTypes, xmlContentTypes, response, options, parseXML) {
	const parsedResponse = await parse(jsonContentTypes, xmlContentTypes, response, options, parseXML);
	if (!shouldDeserializeResponse(parsedResponse)) return parsedResponse;
	const operationSpec = getOperationRequestInfo(parsedResponse.request)?.operationSpec;
	if (!operationSpec || !operationSpec.responses) return parsedResponse;
	const responseSpec = getOperationResponseMap(parsedResponse);
	const { error, shouldReturnResponse } = handleErrorResponse(parsedResponse, operationSpec, responseSpec, options);
	if (error) throw error;
	else if (shouldReturnResponse) return parsedResponse;
	if (responseSpec) {
		if (responseSpec.bodyMapper) {
			let valueToDeserialize = parsedResponse.parsedBody;
			if (operationSpec.isXML && responseSpec.bodyMapper.type.name === MapperTypeNames.Sequence) valueToDeserialize = typeof valueToDeserialize === "object" ? valueToDeserialize[responseSpec.bodyMapper.xmlElementName] : [];
			try {
				parsedResponse.parsedBody = operationSpec.serializer.deserialize(responseSpec.bodyMapper, valueToDeserialize, "operationRes.parsedBody", options);
			} catch (deserializeError) {
				throw new RestError(`Error ${deserializeError} occurred in deserializing the responseBody - ${parsedResponse.bodyAsText}`, {
					statusCode: parsedResponse.status,
					request: parsedResponse.request,
					response: parsedResponse
				});
			}
		} else if (operationSpec.httpMethod === "HEAD") parsedResponse.parsedBody = response.status >= 200 && response.status < 300;
		if (responseSpec.headersMapper) parsedResponse.parsedHeaders = operationSpec.serializer.deserialize(responseSpec.headersMapper, parsedResponse.headers.toJSON(), "operationRes.parsedHeaders", {
			xml: {},
			ignoreUnknownProperties: true
		});
	}
	return parsedResponse;
}
function isOperationSpecEmpty(operationSpec) {
	const expectedStatusCodes = Object.keys(operationSpec.responses);
	return expectedStatusCodes.length === 0 || expectedStatusCodes.length === 1 && expectedStatusCodes[0] === "default";
}
function handleErrorResponse(parsedResponse, operationSpec, responseSpec, options) {
	const isSuccessByStatus = 200 <= parsedResponse.status && parsedResponse.status < 300;
	if (isOperationSpecEmpty(operationSpec) ? isSuccessByStatus : !!responseSpec) {
		if (responseSpec) {
			if (!responseSpec.isError) return {
				error: null,
				shouldReturnResponse: false
			};
		} else return {
			error: null,
			shouldReturnResponse: false
		};
	}
	const errorResponseSpec = responseSpec ?? operationSpec.responses.default;
	const error = new RestError(parsedResponse.request.streamResponseStatusCodes?.has(parsedResponse.status) ? `Unexpected status code: ${parsedResponse.status}` : parsedResponse.bodyAsText, {
		statusCode: parsedResponse.status,
		request: parsedResponse.request,
		response: parsedResponse
	});
	if (!errorResponseSpec && !(parsedResponse.parsedBody?.error?.code && parsedResponse.parsedBody?.error?.message)) throw error;
	const defaultBodyMapper = errorResponseSpec?.bodyMapper;
	const defaultHeadersMapper = errorResponseSpec?.headersMapper;
	try {
		if (parsedResponse.parsedBody) {
			const parsedBody = parsedResponse.parsedBody;
			let deserializedError;
			if (defaultBodyMapper) {
				let valueToDeserialize = parsedBody;
				if (operationSpec.isXML && defaultBodyMapper.type.name === MapperTypeNames.Sequence) {
					valueToDeserialize = [];
					const elementName = defaultBodyMapper.xmlElementName;
					if (typeof parsedBody === "object" && elementName) valueToDeserialize = parsedBody[elementName];
				}
				deserializedError = operationSpec.serializer.deserialize(defaultBodyMapper, valueToDeserialize, "error.response.parsedBody", options);
			}
			const internalError = parsedBody.error || deserializedError || parsedBody;
			error.code = internalError.code;
			if (internalError.message) error.message = internalError.message;
			if (defaultBodyMapper) error.response.parsedBody = deserializedError;
		}
		if (parsedResponse.headers && defaultHeadersMapper) error.response.parsedHeaders = operationSpec.serializer.deserialize(defaultHeadersMapper, parsedResponse.headers.toJSON(), "operationRes.parsedHeaders");
	} catch (defaultError) {
		error.message = `Error "${defaultError.message}" occurred in deserializing the responseBody - "${parsedResponse.bodyAsText}" for the default response.`;
	}
	return {
		error,
		shouldReturnResponse: false
	};
}
async function parse(jsonContentTypes, xmlContentTypes, operationResponse, opts, parseXML) {
	if (!operationResponse.request.streamResponseStatusCodes?.has(operationResponse.status) && operationResponse.bodyAsText) {
		const text = operationResponse.bodyAsText;
		const contentType = operationResponse.headers.get("Content-Type") || "";
		const contentComponents = !contentType ? [] : contentType.split(";").map((component) => component.toLowerCase());
		try {
			if (contentComponents.length === 0 || contentComponents.some((component) => jsonContentTypes.indexOf(component) !== -1)) {
				operationResponse.parsedBody = JSON.parse(text);
				return operationResponse;
			} else if (contentComponents.some((component) => xmlContentTypes.indexOf(component) !== -1)) {
				if (!parseXML) throw new Error("Parsing XML not supported.");
				operationResponse.parsedBody = await parseXML(text, opts.xml);
				return operationResponse;
			}
		} catch (err) {
			throw new RestError(`Error "${err}" occurred while parsing the response body - ${operationResponse.bodyAsText}.`, {
				code: err.code || RestError.PARSE_ERROR,
				statusCode: operationResponse.status,
				request: operationResponse.request,
				response: operationResponse
			});
		}
	}
	return operationResponse;
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/interfaceHelpers.js
/**
* Gets the list of status codes for streaming responses.
* @internal
*/
function getStreamingResponseStatusCodes(operationSpec) {
	const result = /* @__PURE__ */ new Set();
	for (const [statusCode, operationResponse] of Object.entries(operationSpec.responses)) if (operationResponse.bodyMapper && operationResponse.bodyMapper.type.name === MapperTypeNames.Stream) result.add(Number(statusCode));
	return result;
}
/**
* Get the path to this parameter's value as a dotted string (a.b.c).
* @param parameter - The parameter to get the path string for.
* @returns The path to this parameter's value as a dotted string.
* @internal
*/
function getPathStringFromParameter(parameter) {
	const { parameterPath, mapper } = parameter;
	let result;
	if (typeof parameterPath === "string") result = parameterPath;
	else if (Array.isArray(parameterPath)) result = parameterPath.join(".");
	else result = mapper.serializedName;
	return result;
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/serializationPolicy.js
/**
* The programmatic identifier of the serializationPolicy.
*/
var serializationPolicyName = "serializationPolicy";
/**
* This policy handles assembling the request body and headers using
* an OperationSpec and OperationArguments on the request.
*/
function serializationPolicy(options = {}) {
	const stringifyXML = options.stringifyXML;
	return {
		name: serializationPolicyName,
		sendRequest(request, next) {
			const operationInfo = getOperationRequestInfo(request);
			const operationSpec = operationInfo?.operationSpec;
			const operationArguments = operationInfo?.operationArguments;
			if (operationSpec && operationArguments) {
				serializeHeaders(request, operationArguments, operationSpec);
				serializeRequestBody(request, operationArguments, operationSpec, stringifyXML);
			}
			return next(request);
		}
	};
}
/**
* @internal
*/
function serializeHeaders(request, operationArguments, operationSpec) {
	if (operationSpec.headerParameters) for (const headerParameter of operationSpec.headerParameters) {
		let headerValue = getOperationArgumentValueFromParameter(operationArguments, headerParameter);
		if (headerValue !== null && headerValue !== void 0 || headerParameter.mapper.required) {
			headerValue = operationSpec.serializer.serialize(headerParameter.mapper, headerValue, getPathStringFromParameter(headerParameter));
			const headerCollectionPrefix = headerParameter.mapper.headerCollectionPrefix;
			if (headerCollectionPrefix) for (const key of Object.keys(headerValue)) request.headers.set(headerCollectionPrefix + key, headerValue[key]);
			else request.headers.set(headerParameter.mapper.serializedName || getPathStringFromParameter(headerParameter), headerValue);
		}
	}
	const customHeaders = operationArguments.options?.requestOptions?.customHeaders;
	if (customHeaders) for (const customHeaderName of Object.keys(customHeaders)) request.headers.set(customHeaderName, customHeaders[customHeaderName]);
}
/**
* @internal
*/
function serializeRequestBody(request, operationArguments, operationSpec, stringifyXML = function() {
	throw new Error("XML serialization unsupported!");
}) {
	const serializerOptions = operationArguments.options?.serializerOptions;
	const updatedOptions = { xml: {
		rootName: serializerOptions?.xml.rootName ?? "",
		includeRoot: serializerOptions?.xml.includeRoot ?? false,
		xmlCharKey: serializerOptions?.xml.xmlCharKey ?? "_"
	} };
	const xmlCharKey = updatedOptions.xml.xmlCharKey;
	if (operationSpec.requestBody && operationSpec.requestBody.mapper) {
		request.body = getOperationArgumentValueFromParameter(operationArguments, operationSpec.requestBody);
		const bodyMapper = operationSpec.requestBody.mapper;
		const { required, serializedName, xmlName, xmlElementName, xmlNamespace, xmlNamespacePrefix, nullable } = bodyMapper;
		const typeName = bodyMapper.type.name;
		try {
			if (request.body !== void 0 && request.body !== null || nullable && request.body === null || required) {
				const requestBodyParameterPathString = getPathStringFromParameter(operationSpec.requestBody);
				request.body = operationSpec.serializer.serialize(bodyMapper, request.body, requestBodyParameterPathString, updatedOptions);
				const isStream = typeName === MapperTypeNames.Stream;
				if (operationSpec.isXML) {
					const xmlnsKey = xmlNamespacePrefix ? `xmlns:${xmlNamespacePrefix}` : "xmlns";
					const value = getXmlValueWithNamespace(xmlNamespace, xmlnsKey, typeName, request.body, updatedOptions);
					if (typeName === MapperTypeNames.Sequence) request.body = stringifyXML(prepareXMLRootList(value, xmlElementName || xmlName || serializedName, xmlnsKey, xmlNamespace), {
						rootName: xmlName || serializedName,
						xmlCharKey
					});
					else if (!isStream) request.body = stringifyXML(value, {
						rootName: xmlName || serializedName,
						xmlCharKey
					});
				} else if (typeName === MapperTypeNames.String && (operationSpec.contentType?.match("text/plain") || operationSpec.mediaType === "text")) return;
				else if (!isStream) request.body = JSON.stringify(request.body);
			}
		} catch (error) {
			throw new Error(`Error "${error.message}" occurred in serializing the payload - ${JSON.stringify(serializedName, void 0, "  ")}.`);
		}
	} else if (operationSpec.formDataParameters && operationSpec.formDataParameters.length > 0) {
		request.formData = {};
		for (const formDataParameter of operationSpec.formDataParameters) {
			const formDataParameterValue = getOperationArgumentValueFromParameter(operationArguments, formDataParameter);
			if (formDataParameterValue !== void 0 && formDataParameterValue !== null) {
				const formDataParameterPropertyName = formDataParameter.mapper.serializedName || getPathStringFromParameter(formDataParameter);
				request.formData[formDataParameterPropertyName] = operationSpec.serializer.serialize(formDataParameter.mapper, formDataParameterValue, getPathStringFromParameter(formDataParameter), updatedOptions);
			}
		}
	}
}
/**
* Adds an xml namespace to the xml serialized object if needed, otherwise it just returns the value itself
*/
function getXmlValueWithNamespace(xmlNamespace, xmlnsKey, typeName, serializedValue, options) {
	if (xmlNamespace && ![
		"Composite",
		"Sequence",
		"Dictionary"
	].includes(typeName)) {
		const result = {};
		result[options.xml.xmlCharKey] = serializedValue;
		result["$"] = { [xmlnsKey]: xmlNamespace };
		return result;
	}
	return serializedValue;
}
function prepareXMLRootList(obj, elementName, xmlNamespaceKey, xmlNamespace) {
	if (!Array.isArray(obj)) obj = [obj];
	if (!xmlNamespaceKey || !xmlNamespace) return { [elementName]: obj };
	const result = { [elementName]: obj };
	result["$"] = { [xmlNamespaceKey]: xmlNamespace };
	return result;
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/pipeline.js
/**
* Creates a new Pipeline for use with a Service Client.
* Adds in deserializationPolicy by default.
* Also adds in bearerTokenAuthenticationPolicy if passed a TokenCredential.
* @param options - Options to customize the created pipeline.
*/
function createClientPipeline(options = {}) {
	const pipeline = createPipelineFromOptions(options ?? {});
	if (options.credentialOptions) pipeline.addPolicy(bearerTokenAuthenticationPolicy({
		credential: options.credentialOptions.credential,
		scopes: options.credentialOptions.credentialScopes
	}));
	pipeline.addPolicy(serializationPolicy(options.serializationOptions), { phase: "Serialize" });
	pipeline.addPolicy(deserializationPolicy(options.deserializationOptions), { phase: "Deserialize" });
	return pipeline;
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/httpClientCache.js
var cachedHttpClient;
function getCachedDefaultHttpClient$1() {
	if (!cachedHttpClient) cachedHttpClient = createDefaultHttpClient();
	return cachedHttpClient;
}
__name(getCachedDefaultHttpClient$1, "getCachedDefaultHttpClient");
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/urlHelpers.js
var CollectionFormatToDelimiterMap = {
	CSV: ",",
	SSV: " ",
	Multi: "Multi",
	TSV: "	",
	Pipes: "|"
};
function getRequestUrl(baseUri, operationSpec, operationArguments, fallbackObject) {
	const urlReplacements = calculateUrlReplacements(operationSpec, operationArguments, fallbackObject);
	let isAbsolutePath = false;
	let requestUrl = replaceAll(baseUri, urlReplacements);
	if (operationSpec.path) {
		let path = replaceAll(operationSpec.path, urlReplacements);
		if (operationSpec.path === "/{nextLink}" && path.startsWith("/")) path = path.substring(1);
		if (isAbsoluteUrl(path)) {
			requestUrl = path;
			isAbsolutePath = true;
		} else requestUrl = appendPath(requestUrl, path);
	}
	const { queryParams, sequenceParams } = calculateQueryParameters(operationSpec, operationArguments, fallbackObject);
	/**
	* Notice that this call sets the `noOverwrite` parameter to true if the `requestUrl`
	* is an absolute path. This ensures that existing query parameter values in `requestUrl`
	* do not get overwritten. On the other hand when `requestUrl` is not absolute path, it
	* is still being built so there is nothing to overwrite.
	*/
	requestUrl = appendQueryParams(requestUrl, queryParams, sequenceParams, isAbsolutePath);
	return requestUrl;
}
function replaceAll(input, replacements) {
	let result = input;
	for (const [searchValue, replaceValue] of replacements) result = result.split(searchValue).join(replaceValue);
	return result;
}
function calculateUrlReplacements(operationSpec, operationArguments, fallbackObject) {
	const result = /* @__PURE__ */ new Map();
	if (operationSpec.urlParameters?.length) for (const urlParameter of operationSpec.urlParameters) {
		let urlParameterValue = getOperationArgumentValueFromParameter(operationArguments, urlParameter, fallbackObject);
		const parameterPathString = getPathStringFromParameter(urlParameter);
		urlParameterValue = operationSpec.serializer.serialize(urlParameter.mapper, urlParameterValue, parameterPathString);
		if (!urlParameter.skipEncoding) urlParameterValue = encodeURIComponent(urlParameterValue);
		result.set(`{${urlParameter.mapper.serializedName || parameterPathString}}`, urlParameterValue);
	}
	return result;
}
function isAbsoluteUrl(url) {
	return url.includes("://");
}
function appendPath(url, pathToAppend) {
	if (!pathToAppend) return url;
	const parsedUrl = new URL(url);
	let newPath = parsedUrl.pathname;
	if (!newPath.endsWith("/")) newPath = `${newPath}/`;
	if (pathToAppend.startsWith("/")) pathToAppend = pathToAppend.substring(1);
	const searchStart = pathToAppend.indexOf("?");
	if (searchStart !== -1) {
		const path = pathToAppend.substring(0, searchStart);
		const search = pathToAppend.substring(searchStart + 1);
		newPath = newPath + path;
		if (search) parsedUrl.search = parsedUrl.search ? `${parsedUrl.search}&${search}` : search;
	} else newPath = newPath + pathToAppend;
	Object.assign(parsedUrl, { pathname: newPath });
	return parsedUrl.toString();
}
function calculateQueryParameters(operationSpec, operationArguments, fallbackObject) {
	const result = /* @__PURE__ */ new Map();
	const sequenceParams = /* @__PURE__ */ new Set();
	if (operationSpec.queryParameters?.length) for (const queryParameter of operationSpec.queryParameters) {
		if (queryParameter.mapper.type.name === "Sequence" && queryParameter.mapper.serializedName) sequenceParams.add(queryParameter.mapper.serializedName);
		let queryParameterValue = getOperationArgumentValueFromParameter(operationArguments, queryParameter, fallbackObject);
		if (queryParameterValue !== void 0 && queryParameterValue !== null || queryParameter.mapper.required) {
			queryParameterValue = operationSpec.serializer.serialize(queryParameter.mapper, queryParameterValue, getPathStringFromParameter(queryParameter));
			const delimiter = queryParameter.collectionFormat ? CollectionFormatToDelimiterMap[queryParameter.collectionFormat] : "";
			if (Array.isArray(queryParameterValue)) queryParameterValue = queryParameterValue.map((item) => {
				if (item === null || item === void 0) return "";
				return item;
			});
			if (queryParameter.collectionFormat === "Multi" && queryParameterValue.length === 0) continue;
			else if (Array.isArray(queryParameterValue) && (queryParameter.collectionFormat === "SSV" || queryParameter.collectionFormat === "TSV")) queryParameterValue = queryParameterValue.join(delimiter);
			if (!queryParameter.skipEncoding) {
				if (Array.isArray(queryParameterValue)) queryParameterValue = queryParameterValue.map((item) => {
					return encodeURIComponent(item);
				});
				else queryParameterValue = encodeURIComponent(queryParameterValue);
			}
			if (Array.isArray(queryParameterValue) && (queryParameter.collectionFormat === "CSV" || queryParameter.collectionFormat === "Pipes")) queryParameterValue = queryParameterValue.join(delimiter);
			result.set(queryParameter.mapper.serializedName || getPathStringFromParameter(queryParameter), queryParameterValue);
		}
	}
	return {
		queryParams: result,
		sequenceParams
	};
}
function simpleParseQueryParams(queryString) {
	const result = /* @__PURE__ */ new Map();
	if (!queryString || queryString[0] !== "?") return result;
	queryString = queryString.slice(1);
	const pairs = queryString.split("&");
	for (const pair of pairs) {
		const [name, value] = pair.split("=", 2);
		const existingValue = result.get(name);
		if (existingValue) {
			if (Array.isArray(existingValue)) existingValue.push(value);
			else result.set(name, [existingValue, value]);
		} else result.set(name, value);
	}
	return result;
}
/** @internal */
function appendQueryParams(url, queryParams, sequenceParams, noOverwrite = false) {
	if (queryParams.size === 0) return url;
	const parsedUrl = new URL(url);
	const combinedParams = simpleParseQueryParams(parsedUrl.search);
	for (const [name, value] of queryParams) {
		const existingValue = combinedParams.get(name);
		if (Array.isArray(existingValue)) {
			if (Array.isArray(value)) {
				existingValue.push(...value);
				const valueSet = new Set(existingValue);
				combinedParams.set(name, Array.from(valueSet));
			} else existingValue.push(value);
		} else if (existingValue) {
			if (Array.isArray(value)) value.unshift(existingValue);
			else if (sequenceParams.has(name)) combinedParams.set(name, [existingValue, value]);
			if (!noOverwrite) combinedParams.set(name, value);
		} else combinedParams.set(name, value);
	}
	const searchPieces = [];
	for (const [name, value] of combinedParams) if (typeof value === "string") searchPieces.push(`${name}=${value}`);
	else if (Array.isArray(value)) for (const subValue of value) searchPieces.push(`${name}=${subValue}`);
	else searchPieces.push(`${name}=${value}`);
	parsedUrl.search = searchPieces.length ? `?${searchPieces.join("&")}` : "";
	return parsedUrl.toString();
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/log.js
var logger$2 = createClientLogger("core-client");
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/serviceClient.js
/**
* Initializes a new instance of the ServiceClient.
*/
var ServiceClient = class {
	/**
	* If specified, this is the base URI that requests will be made against for this ServiceClient.
	* If it is not specified, then all OperationSpecs must contain a baseUrl property.
	*/
	_endpoint;
	/**
	* The default request content type for the service.
	* Used if no requestContentType is present on an OperationSpec.
	*/
	_requestContentType;
	/**
	* Set to true if the request is sent over HTTP instead of HTTPS
	*/
	_allowInsecureConnection;
	/**
	* The HTTP client that will be used to send requests.
	*/
	_httpClient;
	/**
	* The pipeline used by this client to make requests
	*/
	pipeline;
	/**
	* The ServiceClient constructor
	* @param options - The service client options that govern the behavior of the client.
	*/
	constructor(options = {}) {
		this._requestContentType = options.requestContentType;
		this._endpoint = options.endpoint ?? options.baseUri;
		if (options.baseUri) logger$2.warning("The baseUri option for SDK Clients has been deprecated, please use endpoint instead.");
		this._allowInsecureConnection = options.allowInsecureConnection;
		this._httpClient = options.httpClient || getCachedDefaultHttpClient$1();
		this.pipeline = options.pipeline || createDefaultPipeline(options);
		if (options.additionalPolicies?.length) for (const { policy, position } of options.additionalPolicies) {
			const afterPhase = position === "perRetry" ? "Sign" : void 0;
			this.pipeline.addPolicy(policy, { afterPhase });
		}
	}
	/**
	* Send the provided httpRequest.
	*/
	sendRequest(request) {
		return this.pipeline.sendRequest(this._httpClient, request);
	}
	/**
	* Send an HTTP request that is populated using the provided OperationSpec.
	* @typeParam T - The typed result of the request, based on the OperationSpec.
	* @param operationArguments - The arguments that the HTTP request's templated values will be populated from.
	* @param operationSpec - The OperationSpec to use to populate the httpRequest.
	*/
	async sendOperationRequest(operationArguments, operationSpec) {
		const endpoint = operationSpec.baseUrl || this._endpoint;
		if (!endpoint) throw new Error("If operationSpec.baseUrl is not specified, then the ServiceClient must have a endpoint string property that contains the base URL to use.");
		const request = createPipelineRequest({ url: getRequestUrl(endpoint, operationSpec, operationArguments, this) });
		request.method = operationSpec.httpMethod;
		const operationInfo = getOperationRequestInfo(request);
		operationInfo.operationSpec = operationSpec;
		operationInfo.operationArguments = operationArguments;
		const contentType = operationSpec.contentType || this._requestContentType;
		if (contentType && operationSpec.requestBody) request.headers.set("Content-Type", contentType);
		const options = operationArguments.options;
		if (options) {
			const requestOptions = options.requestOptions;
			if (requestOptions) {
				if (requestOptions.timeout) request.timeout = requestOptions.timeout;
				if (requestOptions.onUploadProgress) request.onUploadProgress = requestOptions.onUploadProgress;
				if (requestOptions.onDownloadProgress) request.onDownloadProgress = requestOptions.onDownloadProgress;
				if (requestOptions.shouldDeserialize !== void 0) operationInfo.shouldDeserialize = requestOptions.shouldDeserialize;
				if (requestOptions.allowInsecureConnection) request.allowInsecureConnection = true;
			}
			if (options.abortSignal) request.abortSignal = options.abortSignal;
			if (options.tracingOptions) request.tracingOptions = options.tracingOptions;
		}
		if (this._allowInsecureConnection) request.allowInsecureConnection = true;
		if (request.streamResponseStatusCodes === void 0) request.streamResponseStatusCodes = getStreamingResponseStatusCodes(operationSpec);
		try {
			const rawResponse = await this.sendRequest(request);
			const flatResponse = flattenResponse(rawResponse, operationSpec.responses[rawResponse.status]);
			if (options?.onResponse) options.onResponse(rawResponse, flatResponse);
			return flatResponse;
		} catch (error) {
			if (typeof error === "object" && error?.response) {
				const rawResponse = error.response;
				const flatResponse = flattenResponse(rawResponse, operationSpec.responses[error.statusCode] || operationSpec.responses["default"]);
				error.details = flatResponse;
				if (options?.onResponse) options.onResponse(rawResponse, flatResponse, error);
			}
			throw error;
		}
	}
};
function createDefaultPipeline(options) {
	const credentialScopes = getCredentialScopes(options);
	const credentialOptions = options.credential && credentialScopes ? {
		credentialScopes,
		credential: options.credential
	} : void 0;
	return createClientPipeline({
		...options,
		credentialOptions
	});
}
function getCredentialScopes(options) {
	if (options.credentialScopes) return options.credentialScopes;
	if (options.endpoint) return `${options.endpoint}/.default`;
	if (options.baseUri) return `${options.baseUri}/.default`;
	if (options.credential) throw new Error(`When using credentials, the ServiceClientOptions must contain either a endpoint or a credentialScopes. Unable to create a bearerTokenAuthenticationPolicy`);
}
//#endregion
//#region node_modules/.pnpm/@azure+core-client@1.11.0_supports-color@7.2.0/node_modules/@azure/core-client/dist/esm/authorizeRequestOnTenantChallenge.js
/**
* A set of constants used internally when processing requests.
*/
var Constants = {
	DefaultScope: "/.default",
	/**
	* Defines constants for use with HTTP headers.
	*/
	HeaderConstants: { 
	/**
	* The Authorization header.
	*/
AUTHORIZATION: "authorization" }
};
function isUuid(text) {
	return /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/.test(text);
}
/**
* Defines a callback to handle auth challenge for Storage APIs.
* This implements the bearer challenge process described here: https://learn.microsoft.com/rest/api/storageservices/authorize-with-azure-active-directory#bearer-challenge
* Handling has specific features for storage that departs to the general AAD challenge docs.
**/
var authorizeRequestOnTenantChallenge = async (challengeOptions) => {
	const requestOptions = requestToOptions(challengeOptions.request);
	const challenge = getChallenge(challengeOptions.response);
	if (challenge) {
		const challengeInfo = parseChallenge(challenge);
		const challengeScopes = buildScopes(challengeOptions, challengeInfo);
		const tenantId = extractTenantId(challengeInfo);
		if (!tenantId) return false;
		const accessToken = await challengeOptions.getAccessToken(challengeScopes, {
			...requestOptions,
			tenantId
		});
		if (!accessToken) return false;
		challengeOptions.request.headers.set(Constants.HeaderConstants.AUTHORIZATION, `${accessToken.tokenType ?? "Bearer"} ${accessToken.token}`);
		return true;
	}
	return false;
};
/**
* Extracts the tenant id from the challenge information
* The tenant id is contained in the authorization_uri as the first
* path part.
*/
function extractTenantId(challengeInfo) {
	const tenantId = new URL(challengeInfo.authorization_uri).pathname.split("/")[1];
	if (tenantId && isUuid(tenantId)) return tenantId;
}
/**
* Builds the authentication scopes based on the information that comes in the
* challenge information. Scopes url is present in the resource_id, if it is empty
* we keep using the original scopes.
*/
function buildScopes(challengeOptions, challengeInfo) {
	if (!challengeInfo.resource_id) return challengeOptions.scopes;
	const challengeScopes = new URL(challengeInfo.resource_id);
	let scope = new URL(Constants.DefaultScope, challengeScopes.origin).toString();
	if (scope === "https://disk.azure.com/.default") scope = "https://disk.azure.com//.default";
	return [scope];
}
/**
* We will retrieve the challenge only if the response status code was 401,
* and if the response contained the header "WWW-Authenticate" with a non-empty value.
*/
function getChallenge(response) {
	const challenge = response.headers.get("WWW-Authenticate");
	if (response.status === 401 && challenge) return challenge;
}
/**
* Converts: `Bearer a="b" c="d"`.
* Into: `[ { a: 'b', c: 'd' }]`.
*
* @internal
*/
function parseChallenge(challenge) {
	return `${challenge.slice(7).trim()} `.split(" ").filter((x) => x).map((keyValue) => (([key, value]) => ({ [key]: value }))(keyValue.trim().split("="))).reduce((a, b) => ({
		...a,
		...b
	}), {});
}
/**
* Extracts the options form a Pipeline Request for later re-use
*/
function requestToOptions(request) {
	return {
		abortSignal: request.abortSignal,
		requestOptions: { timeout: request.timeout },
		tracingOptions: request.tracingOptions
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-http-compat@2.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__@azure+co_d787bc7df786cb651d567e8aaf5a6964/node_modules/@azure/core-http-compat/dist/esm/util.js
var originalRequestSymbol = Symbol("Original PipelineRequest");
var originalClientRequestSymbol = Symbol.for("@azure/core-client original request");
var passThroughProps = /* @__PURE__ */ new Set([
	"url",
	"method",
	"withCredentials",
	"timeout",
	"requestId",
	"abortSignal",
	"body",
	"formData",
	"onDownloadProgress",
	"onUploadProgress",
	"proxySettings",
	"streamResponseStatusCodes",
	"agent",
	"requestOverrides"
]);
function toPipelineRequest(webResource, options = {}) {
	const request = webResource[originalRequestSymbol];
	const headers = createHttpHeaders(webResource.headers.toJson({ preserveCase: true }));
	if (request) {
		request.headers = headers;
		return request;
	} else {
		const newRequest = createPipelineRequest({
			url: webResource.url,
			method: webResource.method,
			headers,
			withCredentials: webResource.withCredentials,
			timeout: webResource.timeout,
			requestId: webResource.requestId,
			abortSignal: webResource.abortSignal,
			body: webResource.body,
			formData: webResource.formData,
			disableKeepAlive: !!webResource.keepAlive,
			onDownloadProgress: webResource.onDownloadProgress,
			onUploadProgress: webResource.onUploadProgress,
			proxySettings: webResource.proxySettings,
			streamResponseStatusCodes: webResource.streamResponseStatusCodes,
			agent: webResource.agent,
			requestOverrides: webResource.requestOverrides
		});
		if (options.originalRequest) newRequest[originalClientRequestSymbol] = options.originalRequest;
		return newRequest;
	}
}
function toWebResourceLike(request, options) {
	const originalRequest = options?.originalRequest ?? request;
	const webResource = {
		url: request.url,
		method: request.method,
		headers: toHttpHeadersLike(request.headers),
		withCredentials: request.withCredentials,
		timeout: request.timeout,
		requestId: request.headers.get("x-ms-client-request-id") || request.requestId,
		abortSignal: request.abortSignal,
		body: request.body,
		formData: request.formData,
		keepAlive: !!request.disableKeepAlive,
		onDownloadProgress: request.onDownloadProgress,
		onUploadProgress: request.onUploadProgress,
		proxySettings: request.proxySettings,
		streamResponseStatusCodes: request.streamResponseStatusCodes,
		agent: request.agent,
		requestOverrides: request.requestOverrides,
		clone() {
			throw new Error("Cannot clone a non-proxied WebResourceLike");
		},
		prepare() {
			throw new Error("WebResourceLike.prepare() is not supported by @azure/core-http-compat");
		},
		validateRequestProperties() {
			/** do nothing */
		}
	};
	if (options?.createProxy) return new Proxy(webResource, {
		get(target, prop, receiver) {
			if (prop === originalRequestSymbol) return request;
			else if (prop === "clone") return () => {
				return toWebResourceLike(toPipelineRequest(webResource, { originalRequest }), {
					createProxy: true,
					originalRequest
				});
			};
			return Reflect.get(target, prop, receiver);
		},
		set(target, prop, value, receiver) {
			if (prop === "keepAlive") request.disableKeepAlive = !value;
			if (typeof prop === "string" && passThroughProps.has(prop)) request[prop] = value;
			return Reflect.set(target, prop, value, receiver);
		}
	});
	else return webResource;
}
/**
* Converts HttpHeaders from core-rest-pipeline to look like
* HttpHeaders from core-http.
* @param headers - HttpHeaders from core-rest-pipeline
* @returns HttpHeaders as they looked in core-http
*/
function toHttpHeadersLike(headers) {
	return new HttpHeaders(headers.toJSON({ preserveCase: true }));
}
/**
* A collection of HttpHeaders that can be sent with a HTTP request.
*/
function getHeaderKey(headerName) {
	return headerName.toLowerCase();
}
/**
* A collection of HTTP header key/value pairs.
*/
var HttpHeaders = class HttpHeaders {
	_headersMap;
	constructor(rawHeaders) {
		this._headersMap = {};
		if (rawHeaders) for (const headerName in rawHeaders) this.set(headerName, rawHeaders[headerName]);
	}
	/**
	* Set a header in this collection with the provided name and value. The name is
	* case-insensitive.
	* @param headerName - The name of the header to set. This value is case-insensitive.
	* @param headerValue - The value of the header to set.
	*/
	set(headerName, headerValue) {
		this._headersMap[getHeaderKey(headerName)] = {
			name: headerName,
			value: headerValue.toString()
		};
	}
	/**
	* Get the header value for the provided header name, or undefined if no header exists in this
	* collection with the provided name.
	* @param headerName - The name of the header.
	*/
	get(headerName) {
		const header = this._headersMap[getHeaderKey(headerName)];
		return !header ? void 0 : header.value;
	}
	/**
	* Get whether or not this header collection contains a header entry for the provided header name.
	*/
	contains(headerName) {
		return !!this._headersMap[getHeaderKey(headerName)];
	}
	/**
	* Remove the header with the provided headerName. Return whether or not the header existed and
	* was removed.
	* @param headerName - The name of the header to remove.
	*/
	remove(headerName) {
		const result = this.contains(headerName);
		delete this._headersMap[getHeaderKey(headerName)];
		return result;
	}
	/**
	* Get the headers that are contained this collection as an object.
	*/
	rawHeaders() {
		return this.toJson({ preserveCase: true });
	}
	/**
	* Get the headers that are contained in this collection as an array.
	*/
	headersArray() {
		const headers = [];
		for (const headerKey in this._headersMap) headers.push(this._headersMap[headerKey]);
		return headers;
	}
	/**
	* Get the header names that are contained in this collection.
	*/
	headerNames() {
		const headerNames = [];
		const headers = this.headersArray();
		for (let i = 0; i < headers.length; ++i) headerNames.push(headers[i].name);
		return headerNames;
	}
	/**
	* Get the header values that are contained in this collection.
	*/
	headerValues() {
		const headerValues = [];
		const headers = this.headersArray();
		for (let i = 0; i < headers.length; ++i) headerValues.push(headers[i].value);
		return headerValues;
	}
	/**
	* Get the JSON object representation of this HTTP header collection.
	*/
	toJson(options = {}) {
		const result = {};
		if (options.preserveCase) for (const headerKey in this._headersMap) {
			const header = this._headersMap[headerKey];
			result[header.name] = header.value;
		}
		else for (const headerKey in this._headersMap) {
			const header = this._headersMap[headerKey];
			result[getHeaderKey(header.name)] = header.value;
		}
		return result;
	}
	/**
	* Get the string representation of this HTTP header collection.
	*/
	toString() {
		return JSON.stringify(this.toJson({ preserveCase: true }));
	}
	/**
	* Create a deep clone/copy of this HttpHeaders collection.
	*/
	clone() {
		const resultPreservingCasing = {};
		for (const headerKey in this._headersMap) {
			const header = this._headersMap[headerKey];
			resultPreservingCasing[header.name] = header.value;
		}
		return new HttpHeaders(resultPreservingCasing);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+core-http-compat@2.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__@azure+co_d787bc7df786cb651d567e8aaf5a6964/node_modules/@azure/core-http-compat/dist/esm/response.js
var originalResponse = Symbol("Original FullOperationResponse");
/**
* A helper to convert response objects from the new pipeline back to the old one.
* @param response - A response object from core-client.
* @returns A response compatible with `HttpOperationResponse` from core-http.
*/
function toCompatResponse(response, options) {
	let request = toWebResourceLike(response.request);
	let headers = toHttpHeadersLike(response.headers);
	if (options?.createProxy) return new Proxy(response, {
		get(target, prop, receiver) {
			if (prop === "headers") return headers;
			else if (prop === "request") return request;
			else if (prop === originalResponse) return response;
			return Reflect.get(target, prop, receiver);
		},
		set(target, prop, value, receiver) {
			if (prop === "headers") headers = value;
			else if (prop === "request") request = value;
			return Reflect.set(target, prop, value, receiver);
		}
	});
	else return {
		...response,
		request,
		headers
	};
}
/**
* A helper to convert back to a PipelineResponse
* @param compatResponse - A response compatible with `HttpOperationResponse` from core-http.
*/
function toPipelineResponse(compatResponse) {
	const response = compatResponse[originalResponse];
	const headers = createHttpHeaders(compatResponse.headers.toJson({ preserveCase: true }));
	if (response) {
		response.headers = headers;
		return response;
	} else return {
		...compatResponse,
		headers,
		request: toPipelineRequest(compatResponse.request)
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-http-compat@2.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__@azure+co_d787bc7df786cb651d567e8aaf5a6964/node_modules/@azure/core-http-compat/dist/esm/extendedClient.js
/**
* Client to provide compatability between core V1 & V2.
*/
var ExtendedServiceClient = class extends ServiceClient {
	constructor(options) {
		super(options);
		if (options.keepAliveOptions?.enable === false && !pipelineContainsDisableKeepAlivePolicy(this.pipeline)) this.pipeline.addPolicy(createDisableKeepAlivePolicy());
		if (options.redirectOptions?.handleRedirects === false) this.pipeline.removePolicy({ name: redirectPolicyName });
	}
	/**
	* Compatible send operation request function.
	*
	* @param operationArguments - Operation arguments
	* @param operationSpec - Operation Spec
	* @returns
	*/
	async sendOperationRequest(operationArguments, operationSpec) {
		const userProvidedCallBack = operationArguments?.options?.onResponse;
		let lastResponse;
		function onResponse(rawResponse, flatResponse, error) {
			lastResponse = rawResponse;
			if (userProvidedCallBack) userProvidedCallBack(rawResponse, flatResponse, error);
		}
		operationArguments.options = {
			...operationArguments.options,
			onResponse
		};
		const result = await super.sendOperationRequest(operationArguments, operationSpec);
		if (lastResponse) Object.defineProperty(result, "_response", { value: toCompatResponse(lastResponse) });
		return result;
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+core-http-compat@2.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__@azure+co_d787bc7df786cb651d567e8aaf5a6964/node_modules/@azure/core-http-compat/dist/esm/policies/requestPolicyFactoryPolicy.js
/**
* An enum for compatibility with RequestPolicy
*/
var HttpPipelineLogLevel;
(function(HttpPipelineLogLevel) {
	HttpPipelineLogLevel[HttpPipelineLogLevel["ERROR"] = 1] = "ERROR";
	HttpPipelineLogLevel[HttpPipelineLogLevel["INFO"] = 3] = "INFO";
	HttpPipelineLogLevel[HttpPipelineLogLevel["OFF"] = 0] = "OFF";
	HttpPipelineLogLevel[HttpPipelineLogLevel["WARNING"] = 2] = "WARNING";
})(HttpPipelineLogLevel || (HttpPipelineLogLevel = {}));
var mockRequestPolicyOptions = {
	log(_logLevel, _message) {},
	shouldLog(_logLevel) {
		return false;
	}
};
/**
* The name of the RequestPolicyFactoryPolicy
*/
var requestPolicyFactoryPolicyName = "RequestPolicyFactoryPolicy";
/**
* A policy that wraps policies written for core-http.
* @param factories - An array of `RequestPolicyFactory` objects from a core-http pipeline
*/
function createRequestPolicyFactoryPolicy(factories) {
	const orderedFactories = factories.slice().reverse();
	return {
		name: requestPolicyFactoryPolicyName,
		async sendRequest(request, next) {
			let httpPipeline = { async sendRequest(httpRequest) {
				return toCompatResponse(await next(toPipelineRequest(httpRequest)), { createProxy: true });
			} };
			for (const factory of orderedFactories) httpPipeline = factory.create(httpPipeline, mockRequestPolicyOptions);
			const webResourceLike = toWebResourceLike(request, { createProxy: true });
			return toPipelineResponse(await httpPipeline.sendRequest(webResourceLike));
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-http-compat@2.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__@azure+co_d787bc7df786cb651d567e8aaf5a6964/node_modules/@azure/core-http-compat/dist/esm/httpClientAdapter.js
/**
* Converts a RequestPolicy based HttpClient to a PipelineRequest based HttpClient.
* @param requestPolicyClient - A HttpClient compatible with core-http
* @returns A HttpClient compatible with core-rest-pipeline
*/
function convertHttpClient(requestPolicyClient) {
	return { sendRequest: async (request) => {
		return toPipelineResponse(await requestPolicyClient.sendRequest(toWebResourceLike(request, { createProxy: true })));
	} };
}
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/util.js
var regexName = /* @__PURE__ */ new RegExp("^[:A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$");
function getAllMatches(string, regex) {
	const matches = [];
	let match = regex.exec(string);
	while (match) {
		const allmatches = [];
		allmatches.startIndex = regex.lastIndex - match[0].length;
		const len = match.length;
		for (let index = 0; index < len; index++) allmatches.push(match[index]);
		matches.push(allmatches);
		match = regex.exec(string);
	}
	return matches;
}
var isName = function(string) {
	const match = regexName.exec(string);
	return !(match === null || typeof match === "undefined");
};
function isExist(v) {
	return typeof v !== "undefined";
}
/**
* Dangerous property names that could lead to prototype pollution or security issues
*/
var DANGEROUS_PROPERTY_NAMES = [
	"hasOwnProperty",
	"toString",
	"valueOf",
	"__defineGetter__",
	"__defineSetter__",
	"__lookupGetter__",
	"__lookupSetter__"
];
var criticalProperties = [
	"__proto__",
	"constructor",
	"prototype"
];
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/validator.js
var defaultOptions$2 = {
	allowBooleanAttributes: false,
	unpairedTags: []
};
function validate(xmlData, options) {
	options = Object.assign({}, defaultOptions$2, options);
	const tags = [];
	let tagFound = false;
	let reachedRoot = false;
	if (xmlData[0] === "﻿") xmlData = xmlData.substr(1);
	for (let i = 0; i < xmlData.length; i++) if (xmlData[i] === "<" && xmlData[i + 1] === "?") {
		i += 2;
		i = readPI(xmlData, i);
		if (i.err) return i;
	} else if (xmlData[i] === "<") {
		let tagStartPos = i;
		i++;
		if (xmlData[i] === "!") {
			i = readCommentAndCDATA(xmlData, i);
			continue;
		} else {
			let closingTag = false;
			if (xmlData[i] === "/") {
				closingTag = true;
				i++;
			}
			let tagName = "";
			for (; i < xmlData.length && xmlData[i] !== ">" && xmlData[i] !== " " && xmlData[i] !== "	" && xmlData[i] !== "\n" && xmlData[i] !== "\r"; i++) tagName += xmlData[i];
			tagName = tagName.trim();
			if (tagName[tagName.length - 1] === "/") {
				tagName = tagName.substring(0, tagName.length - 1);
				i--;
			}
			if (!validateTagName(tagName)) {
				let msg;
				if (tagName.trim().length === 0) msg = "Invalid space after '<'.";
				else msg = "Tag '" + tagName + "' is an invalid name.";
				return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i));
			}
			const result = readAttributeStr(xmlData, i);
			if (result === false) return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i));
			let attrStr = result.value;
			i = result.index;
			if (attrStr[attrStr.length - 1] === "/") {
				const attrStrStart = i - attrStr.length;
				attrStr = attrStr.substring(0, attrStr.length - 1);
				const isValid = validateAttributeString(attrStr, options);
				if (isValid === true) tagFound = true;
				else return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
			} else if (closingTag) {
				if (!result.tagClosed) return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
				else if (attrStr.trim().length > 0) return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
				else if (tags.length === 0) return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' has not been opened.", getLineNumberForPosition(xmlData, tagStartPos));
				else {
					const otg = tags.pop();
					if (tagName !== otg.tagName) {
						let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
						return getErrorObject("InvalidTag", "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.", getLineNumberForPosition(xmlData, tagStartPos));
					}
					if (tags.length == 0) reachedRoot = true;
				}
			} else {
				const isValid = validateAttributeString(attrStr, options);
				if (isValid !== true) return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
				if (reachedRoot === true) return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i));
				else if (options.unpairedTags.indexOf(tagName) !== -1) {} else tags.push({
					tagName,
					tagStartPos
				});
				tagFound = true;
			}
			for (i++; i < xmlData.length; i++) if (xmlData[i] === "<") {
				if (xmlData[i + 1] === "!") {
					i++;
					i = readCommentAndCDATA(xmlData, i);
					continue;
				} else if (xmlData[i + 1] === "?") {
					i = readPI(xmlData, ++i);
					if (i.err) return i;
				} else break;
			} else if (xmlData[i] === "&") {
				const afterAmp = validateAmpersand(xmlData, i);
				if (afterAmp == -1) return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
				i = afterAmp;
			} else if (reachedRoot === true && !isWhiteSpace(xmlData[i])) return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i));
			if (xmlData[i] === "<") i--;
		}
	} else {
		if (isWhiteSpace(xmlData[i])) continue;
		return getErrorObject("InvalidChar", "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
	}
	if (!tagFound) return getErrorObject("InvalidXml", "Start tag expected.", 1);
	else if (tags.length == 1) return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
	else if (tags.length > 0) return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", {
		line: 1,
		col: 1
	});
	return true;
}
function isWhiteSpace(char) {
	return char === " " || char === "	" || char === "\n" || char === "\r";
}
/**
* Read Processing insstructions and skip
* @param {*} xmlData
* @param {*} i
*/
function readPI(xmlData, i) {
	const start = i;
	for (; i < xmlData.length; i++) if (xmlData[i] == "?" || xmlData[i] == " ") {
		const tagname = xmlData.substr(start, i - start);
		if (i > 5 && tagname === "xml") return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i));
		else if (xmlData[i] == "?" && xmlData[i + 1] == ">") {
			i++;
			break;
		} else continue;
	}
	return i;
}
function readCommentAndCDATA(xmlData, i) {
	if (xmlData.length > i + 5 && xmlData[i + 1] === "-" && xmlData[i + 2] === "-") {
		for (i += 3; i < xmlData.length; i++) if (xmlData[i] === "-" && xmlData[i + 1] === "-" && xmlData[i + 2] === ">") {
			i += 2;
			break;
		}
	} else if (xmlData.length > i + 8 && xmlData[i + 1] === "D" && xmlData[i + 2] === "O" && xmlData[i + 3] === "C" && xmlData[i + 4] === "T" && xmlData[i + 5] === "Y" && xmlData[i + 6] === "P" && xmlData[i + 7] === "E") {
		let angleBracketsCount = 1;
		for (i += 8; i < xmlData.length; i++) if (xmlData[i] === "<") angleBracketsCount++;
		else if (xmlData[i] === ">") {
			angleBracketsCount--;
			if (angleBracketsCount === 0) break;
		}
	} else if (xmlData.length > i + 9 && xmlData[i + 1] === "[" && xmlData[i + 2] === "C" && xmlData[i + 3] === "D" && xmlData[i + 4] === "A" && xmlData[i + 5] === "T" && xmlData[i + 6] === "A" && xmlData[i + 7] === "[") {
		for (i += 8; i < xmlData.length; i++) if (xmlData[i] === "]" && xmlData[i + 1] === "]" && xmlData[i + 2] === ">") {
			i += 2;
			break;
		}
	}
	return i;
}
var doubleQuote = "\"";
var singleQuote = "'";
/**
* Keep reading xmlData until '<' is found outside the attribute value.
* @param {string} xmlData
* @param {number} i
*/
function readAttributeStr(xmlData, i) {
	let attrStr = "";
	let startChar = "";
	let tagClosed = false;
	for (; i < xmlData.length; i++) {
		if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
			if (startChar === "") startChar = xmlData[i];
			else if (startChar !== xmlData[i]) {} else startChar = "";
		} else if (xmlData[i] === ">") {
			if (startChar === "") {
				tagClosed = true;
				break;
			}
		}
		attrStr += xmlData[i];
	}
	if (startChar !== "") return false;
	return {
		value: attrStr,
		index: i,
		tagClosed
	};
}
/**
* Select all the attributes whether valid or invalid.
*/
var validAttrStrRegxp = /* @__PURE__ */ new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?", "g");
function validateAttributeString(attrStr, options) {
	const matches = getAllMatches(attrStr, validAttrStrRegxp);
	const attrNames = {};
	for (let i = 0; i < matches.length; i++) {
		if (matches[i][1].length === 0) return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i]));
		else if (matches[i][3] !== void 0 && matches[i][4] === void 0) return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
		else if (matches[i][3] === void 0 && !options.allowBooleanAttributes) return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i]));
		const attrName = matches[i][2];
		if (!validateAttrName(attrName)) return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
		if (!Object.prototype.hasOwnProperty.call(attrNames, attrName)) attrNames[attrName] = 1;
		else return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
	}
	return true;
}
function validateNumberAmpersand(xmlData, i) {
	let re = /\d/;
	if (xmlData[i] === "x") {
		i++;
		re = /[\da-fA-F]/;
	}
	for (; i < xmlData.length; i++) {
		if (xmlData[i] === ";") return i;
		if (!xmlData[i].match(re)) break;
	}
	return -1;
}
function validateAmpersand(xmlData, i) {
	i++;
	if (xmlData[i] === ";") return -1;
	if (xmlData[i] === "#") {
		i++;
		return validateNumberAmpersand(xmlData, i);
	}
	let count = 0;
	for (; i < xmlData.length; i++, count++) {
		if (xmlData[i].match(/\w/) && count < 20) continue;
		if (xmlData[i] === ";") break;
		return -1;
	}
	return i;
}
function getErrorObject(code, message, lineNumber) {
	return { err: {
		code,
		msg: message,
		line: lineNumber.line || lineNumber,
		col: lineNumber.col
	} };
}
function validateAttrName(attrName) {
	return isName(attrName);
}
function validateTagName(tagname) {
	return isName(tagname);
}
function getLineNumberForPosition(xmlData, index) {
	const lines = xmlData.substring(0, index).split(/\r?\n/);
	return {
		line: lines.length,
		col: lines[lines.length - 1].length + 1
	};
}
function getPositionFromMatch(match) {
	return match.startIndex + match[1].length;
}
//#endregion
//#region node_modules/.pnpm/@nodable+entities@3.0.0/node_modules/@nodable/entities/src/entities.js
/**
* Currency Symbols
* @type {Record<string, string>}
*/
var CURRENCY = {
	cent: "¢",
	pound: "£",
	curren: "¤",
	yen: "¥",
	euro: "€",
	dollar: "$",
	fnof: "ƒ",
	inr: "₹",
	af: "؋",
	birr: "ብር",
	peso: "₱",
	rub: "₽",
	won: "₩",
	yuan: "¥",
	cedil: "¸"
};
var XML = {
	amp: "&",
	apos: "'",
	gt: ">",
	lt: "<",
	quot: "\""
};
var COMMON_HTML = {
	nbsp: "\xA0",
	copy: "©",
	reg: "®",
	trade: "™",
	mdash: "—",
	ndash: "–",
	hellip: "…",
	laquo: "«",
	raquo: "»",
	lsquo: "‘",
	rsquo: "’",
	ldquo: "“",
	rdquo: "”",
	bull: "•",
	para: "¶",
	sect: "§",
	deg: "°",
	frac12: "½",
	frac14: "¼",
	frac34: "¾"
};
//#endregion
//#region node_modules/.pnpm/@nodable+entities@3.0.0/node_modules/@nodable/entities/src/EntityDecoder.js
/**
* Action constants for `onExternalEntity` and `onInputEntity` hooks.
*
* Use these instead of raw strings to avoid typos:
*
* @example
* import EntityDecoder, { ENTITY_ACTION } from './EntityDecoder.js';
* const dec = new EntityDecoder({
*   onInputEntity: (name, value) => ENTITY_ACTION.BLOCK,
* });
*/
var ENTITY_ACTION = Object.freeze({
	/** Resolve and expand the entity normally. */
	ALLOW: "allow",
	/** Silently skip this entity — it will not be registered. */
	BLOCK: "block",
	/** Throw an error, aborting entity registration entirely. */
	THROW: "throw"
});
var SPECIAL_CHARS = /* @__PURE__ */ new Set("!?\\\\/[]$%{}^&*()<>|+");
/**
* Validate that an entity name contains no dangerous characters.
* @param {string} name
* @returns {string} the name, unchanged
* @throws {Error} on invalid characters
*/
function validateEntityName$1(name) {
	if (name[0] === "#") throw new Error(`[EntityReplacer] Invalid character '#' in entity name: "${name}"`);
	for (const ch of name) if (SPECIAL_CHARS.has(ch)) throw new Error(`[EntityReplacer] Invalid character '${ch}' in entity name: "${name}"`);
	return name;
}
__name(validateEntityName$1, "validateEntityName");
/**
* Merge one or more entity maps into a flat name→string map.
* Accepts either:
*   - plain string values:             { amp: '&' }
*   - legacy {regex,val} / {regx,val}: { lt: { regex: /.../, val: '<' } }
*
* Values containing '&' are skipped (recursive expansion risk).
*
* @param {...object} maps
* @returns {Record<string, string>}
*/
function mergeEntityMaps(...maps) {
	const out = Object.create(null);
	for (const map of maps) {
		if (!map) continue;
		for (const key of Object.keys(map)) {
			const raw = map[key];
			if (typeof raw === "string") out[key] = raw;
			else if (raw && typeof raw === "object" && raw.val !== void 0) {
				const val = raw.val;
				if (typeof val === "string") out[key] = val;
			}
		}
	}
	return out;
}
var LIMIT_TIER_EXTERNAL = "external";
var LIMIT_TIER_BASE = "base";
var LIMIT_TIER_ALL = "all";
/**
* Resolve `applyLimitsTo` option into a normalised Set of tier strings.
* Accepted values: 'external' | 'base' | 'all' | string[]
* Default: 'external' (only untrusted injected entities are counted).
* @param {string|string[]|undefined} raw
* @returns {Set<string>}
*/
function parseLimitTiers(raw) {
	if (!raw || raw === LIMIT_TIER_EXTERNAL) return /* @__PURE__ */ new Set([LIMIT_TIER_EXTERNAL]);
	if (raw === LIMIT_TIER_ALL) return /* @__PURE__ */ new Set([LIMIT_TIER_ALL]);
	if (raw === LIMIT_TIER_BASE) return /* @__PURE__ */ new Set([LIMIT_TIER_BASE]);
	if (Array.isArray(raw)) return new Set(raw);
	return /* @__PURE__ */ new Set([LIMIT_TIER_EXTERNAL]);
}
var NCR_LEVEL = Object.freeze({
	allow: 0,
	leave: 1,
	remove: 2,
	throw: 3
});
var XML10_ALLOWED_C0 = /* @__PURE__ */ new Set([
	9,
	10,
	13
]);
/**
* Parse the `ncr` constructor option into flat, hot-path-friendly fields.
* @param {object|undefined} ncr
* @returns {{ xmlVersion: number, onLevel: number, nullLevel: number }}
*/
function parseNCRConfig(ncr) {
	if (!ncr) return {
		xmlVersion: 1,
		onLevel: NCR_LEVEL.allow,
		nullLevel: NCR_LEVEL.remove
	};
	const xmlVersion = ncr.xmlVersion === 1.1 ? 1.1 : 1;
	const onLevel = NCR_LEVEL[ncr.onNCR] ?? NCR_LEVEL.allow;
	const nullLevel = NCR_LEVEL[ncr.nullNCR] ?? NCR_LEVEL.remove;
	return {
		xmlVersion,
		onLevel,
		nullLevel: Math.max(nullLevel, NCR_LEVEL.remove)
	};
}
/**
* Single-pass, zero-regex entity replacer for XML/HTML content.
*
* Algorithm: scan the string once for '&', read to ';', resolve via map
* or direct codepoint conversion, build output chunks, join once at the end.
*
* Entity lookup priority (highest → lowest):
*   1. input / runtime  (DOCTYPE entities for current document)
*   2. persistent external (survive across documents)
*   3. base named map   (DEFAULT_XML_ENTITIES + user-supplied namedEntities)
*
* Both input and external resolve as the 'external' tier for limit purposes.
* Base map entities resolve as the 'base' tier.
*
* Numeric / hex references (&#NNN; / &#xHH;) are resolved directly via
* String.fromCodePoint() — no map needed. They count as 'base' tier.
*
* @example
* const replacer = new EntityReplacer({ namedEntities: COMMON_HTML });
* replacer.setExternalEntities({ brand: 'Acme' });
*
* const instance = replacer.reset();
* instance.addInputEntities({ version: '1.0' });
* instance.encode('&brand; v&version; &lt;'); // 'Acme v1.0 <'
*/
var EntityDecoder = class {
	/**
	* @param {object} [options]
	* @param {object|null}  [options.namedEntities]        — extra named entities merged into base map
	* @param {object}  [options.limit]                 — security limits
	* @param {number}       [options.limit.maxTotalExpansions=0]  — 0 = unlimited
	* @param {number}       [options.limit.maxExpandedLength=0]   — 0 = unlimited
	* @param {'external'|'base'|'all'|string[]} [options.limit.applyLimitsTo='external']
	*   Which entity tiers count against the security limits:
	*   - 'external' (default) — only input/runtime + persistent external entities
	*   - 'base'               — only DEFAULT_XML_ENTITIES + namedEntities
	*   - 'all'                — every entity regardless of tier
	*   - string[]             — explicit combination, e.g. ['external', 'base']
	* @param {((resolved: string, original: string) => string)|null} [options.postCheck=null]
	* @param {string[]} [options.remove=[]] — entity names (e.g. ['nbsp', '#13']) to delete (replace with empty string)
	* @param {string[]} [options.leave=[]]  — entity names to keep as literal (unchanged in output)
	* @param {object}   [options.ncr]       — Numeric Character Reference controls
	* @param {1.0|1.1}  [options.ncr.xmlVersion=1.0]
	*   XML version governing which codepoint ranges are restricted:
	*   - 1.0 — C0 controls U+0001–U+001F (except U+0009/000A/000D) are prohibited
	*   - 1.1 — C0 controls are allowed when written as NCRs; C1 (U+007F–U+009F) decoded as-is
	* @param {'allow'|'leave'|'remove'|'throw'} [options.ncr.onNCR='allow']
	*   Base action for numeric references. Severity order: allow < leave < remove < throw.
	*   For codepoint ranges that carry a minimum level (surrogates → remove, XML 1.0 C0 → remove),
	*   the effective action is max(onNCR, rangeMinimum).
	* @param {'remove'|'throw'} [options.ncr.nullNCR='remove']
	*   Action for U+0000 (null). 'allow' and 'leave' are clamped to 'remove' since null is never safe.
	* @param {((name: string, value: string) => 'allow'|'block'|'throw')|null} [options.onExternalEntity=null]
	*   Hook called when an external entity is registered via `setExternalEntities()` or
	*   `addExternalEntity()`. Return `ENTITY_ACTION.ALLOW` to accept the entity,
	*   `ENTITY_ACTION.BLOCK` to silently skip it, or `ENTITY_ACTION.THROW` to abort with an error.
	* @param {((name: string, value: string) => 'allow'|'block'|'throw')|null} [options.onInputEntity=null]
	*   Hook called when an input entity is registered via `addInputEntities()`. Return
	*   `ENTITY_ACTION.ALLOW` to accept, `ENTITY_ACTION.BLOCK` to silently skip, or
	*   `ENTITY_ACTION.THROW` to abort with an error.
	*/
	constructor(options = {}) {
		this._limit = options.limit || {};
		this._maxTotalExpansions = this._limit.maxTotalExpansions || 0;
		this._maxExpandedLength = this._limit.maxExpandedLength || 0;
		this._postCheck = typeof options.postCheck === "function" ? options.postCheck : (r) => r;
		this._limitTiers = parseLimitTiers(this._limit.applyLimitsTo ?? LIMIT_TIER_EXTERNAL);
		this._numericAllowed = options.numericAllowed ?? true;
		this._baseMap = mergeEntityMaps(XML, options.namedEntities || null);
		/** @type {Record<string, string>} */
		this._externalMap = Object.create(null);
		/** @type {Record<string, string>} */
		this._inputMap = Object.create(null);
		this._totalExpansions = 0;
		this._expandedLength = 0;
		/** @type {Set<string>} */
		this._removeSet = new Set(options.remove && Array.isArray(options.remove) ? options.remove : []);
		/** @type {Set<string>} */
		this._leaveSet = new Set(options.leave && Array.isArray(options.leave) ? options.leave : []);
		const ncrCfg = parseNCRConfig(options.ncr);
		this._ncrXmlVersion = ncrCfg.xmlVersion;
		this._ncrOnLevel = ncrCfg.onLevel;
		this._ncrNullLevel = ncrCfg.nullLevel;
		/** @type {((name: string, value: string) => 'allow'|'block'|'throw')|null} */
		this._onExternalEntity = typeof options.onExternalEntity === "function" ? options.onExternalEntity : null;
		/** @type {((name: string, value: string) => 'allow'|'block'|'throw')|null} */
		this._onInputEntity = typeof options.onInputEntity === "function" ? options.onInputEntity : null;
	}
	/**
	* Invoke a registration hook for a single entity name/value pair.
	* Returns true when the entity should be accepted, false when it should be
	* silently skipped (BLOCK), and throws when the hook returns THROW.
	*
	* @param {((name: string, value: string) => 'allow'|'block'|'throw')|null} hook
	* @param {string} name
	* @param {string} value
	* @param {string} context  — used in error messages ('external' | 'input')
	* @returns {boolean}  true = accept, false = skip
	*/
	_applyRegistrationHook(hook, name, value, context) {
		if (!hook) return true;
		const action = hook(name, value);
		if (action === ENTITY_ACTION.BLOCK) return false;
		if (action === ENTITY_ACTION.THROW) throw new Error(`[EntityDecoder] Registration of ${context} entity "&${name};" was rejected by hook`);
		return true;
	}
	/**
	* Replace the full set of persistent external entities.
	* All keys are validated — throws on invalid characters.
	* If `onExternalEntity` is set, it is called once per entry; entries that
	* return `ENTITY_ACTION.BLOCK` are silently omitted, `ENTITY_ACTION.THROW`
	* aborts the whole call.
	* @param {Record<string, string | { regex?: RegExp, val: string }>} map
	*/
	setExternalEntities(map) {
		if (map) for (const key of Object.keys(map)) validateEntityName$1(key);
		if (!this._onExternalEntity) {
			this._externalMap = mergeEntityMaps(map);
			return;
		}
		const flat = mergeEntityMaps(map);
		const filtered = Object.create(null);
		for (const [name, value] of Object.entries(flat)) if (this._applyRegistrationHook(this._onExternalEntity, name, value, "external")) filtered[name] = value;
		this._externalMap = filtered;
	}
	/**
	* Add a single persistent external entity.
	* If `onExternalEntity` is set it is called before the entity is stored;
	* `ENTITY_ACTION.BLOCK` silently skips storage, `ENTITY_ACTION.THROW` raises.
	* @param {string} key
	* @param {string} value
	*/
	addExternalEntity(key, value) {
		validateEntityName$1(key);
		if (typeof value === "string" && value.indexOf("&") === -1) {
			if (this._applyRegistrationHook(this._onExternalEntity, key, value, "external")) this._externalMap[key] = value;
		}
	}
	/**
	* Inject DOCTYPE entities for the current document.
	* Also resets per-document expansion counters.
	* If `onInputEntity` is set it is called once per entry; entries returning
	* `ENTITY_ACTION.BLOCK` are silently omitted, `ENTITY_ACTION.THROW` aborts.
	* @param {Record<string, string | { regx?: RegExp, regex?: RegExp, val: string }>} map
	*/
	addInputEntities(map) {
		this._totalExpansions = 0;
		this._expandedLength = 0;
		if (!this._onInputEntity) {
			this._inputMap = mergeEntityMaps(map);
			return;
		}
		const flat = mergeEntityMaps(map);
		const filtered = Object.create(null);
		for (const [name, value] of Object.entries(flat)) if (this._applyRegistrationHook(this._onInputEntity, name, value, "input")) filtered[name] = value;
		this._inputMap = filtered;
	}
	/**
	* Wipe input/runtime entities and reset counters.
	* Call this before processing each new document.
	* @returns {this}
	*/
	reset() {
		this._inputMap = Object.create(null);
		this._totalExpansions = 0;
		this._expandedLength = 0;
		return this;
	}
	/**
	* Update the XML version used for NCR classification.
	* Call this as soon as the document's `<?xml version="...">` declaration is parsed.
	* @param {1.0|1.1|number} version
	*/
	setXmlVersion(version) {
		this._ncrXmlVersion = version === 1.1 ? 1.1 : 1;
	}
	/**
	* Replace all entity references in `str` in a single pass.
	*
	* @param {string} str
	* @returns {string}
	*/
	decode(str) {
		if (typeof str !== "string" || str.length === 0) return str;
		if (str.indexOf("&") === -1) return str;
		const original = str;
		const chunks = [];
		const len = str.length;
		let last = 0;
		let i = 0;
		const limitExpansions = this._maxTotalExpansions > 0;
		const limitLength = this._maxExpandedLength > 0;
		const checkLimits = limitExpansions || limitLength;
		while (i < len) {
			if (str.charCodeAt(i) !== 38) {
				i++;
				continue;
			}
			let j = i + 1;
			while (j < len && str.charCodeAt(j) !== 59 && j - i <= 32) j++;
			if (j >= len || str.charCodeAt(j) !== 59) {
				i++;
				continue;
			}
			const token = str.slice(i + 1, j);
			if (token.length === 0) {
				i++;
				continue;
			}
			let replacement;
			let tier;
			if (this._removeSet.has(token)) {
				replacement = "";
				if (tier === void 0) tier = LIMIT_TIER_EXTERNAL;
			} else if (this._leaveSet.has(token)) {
				i++;
				continue;
			} else if (token.charCodeAt(0) === 35) {
				const ncrResult = this._resolveNCR(token);
				if (ncrResult === void 0) {
					i++;
					continue;
				}
				replacement = ncrResult;
				tier = LIMIT_TIER_BASE;
			} else {
				const resolved = this._resolveName(token);
				replacement = resolved?.value;
				tier = resolved?.tier;
			}
			if (replacement === void 0) {
				i++;
				continue;
			}
			if (i > last) chunks.push(str.slice(last, i));
			chunks.push(replacement);
			last = j + 1;
			i = last;
			if (checkLimits && this._tierCounts(tier)) {
				if (limitExpansions) {
					this._totalExpansions++;
					if (this._totalExpansions > this._maxTotalExpansions) throw new Error(`[EntityReplacer] Entity expansion count limit exceeded: ${this._totalExpansions} > ${this._maxTotalExpansions}`);
				}
				if (limitLength) {
					const delta = replacement.length - (token.length + 2);
					if (delta > 0) {
						this._expandedLength += delta;
						if (this._expandedLength > this._maxExpandedLength) throw new Error(`[EntityReplacer] Expanded content length limit exceeded: ${this._expandedLength} > ${this._maxExpandedLength}`);
					}
				}
			}
		}
		if (last < len) chunks.push(str.slice(last));
		const result = chunks.length === 0 ? str : chunks.join("");
		return this._postCheck(result, original);
	}
	/**
	* Returns true if a resolved entity of the given tier should count
	* against the expansion/length limits.
	* @param {string} tier  — LIMIT_TIER_EXTERNAL | LIMIT_TIER_BASE
	* @returns {boolean}
	*/
	_tierCounts(tier) {
		if (this._limitTiers.has(LIMIT_TIER_ALL)) return true;
		return this._limitTiers.has(tier);
	}
	/**
	* Resolve a named entity token (without & and ;).
	* Priority: inputMap > externalMap > baseMap
	* Returns the resolved value tagged with its limit tier.
	*
	* @param {string} name
	* @returns {{ value: string, tier: string }|undefined}
	*/
	_resolveName(name) {
		if (name in this._inputMap) return {
			value: this._inputMap[name],
			tier: LIMIT_TIER_EXTERNAL
		};
		if (name in this._externalMap) return {
			value: this._externalMap[name],
			tier: LIMIT_TIER_EXTERNAL
		};
		if (name in this._baseMap) return {
			value: this._baseMap[name],
			tier: LIMIT_TIER_BASE
		};
	}
	/**
	* Classify a codepoint and return the minimum action level that must be applied.
	* Returns -1 when no minimum is imposed (normal allow path).
	*
	* Ranges checked (in priority order):
	*   1. U+0000            — null, governed by nullNCR (always ≥ remove)
	*   2. U+D800–U+DFFF     — surrogates, always prohibited (min: remove)
	*   3. U+0001–U+001F \ {0x09,0x0A,0x0D}  — XML 1.0 restricted C0 (min: remove)
	*      (skipped in XML 1.1 — C0 controls are allowed when written as NCRs)
	*
	* @param {number} cp  — codepoint
	* @returns {number}   — minimum NCR_LEVEL value, or -1 for no restriction
	*/
	_classifyNCR(cp) {
		if (cp === 0) return this._ncrNullLevel;
		if (cp >= 55296 && cp <= 57343) return NCR_LEVEL.remove;
		if (this._ncrXmlVersion === 1) {
			if (cp >= 1 && cp <= 31 && !XML10_ALLOWED_C0.has(cp)) return NCR_LEVEL.remove;
		}
		return -1;
	}
	/**
	* Execute a resolved NCR action.
	*
	* @param {number} action   — NCR_LEVEL value
	* @param {string} token    — raw token (e.g. '#38') for error messages
	* @param {number} cp       — codepoint, used only for error messages
	* @returns {string|undefined}
	*   - decoded character string  → 'allow'
	*   - ''                        → 'remove'
	*   - undefined                 → 'leave' (caller must skip past '&' only)
	*   - throws Error              → 'throw'
	*/
	_applyNCRAction(action, token, cp) {
		switch (action) {
			case NCR_LEVEL.allow: return String.fromCodePoint(cp);
			case NCR_LEVEL.remove: return "";
			case NCR_LEVEL.leave: return;
			case NCR_LEVEL.throw: throw new Error(`[EntityDecoder] Prohibited numeric character reference &${token}; (U+${cp.toString(16).toUpperCase().padStart(4, "0")})`);
			default: return String.fromCodePoint(cp);
		}
	}
	/**
	* Full NCR resolution pipeline for a numeric token.
	*
	* Steps:
	*   1. Parse the codepoint (decimal or hex).
	*   2. Validate the raw codepoint range (NaN, <0, >0x10FFFF).
	*   3. If numericAllowed is false and no minimum restriction applies → leave as-is.
	*   4. Classify the codepoint to find the minimum required action level.
	*   5. Resolve effective action = max(onNCR, minimum).
	*   6. Apply and return.
	*
	* @param {string} token  — e.g. '#38', '#x26', '#X26'
	* @returns {string|undefined}
	*   - string (incl. '')  — replacement ('' = remove)
	*   - undefined          — leave original &token; as-is
	*/
	_resolveNCR(token) {
		const second = token.charCodeAt(1);
		let cp;
		if (second === 120 || second === 88) cp = parseInt(token.slice(2), 16);
		else cp = parseInt(token.slice(1), 10);
		if (Number.isNaN(cp) || cp < 0 || cp > 1114111) return void 0;
		const minimum = this._classifyNCR(cp);
		if (!this._numericAllowed && minimum < NCR_LEVEL.remove) return void 0;
		const effective = minimum === -1 ? this._ncrOnLevel : Math.max(this._ncrOnLevel, minimum);
		return this._applyNCRAction(effective, token, cp);
	}
};
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
var defaultOnDangerousProperty = (name) => {
	if (DANGEROUS_PROPERTY_NAMES.includes(name)) return "__" + name;
	return name;
};
var defaultOptions$1 = {
	preserveOrder: false,
	attributeNamePrefix: "@_",
	attributesGroupName: false,
	textNodeName: "#text",
	ignoreAttributes: true,
	removeNSPrefix: false,
	allowBooleanAttributes: false,
	parseTagValue: true,
	parseAttributeValue: false,
	trimValues: true,
	cdataPropName: false,
	numberParseOptions: {
		hex: true,
		leadingZeros: true,
		eNotation: true,
		unicode: false
	},
	tagValueProcessor: function(tagName, val) {
		return val;
	},
	attributeValueProcessor: function(attrName, val) {
		return val;
	},
	stopNodes: [],
	alwaysCreateTextNode: false,
	isArray: () => false,
	commentPropName: false,
	unpairedTags: [],
	processEntities: true,
	htmlEntities: false,
	entityDecoder: null,
	ignoreDeclaration: false,
	ignorePiTags: false,
	transformTagName: false,
	transformAttributeName: false,
	updateTag: function(tagName, jPath, attrs) {
		return tagName;
	},
	captureMetaData: false,
	maxNestedTags: 100,
	strictReservedNames: true,
	jPath: true,
	onDangerousProperty: defaultOnDangerousProperty
};
/**
* Validates that a property name is safe to use
* @param {string} propertyName - The property name to validate
* @param {string} optionName - The option field name (for error message)
* @throws {Error} If property name is dangerous
*/
function validatePropertyName(propertyName, optionName) {
	if (typeof propertyName !== "string") return;
	const normalized = propertyName.toLowerCase();
	if (DANGEROUS_PROPERTY_NAMES.some((dangerous) => normalized === dangerous.toLowerCase())) throw new Error(`[SECURITY] Invalid ${optionName}: "${propertyName}" is a reserved JavaScript keyword that could cause prototype pollution`);
	if (criticalProperties.some((dangerous) => normalized === dangerous.toLowerCase())) throw new Error(`[SECURITY] Invalid ${optionName}: "${propertyName}" is a reserved JavaScript keyword that could cause prototype pollution`);
}
/**
* Normalizes processEntities option for backward compatibility
* @param {boolean|object} value 
* @returns {object} Always returns normalized object
*/
function normalizeProcessEntities(value, htmlEntities) {
	if (typeof value === "boolean") return {
		enabled: value,
		maxEntitySize: 1e4,
		maxExpansionDepth: 1e4,
		maxTotalExpansions: Infinity,
		maxExpandedLength: 1e5,
		maxEntityCount: 1e3,
		allowedTags: null,
		tagFilter: null,
		appliesTo: "all"
	};
	if (typeof value === "object" && value !== null) return {
		enabled: value.enabled !== false,
		maxEntitySize: Math.max(1, value.maxEntitySize ?? 1e4),
		maxExpansionDepth: Math.max(1, value.maxExpansionDepth ?? 1e4),
		maxTotalExpansions: Math.max(1, value.maxTotalExpansions ?? Infinity),
		maxExpandedLength: Math.max(1, value.maxExpandedLength ?? 1e5),
		maxEntityCount: Math.max(1, value.maxEntityCount ?? 1e3),
		allowedTags: value.allowedTags ?? null,
		tagFilter: value.tagFilter ?? null,
		appliesTo: value.appliesTo ?? "all"
	};
	return normalizeProcessEntities(true);
}
var buildOptions = function(options) {
	const built = Object.assign({}, defaultOptions$1, options);
	const propertyNameOptions = [
		{
			value: built.attributeNamePrefix,
			name: "attributeNamePrefix"
		},
		{
			value: built.attributesGroupName,
			name: "attributesGroupName"
		},
		{
			value: built.textNodeName,
			name: "textNodeName"
		},
		{
			value: built.cdataPropName,
			name: "cdataPropName"
		},
		{
			value: built.commentPropName,
			name: "commentPropName"
		}
	];
	for (const { value, name } of propertyNameOptions) if (value) validatePropertyName(value, name);
	if (built.onDangerousProperty === null) built.onDangerousProperty = defaultOnDangerousProperty;
	built.processEntities = normalizeProcessEntities(built.processEntities, built.htmlEntities);
	built.unpairedTagsSet = new Set(built.unpairedTags);
	if (built.stopNodes && Array.isArray(built.stopNodes)) built.stopNodes = built.stopNodes.map((node) => {
		if (typeof node === "string" && node.startsWith("*.")) return ".." + node.substring(2);
		return node;
	});
	return built;
};
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
var METADATA_SYMBOL$1;
if (typeof Symbol !== "function") METADATA_SYMBOL$1 = "@@xmlMetadata";
else METADATA_SYMBOL$1 = Symbol("XML Node Metadata");
var XmlNode = class {
	constructor(tagname) {
		this.tagname = tagname;
		this.child = [];
		this[":@"] = Object.create(null);
	}
	add(key, val) {
		if (key === "__proto__") key = "#__proto__";
		this.child.push({ [key]: val });
	}
	addChild(node, startIndex) {
		if (node.tagname === "__proto__") node.tagname = "#__proto__";
		if (node[":@"] && Object.keys(node[":@"]).length > 0) this.child.push({
			[node.tagname]: node.child,
			[":@"]: node[":@"]
		});
		else this.child.push({ [node.tagname]: node.child });
		if (startIndex !== void 0) this.child[this.child.length - 1][METADATA_SYMBOL$1] = { startIndex };
	}
	/** symbol used for metadata */
	static getMetaDataSymbol() {
		return METADATA_SYMBOL$1;
	}
};
//#endregion
//#region node_modules/.pnpm/xml-naming@0.3.0/node_modules/xml-naming/src/index.js
/**
* xml-naming
* Validates XML Name productions as defined in the XML 1.0 and 1.1 specifications.
* Covers: Name, NCName, QName, NMToken, NMTokens
*
* XML 1.0 spec: https://www.w3.org/TR/xml/#NT-Name
* XML 1.1 spec: https://www.w3.org/TR/xml11/#NT-NameStartChar
* XML NS spec:  https://www.w3.org/TR/xml-names/#NT-NCName
*/
var nameStartChar10 = ":A-Za-z_À-ÖØ-öø-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�";
var nameChar10 = ":A-Za-z_À-ÖØ-öø-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�\\-\\.\\d·̀-ͯ‿-⁀";
var nameStartChar11 = ":A-Za-z_À-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿";
var nameChar11 = ":A-Za-z_À-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿\\-\\.\\d·̀-ͯ҇‿-⁀";
var buildRegexes = (startChar, char, flags = "") => {
	const ncNamePat = `[${startChar.replace(":", "")}][${char.replace(":", "")}]*`;
	return {
		name: new RegExp(`^[${startChar}][${char}]*$`, flags),
		ncName: new RegExp(`^${ncNamePat}$`, flags),
		qName: new RegExp(`^${ncNamePat}(?::${ncNamePat})?$`, flags),
		nmToken: new RegExp(`^[${char}]+$`, flags),
		nmTokens: new RegExp(`^[${char}]+(?:\\s+[${char}]+)*$`, flags)
	};
};
var regexes10 = buildRegexes(nameStartChar10, nameChar10);
var regexes11 = buildRegexes(nameStartChar11, nameChar11, "u");
var regexesAscii = buildRegexes(":A-Za-z_", ":A-Za-z_\\-\\.\\d");
var getRegexes = (xmlVersion = "1.0", asciiOnly = false) => {
	if (asciiOnly) return regexesAscii;
	return xmlVersion === "1.1" ? regexes11 : regexes10;
};
/**
* Returns true if the string is a valid QName (Qualified Name).
* Allows exactly one colon as a prefix separator: prefix:localName.
* Used for: element and attribute names in namespace-aware XML/SVG.
*
* @param {{ xmlVersion?: '1.0'|'1.1', asciiOnly?: boolean }} [opts]
*   asciiOnly: skip unicode-aware matching, ASCII names only (default false).
*/
var qName = (str, { xmlVersion = "1.0", asciiOnly = false } = {}) => getRegexes(xmlVersion, asciiOnly).qName.test(str);
var PRODUCTIONS = [
	"name",
	"ncName",
	"qName",
	"nmToken",
	"nmTokens"
];
/**
* Returns a memoized boolean validator function for a single production,
* with opts fixed at creation time.
*
* @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production
* @param {{ xmlVersion?: '1.0'|'1.1', asciiOnly?: boolean, maxCacheSize?: number }} [opts]
*   maxCacheSize: max number of distinct strings to cache (default 2048).
*   Once reached, new strings are validated but not cached; existing cached
*   entries keep being served.
* @returns {((str: string) => boolean) & { reset: () => void }}
*/
var createValidator = (production, { xmlVersion = "1.0", asciiOnly = false, maxCacheSize = 2048 } = {}) => {
	if (!PRODUCTIONS.includes(production)) throw new TypeError(`Unknown production "${production}". Must be one of: ${PRODUCTIONS.join(", ")}`);
	const regex = getRegexes(xmlVersion, asciiOnly)[production];
	let cache = /* @__PURE__ */ new Map();
	const validator = (str) => {
		const cached = cache.get(str);
		if (cached !== void 0) return cached;
		const result = regex.test(str);
		if (cache.size < maxCacheSize) cache.set(str, result);
		return result;
	};
	validator.reset = () => {
		cache = /* @__PURE__ */ new Map();
	};
	return validator;
};
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
var DocTypeReader = class {
	constructor(options, xmlVersion) {
		this.suppressValidationErr = !options;
		this.options = options;
		this.xmlVersion = xmlVersion || 1;
	}
	setXmlVersion(xmlVersion = 1) {
		this.xmlVersion = xmlVersion;
	}
	readDocType(xmlData, i) {
		const entities = Object.create(null);
		let entityCount = 0;
		if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
			i = i + 9;
			let angleBracketsCount = 1;
			let hasBody = false;
			let comment = false;
			let exp = "";
			for (; i < xmlData.length; i++) if (xmlData[i] === "<" && !comment) {
				if (hasBody && hasSeq(xmlData, "!ENTITY", i)) {
					i += 7;
					let entityName;
					let val;
					[entityName, val, i] = this.readEntityExp(xmlData, i + 1, this.suppressValidationErr);
					if (val.indexOf("&") === -1) {
						if (this.options.enabled !== false && this.options.maxEntityCount != null && entityCount >= this.options.maxEntityCount) throw new Error(`Entity count (${entityCount + 1}) exceeds maximum allowed (${this.options.maxEntityCount})`);
						entities[entityName] = val;
						entityCount++;
					}
				} else if (hasBody && hasSeq(xmlData, "!ELEMENT", i)) {
					i += 8;
					const { index } = this.readElementExp(xmlData, i + 1);
					i = index;
				} else if (hasBody && hasSeq(xmlData, "!ATTLIST", i)) i += 8;
				else if (hasBody && hasSeq(xmlData, "!NOTATION", i)) {
					i += 9;
					const { index } = this.readNotationExp(xmlData, i + 1, this.suppressValidationErr);
					i = index;
				} else if (hasSeq(xmlData, "!--", i)) comment = true;
				else throw new Error(`Invalid DOCTYPE`);
				angleBracketsCount++;
				exp = "";
			} else if (xmlData[i] === ">") {
				if (comment) {
					if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
						comment = false;
						angleBracketsCount--;
					}
				} else angleBracketsCount--;
				if (angleBracketsCount === 0) break;
			} else if (xmlData[i] === "[") hasBody = true;
			else exp += xmlData[i];
			if (angleBracketsCount !== 0) throw new Error(`Unclosed DOCTYPE`);
		} else throw new Error(`Invalid Tag instead of DOCTYPE`);
		return {
			entities,
			i
		};
	}
	readEntityExp(xmlData, i) {
		i = skipWhitespace(xmlData, i);
		const startIndex = i;
		while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== "\"" && xmlData[i] !== "'") i++;
		let entityName = xmlData.substring(startIndex, i);
		validateEntityName(entityName, { xmlVersion: this.xmlVersion });
		i = skipWhitespace(xmlData, i);
		if (!this.suppressValidationErr) {
			if (xmlData.substring(i, i + 6).toUpperCase() === "SYSTEM") throw new Error("External entities are not supported");
			else if (xmlData[i] === "%") throw new Error("Parameter entities are not supported");
		}
		let entityValue = "";
		[i, entityValue] = this.readIdentifierVal(xmlData, i, "entity");
		if (this.options.enabled !== false && this.options.maxEntitySize != null && entityValue.length > this.options.maxEntitySize) throw new Error(`Entity "${entityName}" size (${entityValue.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`);
		i--;
		return [
			entityName,
			entityValue,
			i
		];
	}
	readNotationExp(xmlData, i) {
		i = skipWhitespace(xmlData, i);
		const startIndex = i;
		while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
		let notationName = xmlData.substring(startIndex, i);
		!this.suppressValidationErr && validateEntityName(notationName, { xmlVersion: this.xmlVersion });
		i = skipWhitespace(xmlData, i);
		const identifierType = xmlData.substring(i, i + 6).toUpperCase();
		if (!this.suppressValidationErr && identifierType !== "SYSTEM" && identifierType !== "PUBLIC") throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
		i += identifierType.length;
		i = skipWhitespace(xmlData, i);
		let publicIdentifier = null;
		let systemIdentifier = null;
		if (identifierType === "PUBLIC") {
			[i, publicIdentifier] = this.readIdentifierVal(xmlData, i, "publicIdentifier");
			i = skipWhitespace(xmlData, i);
			if (xmlData[i] === "\"" || xmlData[i] === "'") [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, "systemIdentifier");
		} else if (identifierType === "SYSTEM") {
			[i, systemIdentifier] = this.readIdentifierVal(xmlData, i, "systemIdentifier");
			if (!this.suppressValidationErr && !systemIdentifier) throw new Error("Missing mandatory system identifier for SYSTEM notation");
		}
		return {
			notationName,
			publicIdentifier,
			systemIdentifier,
			index: --i
		};
	}
	readIdentifierVal(xmlData, i, type) {
		let identifierVal = "";
		const startChar = xmlData[i];
		if (startChar !== "\"" && startChar !== "'") throw new Error(`Expected quoted string, found "${startChar}"`);
		i++;
		const startIndex = i;
		while (i < xmlData.length && xmlData[i] !== startChar) i++;
		identifierVal = xmlData.substring(startIndex, i);
		if (xmlData[i] !== startChar) throw new Error(`Unterminated ${type} value`);
		i++;
		return [i, identifierVal];
	}
	readElementExp(xmlData, i) {
		i = skipWhitespace(xmlData, i);
		const startIndex = i;
		while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
		let elementName = xmlData.substring(startIndex, i);
		if (!this.suppressValidationErr && !qName(elementName, { xmlVersion: this.xmlVersion })) throw new Error(`Invalid element name: "${elementName}"`);
		i = skipWhitespace(xmlData, i);
		let contentModel = "";
		if (xmlData[i] === "E" && hasSeq(xmlData, "MPTY", i)) i += 4;
		else if (xmlData[i] === "A" && hasSeq(xmlData, "NY", i)) i += 2;
		else if (xmlData[i] === "(") {
			i++;
			const startIndex = i;
			while (i < xmlData.length && xmlData[i] !== ")") i++;
			contentModel = xmlData.substring(startIndex, i);
			if (xmlData[i] !== ")") throw new Error("Unterminated content model");
		} else if (!this.suppressValidationErr) throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
		return {
			elementName,
			contentModel: contentModel.trim(),
			index: i
		};
	}
	readAttlistExp(xmlData, i) {
		i = skipWhitespace(xmlData, i);
		let startIndex = i;
		while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
		let elementName = xmlData.substring(startIndex, i);
		validateEntityName(elementName, { xmlVersion: this.xmlVersion });
		i = skipWhitespace(xmlData, i);
		startIndex = i;
		while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
		let attributeName = xmlData.substring(startIndex, i);
		if (!validateEntityName(attributeName, { xmlVersion: this.xmlVersion })) throw new Error(`Invalid attribute name: "${attributeName}"`);
		i = skipWhitespace(xmlData, i);
		let attributeType = "";
		if (xmlData.substring(i, i + 8).toUpperCase() === "NOTATION") {
			attributeType = "NOTATION";
			i += 8;
			i = skipWhitespace(xmlData, i);
			if (xmlData[i] !== "(") throw new Error(`Expected '(', found "${xmlData[i]}"`);
			i++;
			let allowedNotations = [];
			while (i < xmlData.length && xmlData[i] !== ")") {
				const startIndex = i;
				while (i < xmlData.length && xmlData[i] !== "|" && xmlData[i] !== ")") i++;
				let notation = xmlData.substring(startIndex, i);
				notation = notation.trim();
				if (!validateEntityName(notation, { xmlVersion: this.xmlVersion })) throw new Error(`Invalid notation name: "${notation}"`);
				allowedNotations.push(notation);
				if (xmlData[i] === "|") {
					i++;
					i = skipWhitespace(xmlData, i);
				}
			}
			if (xmlData[i] !== ")") throw new Error("Unterminated list of notations");
			i++;
			attributeType += " (" + allowedNotations.join("|") + ")";
		} else {
			const startIndex = i;
			while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
			attributeType += xmlData.substring(startIndex, i);
			if (!this.suppressValidationErr && ![
				"CDATA",
				"ID",
				"IDREF",
				"IDREFS",
				"ENTITY",
				"ENTITIES",
				"NMTOKEN",
				"NMTOKENS"
			].includes(attributeType.toUpperCase())) throw new Error(`Invalid attribute type: "${attributeType}"`);
		}
		i = skipWhitespace(xmlData, i);
		let defaultValue = "";
		if (xmlData.substring(i, i + 8).toUpperCase() === "#REQUIRED") {
			defaultValue = "#REQUIRED";
			i += 8;
		} else if (xmlData.substring(i, i + 7).toUpperCase() === "#IMPLIED") {
			defaultValue = "#IMPLIED";
			i += 7;
		} else [i, defaultValue] = this.readIdentifierVal(xmlData, i, "ATTLIST");
		return {
			elementName,
			attributeName,
			attributeType,
			defaultValue,
			index: i
		};
	}
};
var skipWhitespace = (data, index) => {
	while (index < data.length && /\s/.test(data[index])) index++;
	return index;
};
function hasSeq(data, seq, i) {
	for (let j = 0; j < seq.length; j++) if (seq[j] !== data[i + j + 1]) return false;
	return true;
}
function validateEntityName(name, xmlVersion) {
	if (qName(name, { xmlVersion })) return name;
	else throw new Error(`Invalid entity name ${name}`);
}
//#endregion
//#region node_modules/.pnpm/anynum@1.0.1/node_modules/anynum/digitTable.js
/**
* Flat lookup table: maps Unicode code point → ASCII digit (0-9).
* Only decimal digit characters (Unicode category Nd) are included.
*
* Strategy: Int32Array of size (maxCodePoint - minCodePoint + 1).
* Value 0xFF means "not a digit". Value 0-9 is the ASCII digit value.
* This gives O(1) lookup with no branching, no bisect, no loop.
*
* Memory: range is 0x0660 to 0x1FBF0 → ~129,936 entries × 1 byte = ~127 KB.
* Acceptable for a one-time init; lookup is a single array index.
*/
var SCRIPT_ZEROS = [
	48,
	1632,
	1776,
	2406,
	2534,
	2662,
	2790,
	2918,
	3046,
	3174,
	3302,
	3430,
	3558,
	3664,
	3792,
	3872,
	4160,
	4240,
	6112,
	6160,
	6470,
	6608,
	6784,
	6800,
	6992,
	7088,
	7232,
	7248,
	65296,
	120782,
	120792,
	120802,
	120812,
	120822,
	66720,
	68912,
	69734,
	69872,
	69942,
	70096,
	70384,
	70736,
	70864,
	71248,
	71360,
	71472,
	71904,
	72016,
	72688,
	72784,
	73040,
	73120,
	73552,
	92768,
	92864,
	93008,
	123200,
	123632,
	124144,
	125264,
	130032
];
var HIGH_MAP = /* @__PURE__ */ new Map();
var LOW_MAX = 65535;
var TABLE_OFFSET = 1632;
var TABLE = (/* @__PURE__ */ new Uint8Array(63904)).fill(255);
for (const zero of SCRIPT_ZEROS) for (let d = 0; d < 10; d++) {
	const cp = zero + d;
	if (cp <= LOW_MAX) TABLE[cp - TABLE_OFFSET] = d;
	else HIGH_MAP.set(cp, d);
}
//#endregion
//#region node_modules/.pnpm/anynum@1.0.1/node_modules/anynum/anynum.js
var CHAR_0 = 48;
var CHAR_9 = 57;
var CHAR_MINUS = 45;
var MINUS_SET = /* @__PURE__ */ new Set([
	8722,
	65293,
	65123
]);
/**
* Normalize all Unicode decimal digit characters in a string to ASCII (0-9),
* and normalize Unicode minus variants to ASCII '-' (U+002D).
*
* Non-digit, non-minus characters are passed through unchanged.
*
* Performance design:
* - Fast path: if the string has no convertible characters, return it unchanged
*   (zero allocation).
* - BMP digits (0x0660..0xFFFF excl. surrogates): flat Uint8Array lookup (O(1)).
* - Supplementary plane digits (> 0xFFFF, encoded as surrogate pairs): Map lookup.
* - Minus variants: checked inline with a small fixed Set.
*
* @param {string} str
* @returns {string}
*/
function anynum(str) {
	if (typeof str !== "string") return str;
	const len = str.length;
	if (len === 0) return str;
	let firstHit = -1;
	for (let i = 0; i < len; i++) {
		const cc = str.charCodeAt(i);
		if (cc >= CHAR_0 && cc <= CHAR_9 || cc === CHAR_MINUS) continue;
		if (cc < 1632) {
			if (MINUS_SET.has(cc)) {
				firstHit = i;
				break;
			}
			continue;
		}
		if (cc >= 55296 && cc <= 56319) {
			if (i + 1 < len) {
				const low = str.charCodeAt(i + 1);
				if (low >= 56320 && low <= 57343) {
					const cp = 65536 + (cc - 55296 << 10) + (low - 56320);
					if (HIGH_MAP.has(cp)) {
						firstHit = i;
						break;
					}
				}
			}
			continue;
		}
		if (TABLE[cc - 1632] !== 255 || MINUS_SET.has(cc)) {
			firstHit = i;
			break;
		}
	}
	if (firstHit === -1) return str;
	const chars = [];
	if (firstHit > 0) chars.push(str.slice(0, firstHit));
	for (let i = firstHit; i < len; i++) {
		const cc = str.charCodeAt(i);
		if (cc >= CHAR_0 && cc <= CHAR_9 || cc === CHAR_MINUS) {
			chars.push(str[i]);
			continue;
		}
		if (cc < 1632) {
			chars.push(MINUS_SET.has(cc) ? "-" : str[i]);
			continue;
		}
		if (cc >= 55296 && cc <= 56319) {
			if (i + 1 < len) {
				const low = str.charCodeAt(i + 1);
				if (low >= 56320 && low <= 57343) {
					const cp = 65536 + (cc - 55296 << 10) + (low - 56320);
					const d = HIGH_MAP.get(cp);
					if (d !== void 0) {
						chars.push(String.fromCharCode(d + 48));
						i++;
						continue;
					}
				}
			}
			chars.push(str[i]);
			continue;
		}
		if (MINUS_SET.has(cc)) {
			chars.push("-");
			continue;
		}
		const d = TABLE[cc - TABLE_OFFSET];
		chars.push(d !== 255 ? String.fromCharCode(d + 48) : str[i]);
	}
	return chars.join("");
}
//#endregion
//#region node_modules/.pnpm/strnum@2.4.1/node_modules/strnum/strnum.js
var hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
var binRegex = /^0b[01]+$/;
var octRegex = /^0o[0-7]+$/;
var numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
var consider = {
	hex: true,
	binary: false,
	octal: false,
	leadingZeros: true,
	decimalPoint: ".",
	eNotation: true,
	infinity: "original",
	unicode: false
};
function toNumber(str, options = {}) {
	options = Object.assign({}, consider, options);
	if (!str || typeof str !== "string") return str;
	let trimmedStr = str.trim();
	if (trimmedStr.length === 0) return str;
	else if (options.skipLike !== void 0 && options.skipLike.test(trimmedStr)) return str;
	else if (trimmedStr === "0") return 0;
	if (options.unicode) {
		trimmedStr = anynum(trimmedStr);
		if (trimmedStr === "0") return 0;
	}
	if (options.hex && hexRegex.test(trimmedStr)) return parse_int(trimmedStr, 16);
	else if (options.binary && binRegex.test(trimmedStr)) return parse_int(trimmedStr, 2);
	else if (options.octal && octRegex.test(trimmedStr)) return parse_int(trimmedStr, 8);
	else if (!isFinite(trimmedStr)) return handleInfinity(str, Number(trimmedStr), options);
	else if (trimmedStr.includes("e") || trimmedStr.includes("E")) return resolveEnotation(str, trimmedStr, options);
	else {
		const match = numRegex.exec(trimmedStr);
		if (match) {
			const sign = match[1] || "";
			const leadingZeros = match[2];
			let numTrimmedByZeros = trimZeros(match[3]);
			const decimalAdjacentToLeadingZeros = sign ? str[leadingZeros.length + 1] === "." : str[leadingZeros.length] === ".";
			if (!options.leadingZeros && (leadingZeros.length > 1 || leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros)) return str;
			else {
				const num = Number(trimmedStr);
				const parsedStr = String(num);
				if (num === 0) return num;
				if (parsedStr.search(/[eE]/) !== -1) {
					if (options.eNotation) return num;
					else return str;
				} else if (trimmedStr.indexOf(".") !== -1) {
					if (parsedStr === "0") return num;
					else if (parsedStr === numTrimmedByZeros) return num;
					else if (parsedStr === `${sign}${numTrimmedByZeros}`) return num;
					else return str;
				}
				let n = leadingZeros ? numTrimmedByZeros : trimmedStr;
				if (leadingZeros) return n === parsedStr || sign + n === parsedStr ? num : str;
				else return n === parsedStr || n === sign + parsedStr ? num : str;
			}
		} else return str;
	}
}
var eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
function resolveEnotation(str, trimmedStr, options) {
	if (!options.eNotation) return str;
	const notation = trimmedStr.match(eNotationRegx);
	if (notation) {
		let sign = notation[1] || "";
		const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";
		const leadingZeros = notation[2];
		const eAdjacentToLeadingZeros = sign ? str[leadingZeros.length + 1] === eChar : str[leadingZeros.length] === eChar;
		if (leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;
		else if (leadingZeros.length === 1 && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) return Number(trimmedStr);
		else if (leadingZeros.length > 0) {
			if (options.leadingZeros && !eAdjacentToLeadingZeros) {
				trimmedStr = (notation[1] || "") + notation[3];
				return Number(trimmedStr);
			} else return str;
		} else return Number(trimmedStr);
	} else return str;
}
/**
* 
* @param {string} numStr without leading zeros
* @returns 
*/
function trimZeros(numStr) {
	if (numStr && numStr.indexOf(".") !== -1) {
		numStr = numStr.replace(/0+$/, "");
		if (numStr === ".") numStr = "0";
		else if (numStr[0] === ".") numStr = "0" + numStr;
		else if (numStr[numStr.length - 1] === ".") numStr = numStr.substring(0, numStr.length - 1);
		return numStr;
	}
	return numStr;
}
function parse_int(numStr, base) {
	const str = numStr.trim();
	if (base === 2 || base === 8) numStr = str.substring(2);
	if (parseInt) return parseInt(numStr, base);
	else if (Number.parseInt) return Number.parseInt(numStr, base);
	else if (window && window.parseInt) return window.parseInt(numStr, base);
	else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
}
/**
* Handle infinite values based on user option
* @param {string} str - original input string
* @param {number} num - parsed number (Infinity or -Infinity)
* @param {object} options - user options
* @returns {string|number|null} based on infinity option
*/
function handleInfinity(str, num, options) {
	const isPositive = num === Infinity;
	switch (options.infinity.toLowerCase()) {
		case "null": return null;
		case "infinity": return num;
		case "string": return isPositive ? "Infinity" : "-Infinity";
		default: return str;
	}
}
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/ignoreAttributes.js
function getIgnoreAttributesFn$1(ignoreAttributes) {
	if (typeof ignoreAttributes === "function") return ignoreAttributes;
	if (Array.isArray(ignoreAttributes)) return (attrName) => {
		for (const pattern of ignoreAttributes) {
			if (typeof pattern === "string" && attrName === pattern) return true;
			if (pattern instanceof RegExp && pattern.test(attrName)) return true;
		}
	};
	return () => false;
}
__name(getIgnoreAttributesFn$1, "getIgnoreAttributesFn");
//#endregion
//#region node_modules/.pnpm/path-expression-matcher@1.6.2/node_modules/path-expression-matcher/src/Expression.js
/**
* Expression - Parses and stores a tag pattern expression
* 
* Patterns are parsed once and stored in an optimized structure for fast matching.
* 
* @example
* const expr = new Expression("root.users.user");
* const expr2 = new Expression("..user[id]:first");
* const expr3 = new Expression("root/users/user", { separator: '/' });
*/
var Expression = class {
	/**
	* Create a new Expression
	* @param {string} pattern - Pattern string (e.g., "root.users.user", "..user[id]")
	* @param {Object} options - Configuration options
	* @param {string} options.separator - Path separator (default: '.')
	*/
	constructor(pattern, options = {}, data) {
		this.pattern = pattern;
		this.separator = options.separator || ".";
		this.segments = this._parse(pattern);
		this.data = data;
		this._hasDeepWildcard = this.segments.some((seg) => seg.type === "deep-wildcard");
		this._hasAttributeCondition = this.segments.some((seg) => seg.attrName !== void 0);
		this._hasPositionSelector = this.segments.some((seg) => seg.position !== void 0);
	}
	/**
	* Parse pattern string into segments
	* @private
	* @param {string} pattern - Pattern to parse
	* @returns {Array} Array of segment objects
	*/
	_parse(pattern) {
		const segments = [];
		let i = 0;
		let currentPart = "";
		while (i < pattern.length) if (pattern[i] === this.separator) {
			if (i + 1 < pattern.length && pattern[i + 1] === this.separator) {
				if (currentPart.trim()) {
					segments.push(this._parseSegment(currentPart.trim()));
					currentPart = "";
				}
				segments.push({ type: "deep-wildcard" });
				i += 2;
			} else {
				if (currentPart.trim()) segments.push(this._parseSegment(currentPart.trim()));
				currentPart = "";
				i++;
			}
		} else {
			currentPart += pattern[i];
			i++;
		}
		if (currentPart.trim()) segments.push(this._parseSegment(currentPart.trim()));
		return segments;
	}
	/**
	* Parse a single segment
	* @private
	* @param {string} part - Segment string (e.g., "user", "ns::user", "user[id]", "ns::user:first")
	* @returns {Object} Segment object
	*/
	_parseSegment(part) {
		const segment = { type: "tag" };
		let bracketContent = null;
		let withoutBrackets = part;
		const bracketMatch = part.match(/^([^\[]+)(\[[^\]]*\])(.*)$/);
		if (bracketMatch) {
			withoutBrackets = bracketMatch[1] + bracketMatch[3];
			if (bracketMatch[2]) {
				const content = bracketMatch[2].slice(1, -1);
				if (content) bracketContent = content;
			}
		}
		let namespace = void 0;
		let tagAndPosition = withoutBrackets;
		if (withoutBrackets.includes("::")) {
			const nsIndex = withoutBrackets.indexOf("::");
			namespace = withoutBrackets.substring(0, nsIndex).trim();
			tagAndPosition = withoutBrackets.substring(nsIndex + 2).trim();
			if (!namespace) throw new Error(`Invalid namespace in pattern: ${part}`);
		}
		let tag = void 0;
		let positionMatch = null;
		if (tagAndPosition.includes(":")) {
			const colonIndex = tagAndPosition.lastIndexOf(":");
			const tagPart = tagAndPosition.substring(0, colonIndex).trim();
			const posPart = tagAndPosition.substring(colonIndex + 1).trim();
			if ([
				"first",
				"last",
				"odd",
				"even"
			].includes(posPart) || /^nth\(\d+\)$/.test(posPart)) {
				tag = tagPart;
				positionMatch = posPart;
			} else tag = tagAndPosition;
		} else tag = tagAndPosition;
		if (!tag) throw new Error(`Invalid segment pattern: ${part}`);
		segment.tag = tag;
		if (namespace) segment.namespace = namespace;
		if (bracketContent) {
			if (bracketContent.includes("=")) {
				const eqIndex = bracketContent.indexOf("=");
				segment.attrName = bracketContent.substring(0, eqIndex).trim();
				segment.attrValue = bracketContent.substring(eqIndex + 1).trim();
			} else segment.attrName = bracketContent.trim();
		}
		if (positionMatch) {
			const nthMatch = positionMatch.match(/^nth\((\d+)\)$/);
			if (nthMatch) {
				segment.position = "nth";
				segment.positionValue = parseInt(nthMatch[1], 10);
			} else segment.position = positionMatch;
		}
		return segment;
	}
	/**
	* Get the number of segments
	* @returns {number}
	*/
	get length() {
		return this.segments.length;
	}
	/**
	* Check if expression contains deep wildcard
	* @returns {boolean}
	*/
	hasDeepWildcard() {
		return this._hasDeepWildcard;
	}
	/**
	* Check if expression has attribute conditions
	* @returns {boolean}
	*/
	hasAttributeCondition() {
		return this._hasAttributeCondition;
	}
	/**
	* Check if expression has position selectors
	* @returns {boolean}
	*/
	hasPositionSelector() {
		return this._hasPositionSelector;
	}
	/**
	* Get string representation
	* @returns {string}
	*/
	toString() {
		return this.pattern;
	}
};
//#endregion
//#region node_modules/.pnpm/path-expression-matcher@1.6.2/node_modules/path-expression-matcher/src/ExpressionSet.js
/**
* ExpressionSet - An indexed collection of Expressions for efficient bulk matching
*
* Instead of iterating all expressions on every tag, ExpressionSet pre-indexes
* them at insertion time by depth and terminal tag name. At match time, only
* the relevant bucket is evaluated — typically reducing checks from O(E) to O(1)
* lookup plus O(small bucket) matches.
*
* Three buckets are maintained:
*  - `_byDepthAndTag`  — exact depth + exact tag name  (tightest, used first)
*  - `_wildcardByDepth` — exact depth + wildcard tag `*` (depth-matched only)
*  - `_deepWildcards`  — expressions containing `..`  (cannot be depth-indexed)
*
* @example
* import { Expression, ExpressionSet } from 'fast-xml-tagger';
*
* // Build once at config time
* const stopNodes = new ExpressionSet();
* stopNodes.add(new Expression('root.users.user'));
* stopNodes.add(new Expression('root.config.setting'));
* stopNodes.add(new Expression('..script'));
*
* // Query on every tag — hot path
* if (stopNodes.matchesAny(matcher)) { ... }
*/
var ExpressionSet = class {
	constructor() {
		/** @type {Map<string, import('./Expression.js').default[]>} depth:tag → expressions */
		this._byDepthAndTag = /* @__PURE__ */ new Map();
		/** @type {Map<number, import('./Expression.js').default[]>} depth → wildcard-tag expressions */
		this._wildcardByDepth = /* @__PURE__ */ new Map();
		/** @type {import('./Expression.js').default[]} expressions containing deep wildcard (..) */
		this._deepWildcards = [];
		/** @type {Map<string, import('./Expression.js').default[]>} terminalTag → deep wildcard expressions */
		this._deepByTerminalTag = /* @__PURE__ */ new Map();
		/** @type {Set<string>} pattern strings already added — used for deduplication */
		this._patterns = /* @__PURE__ */ new Set();
		/** @type {boolean} whether the set is sealed against further additions */
		this._sealed = false;
	}
	/**
	* Add an Expression to the set.
	* Duplicate patterns (same pattern string) are silently ignored.
	*
	* @param {import('./Expression.js').default} expression - A pre-constructed Expression instance
	* @returns {this} for chaining
	* @throws {TypeError} if called after seal()
	*
	* @example
	* set.add(new Expression('root.users.user'));
	* set.add(new Expression('..script'));
	*/
	add(expression) {
		if (this._sealed) throw new TypeError("ExpressionSet is sealed. Create a new ExpressionSet to add more expressions.");
		if (this._patterns.has(expression.pattern)) return this;
		this._patterns.add(expression.pattern);
		if (expression.hasDeepWildcard()) {
			const lastSeg = expression.segments[expression.segments.length - 1];
			if (lastSeg && lastSeg.type !== "deep-wildcard" && lastSeg.tag !== "*") {
				const tag = lastSeg.tag;
				if (!this._deepByTerminalTag.has(tag)) this._deepByTerminalTag.set(tag, []);
				this._deepByTerminalTag.get(tag).push(expression);
			} else this._deepWildcards.push(expression);
			return this;
		}
		const depth = expression.length;
		const tag = expression.segments[expression.segments.length - 1]?.tag;
		if (!tag || tag === "*") {
			if (!this._wildcardByDepth.has(depth)) this._wildcardByDepth.set(depth, []);
			this._wildcardByDepth.get(depth).push(expression);
		} else {
			const key = `${depth}:${tag}`;
			if (!this._byDepthAndTag.has(key)) this._byDepthAndTag.set(key, []);
			this._byDepthAndTag.get(key).push(expression);
		}
		return this;
	}
	/**
	* Add multiple expressions at once.
	*
	* @param {import('./Expression.js').default[]} expressions - Array of Expression instances
	* @returns {this} for chaining
	*
	* @example
	* set.addAll([
	*   new Expression('root.users.user'),
	*   new Expression('root.config.setting'),
	* ]);
	*/
	addAll(expressions) {
		for (const expr of expressions) this.add(expr);
		return this;
	}
	/**
	* Check whether a pattern string is already present in the set.
	*
	* @param {import('./Expression.js').default} expression
	* @returns {boolean}
	*/
	has(expression) {
		return this._patterns.has(expression.pattern);
	}
	/**
	* Number of expressions in the set.
	* @type {number}
	*/
	get size() {
		return this._patterns.size;
	}
	/**
	* Seal the set against further modifications.
	* Useful to prevent accidental mutations after config is built.
	* Calling add() or addAll() on a sealed set throws a TypeError.
	*
	* @returns {this}
	*/
	seal() {
		this._sealed = true;
		return this;
	}
	/**
	* Whether the set has been sealed.
	* @type {boolean}
	*/
	get isSealed() {
		return this._sealed;
	}
	/**
	* Test whether the matcher's current path matches any expression in the set.
	*
	* Evaluation order (cheapest → most expensive):
	*  1. Exact depth + tag bucket  — O(1) lookup, typically 0–2 expressions
	*  2. Depth-only wildcard bucket — O(1) lookup, rare
	*  3. Deep-wildcard list         — always checked, but usually small
	*
	* @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)
	* @returns {boolean} true if any expression matches the current path
	*
	* @example
	* if (stopNodes.matchesAny(matcher)) {
	*   // handle stop node
	* }
	*/
	matchesAny(matcher) {
		return this.findMatch(matcher) !== null;
	}
	/**
	* Find and return the first Expression that matches the matcher's current path.
	*
	* Uses the same evaluation order as matchesAny (cheapest → most expensive):
	*  1. Exact depth + tag bucket
	*  2. Depth-only wildcard bucket
	*  3. Deep-wildcard list
	*
	* @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)
	* @returns {import('./Expression.js').default | null} the first matching Expression, or null
	*
	* @example
	* const expr = stopNodes.findMatch(matcher);
	* if (expr) {
	*   // access expr.config, expr.pattern, etc.
	* }
	*/
	findMatch(matcher) {
		const depth = matcher.getDepth();
		const tag = matcher.getCurrentTag();
		const exactKey = `${depth}:${tag}`;
		const exactBucket = this._byDepthAndTag.get(exactKey);
		if (exactBucket) {
			for (let i = 0; i < exactBucket.length; i++) if (matcher.matches(exactBucket[i])) return exactBucket[i];
		}
		const wildcardBucket = this._wildcardByDepth.get(depth);
		if (wildcardBucket) {
			for (let i = 0; i < wildcardBucket.length; i++) if (matcher.matches(wildcardBucket[i])) return wildcardBucket[i];
		}
		const deepBucket = this._deepByTerminalTag.get(tag);
		if (deepBucket) {
			for (let i = 0; i < deepBucket.length; i++) if (matcher.matches(deepBucket[i])) return deepBucket[i];
		}
		for (let i = 0; i < this._deepWildcards.length; i++) if (matcher.matches(this._deepWildcards[i])) return this._deepWildcards[i];
		return null;
	}
};
//#endregion
//#region node_modules/.pnpm/path-expression-matcher@1.6.2/node_modules/path-expression-matcher/src/Matcher.js
/**
* MatcherView - A lightweight read-only view over a Matcher's internal state.
*
* Created once by Matcher and reused across all callbacks. Holds a direct
* reference to the parent Matcher so it always reflects current parser state
* with zero copying or freezing overhead.
*
* Users receive this via {@link Matcher#readOnly} or directly from parser
* callbacks. It exposes all query and matching methods but has no mutation
* methods — misuse is caught at the TypeScript level rather than at runtime.
*
* @example
* const matcher = new Matcher();
* const view = matcher.readOnly();
*
* matcher.push("root", {});
* view.getCurrentTag(); // "root"
* view.getDepth();      // 1
*/
var MatcherView = class {
	/**
	* @param {Matcher} matcher - The parent Matcher instance to read from.
	*/
	constructor(matcher) {
		this._matcher = matcher;
	}
	/**
	* Get the path separator used by the parent matcher.
	* @returns {string}
	*/
	get separator() {
		return this._matcher.separator;
	}
	/**
	* Get current tag name.
	* @returns {string|undefined}
	*/
	getCurrentTag() {
		const path = this._matcher.path;
		return path.length > 0 ? path[path.length - 1].tag : void 0;
	}
	/**
	* Get current namespace.
	* @returns {string|undefined}
	*/
	getCurrentNamespace() {
		const path = this._matcher.path;
		return path.length > 0 ? path[path.length - 1].namespace : void 0;
	}
	/**
	* Get current node's attribute value.
	* @param {string} attrName
	* @returns {*}
	*/
	getAttrValue(attrName) {
		const path = this._matcher.path;
		if (path.length === 0) return void 0;
		return path[path.length - 1].values?.[attrName];
	}
	/**
	* Check if current node has an attribute.
	* @param {string} attrName
	* @returns {boolean}
	*/
	hasAttr(attrName) {
		const path = this._matcher.path;
		if (path.length === 0) return false;
		const current = path[path.length - 1];
		return current.values !== void 0 && attrName in current.values;
	}
	/**
	* Get the value of a "kept" attribute from the nearest ancestor (or
	* current node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
	* @param {string} attrName
	* @returns {*}
	*/
	getAnyParentAttr(attrName) {
		return this._matcher.getAnyParentAttr(attrName);
	}
	/**
	* Check whether any ancestor (or the current node) kept the given
	* attribute via `push(tag, attrs, ns, { keep: [...] })`.
	* @param {string} attrName
	* @returns {boolean}
	*/
	hasAnyParentAttr(attrName) {
		return this._matcher.hasAnyParentAttr(attrName);
	}
	/**
	* Get current node's sibling position (child index in parent).
	* @returns {number}
	*/
	getPosition() {
		const path = this._matcher.path;
		if (path.length === 0) return -1;
		return path[path.length - 1].position ?? 0;
	}
	/**
	* Get current node's repeat counter (occurrence count of this tag name).
	* @returns {number}
	*/
	getCounter() {
		const path = this._matcher.path;
		if (path.length === 0) return -1;
		return path[path.length - 1].counter ?? 0;
	}
	/**
	* Get current node's sibling index (alias for getPosition).
	* @returns {number}
	* @deprecated Use getPosition() or getCounter() instead
	*/
	getIndex() {
		return this.getPosition();
	}
	/**
	* Get current path depth.
	* @returns {number}
	*/
	getDepth() {
		return this._matcher.path.length;
	}
	/**
	* Get path as string.
	* @param {string} [separator] - Optional separator (uses default if not provided)
	* @param {boolean} [includeNamespace=true]
	* @returns {string}
	*/
	toString(separator, includeNamespace = true) {
		return this._matcher.toString(separator, includeNamespace);
	}
	/**
	* Get path as array of tag names.
	* @returns {string[]}
	*/
	toArray() {
		return this._matcher.path.map((n) => n.tag);
	}
	/**
	* Match current path against an Expression.
	* @param {Expression} expression
	* @returns {boolean}
	*/
	matches(expression) {
		return this._matcher.matches(expression);
	}
	/**
	* Match any expression in the given set against the current path.
	* @param {ExpressionSet} exprSet
	* @returns {boolean}
	*/
	matchesAny(exprSet) {
		return exprSet.matchesAny(this._matcher);
	}
};
/**
* Matcher - Tracks current path in XML/JSON tree and matches against Expressions.
*
* The matcher maintains a stack of nodes representing the current path from root to
* current tag. It only stores attribute values for the current (top) node to minimize
* memory usage. Sibling tracking is used to auto-calculate position and counter.
*
* Use {@link Matcher#readOnly} to obtain a {@link MatcherView} safe to pass to
* user callbacks — it always reflects current state with no Proxy overhead.
*
* @example
* const matcher = new Matcher();
* matcher.push("root", {});
* matcher.push("users", {});
* matcher.push("user", { id: "123", type: "admin" });
*
* const expr = new Expression("root.users.user");
* matcher.matches(expr); // true
*/
var Matcher = class {
	/**
	* Create a new Matcher.
	* @param {Object} [options={}]
	* @param {string} [options.separator='.'] - Default path separator
	*/
	constructor(options = {}) {
		this.separator = options.separator || ".";
		this.path = [];
		this.siblingStacks = [];
		this._pathStringCache = null;
		this._view = new MatcherView(this);
		this._keptAttrs = [];
	}
	/**
	* Push a new tag onto the path.
	* @param {string} tagName
	* @param {Object|null} [attrValues=null]
	* @param {string|null} [namespace=null]
	* @param {Object|null} [options=null]
	* @param {string[]} [options.keep] - Names of attributes (from attrValues)
	*/
	push(tagName, attrValues = null, namespace = null, options = null) {
		this._pathStringCache = null;
		if (this.path.length > 0) this.path[this.path.length - 1].values = void 0;
		const currentLevel = this.path.length;
		let level = this.siblingStacks[currentLevel];
		if (!level) {
			level = {
				counts: /* @__PURE__ */ new Map(),
				total: 0
			};
			this.siblingStacks[currentLevel] = level;
		}
		const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;
		const counter = level.counts.get(siblingKey) || 0;
		const position = level.total;
		level.counts.set(siblingKey, counter + 1);
		level.total++;
		const node = {
			tag: tagName,
			position,
			counter
		};
		if (namespace !== null && namespace !== void 0) node.namespace = namespace;
		if (attrValues !== null && attrValues !== void 0) node.values = attrValues;
		this.path.push(node);
		const depth = this.path.length;
		const keep = options !== null ? options.keep : null;
		if (keep !== null && keep !== void 0 && keep.length > 0 && attrValues) for (let i = 0; i < keep.length; i++) {
			const name = keep[i];
			if (attrValues[name] !== void 0) this._keptAttrs.push({
				depth,
				name,
				value: attrValues[name]
			});
		}
	}
	/**
	* Pop the last tag from the path.
	* @returns {Object|undefined} The popped node
	*/
	pop() {
		if (this.path.length === 0) return void 0;
		this._pathStringCache = null;
		const node = this.path.pop();
		if (this.siblingStacks.length > this.path.length + 1) this.siblingStacks.length = this.path.length + 1;
		const poppedDepth = this.path.length + 1;
		while (this._keptAttrs.length > 0 && this._keptAttrs[this._keptAttrs.length - 1].depth >= poppedDepth) this._keptAttrs.pop();
		return node;
	}
	/**
	* Update current node's attribute values.
	* Useful when attributes are parsed after push.
	* @param {Object} attrValues
	*/
	updateCurrent(attrValues) {
		if (this.path.length > 0) {
			const current = this.path[this.path.length - 1];
			if (attrValues !== null && attrValues !== void 0) current.values = attrValues;
		}
	}
	/**
	* Get current tag name.
	* @returns {string|undefined}
	*/
	getCurrentTag() {
		return this.path.length > 0 ? this.path[this.path.length - 1].tag : void 0;
	}
	/**
	* Get current namespace.
	* @returns {string|undefined}
	*/
	getCurrentNamespace() {
		return this.path.length > 0 ? this.path[this.path.length - 1].namespace : void 0;
	}
	/**
	* Get current node's attribute value.
	* @param {string} attrName
	* @returns {*}
	*/
	getAttrValue(attrName) {
		if (this.path.length === 0) return void 0;
		return this.path[this.path.length - 1].values?.[attrName];
	}
	/**
	* Check if current node has an attribute.
	* @param {string} attrName
	* @returns {boolean}
	*/
	hasAttr(attrName) {
		if (this.path.length === 0) return false;
		const current = this.path[this.path.length - 1];
		return current.values !== void 0 && attrName in current.values;
	}
	/**
	* Get the value of a "kept" attribute from the nearest ancestor (or
	* current node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
	* Unlike getAttrValue(), this works regardless of how deep the path has
	* gone since the attribute was pushed — but only for attribute names that
	* were explicitly marked with `keep` at push time. Cost is proportional to
	* the number of currently-kept attributes (typically 0-3), not path depth.
	* @param {string} attrName
	* @returns {*} the value, or undefined if no ancestor kept this attribute
	*/
	getAnyParentAttr(attrName) {
		const kept = this._keptAttrs;
		for (let i = kept.length - 1; i >= 0; i--) if (kept[i].name === attrName) return kept[i].value;
	}
	/**
	* Check whether any ancestor (or the current node) kept the given
	* attribute via `push(tag, attrs, ns, { keep: [...] })`.
	* @param {string} attrName
	* @returns {boolean}
	*/
	hasAnyParentAttr(attrName) {
		const kept = this._keptAttrs;
		for (let i = kept.length - 1; i >= 0; i--) if (kept[i].name === attrName) return true;
		return false;
	}
	/**
	* Get current node's sibling position (child index in parent).
	* @returns {number}
	*/
	getPosition() {
		if (this.path.length === 0) return -1;
		return this.path[this.path.length - 1].position ?? 0;
	}
	/**
	* Get current node's repeat counter (occurrence count of this tag name).
	* @returns {number}
	*/
	getCounter() {
		if (this.path.length === 0) return -1;
		return this.path[this.path.length - 1].counter ?? 0;
	}
	/**
	* Get current node's sibling index (alias for getPosition).
	* @returns {number}
	* @deprecated Use getPosition() or getCounter() instead
	*/
	getIndex() {
		return this.getPosition();
	}
	/**
	* Get current path depth.
	* @returns {number}
	*/
	getDepth() {
		return this.path.length;
	}
	/**
	* Get path as string.
	* @param {string} [separator] - Optional separator (uses default if not provided)
	* @param {boolean} [includeNamespace=true]
	* @returns {string}
	*/
	toString(separator, includeNamespace = true) {
		const sep = separator || this.separator;
		if (sep === this.separator && includeNamespace === true) {
			if (this._pathStringCache !== null) return this._pathStringCache;
			const result = this.path.map((n) => n.namespace ? `${n.namespace}:${n.tag}` : n.tag).join(sep);
			this._pathStringCache = result;
			return result;
		}
		return this.path.map((n) => includeNamespace && n.namespace ? `${n.namespace}:${n.tag}` : n.tag).join(sep);
	}
	/**
	* Get path as array of tag names.
	* @returns {string[]}
	*/
	toArray() {
		return this.path.map((n) => n.tag);
	}
	/**
	* Reset the path to empty.
	*/
	reset() {
		this._pathStringCache = null;
		this.path = [];
		this.siblingStacks = [];
		this._keptAttrs = [];
	}
	/**
	* Match current path against an Expression.
	* @param {Expression} expression
	* @returns {boolean}
	*/
	matches(expression) {
		const segments = expression.segments;
		if (segments.length === 0) return false;
		if (expression.hasDeepWildcard()) return this._matchWithDeepWildcard(segments);
		return this._matchSimple(segments);
	}
	/**
	* @private
	*/
	_matchSimple(segments) {
		if (this.path.length !== segments.length) return false;
		for (let i = 0; i < segments.length; i++) if (!this._matchSegment(segments[i], this.path[i], i === this.path.length - 1)) return false;
		return true;
	}
	/**
	* @private
	*/
	_matchWithDeepWildcard(segments) {
		let pathIdx = this.path.length - 1;
		let segIdx = segments.length - 1;
		while (segIdx >= 0 && pathIdx >= 0) {
			const segment = segments[segIdx];
			if (segment.type === "deep-wildcard") {
				segIdx--;
				if (segIdx < 0) return true;
				const nextSeg = segments[segIdx];
				let found = false;
				for (let i = pathIdx; i >= 0; i--) if (this._matchSegment(nextSeg, this.path[i], i === this.path.length - 1)) {
					pathIdx = i - 1;
					segIdx--;
					found = true;
					break;
				}
				if (!found) return false;
			} else {
				if (!this._matchSegment(segment, this.path[pathIdx], pathIdx === this.path.length - 1)) return false;
				pathIdx--;
				segIdx--;
			}
		}
		return segIdx < 0;
	}
	/**
	* @private
	*/
	_matchSegment(segment, node, isCurrentNode) {
		if (segment.tag !== "*" && segment.tag !== node.tag) return false;
		if (segment.namespace !== void 0) {
			if (segment.namespace !== "*" && segment.namespace !== node.namespace) return false;
		}
		if (segment.attrName !== void 0) {
			if (!isCurrentNode) return false;
			if (!node.values || !(segment.attrName in node.values)) return false;
			if (segment.attrValue !== void 0) {
				if (String(node.values[segment.attrName]) !== String(segment.attrValue)) return false;
			}
		}
		if (segment.position !== void 0) {
			if (!isCurrentNode) return false;
			const counter = node.counter ?? 0;
			if (segment.position === "first" && counter !== 0) return false;
			else if (segment.position === "odd" && counter % 2 !== 1) return false;
			else if (segment.position === "even" && counter % 2 !== 0) return false;
			else if (segment.position === "nth" && counter !== segment.positionValue) return false;
		}
		return true;
	}
	/**
	* Match any expression in the given set against the current path.
	* @param {ExpressionSet} exprSet
	* @returns {boolean}
	*/
	matchesAny(exprSet) {
		return exprSet.matchesAny(this);
	}
	/**
	* Create a snapshot of current state.
	* @returns {Object}
	*/
	snapshot() {
		return {
			path: this.path.map((node) => ({ ...node })),
			siblingStacks: this.siblingStacks.map((level) => level ? {
				counts: new Map(level.counts),
				total: level.total
			} : level),
			keptAttrs: this._keptAttrs.map((entry) => ({ ...entry }))
		};
	}
	/**
	* Restore state from snapshot.
	* @param {Object} snapshot
	*/
	restore(snapshot) {
		this._pathStringCache = null;
		this.path = snapshot.path.map((node) => ({ ...node }));
		this.siblingStacks = snapshot.siblingStacks.map((level) => level ? {
			counts: new Map(level.counts),
			total: level.total
		} : level);
		this._keptAttrs = (snapshot.keptAttrs || []).map((entry) => ({ ...entry }));
	}
	/**
	* Return the read-only {@link MatcherView} for this matcher.
	*
	* The same instance is returned on every call — no allocation occurs.
	* It always reflects the current parser state and is safe to pass to
	* user callbacks without risk of accidental mutation.
	*
	* @returns {MatcherView}
	*
	* @example
	* const view = matcher.readOnly();
	* // pass view to callbacks — it stays in sync automatically
	* view.matches(expr);       // ✓
	* view.getCurrentTag();     // ✓
	* // view.push(...)         // ✗ method does not exist — caught by TypeScript
	*/
	readOnly() {
		return this._view;
	}
};
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/contexts/html.js
/**
* HTML context patterns.
*
* Detects XSS vectors that are dangerous when a string ends up rendered as HTML.
* All patterns use bounded quantifiers to ensure linear-time matching (ReDoS-safe).
*
* Each entry is { pattern: RegExp, id: string, description: string }
* so callers can inspect which rule fired if they need to.
*/
var HTML_PATTERNS = [
	{
		id: "html-script-open",
		description: "<script opening tag",
		pattern: /<script[\s>/]/i
	},
	{
		id: "html-script-close",
		description: "<\/script closing tag",
		pattern: /<\/script[\s>]/i
	},
	{
		id: "html-javascript-protocol",
		description: "javascript: URI scheme (with optional whitespace/encoding)",
		pattern: /j[\t\n\r ]*a[\t\n\r ]*v[\t\n\r ]*a[\t\n\r ]*s[\t\n\r ]*c[\t\n\r ]*r[\t\n\r ]*i[\t\n\r ]*p[\t\n\r ]*t[\t\n\r ]*:/i
	},
	{
		id: "html-vbscript-protocol",
		description: "vbscript: URI scheme",
		pattern: /vbscript[\t\n\r ]*:/i
	},
	{
		id: "html-data-html",
		description: "data:text/html URI — can execute scripts in browsers",
		pattern: /data[\t\n\r ]*:[\t\n\r ]*text\/html/i
	},
	{
		id: "html-data-xhtml",
		description: "data:application/xhtml+xml URI",
		pattern: /data[\t\n\r ]*:[\t\n\r ]*application\/xhtml/i
	},
	{
		id: "html-data-svg",
		description: "data:image/svg+xml URI — can execute scripts",
		pattern: /data[\t\n\r ]*:[\t\n\r ]*image\/svg\+xml/i
	},
	{
		id: "html-inline-event-handler",
		description: "Inline event handler attributes: onclick=, onerror=, onload=, etc.",
		pattern: /\bon\w{1,30}\s*=/i
	},
	{
		id: "html-entity-obfuscated-script",
		description: "HTML-entity-encoded <script (e.g. &#x3C;script or &lt;script)",
		pattern: /(?:&#x0*3[Cc];?|&#0*60;?|&lt;)\s*script/i
	},
	{
		id: "html-entity-obfuscated-javascript",
		description: "HTML-entity-encoded javascript: (partial — catches common &#106; or &#x6a; for \"j\")",
		pattern: /(?:&#x0*6[Aa];?|&#0*106;?)\s*(?:&#x0*61;?|a)[\s\S]{0,80}script\s*:/i
	},
	{
		id: "html-style-expression",
		description: "CSS expression() — IE-era code execution in style attributes",
		pattern: /style[\s\S]{0,20}expression\s*\(/i
	},
	{
		id: "html-object-embed",
		description: "<object or <embed tags that can load active content",
		pattern: /<(?:object|embed)[\s>/]/i
	},
	{
		id: "html-base-tag",
		description: "<base href= — can hijack all relative URLs on a page",
		pattern: /<base[\s>]/i
	},
	{
		id: "html-meta-refresh",
		description: "<meta http-equiv=\"refresh\" — can redirect users",
		pattern: /<meta[\s\S]{0,40}http-equiv[\s\S]{0,20}refresh/i
	},
	{
		id: "html-srcdoc",
		description: "srcdoc= attribute on iframes — embeds HTML that can run scripts",
		pattern: /srcdoc\s*=/i
	},
	{
		id: "html-iframe",
		description: "<iframe tag",
		pattern: /<iframe[\s>/]/i
	},
	{
		id: "html-form",
		description: "<form tag — can be used for phishing / credential harvesting injection",
		pattern: /<form[\s>/]/i
	}
];
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/contexts/xml.js
/**
* XML context patterns.
*
* Detects injection vectors that are specifically dangerous when a string
* is inserted into an XML document (not HTML rendering context).
*
* Key distinction from HTML: these patterns target parser-level attacks —
* things that can confuse or subvert an XML parser, trigger external entity
* resolution, or inject DTD content. HTML rendering concerns (XSS) belong
* in the HTML context.
*/
var XML_PATTERNS = [
	{
		id: "xml-cdata-injection",
		description: "CDATA section injection: <![CDATA[ breaks out of text node context",
		pattern: /<!\[CDATA\[/i
	},
	{
		id: "xml-cdata-close",
		description: "CDATA close sequence: ]]> can terminate an enclosing CDATA section",
		pattern: /\]\]>/
	},
	{
		id: "xml-processing-instruction",
		description: "XML processing instruction: <?xml-stylesheet or <?php etc.",
		pattern: /<\?(?:xml[\- ]|php|asp)/i
	},
	{
		id: "xml-doctype-injection",
		description: "DOCTYPE declaration embedded in content — can define entities",
		pattern: /<!DOCTYPE(?:[\s[]|$)/i
	},
	{
		id: "xml-entity-system",
		description: "SYSTEM keyword — used in external entity declarations (XXE)",
		pattern: /\bSYSTEM\s+["']/i
	},
	{
		id: "xml-entity-public",
		description: "PUBLIC keyword — used in external entity declarations (XXE)",
		pattern: /\bPUBLIC\s+["']/i
	},
	{
		id: "xml-entity-declaration",
		description: "<!ENTITY declaration — defines entities, potential XXE or entity expansion",
		pattern: /<!ENTITY[\s%]/i
	},
	{
		id: "xml-billion-laughs",
		description: "Entity reference chaining / billion laughs: repeated &eX; style references",
		pattern: /(?:&\w{1,20};){3,}/
	},
	{
		id: "xml-namespace-confusion",
		description: "xmlns: attribute injection — can redefine namespaces to confuse parsers",
		pattern: /\bxmlns\s*(?::\w{1,40})?\s*=/i
	},
	{
		id: "xml-comment-injection",
		description: "<!-- comment injection — can hide content from some parsers",
		pattern: /<!--/
	},
	{
		id: "xml-comment-close",
		description: "--> closes an enclosing XML comment",
		pattern: /-->/
	},
	{
		id: "xml-pi-close",
		description: "?> closes an enclosing processing instruction",
		pattern: /\?>/
	}
];
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/contexts/svg.js
/**
* SVG context patterns.
*
* SVG is XML-based but renders in browsers, giving it a unique attack surface
* that combines XML parser behaviour with browser rendering and JavaScript execution.
*
* Many of these vectors bypass HTML sanitizers that don't understand SVG semantics
* (DOMPurify has documented bypass vulnerabilities specifically in SVG/XML context).
*/
var SVG_PATTERNS = [
	{
		id: "svg-script-element",
		description: "<script element inside SVG executes JavaScript",
		pattern: /<script[\s>/]/i
	},
	{
		id: "svg-xlink-href-javascript",
		description: "xlink:href with javascript: — classic SVG XSS via <a> or <use>",
		pattern: /xlink\s*:\s*href\s*=\s*["']?\s*javascript\s*:/i
	},
	{
		id: "svg-href-javascript",
		description: "href= with javascript: in SVG context (<a>, <animate>, etc.)",
		pattern: /href\s*=\s*["']?\s*javascript\s*:/i
	},
	{
		id: "svg-foreignobject",
		description: "<foreignObject embeds HTML inside SVG — can execute scripts",
		pattern: /<foreignObject[\s>/]/i
	},
	{
		id: "svg-use-external",
		description: "<use xlink:href or href pointing to external resource (non-fragment URL)",
		pattern: /<use[\s\S]{0,60}(?:xlink\s*:\s*)?href\s*=\s*(?:["'][^#]|[^"'#\s>])/i
	},
	{
		id: "svg-animate-href",
		description: "<animate attributeName=\"href\" — can dynamically change href to javascript:",
		pattern: /<animate[\s\S]{0,80}attributeName\s*=\s*["'][\s]*href["']/i
	},
	{
		id: "svg-animate-xlinkhref",
		description: "<animate attributeName=\"xlink:href\"",
		pattern: /<animate[\s\S]{0,80}attributeName\s*=\s*["'][\s]*xlink\s*:\s*href["']/i
	},
	{
		id: "svg-set-javascript",
		description: "<set to=\"javascript:...\" — sets an attribute to a javascript: URI",
		pattern: /<set[\s\S]{0,80}to\s*=\s*["']?\s*javascript\s*:/i
	},
	{
		id: "svg-event-handler",
		description: "SVG-specific event handler attributes: onload=, onerror=, onactivate=, etc.",
		pattern: /\bon(?:load|error|activate|begin|end|repeat|focus|blur|click|mouse\w{1,20}|key\w{1,20})\s*=/i
	},
	{
		id: "svg-handler-generic",
		description: "Generic on* handler catch-all for SVG attributes",
		pattern: /\bon\w{1,30}\s*=/i
	},
	{
		id: "svg-filter-feimage",
		description: "<feImage href= — filter primitive that can load external resources",
		pattern: /<feImage[\s\S]{0,80}(?:xlink\s*:\s*)?href\s*=/i
	},
	{
		id: "svg-image-external",
		description: "<image xlink:href with http/https or javascript protocol",
		pattern: /<image[\s\S]{0,80}(?:xlink\s*:\s*)?href\s*=\s*["']?\s*(?:https?|javascript)\s*:/i
	},
	{
		id: "svg-style-javascript",
		description: "style= attribute containing javascript: (e.g. background:url(javascript:...))",
		pattern: /style\s*=[\s\S]{0,60}javascript\s*:/i
	}
];
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/contexts/sql.js
/**
* SQL context patterns — high-precision rules only.
*
* These rules have very low false-positive risk and are safe to apply to
* general user text (names, descriptions, search queries, etc.).
* All patterns are ReDoS-safe — unlike the `sql-injection` npm package
* which has an active CVE on its own detection regexes.
*
* For exhaustive coverage including noisier heuristics (comment sequences,
* hex literals, stacked queries with semicolons), use 'SQL-STRICT' instead.
* Apply 'SQL-STRICT' only to strings that are specifically SQL fragments,
* not to general free-text fields.
*/
var SQL_PATTERNS = [
	{
		id: "sql-block-comment-open",
		description: "SQL block comment open: /* ... */ — unusual in legitimate user text",
		pattern: /\/\*/
	},
	{
		id: "sql-union-select",
		description: "UNION SELECT — most common SQL injection aggregation attack",
		pattern: /\bUNION\s{1,20}(?:ALL\s{1,20})?SELECT\b/i
	},
	{
		id: "sql-drop-table",
		description: "DROP TABLE — destructive DDL injection",
		pattern: /\bDROP\s{1,20}TABLE\b/i
	},
	{
		id: "sql-drop-database",
		description: "DROP DATABASE — destructive DDL injection",
		pattern: /\bDROP\s{1,20}DATABASE\b/i
	},
	{
		id: "sql-insert-into",
		description: "INSERT INTO — data injection",
		pattern: /\bINSERT\s{1,20}INTO\b/i
	},
	{
		id: "sql-delete-from",
		description: "DELETE FROM — data deletion injection",
		pattern: /\bDELETE\s{1,20}FROM\b/i
	},
	{
		id: "sql-update-set",
		description: "UPDATE ... SET — data modification injection",
		pattern: /\bUPDATE\b[\s\S]{1,60}\bSET\b/i
	},
	{
		id: "sql-exec-xp",
		description: "EXEC xp_ — MSSQL extended stored procedure execution",
		pattern: /\bEXEC(?:UTE)?\s{1,20}xp_/i
	},
	{
		id: "sql-tautology-string",
		description: "Classic string tautology: ' OR '1'='1 or \" OR \"1\"=\"1\"",
		pattern: /'\s{0,10}OR\s{0,10}'[^']{0,20}'\s*=\s*'[^']{0,20}/i
	},
	{
		id: "sql-tautology-numeric",
		description: "Numeric tautology: OR 1=1",
		pattern: /\bOR\s{1,10}1\s*=\s*1\b/i
	},
	{
		id: "sql-always-true-zero",
		description: "Numeric tautology: OR 0=0",
		pattern: /\bOR\s{1,10}0\s*=\s*0\b/i
	},
	{
		id: "sql-sleep-benchmark",
		description: "Time-based blind injection: SLEEP() or BENCHMARK()",
		pattern: /\b(?:SLEEP|BENCHMARK)\s*\(/i
	},
	{
		id: "sql-waitfor-delay",
		description: "MSSQL time-based blind injection: WAITFOR DELAY",
		pattern: /\bWAITFOR\s{1,20}DELAY\b/i
	},
	{
		id: "sql-char-function",
		description: "CHAR() function — used to obfuscate injected strings",
		pattern: /\bCHAR\s*\(\s*\d{1,3}/i
	},
	{
		id: "sql-information-schema",
		description: "INFORMATION_SCHEMA — reconnaissance query for table/column enumeration",
		pattern: /\bINFORMATION_SCHEMA\b/i
	}
];
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/contexts/shell.js
/**
* SHELL context patterns.
*
* Detects shell injection vectors and path traversal patterns.
* Designed for use when a string will be passed to a shell command,
* used as a file path, or interpolated into OS-level operations.
*/
var SHELL_PATTERNS = [
	{
		id: "shell-path-traversal-unix",
		description: "Unix path traversal: ../  — climbing the directory tree",
		pattern: /\.\.\//
	},
	{
		id: "shell-path-traversal-windows",
		description: "Windows path traversal: ..\\ — climbing the directory tree",
		pattern: /\.\.\\/
	},
	{
		id: "shell-path-traversal-encoded",
		description: "URL-encoded path traversal: %2e%2e or %2f variants",
		pattern: /%2e%2e|%2f\.\.|\.\.%2f/i
	},
	{
		id: "shell-null-byte",
		description: "Null byte injection: \\x00 or %00 — truncates strings in C-backed functions",
		pattern: /\x00|%00/
	},
	{
		id: "shell-semicolon",
		description: "Semicolon command separator: cmd1; cmd2",
		pattern: /;/
	},
	{
		id: "shell-pipe",
		description: "Pipe operator: cmd1 | cmd2",
		pattern: /\|/
	},
	{
		id: "shell-and-operator",
		description: "AND operator: cmd1 && cmd2",
		pattern: /&&/
	},
	{
		id: "shell-or-operator",
		description: "OR operator: cmd1 || cmd2",
		pattern: /\|\|/
	},
	{
		id: "shell-backtick",
		description: "Backtick command substitution: `cmd`",
		pattern: /`/
	},
	{
		id: "shell-dollar-paren",
		description: "Dollar-paren command substitution: $(cmd)",
		pattern: /\$\(/
	},
	{
		id: "shell-dollar-brace",
		description: "Dollar-brace variable expansion: ${var} — can be abused for injection",
		pattern: /\$\{/
	},
	{
		id: "shell-redirect-out",
		description: "Output redirection: cmd > file or cmd >> file",
		pattern: />{1,2}/
	},
	{
		id: "shell-redirect-in",
		description: "Input redirection: cmd < file",
		pattern: /</
	},
	{
		id: "shell-newline-injection",
		description: "Newline injection: \\n or \\r — can inject new shell commands",
		pattern: /[\n\r]/
	},
	{
		id: "shell-glob-star",
		description: "Glob expansion: * or ? — can expand to unintended files",
		pattern: /[/\\][*?]/
	},
	{
		id: "shell-absolute-root",
		description: "Absolute root path injection: string starting with / or \\ (Windows UNC)",
		pattern: /^(?:\/|\\\\)/
	},
	{
		id: "shell-windows-drive",
		description: "Windows drive letter path injection: C:\\ or D:/",
		pattern: /^[a-zA-Z]:[/\\]/
	},
	{
		id: "shell-curl-wget",
		description: "curl/wget with URL or flags — can exfiltrate data or download payloads",
		pattern: /\b(?:curl|wget)\s+(?:https?:\/\/|ftp:\/\/|-)/i
	}
];
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/contexts/redos.js
/**
* REDOS context patterns.
*
* Detects strings that, if used as regular expressions, could cause
* catastrophic backtracking (ReDoS — Regular Expression Denial of Service).
*
* These patterns detect the structural forms that lead to exponential or
* polynomial backtracking in NFA-based regex engines (V8, PCRE, Java, etc.).
*
* Use this context when user-supplied strings will be compiled into RegExp objects.
*/
var REDOS_PATTERNS = [
	{
		id: "redos-nested-quantifier-plus",
		description: "Nested + quantifier inside a group with outer quantifier: (a+)+, (.+b)*, etc.",
		pattern: /\([^)]*\+[^)]*\)[+*]/
	},
	{
		id: "redos-nested-quantifier-star",
		description: "Nested * quantifier: (a*)* or (a*)+ — catastrophic backtracking",
		pattern: /\([^)]*\*[^)]*\)[*+]/
	},
	{
		id: "redos-nested-groups",
		description: "Doubly nested quantified groups: ((a+)+) — guaranteed catastrophic",
		pattern: /\(\([^)]{0,40}\)[+*]\)[+*]/
	},
	{
		id: "redos-alternation-overlap",
		description: "Overlapping alternation under quantifier: (a|a)+ — ambiguous NFA paths",
		pattern: /\(([^|()]{1,20})\|(?:\1)(?:\|[^|()]{1,20}){0,5}\)[+*?]{1,2}/
	},
	{
		id: "redos-star-plus-concat",
		description: "(x*x)+ pattern — triggers super-linear backtracking",
		pattern: /\([^)]{0,10}\*[^)]{0,10}\)[+*]/
	},
	{
		id: "redos-dot-star-greedy",
		description: "(.*){n,} or (.+){n,} — repeated greedy dot quantifiers",
		pattern: /\(\.[*+]\)\{?\d/
	},
	{
		id: "redos-large-repetition",
		description: "Very large fixed or range repetition count {1000,} or {1000,n} — denial of service via backtracking",
		pattern: /\{\d{4,}(?:,\d*)?\}/
	},
	{
		id: "redos-catastrophic-alternation",
		description: "Long alternation with many similar branches — polynomial backtracking risk",
		pattern: /\([^)]{0,200}(?:\|[^|)]{0,50}){9,}\)/
	}
];
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/contexts/nosql.js
var sep = "[\"'\\s]*:";
var NOSQL_PATTERNS = [
	{
		id: "nosql-where-operator",
		description: "$where — executes arbitrary JavaScript server-side in MongoDB",
		pattern: new RegExp(`\\$where${sep}`, "i")
	},
	{
		id: "nosql-ne-operator",
		description: "$ne — \"not equal\" operator used to bypass equality checks",
		pattern: new RegExp(`\\$ne${sep}`, "i")
	},
	{
		id: "nosql-gt-operator",
		description: "$gt — \"greater than\" used to bypass password/value checks",
		pattern: new RegExp(`\\$gte?${sep}`, "i")
	},
	{
		id: "nosql-lt-operator",
		description: "$lt / $lte — \"less than\" bypass variants",
		pattern: new RegExp(`\\$lte?${sep}`, "i")
	},
	{
		id: "nosql-regex-operator",
		description: "$regex — can be used to extract data character by character (blind injection)",
		pattern: new RegExp(`\\$regex${sep}`, "i")
	},
	{
		id: "nosql-or-operator",
		description: "$or — logical OR; used to create always-true conditions",
		pattern: new RegExp(`\\$or${sep}\\s*\\[`, "i")
	},
	{
		id: "nosql-and-operator",
		description: "$and — logical AND operator injection",
		pattern: new RegExp(`\\$and${sep}\\s*\\[`, "i")
	},
	{
		id: "nosql-nor-operator",
		description: "$nor — logical NOR operator injection",
		pattern: new RegExp(`\\$nor${sep}\\s*\\[`, "i")
	},
	{
		id: "nosql-exists-operator",
		description: "$exists — can enumerate fields to determine schema",
		pattern: new RegExp(`\\$exists${sep}`, "i")
	},
	{
		id: "nosql-in-operator",
		description: "$in — matches any value in a list; can enumerate values",
		pattern: new RegExp(`\\$in${sep}\\s*\\[`, "i")
	},
	{
		id: "nosql-expr-operator",
		description: "$expr — allows aggregation expressions in queries (MongoDB 3.6+)",
		pattern: new RegExp(`\\$expr${sep}`, "i")
	},
	{
		id: "nosql-function-operator",
		description: "$function — executes arbitrary JavaScript in MongoDB 4.4+",
		pattern: new RegExp(`\\$function${sep}`, "i")
	},
	{
		id: "nosql-accumulator-operator",
		description: "$accumulator — custom aggregation with arbitrary JS execution",
		pattern: new RegExp(`\\$accumulator${sep}`, "i")
	},
	{
		id: "nosql-proto-pollution",
		description: "__proto__ — prototype pollution via object key injection",
		pattern: /__proto__/
	},
	{
		id: "nosql-constructor-prototype",
		description: "constructor.prototype — alternative prototype pollution vector (dot notation or JSON key)",
		pattern: /constructor[\s"':.,{\[]*prototype/i
	},
	{
		id: "nosql-proto-bracket",
		description: "[\"__proto__\"] — bracket-notation prototype pollution",
		pattern: /\[["']__proto__["']\]/
	}
];
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/contexts/log.js
/**
* LOG context patterns.
*
* Detects injection vectors that are dangerous when a string is written
* to a log file, passed to a logging framework, or interpolated into
* a log message that will be parsed or displayed.
*
* Attack categories:
*   1. CRLF injection — injects fake log lines by embedding newlines
*   2. Log4Shell (CVE-2021-44228) — ${jndi:...} triggers JNDI lookup in Log4j
*   3. SSTI in log templates — {{...}}, #{...} trigger template evaluation
*      if the log message is passed through a template engine
*   4. Null byte injection — truncates log entries in some implementations
*   5. ANSI escape injection — manipulates terminal output when logs are
*      tailed in a terminal (colour codes, cursor movement, etc.)
*
* Note: Newline characters (\n, \r) will produce false positives for
* multi-line legitimate values. Use this context only for single-line
* log field values (usernames, IDs, request parameters, etc.).
*/
var LOG_PATTERNS = [
	{
		id: "log-crlf-injection",
		description: "CRLF injection: literal \\r or \\n embeds fake log lines",
		pattern: /[\r\n]/
	},
	{
		id: "log-url-encoded-crlf",
		description: "URL-encoded CRLF: %0d, %0a, %0D, %0A — decoded by some log parsers",
		pattern: /%0[dDaA]/
	},
	{
		id: "log-unicode-newline",
		description: "Unicode newline variants: U+2028 (line separator), U+2029 (paragraph separator)",
		pattern: /[\u2028\u2029]/
	},
	{
		id: "log-log4shell-jndi",
		description: "Log4Shell: ${jndi:...} triggers remote code execution in Apache Log4j",
		pattern: /\$\{jndi\s*:/i
	},
	{
		id: "log-log4shell-obfuscated",
		description: "Obfuscated Log4Shell: ${::-j}... lookup-bypass prefix used to evade WAF detection",
		pattern: /\$\{::-/
	},
	{
		id: "log-log4j-lookup",
		description: "Log4j lookup syntax: ${env:...}, ${sys:...}, ${ctx:...} — data exfiltration",
		pattern: /\$\{(?:env|sys|ctx|main|map|sd|web|docker|k8s|spring)\s*:/i
	},
	{
		id: "log-ssti-double-brace",
		description: "SSTI double-brace: {{expression}} — Jinja2, Twig, Handlebars, etc.",
		pattern: /\{\{[\s\S]{0,80}\}\}/
	},
	{
		id: "log-ssti-hash-brace",
		description: "SSTI hash-brace: #{expression} — Thymeleaf, Velocity, Ruby ERB",
		pattern: /#\{[\s\S]{0,80}\}/
	},
	{
		id: "log-ssti-dollar-brace",
		description: "SSTI/EL injection: ${expression with operators or method calls} — JSP EL, Freemarker, SpEL",
		pattern: /\$\{[^}]*(?:\.|\(|\*|\+|\bclass\b|\bruntime\b|\bprocess\b|\bexec\b)[^}]{0,80}\}/i
	},
	{
		id: "log-ssti-percent-tag",
		description: "SSTI ERB/ASP tag: <%= expression %> — Ruby ERB, ASP",
		pattern: /<%=[\s\S]{0,80}%>/
	},
	{
		id: "log-null-byte",
		description: "Null byte: \\x00 or %00 — can truncate log entries in C-backed loggers",
		pattern: /\x00|%00/
	},
	{
		id: "log-ansi-escape",
		description: "ANSI escape sequence: ESC[ — can manipulate terminal output when logs are tailed",
		pattern: /\x1b\[/
	}
];
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/contexts/sql-strict.js
/**
* SQL-STRICT context patterns.
*
* Extends the base 'SQL' context with three additional rules that are
* effective at detecting real injections but carry a higher false-positive
* risk on general free-text input.
*
* Use 'SQL-STRICT' when:
*   - The string is specifically a SQL fragment or database identifier
*   - You control the input domain (e.g. a dedicated SQL search field)
*   - You can tolerate occasional false positives in exchange for broader coverage
*
* Use 'SQL' (not STRICT) when:
*   - The field is general user text (names, descriptions, comments)
*   - False positives would block legitimate content (e.g. "see note -- above")
*
* Rules moved here from 'SQL' due to false-positive risk:
*
*   sql-line-comment   — "--" fires on "see note -- above", "value--", CSS var(--primary)
*   sql-stacked-query  — "; SELECT" fires on legitimate prose with semicolons + SQL words
*   sql-hex-encoding   — "0xDEAD" fires on hex values in technical docs and log output
*/
var SQL_STRICT_EXTRA = [
	{
		id: "sql-line-comment",
		description: "SQL line comment: -- followed by whitespace or end of string",
		pattern: /--(?:\s|$)/
	},
	{
		id: "sql-stacked-query",
		description: "Stacked queries: semicolon immediately followed by a SQL keyword",
		pattern: /;\s{0,10}(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|EXEC)\b/i
	},
	{
		id: "sql-hex-encoding",
		description: "Hex-encoded string injection: 0x41414141 style (MySQL)",
		pattern: /\b0x[0-9a-f]{4,}/i
	}
];
var SQL_STRICT_PATTERNS = [...SQL_PATTERNS, ...SQL_STRICT_EXTRA];
//#endregion
//#region node_modules/.pnpm/is-unsafe@2.0.0/node_modules/is-unsafe/src/index.js
HTML_PATTERNS.label = "HTML";
XML_PATTERNS.label = "XML";
SVG_PATTERNS.label = "SVG";
SQL_PATTERNS.label = "SQL";
SQL_STRICT_PATTERNS.label = "SQL-STRICT";
SHELL_PATTERNS.label = "SHELL";
REDOS_PATTERNS.label = "REDOS";
NOSQL_PATTERNS.label = "NOSQL";
LOG_PATTERNS.label = "LOG";
Object.freeze({
	HTML: HTML_PATTERNS,
	XML: XML_PATTERNS,
	SVG: SVG_PATTERNS,
	SQL: SQL_PATTERNS,
	"SQL-STRICT": SQL_STRICT_PATTERNS,
	SHELL: SHELL_PATTERNS,
	REDOS: REDOS_PATTERNS,
	NOSQL: NOSQL_PATTERNS,
	LOG: LOG_PATTERNS
});
/**
* @typedef {{ id: string, description: string, pattern: RegExp }} Rule
*/
/**
* @typedef {Rule[]} PatternList
*/
/**
* @typedef {Object} MatchResult
* @property {string} context     - Label identifying which context matched ('HTML', 'CUSTOM', etc.)
* @property {string} id          - Rule identifier
* @property {string} description - Human-readable description of what was matched
* @property {RegExp} pattern     - The pattern that matched
*/
/**
* @param {unknown} value
*/
function assertString(value) {
	if (typeof value !== "string") throw new TypeError(`is-unsafe: first argument must be a string, got ${typeof value}`);
}
/**
* @param {unknown} context
*/
function assertContext(context) {
	if (context instanceof RegExp) return;
	if (Array.isArray(context)) {
		if (context.length === 0) throw new TypeError("is-unsafe: context must not be an empty array");
		if (Array.isArray(context[0])) {
			for (const list of context) if (!Array.isArray(list) || list.length === 0) throw new TypeError("is-unsafe: each context in the array must be a non-empty pattern array (PatternList)");
		}
		return;
	}
	throw new TypeError(`is-unsafe: second argument must be a PatternList (e.g. HTML), an array of PatternLists (e.g. [HTML, XML]), or a RegExp. Got: ${typeof context}`);
}
/**
* Normalise any valid context arg into an array of PatternLists.
*
* @param {Rule[]|Rule[][]|RegExp} context
* @returns {{ lists: Rule[][]|null, regex: RegExp|null }}
*/
function normalise(context) {
	if (context instanceof RegExp) return {
		lists: null,
		regex: context
	};
	if (Array.isArray(context[0])) return {
		lists: context,
		regex: null
	};
	return {
		lists: [context],
		regex: null
	};
}
/**
* Test value against a single PatternList. Returns the first MatchResult or null.
*
* @param {string} value
* @param {Rule[]} list
* @returns {MatchResult|null}
*/
function matchList(value, list) {
	const label = list.label ?? "CUSTOM";
	for (const rule of list) if (rule.pattern.test(value)) return {
		context: label,
		id: rule.id,
		description: rule.description,
		pattern: rule.pattern
	};
	return null;
}
/**
* Returns `true` if `value` is unsafe in the given context(s), `false` otherwise.
*
* @param {string} value - The string to test
* @param {PatternList | PatternList[] | RegExp} context
*   - A PatternList imported from is-unsafe (e.g. `HTML`, `XML`)
*   - An array of PatternLists — returns true if unsafe in **any** of them
*   - A custom RegExp — returns true if the pattern matches
* @returns {boolean}
*
* @example
* import { isUnsafe, HTML, SQL } from 'is-unsafe';
*
* isUnsafe('<script>alert(1)<\/script>', HTML)       // true
* isUnsafe('hello world', HTML)                     // false
* isUnsafe('value', [HTML, SQL])                    // false
* isUnsafe('value', /my-pattern/i)                  // false
*/
function isUnsafe(value, context) {
	assertString(value);
	assertContext(context);
	const { lists, regex } = normalise(context);
	if (regex) return regex.test(value);
	for (const list of lists) if (matchList(value, list) !== null) return true;
	return false;
}
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
/**
* Extract raw attributes (without prefix) from prefixed attribute map
* @param {object} prefixedAttrs - Attributes with prefix from buildAttributesMap
* @param {object} options - Parser options containing attributeNamePrefix
* @returns {object} Raw attributes for matcher
*/
function extractRawAttributes(prefixedAttrs, options) {
	if (!prefixedAttrs) return {};
	const attrs = options.attributesGroupName ? prefixedAttrs[options.attributesGroupName] : prefixedAttrs;
	if (!attrs) return {};
	const rawAttrs = {};
	for (const key in attrs) if (key.startsWith(options.attributeNamePrefix)) {
		const rawName = key.substring(options.attributeNamePrefix.length);
		rawAttrs[rawName] = attrs[key];
	} else rawAttrs[key] = attrs[key];
	return rawAttrs;
}
/**
* Extract namespace from raw tag name
* @param {string} rawTagName - Tag name possibly with namespace (e.g., "soap:Envelope")
* @returns {string|undefined} Namespace or undefined
*/
function extractNamespace(rawTagName) {
	if (!rawTagName || typeof rawTagName !== "string") return void 0;
	const colonIndex = rawTagName.indexOf(":");
	if (colonIndex !== -1 && colonIndex > 0) {
		const ns = rawTagName.substring(0, colonIndex);
		if (ns !== "xmlns") return ns;
	}
}
var OrderedObjParser = class {
	constructor(options, externalEntities) {
		this.options = options;
		this.currentNode = null;
		this.tagsNodeStack = [];
		this.parseXml = parseXml;
		this.parseTextData = parseTextData;
		this.resolveNameSpace = resolveNameSpace;
		this.buildAttributesMap = buildAttributesMap;
		this.isItStopNode = isItStopNode;
		this.replaceEntitiesValue = replaceEntitiesValue$1;
		this.readStopNodeData = readStopNodeData;
		this.saveTextToParentTag = saveTextToParentTag;
		this.addChild = addChild;
		this.ignoreAttributesFn = getIgnoreAttributesFn$1(this.options.ignoreAttributes);
		this.entityExpansionCount = 0;
		this.currentExpandedLength = 0;
		this.doctypefound = false;
		let namedEntities = { ...XML };
		if (this.options.entityDecoder) this.entityDecoder = this.options.entityDecoder;
		else {
			if (typeof this.options.htmlEntities === "object") namedEntities = this.options.htmlEntities;
			else if (this.options.htmlEntities === true) namedEntities = {
				...COMMON_HTML,
				...CURRENCY
			};
			this.entityDecoder = new EntityDecoder({
				namedEntities: {
					...namedEntities,
					...externalEntities
				},
				numericAllowed: this.options.htmlEntities,
				limit: {
					maxTotalExpansions: this.options.processEntities.maxTotalExpansions,
					maxExpandedLength: this.options.processEntities.maxExpandedLength,
					applyLimitsTo: this.options.processEntities.appliesTo
				},
				onInputEntity: (name, value) => isUnsafe(value, [HTML_PATTERNS, XML_PATTERNS]) ? ENTITY_ACTION.BLOCK : ENTITY_ACTION.ALLOW
			});
		}
		this.matcher = new Matcher();
		this.readonlyMatcher = this.matcher.readOnly();
		this.isCurrentNodeStopNode = false;
		this.stopNodeExpressionsSet = new ExpressionSet();
		const stopNodesOpts = this.options.stopNodes;
		if (stopNodesOpts && stopNodesOpts.length > 0) {
			for (let i = 0; i < stopNodesOpts.length; i++) {
				const stopNodeExp = stopNodesOpts[i];
				if (typeof stopNodeExp === "string") this.stopNodeExpressionsSet.add(new Expression(stopNodeExp));
				else if (stopNodeExp instanceof Expression) this.stopNodeExpressionsSet.add(stopNodeExp);
			}
			this.stopNodeExpressionsSet.seal();
		}
	}
};
/**
* @param {string} val
* @param {string} tagName
* @param {string|Matcher} jPath - jPath string or Matcher instance based on options.jPath
* @param {boolean} dontTrim
* @param {boolean} hasAttributes
* @param {boolean} isLeafNode
* @param {boolean} escapeEntities
*/
function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
	const options = this.options;
	if (val !== void 0) {
		if (options.trimValues && !dontTrim) val = val.trim();
		if (val.length > 0) {
			if (!escapeEntities) val = this.replaceEntitiesValue(val, tagName, jPath);
			const jPathOrMatcher = options.jPath ? jPath.toString() : jPath;
			const newval = options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);
			if (newval === null || newval === void 0) return val;
			else if (typeof newval !== typeof val || newval !== val) return newval;
			else if (options.trimValues) return parseValue(val, options.parseTagValue, options.numberParseOptions);
			else if (val.trim() === val) return parseValue(val, options.parseTagValue, options.numberParseOptions);
			else return val;
		}
	}
}
function resolveNameSpace(tagname) {
	if (this.options.removeNSPrefix) {
		const tags = tagname.split(":");
		const prefix = tagname.charAt(0) === "/" ? "/" : "";
		if (tags[0] === "xmlns") return "";
		if (tags.length === 2) tagname = prefix + tags[1];
	}
	return tagname;
}
var attrsRegx = /* @__PURE__ */ new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?", "gm");
function buildAttributesMap(attrStr, jPath, tagName, force = false) {
	const options = this.options;
	if (force === true || options.ignoreAttributes !== true && typeof attrStr === "string") {
		const matches = getAllMatches(attrStr, attrsRegx);
		const len = matches.length;
		const attrs = {};
		const processedVals = new Array(len);
		let hasRawAttrs = false;
		const rawAttrsForMatcher = {};
		for (let i = 0; i < len; i++) {
			const attrName = this.resolveNameSpace(matches[i][1]);
			const oldVal = matches[i][4];
			if (attrName.length && oldVal !== void 0) {
				let val = oldVal;
				if (options.trimValues) val = val.trim();
				val = this.replaceEntitiesValue(val, tagName, this.readonlyMatcher);
				processedVals[i] = val;
				rawAttrsForMatcher[attrName] = val;
				hasRawAttrs = true;
			}
		}
		if (hasRawAttrs && typeof jPath === "object" && jPath.updateCurrent) jPath.updateCurrent(rawAttrsForMatcher);
		const jPathStr = options.jPath ? jPath.toString() : this.readonlyMatcher;
		let hasAttrs = false;
		for (let i = 0; i < len; i++) {
			const attrName = this.resolveNameSpace(matches[i][1]);
			if (this.ignoreAttributesFn(attrName, jPathStr)) continue;
			let aName = options.attributeNamePrefix + attrName;
			if (attrName.length) {
				if (options.transformAttributeName) aName = options.transformAttributeName(aName);
				aName = sanitizeName(aName, options);
				if (matches[i][4] !== void 0) {
					const oldVal = processedVals[i];
					const newVal = options.attributeValueProcessor(attrName, oldVal, jPathStr);
					if (newVal === null || newVal === void 0) attrs[aName] = oldVal;
					else if (typeof newVal !== typeof oldVal || newVal !== oldVal) attrs[aName] = newVal;
					else attrs[aName] = parseValue(oldVal, options.parseAttributeValue, options.numberParseOptions);
					hasAttrs = true;
				} else if (options.allowBooleanAttributes) {
					attrs[aName] = true;
					hasAttrs = true;
				}
			}
		}
		if (!hasAttrs) return;
		if (options.attributesGroupName && !options.preserveOrder) {
			const attrCollection = {};
			attrCollection[options.attributesGroupName] = attrs;
			return attrCollection;
		}
		return attrs;
	}
}
var parseXml = function(xmlData) {
	xmlData = xmlData.replace(/\r\n?/g, "\n");
	const xmlObj = new XmlNode("!xml");
	let currentNode = xmlObj;
	let textData = "";
	this.matcher.reset();
	this.entityDecoder.reset();
	this.entityExpansionCount = 0;
	this.currentExpandedLength = 0;
	this.doctypefound = false;
	const options = this.options;
	const docTypeReader = new DocTypeReader(options.processEntities);
	const xmlLen = xmlData.length;
	for (let i = 0; i < xmlLen; i++) if (xmlData[i] === "<") {
		const c1 = xmlData.charCodeAt(i + 1);
		if (c1 === 47) {
			const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
			let tagName = xmlData.substring(i + 2, closeIndex).trim();
			if (options.removeNSPrefix) {
				const colonIndex = tagName.indexOf(":");
				if (colonIndex !== -1) tagName = tagName.substr(colonIndex + 1);
			}
			tagName = transformTagName(options.transformTagName, tagName, "", options).tagName;
			if (currentNode) textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
			const lastTagName = this.matcher.getCurrentTag();
			if (tagName && options.unpairedTagsSet.has(tagName)) throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
			if (lastTagName && options.unpairedTagsSet.has(lastTagName)) {
				this.matcher.pop();
				this.tagsNodeStack.pop();
			}
			this.matcher.pop();
			this.isCurrentNodeStopNode = false;
			currentNode = this.tagsNodeStack.pop();
			textData = "";
			i = closeIndex;
		} else if (c1 === 63) {
			let tagData = readTagExp(xmlData, i, false, "?>");
			if (!tagData) throw new Error("Pi Tag is not closed.");
			textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
			const attsMap = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName, true);
			if (attsMap) {
				const ver = attsMap[this.options.attributeNamePrefix + "version"];
				this.entityDecoder.setXmlVersion(Number(ver) || 1);
				docTypeReader.setXmlVersion(Number(ver) || 1);
			}
			if (options.ignoreDeclaration && tagData.tagName === "?xml" || options.ignorePiTags) {} else {
				const childNode = new XmlNode(tagData.tagName);
				childNode.add(options.textNodeName, "");
				if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent && options.ignoreAttributes !== true) childNode[":@"] = attsMap;
				this.addChild(currentNode, childNode, this.readonlyMatcher, i);
			}
			i = tagData.closeIndex + 1;
		} else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 45 && xmlData.charCodeAt(i + 3) === 45) {
			const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
			if (options.commentPropName) {
				const comment = xmlData.substring(i + 4, endIndex - 2);
				textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
				currentNode.add(options.commentPropName, [{ [options.textNodeName]: comment }]);
			}
			i = endIndex;
		} else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 68) {
			if (this.doctypefound) throw new Error("Multiple DOCTYPE declarations found.");
			this.doctypefound = true;
			const result = docTypeReader.readDocType(xmlData, i);
			this.entityDecoder.addInputEntities(result.entities);
			i = result.i;
		} else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 91) {
			const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
			const tagExp = xmlData.substring(i + 9, closeIndex);
			textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
			let val = this.parseTextData(tagExp, currentNode.tagname, this.readonlyMatcher, true, false, true, true);
			if (val == void 0) val = "";
			if (options.cdataPropName) currentNode.add(options.cdataPropName, [{ [options.textNodeName]: tagExp }]);
			else currentNode.add(options.textNodeName, val);
			i = closeIndex + 2;
		} else {
			let result = readTagExp(xmlData, i, options.removeNSPrefix);
			if (!result) {
				const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlLen, i + 50));
				throw new Error(`readTagExp returned undefined at position ${i}. Context: "${context}"`);
			}
			let tagName = result.tagName;
			const rawTagName = result.rawTagName;
			let tagExp = result.tagExp;
			let attrExpPresent = result.attrExpPresent;
			let closeIndex = result.closeIndex;
			({tagName, tagExp} = transformTagName(options.transformTagName, tagName, tagExp, options));
			if (options.strictReservedNames && (tagName === options.commentPropName || tagName === options.cdataPropName || tagName === options.textNodeName || tagName === options.attributesGroupName)) throw new Error(`Invalid tag name: ${tagName}`);
			if (currentNode && textData) {
				if (currentNode.tagname !== "!xml") textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher, false);
			}
			const lastTag = currentNode;
			if (lastTag && options.unpairedTagsSet.has(lastTag.tagname)) {
				currentNode = this.tagsNodeStack.pop();
				this.matcher.pop();
			}
			let isSelfClosing = false;
			if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
				isSelfClosing = true;
				if (tagName[tagName.length - 1] === "/") {
					tagName = tagName.substr(0, tagName.length - 1);
					tagExp = tagName;
				} else tagExp = tagExp.substr(0, tagExp.length - 1);
				attrExpPresent = tagName !== tagExp;
			}
			let prefixedAttrs = null;
			let namespace = void 0;
			namespace = extractNamespace(rawTagName);
			if (tagName !== xmlObj.tagname) this.matcher.push(tagName, {}, namespace);
			if (tagName !== tagExp && attrExpPresent) {
				prefixedAttrs = this.buildAttributesMap(tagExp, this.matcher, tagName);
				if (prefixedAttrs) extractRawAttributes(prefixedAttrs, options);
			}
			if (tagName !== xmlObj.tagname) this.isCurrentNodeStopNode = this.isItStopNode();
			const startIndex = i;
			if (this.isCurrentNodeStopNode) {
				let tagContent = "";
				if (isSelfClosing) i = result.closeIndex;
				else if (options.unpairedTagsSet.has(tagName)) i = result.closeIndex;
				else {
					const result = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
					if (!result) throw new Error(`Unexpected end of ${rawTagName}`);
					i = result.i;
					tagContent = result.tagContent;
				}
				const childNode = new XmlNode(tagName);
				if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
				childNode.add(options.textNodeName, tagContent);
				this.matcher.pop();
				this.isCurrentNodeStopNode = false;
				this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
			} else {
				if (isSelfClosing) {
					({tagName, tagExp} = transformTagName(options.transformTagName, tagName, tagExp, options));
					const childNode = new XmlNode(tagName);
					if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
					this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
					this.matcher.pop();
					this.isCurrentNodeStopNode = false;
				} else if (options.unpairedTagsSet.has(tagName)) {
					const childNode = new XmlNode(tagName);
					if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
					this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
					this.matcher.pop();
					this.isCurrentNodeStopNode = false;
					i = result.closeIndex;
					continue;
				} else {
					const childNode = new XmlNode(tagName);
					if (this.tagsNodeStack.length > options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
					this.tagsNodeStack.push(currentNode);
					if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
					this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
					currentNode = childNode;
				}
				textData = "";
				i = closeIndex;
			}
		}
	} else textData += xmlData[i];
	return xmlObj.child;
};
function addChild(currentNode, childNode, matcher, startIndex) {
	if (!this.options.captureMetaData) startIndex = void 0;
	const jPathOrMatcher = this.options.jPath ? matcher.toString() : matcher;
	const result = this.options.updateTag(childNode.tagname, jPathOrMatcher, childNode[":@"]);
	if (result === false) {} else if (typeof result === "string") {
		childNode.tagname = result;
		currentNode.addChild(childNode, startIndex);
	} else currentNode.addChild(childNode, startIndex);
}
/**
* @param {object} val - Entity object with regex and val properties
* @param {string} tagName - Tag name
* @param {string|Matcher} jPath - jPath string or Matcher instance based on options.jPath
*/
function replaceEntitiesValue$1(val, tagName, jPath) {
	const entityConfig = this.options.processEntities;
	if (!entityConfig || !entityConfig.enabled) return val;
	if (entityConfig.allowedTags) {
		const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
		if (!(Array.isArray(entityConfig.allowedTags) ? entityConfig.allowedTags.includes(tagName) : entityConfig.allowedTags(tagName, jPathOrMatcher))) return val;
	}
	if (entityConfig.tagFilter) {
		const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
		if (!entityConfig.tagFilter(tagName, jPathOrMatcher)) return val;
	}
	return this.entityDecoder.decode(val);
}
__name(replaceEntitiesValue$1, "replaceEntitiesValue");
function saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {
	if (textData) {
		if (isLeafNode === void 0) isLeafNode = parentNode.child.length === 0;
		textData = this.parseTextData(textData, parentNode.tagname, matcher, false, parentNode[":@"] ? Object.keys(parentNode[":@"]).length !== 0 : false, isLeafNode);
		if (textData !== void 0 && textData !== "") parentNode.add(this.options.textNodeName, textData);
		textData = "";
	}
	return textData;
}
/**
* @param {Array<Expression>} stopNodeExpressions - Array of compiled Expression objects
* @param {Matcher} matcher - Current path matcher
*/
function isItStopNode() {
	if (this.stopNodeExpressionsSet.size === 0) return false;
	return this.matcher.matchesAny(this.stopNodeExpressionsSet);
}
/**
* Returns the tag Expression and where it is ending handling single-double quotes situation
* @param {string} xmlData 
* @param {number} i starting index
* @returns 
*/
function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
	let attrBoundary = 0;
	const len = xmlData.length;
	const closeCode0 = closingChar.charCodeAt(0);
	const closeCode1 = closingChar.length > 1 ? closingChar.charCodeAt(1) : -1;
	let result = "";
	let segmentStart = i;
	for (let index = i; index < len; index++) {
		const code = xmlData.charCodeAt(index);
		if (attrBoundary) {
			if (code === attrBoundary) attrBoundary = 0;
		} else if (code === 34 || code === 39) attrBoundary = code;
		else if (code === closeCode0) {
			if (closeCode1 !== -1) {
				if (xmlData.charCodeAt(index + 1) === closeCode1) {
					result += xmlData.substring(segmentStart, index);
					return {
						data: result,
						index
					};
				}
			} else {
				result += xmlData.substring(segmentStart, index);
				return {
					data: result,
					index
				};
			}
		} else if (code === 9 && !attrBoundary) {
			result += xmlData.substring(segmentStart, index) + " ";
			segmentStart = index + 1;
		}
	}
}
function findClosingIndex(xmlData, str, i, errMsg) {
	const closingIndex = xmlData.indexOf(str, i);
	if (closingIndex === -1) throw new Error(errMsg);
	else return closingIndex + str.length - 1;
}
function findClosingChar(xmlData, char, i, errMsg) {
	const closingIndex = xmlData.indexOf(char, i);
	if (closingIndex === -1) throw new Error(errMsg);
	return closingIndex;
}
function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
	const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
	if (!result) return;
	let tagExp = result.data;
	const closeIndex = result.index;
	const separatorIndex = tagExp.search(/\s/);
	let tagName = tagExp;
	let attrExpPresent = true;
	if (separatorIndex !== -1) {
		tagName = tagExp.substring(0, separatorIndex);
		tagExp = tagExp.substring(separatorIndex + 1).trimStart();
	}
	const rawTagName = tagName;
	if (removeNSPrefix) {
		const colonIndex = tagName.indexOf(":");
		if (colonIndex !== -1) {
			tagName = tagName.substr(colonIndex + 1);
			attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
		}
	}
	return {
		tagName,
		tagExp,
		closeIndex,
		attrExpPresent,
		rawTagName
	};
}
/**
* find paired tag for a stop node
* @param {string} xmlData 
* @param {string} tagName 
* @param {number} i 
*/
function readStopNodeData(xmlData, tagName, i) {
	const startIndex = i;
	let openTagCount = 1;
	const xmllen = xmlData.length;
	for (; i < xmllen; i++) if (xmlData[i] === "<") {
		const c1 = xmlData.charCodeAt(i + 1);
		if (c1 === 47) {
			const closeIndex = findClosingChar(xmlData, ">", i, `${tagName} is not closed`);
			if (xmlData.substring(i + 2, closeIndex).trim() === tagName) {
				openTagCount--;
				if (openTagCount === 0) return {
					tagContent: xmlData.substring(startIndex, i),
					i: closeIndex
				};
			}
			i = closeIndex;
		} else if (c1 === 63) i = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
		else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 45 && xmlData.charCodeAt(i + 3) === 45) i = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
		else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 91) i = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
		else {
			const tagData = readTagExp(xmlData, i, false);
			if (tagData) {
				if ((tagData && tagData.tagName) === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") openTagCount++;
				i = tagData.closeIndex;
			}
		}
	}
}
function parseValue(val, shouldParse, options) {
	if (shouldParse && typeof val === "string") {
		const newval = val.trim();
		if (newval === "true") return true;
		else if (newval === "false") return false;
		else return toNumber(val, options);
	} else if (isExist(val)) return val;
	else return "";
}
function transformTagName(fn, tagName, tagExp, options) {
	if (fn) {
		const newTagName = fn(tagName);
		if (tagExp === tagName) tagExp = newTagName;
		tagName = newTagName;
	}
	tagName = sanitizeName(tagName, options);
	return {
		tagName,
		tagExp
	};
}
function sanitizeName(name, options) {
	if (criticalProperties.includes(name)) throw new Error(`[SECURITY] Invalid name: "${name}" is a reserved JavaScript keyword that could cause prototype pollution`);
	else if (DANGEROUS_PROPERTY_NAMES.includes(name)) return options.onDangerousProperty(name);
	return name;
}
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/xmlparser/node2json.js
var METADATA_SYMBOL = XmlNode.getMetaDataSymbol();
/**
* Helper function to strip attribute prefix from attribute map
* @param {object} attrs - Attributes with prefix (e.g., {"@_class": "code"})
* @param {string} prefix - Attribute prefix to remove (e.g., "@_")
* @returns {object} Attributes without prefix (e.g., {"class": "code"})
*/
function stripAttributePrefix(attrs, prefix) {
	if (!attrs || typeof attrs !== "object") return {};
	if (!prefix) return attrs;
	const rawAttrs = {};
	for (const key in attrs) if (key.startsWith(prefix)) {
		const rawName = key.substring(prefix.length);
		rawAttrs[rawName] = attrs[key];
	} else rawAttrs[key] = attrs[key];
	return rawAttrs;
}
/**
* 
* @param {array} node 
* @param {any} options 
* @param {Matcher} matcher - Path matcher instance
* @returns 
*/
function prettify(node, options, matcher, readonlyMatcher) {
	return compress(node, options, matcher, readonlyMatcher);
}
/**
* @param {array} arr 
* @param {object} options 
* @param {Matcher} matcher - Path matcher instance
* @returns object
*/
function compress(arr, options, matcher, readonlyMatcher) {
	let text;
	const compressedObj = {};
	for (let i = 0; i < arr.length; i++) {
		const tagObj = arr[i];
		const property = propName$1(tagObj);
		if (property !== void 0 && property !== options.textNodeName) {
			const rawAttrs = stripAttributePrefix(tagObj[":@"] || {}, options.attributeNamePrefix);
			matcher.push(property, rawAttrs);
		}
		if (property === options.textNodeName) {
			if (text === void 0) text = tagObj[property];
			else text += "" + tagObj[property];
		} else if (property === void 0) continue;
		else if (tagObj[property]) {
			let val = compress(tagObj[property], options, matcher, readonlyMatcher);
			const isLeaf = isLeafTag(val, options);
			if (Object.keys(val).length === 0 && options.alwaysCreateTextNode) val[options.textNodeName] = "";
			if (tagObj[":@"]) assignAttributes(val, tagObj[":@"], readonlyMatcher, options);
			else if (Object.keys(val).length === 1 && val[options.textNodeName] !== void 0 && !options.alwaysCreateTextNode) val = val[options.textNodeName];
			else if (Object.keys(val).length === 0) {
				if (options.alwaysCreateTextNode) val[options.textNodeName] = "";
				else val = "";
			}
			if (tagObj[METADATA_SYMBOL] !== void 0 && typeof val === "object" && val !== null) val[METADATA_SYMBOL] = tagObj[METADATA_SYMBOL];
			if (compressedObj[property] !== void 0 && Object.prototype.hasOwnProperty.call(compressedObj, property)) {
				if (!Array.isArray(compressedObj[property])) compressedObj[property] = [compressedObj[property]];
				compressedObj[property].push(val);
			} else {
				const jPathOrMatcher = options.jPath ? readonlyMatcher.toString() : readonlyMatcher;
				if (options.isArray(property, jPathOrMatcher, isLeaf)) compressedObj[property] = [val];
				else compressedObj[property] = val;
			}
			if (property !== void 0 && property !== options.textNodeName) matcher.pop();
		}
	}
	if (typeof text === "string") {
		if (text.length > 0) compressedObj[options.textNodeName] = text;
	} else if (text !== void 0) compressedObj[options.textNodeName] = text;
	return compressedObj;
}
function propName$1(obj) {
	const keys = Object.keys(obj);
	for (let i = 0; i < keys.length; i++) {
		const key = keys[i];
		if (key !== ":@") return key;
	}
}
__name(propName$1, "propName");
function assignAttributes(obj, attrMap, readonlyMatcher, options) {
	if (attrMap) {
		const keys = Object.keys(attrMap);
		const len = keys.length;
		for (let i = 0; i < len; i++) {
			const atrrName = keys[i];
			const rawAttrName = atrrName.startsWith(options.attributeNamePrefix) ? atrrName.substring(options.attributeNamePrefix.length) : atrrName;
			const jPathOrMatcher = options.jPath ? readonlyMatcher.toString() + "." + rawAttrName : readonlyMatcher;
			if (options.isArray(atrrName, jPathOrMatcher, true, true)) obj[atrrName] = [attrMap[atrrName]];
			else obj[atrrName] = attrMap[atrrName];
		}
	}
}
function isLeafTag(obj, options) {
	const { textNodeName } = options;
	const propCount = Object.keys(obj).length;
	if (propCount === 0) return true;
	if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)) return true;
	return false;
}
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
var XMLParser = class {
	constructor(options) {
		this.externalEntities = {};
		this.options = buildOptions(options);
	}
	/**
	* Parse XML dats to JS object 
	* @param {string|Uint8Array} xmlData 
	* @param {boolean|Object} validationOption 
	*/
	parse(xmlData, validationOption) {
		if (typeof xmlData !== "string" && xmlData.toString) xmlData = xmlData.toString();
		else if (typeof xmlData !== "string") throw new Error("XML data is accepted in String or Bytes[] form.");
		if (validationOption) {
			if (validationOption === true) validationOption = {};
			const result = validate(xmlData, validationOption);
			if (result !== true) throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`);
		}
		const orderedObjParser = new OrderedObjParser(this.options, this.externalEntities);
		const orderedResult = orderedObjParser.parseXml(xmlData);
		if (this.options.preserveOrder || orderedResult === void 0) return orderedResult;
		else return prettify(orderedResult, this.options, orderedObjParser.matcher, orderedObjParser.readonlyMatcher);
	}
	/**
	* Add Entity which is not by default supported by this library
	* @param {string} key 
	* @param {string} value 
	*/
	addEntity(key, value) {
		if (value.indexOf("&") !== -1) throw new Error("Entity value can't have '&'");
		else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
		else if (value === "&") throw new Error("An entity with value '&' is not permitted");
		else this.externalEntities[key] = value;
	}
	/**
	* Returns a Symbol that can be used to access the metadata
	* property on a node.
	* 
	* If Symbol is not available in the environment, an ordinary property is used
	* and the name of the property is here returned.
	* 
	* The XMLMetaData property is only present when `captureMetaData`
	* is true in the options.
	*/
	static getMetaDataSymbol() {
		return XmlNode.getMetaDataSymbol();
	}
};
//#endregion
//#region node_modules/.pnpm/fast-xml-builder@1.3.0/node_modules/fast-xml-builder/src/util.js
function safeComment(val) {
	return String(val).replace(/--/g, "- -").replace(/--/g, "- -").replace(/-$/, "- ");
}
function safeCdata(val) {
	return String(val).replace(/\]\]>/g, "]]]]><![CDATA[>");
}
function escapeAttribute(val) {
	return String(val).replace(/"/g, "&quot;").replace(/'/g, "&apos;");
}
//#endregion
//#region node_modules/.pnpm/fast-xml-builder@1.3.0/node_modules/fast-xml-builder/src/orderedJs2Xml.js
var EOL$2 = "\n";
/**
* Detect XML version from the first element of the ordered array input.
* The first element must be a ?xml processing instruction with a version attribute.
* Returns '1.0' if not found.
*
* @param {array}  jArray
* @param {object} options
*/
function detectXmlVersionFromArray(jArray, options) {
	if (!Array.isArray(jArray) || jArray.length === 0) return "1.0";
	const first = jArray[0];
	if (propName(first) === "?xml") {
		const attrs = first[":@"];
		if (attrs) {
			const versionKey = options.attributeNamePrefix + "version";
			if (attrs[versionKey]) return attrs[versionKey];
		}
	}
	return "1.0";
}
/**
* Resolve a tag or attribute name through sanitizeName if configured.
* Validation via xml-naming's qName is performed first; the sanitizeName
* callback is invoked only when the name is invalid. If sanitizeName is
* false (default), no validation occurs and the name is used as-is.
*
* @param {string}  name        - raw name from the JS object
* @param {boolean} isAttribute - true when resolving an attribute name
* @param {object}  options
* @param {Matcher} matcher     - current matcher state (readonly from callback perspective)
* @param {function} qNameValidator - function to validate tag names
*/
function resolveTagName$1(name, isAttribute, options, matcher, qNameValidator) {
	if (!options.sanitizeName) return name;
	if (qNameValidator(name)) return name;
	return options.sanitizeName(name, {
		isAttribute,
		matcher: matcher.readOnly()
	});
}
__name(resolveTagName$1, "resolveTagName");
/**
* @param {array} jArray
* @param {any} options
* @returns
*/
function toXml(jArray, options) {
	let indentation = "";
	if (options.format) indentation = EOL$2;
	const stopNodeExpressions = [];
	if (options.stopNodes && Array.isArray(options.stopNodes)) for (let i = 0; i < options.stopNodes.length; i++) {
		const node = options.stopNodes[i];
		if (typeof node === "string") stopNodeExpressions.push(new Expression(node));
		else if (node instanceof Expression) stopNodeExpressions.push(node);
	}
	const qNameValidator = createValidator("qName", { xmlVersion: detectXmlVersionFromArray(jArray, options) });
	const matcher = new Matcher();
	return arrToStr(jArray, options, indentation, matcher, stopNodeExpressions, qNameValidator);
}
function arrToStr(arr, options, indentation, matcher, stopNodeExpressions, qNameValidator) {
	let xmlStr = "";
	let isPreviousElementTag = false;
	if (options.maxNestedTags && matcher.getDepth() > options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
	if (!Array.isArray(arr)) {
		if (arr !== void 0 && arr !== null) {
			let text = arr.toString();
			text = replaceEntitiesValue(text, options);
			return text;
		}
		return "";
	}
	for (let i = 0; i < arr.length; i++) {
		const tagObj = arr[i];
		const rawTagName = propName(tagObj);
		if (rawTagName === void 0) continue;
		const tagName = rawTagName === options.textNodeName || rawTagName === options.cdataPropName || rawTagName === options.commentPropName || rawTagName[0] === "?" ? rawTagName : resolveTagName$1(rawTagName, false, options, matcher, qNameValidator);
		const attrValues = extractAttributeValues(tagObj[":@"], options);
		matcher.push(tagName, attrValues);
		const isStopNode = checkStopNode(matcher, stopNodeExpressions);
		if (tagName === options.textNodeName) {
			let tagText = tagObj[rawTagName];
			if (!isStopNode) {
				tagText = options.tagValueProcessor(tagName, tagText);
				tagText = replaceEntitiesValue(tagText, options);
			}
			if (isPreviousElementTag) xmlStr += indentation;
			xmlStr += tagText;
			isPreviousElementTag = false;
			matcher.pop();
			continue;
		} else if (tagName === options.cdataPropName) {
			if (isPreviousElementTag) xmlStr += indentation;
			const val = tagObj[rawTagName][0][options.textNodeName];
			const safeVal = safeCdata(val);
			xmlStr += `<![CDATA[${safeVal}]]>`;
			isPreviousElementTag = false;
			matcher.pop();
			continue;
		} else if (tagName === options.commentPropName) {
			const val = tagObj[rawTagName][0][options.textNodeName];
			const safeVal = safeComment(val);
			xmlStr += indentation + `<!--${safeVal}-->`;
			isPreviousElementTag = true;
			matcher.pop();
			continue;
		} else if (tagName[0] === "?") {
			const attStr = attr_to_str(tagObj[":@"], options, isStopNode, matcher, qNameValidator);
			xmlStr += (tagName === "?xml" ? "" : indentation) + `<${tagName}${attStr}?>`;
			isPreviousElementTag = true;
			matcher.pop();
			continue;
		}
		let newIdentation = indentation;
		if (newIdentation !== "") newIdentation += options.indentBy;
		const tagStart = indentation + `<${tagName}${attr_to_str(tagObj[":@"], options, isStopNode, matcher, qNameValidator)}`;
		let tagValue;
		if (isStopNode) tagValue = getRawContent(tagObj[rawTagName], options);
		else tagValue = arrToStr(tagObj[rawTagName], options, newIdentation, matcher, stopNodeExpressions, qNameValidator);
		if (options.unpairedTags.indexOf(tagName) !== -1) {
			if (options.suppressUnpairedNode) xmlStr += tagStart + ">";
			else xmlStr += tagStart + "/>";
		} else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) xmlStr += tagStart + "/>";
		else if (tagValue && tagValue.endsWith(">")) xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;
		else {
			xmlStr += tagStart + ">";
			if (tagValue && indentation !== "" && (tagValue.includes("/>") || tagValue.includes("</"))) xmlStr += indentation + options.indentBy + tagValue + indentation;
			else xmlStr += tagValue;
			xmlStr += `</${tagName}>`;
		}
		isPreviousElementTag = true;
		matcher.pop();
	}
	return xmlStr;
}
/**
* Extract attribute values from the ":@" object and return as plain object
* for passing to matcher.push()
*/
function extractAttributeValues(attrMap, options) {
	if (!attrMap || options.ignoreAttributes) return null;
	const attrValues = {};
	let hasAttrs = false;
	for (let attr in attrMap) {
		if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;
		const cleanAttrName = attr.startsWith(options.attributeNamePrefix) ? attr.substr(options.attributeNamePrefix.length) : attr;
		attrValues[cleanAttrName] = escapeAttribute(attrMap[attr]);
		hasAttrs = true;
	}
	return hasAttrs ? attrValues : null;
}
/**
* Extract raw content from a stopNode without any processing
* This preserves the content exactly as-is, including special characters
*/
function getRawContent(arr, options) {
	if (!Array.isArray(arr)) {
		if (arr !== void 0 && arr !== null) return arr.toString();
		return "";
	}
	let content = "";
	for (let i = 0; i < arr.length; i++) {
		const item = arr[i];
		const tagName = propName(item);
		if (tagName === options.textNodeName) content += item[tagName];
		else if (tagName === options.cdataPropName) content += item[tagName][0][options.textNodeName];
		else if (tagName === options.commentPropName) content += item[tagName][0][options.textNodeName];
		else if (tagName && tagName[0] === "?") continue;
		else if (tagName) {
			const attStr = attr_to_str_raw(item[":@"], options);
			const nestedContent = getRawContent(item[tagName], options);
			if (!nestedContent || nestedContent.length === 0) content += `<${tagName}${attStr}/>`;
			else content += `<${tagName}${attStr}>${nestedContent}</${tagName}>`;
		}
	}
	return content;
}
/**
* Build attribute string for stopNodes - NO entity replacement
*/
function attr_to_str_raw(attrMap, options) {
	let attrStr = "";
	if (attrMap && !options.ignoreAttributes) for (let attr in attrMap) {
		if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;
		let attrVal = attrMap[attr];
		if (attrVal === true && options.suppressBooleanAttributes) attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;
		else attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${escapeAttribute(attrVal)}"`;
	}
	return attrStr;
}
function propName(obj) {
	const keys = Object.keys(obj);
	for (let i = 0; i < keys.length; i++) {
		const key = keys[i];
		if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
		if (key !== ":@") return key;
	}
}
/**
* Build attribute string, resolving attribute names through sanitizeName when configured.
* Accepts matcher so the callback has path context.
*/
function attr_to_str(attrMap, options, isStopNode, matcher, qNameValidator) {
	let attrStr = "";
	if (attrMap && !options.ignoreAttributes) for (let attr in attrMap) {
		if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;
		const cleanAttrName = attr.substr(options.attributeNamePrefix.length);
		const resolvedAttrName = isStopNode ? cleanAttrName : resolveTagName$1(cleanAttrName, true, options, matcher, qNameValidator);
		let attrVal;
		if (isStopNode) attrVal = attrMap[attr];
		else {
			attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
			attrVal = replaceEntitiesValue(attrVal, options);
		}
		if (attrVal === true && options.suppressBooleanAttributes) attrStr += ` ${resolvedAttrName}`;
		else attrStr += ` ${resolvedAttrName}="${escapeAttribute(attrVal)}"`;
	}
	return attrStr;
}
function checkStopNode(matcher, stopNodeExpressions) {
	if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;
	for (let i = 0; i < stopNodeExpressions.length; i++) if (matcher.matches(stopNodeExpressions[i])) return true;
	return false;
}
function replaceEntitiesValue(textValue, options) {
	if (textValue && textValue.length > 0 && options.processEntities) for (let i = 0; i < options.entities.length; i++) {
		const entity = options.entities[i];
		textValue = textValue.replace(entity.regex, entity.val);
	}
	return textValue;
}
//#endregion
//#region node_modules/.pnpm/fast-xml-builder@1.3.0/node_modules/fast-xml-builder/src/ignoreAttributes.js
function getIgnoreAttributesFn(ignoreAttributes) {
	if (typeof ignoreAttributes === "function") return ignoreAttributes;
	if (Array.isArray(ignoreAttributes)) return (attrName) => {
		for (const pattern of ignoreAttributes) {
			if (typeof pattern === "string" && attrName === pattern) return true;
			if (pattern instanceof RegExp && pattern.test(attrName)) return true;
		}
	};
	return () => false;
}
//#endregion
//#region node_modules/.pnpm/fast-xml-builder@1.3.0/node_modules/fast-xml-builder/src/fxb.js
var defaultOptions = {
	attributeNamePrefix: "@_",
	attributesGroupName: false,
	textNodeName: "#text",
	ignoreAttributes: true,
	cdataPropName: false,
	format: false,
	indentBy: "  ",
	suppressEmptyNode: false,
	suppressUnpairedNode: true,
	suppressBooleanAttributes: true,
	tagValueProcessor: function(key, a) {
		return a;
	},
	attributeValueProcessor: function(attrName, a) {
		return a;
	},
	preserveOrder: false,
	commentPropName: false,
	unpairedTags: [],
	entities: [
		{
			regex: /* @__PURE__ */ new RegExp("&", "g"),
			val: "&amp;"
		},
		{
			regex: /* @__PURE__ */ new RegExp(">", "g"),
			val: "&gt;"
		},
		{
			regex: /* @__PURE__ */ new RegExp("<", "g"),
			val: "&lt;"
		},
		{
			regex: /* @__PURE__ */ new RegExp("'", "g"),
			val: "&apos;"
		},
		{
			regex: /* @__PURE__ */ new RegExp("\"", "g"),
			val: "&quot;"
		}
	],
	processEntities: true,
	stopNodes: [],
	oneListGroup: false,
	maxNestedTags: 100,
	jPath: true,
	sanitizeName: false
};
function Builder(options) {
	this.options = Object.assign({}, defaultOptions, options);
	if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) this.options.stopNodes = this.options.stopNodes.map((node) => {
		if (typeof node === "string" && node.startsWith("*.")) return ".." + node.substring(2);
		return node;
	});
	this.stopNodeExpressions = [];
	if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) for (let i = 0; i < this.options.stopNodes.length; i++) {
		const node = this.options.stopNodes[i];
		if (typeof node === "string") this.stopNodeExpressions.push(new Expression(node));
		else if (node instanceof Expression) this.stopNodeExpressions.push(node);
	}
	if (this.options.ignoreAttributes === true || this.options.attributesGroupName) this.isAttribute = function() {
		return false;
	};
	else {
		this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
		this.attrPrefixLen = this.options.attributeNamePrefix.length;
		this.isAttribute = isAttribute;
	}
	this.processTextOrObjNode = processTextOrObjNode;
	if (this.options.format) {
		this.indentate = indentate;
		this.tagEndChar = ">\n";
		this.newLine = "\n";
	} else {
		this.indentate = function() {
			return "";
		};
		this.tagEndChar = ">";
		this.newLine = "";
	}
}
/**
* Detect XML version from the ?xml declaration at the root of a plain-object input.
* Checks both attributesGroupName and flat attribute forms.
* Returns '1.0' if no declaration is found.
*/
function detectXmlVersionFromObj(jObj, options) {
	const decl = jObj["?xml"];
	if (decl && typeof decl === "object") {
		if (options.attributesGroupName && decl[options.attributesGroupName]) {
			const v = decl[options.attributesGroupName][options.attributeNamePrefix + "version"];
			if (v) return v;
		}
		const v = decl[options.attributeNamePrefix + "version"];
		if (v) return v;
	}
	return "1.0";
}
/**
* Resolve a tag or attribute name through sanitizeName if configured.
* Validation via xml-naming's qName is performed first; the sanitizeName
* callback is invoked only when the name is invalid. If sanitizeName is
* false (default), no validation occurs and the name is used as-is.
*
* @param {string}  name        - raw name from the JS object
* @param {boolean} isAttribute - true when resolving an attribute name
* @param {object}  options
* @param {Matcher} matcher     - current matcher state (readonly from callback perspective)
* @param {function} qNameValidator - function to validate tag names
*/
function resolveTagName(name, isAttribute, options, matcher, qNameValidator) {
	if (!options.sanitizeName) return name;
	if (qNameValidator(name)) return name;
	return options.sanitizeName(name, {
		isAttribute,
		matcher: matcher.readOnly()
	});
}
Builder.prototype.build = function(jObj) {
	if (this.options.preserveOrder) return toXml(jObj, this.options);
	else {
		if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) jObj = { [this.options.arrayNodeName]: jObj };
		const matcher = new Matcher();
		const qNameValidator = createValidator("qName", { xmlVersion: detectXmlVersionFromObj(jObj, this.options) });
		return this.j2x(jObj, 0, matcher, qNameValidator).val;
	}
};
Builder.prototype.j2x = function(jObj, level, matcher, qNameValidator) {
	let attrStr = "";
	let val = "";
	if (this.options.maxNestedTags && matcher.getDepth() >= this.options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
	const jPath = this.options.jPath ? matcher.toString() : matcher;
	const isCurrentStopNode = this.checkStopNode(matcher);
	for (let key in jObj) {
		if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;
		const resolvedKey = key === this.options.textNodeName || key === this.options.cdataPropName || key === this.options.commentPropName || this.options.attributesGroupName && key === this.options.attributesGroupName || this.isAttribute(key) || key[0] === "?" ? key : resolveTagName(key, false, this.options, matcher, qNameValidator);
		if (typeof jObj[key] === "undefined") {
			if (this.isAttribute(key)) val += "";
		} else if (jObj[key] === null) {
			if (this.isAttribute(key)) val += "";
			else if (resolvedKey === this.options.cdataPropName || resolvedKey === this.options.commentPropName) val += "";
			else if (resolvedKey[0] === "?") val += this.indentate(level) + "<" + resolvedKey + "?" + this.tagEndChar;
			else val += this.indentate(level) + "<" + resolvedKey + "/" + this.tagEndChar;
		} else if (jObj[key] instanceof Date) val += this.buildTextValNode(jObj[key], resolvedKey, "", level, matcher);
		else if (typeof jObj[key] !== "object") {
			const attr = this.isAttribute(key);
			if (attr && !this.ignoreAttributesFn(attr, jPath)) {
				const resolvedAttr = resolveTagName(attr, true, this.options, matcher, qNameValidator);
				attrStr += this.buildAttrPairStr(resolvedAttr, "" + jObj[key], isCurrentStopNode);
			} else if (!attr) {
				if (key === this.options.textNodeName) {
					let newval = this.options.tagValueProcessor(key, "" + jObj[key]);
					val += this.replaceEntitiesValue(newval);
				} else {
					matcher.push(resolvedKey);
					const isStopNode = this.checkStopNode(matcher);
					matcher.pop();
					if (isStopNode) {
						const textValue = "" + jObj[key];
						if (textValue === "") val += this.indentate(level) + "<" + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;
						else val += this.indentate(level) + "<" + resolvedKey + ">" + textValue + "</" + resolvedKey + this.tagEndChar;
					} else val += this.buildTextValNode(jObj[key], resolvedKey, "", level, matcher);
				}
			}
		} else if (Array.isArray(jObj[key])) {
			const arrLen = jObj[key].length;
			let listTagVal = "";
			let listTagAttr = "";
			for (let j = 0; j < arrLen; j++) {
				const item = jObj[key][j];
				if (typeof item === "undefined") {} else if (item === null) {
					if (resolvedKey[0] === "?") val += this.indentate(level) + "<" + resolvedKey + "?" + this.tagEndChar;
					else val += this.indentate(level) + "<" + resolvedKey + "/" + this.tagEndChar;
				} else if (typeof item === "object") {
					if (this.options.oneListGroup) {
						matcher.push(resolvedKey);
						const result = this.j2x(item, level + 1, matcher, qNameValidator);
						matcher.pop();
						listTagVal += result.val;
						if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) listTagAttr += result.attrStr;
					} else listTagVal += this.processTextOrObjNode(item, resolvedKey, level, matcher, qNameValidator);
				} else if (this.options.oneListGroup) {
					let textValue = this.options.tagValueProcessor(resolvedKey, item);
					textValue = this.replaceEntitiesValue(textValue);
					listTagVal += textValue;
				} else {
					matcher.push(resolvedKey);
					const isStopNode = this.checkStopNode(matcher);
					matcher.pop();
					if (isStopNode) {
						const textValue = "" + item;
						if (textValue === "") listTagVal += this.indentate(level) + "<" + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;
						else listTagVal += this.indentate(level) + "<" + resolvedKey + ">" + textValue + "</" + resolvedKey + this.tagEndChar;
					} else listTagVal += this.buildTextValNode(item, resolvedKey, "", level, matcher);
				}
			}
			if (this.options.oneListGroup) listTagVal = this.buildObjectNode(listTagVal, resolvedKey, listTagAttr, level);
			val += listTagVal;
		} else if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
			const Ks = Object.keys(jObj[key]);
			const L = Ks.length;
			for (let j = 0; j < L; j++) {
				const resolvedAttr = resolveTagName(Ks[j], true, this.options, matcher, qNameValidator);
				attrStr += this.buildAttrPairStr(resolvedAttr, "" + jObj[key][Ks[j]], isCurrentStopNode);
			}
		} else val += this.processTextOrObjNode(jObj[key], resolvedKey, level, matcher, qNameValidator);
	}
	return {
		attrStr,
		val
	};
};
Builder.prototype.buildAttrPairStr = function(attrName, val, isStopNode) {
	if (!isStopNode) {
		val = this.options.attributeValueProcessor(attrName, "" + val);
		val = this.replaceEntitiesValue(val);
	}
	if (this.options.suppressBooleanAttributes && val === "true") return " " + attrName;
	else return " " + attrName + "=\"" + escapeAttribute(val) + "\"";
};
function processTextOrObjNode(object, key, level, matcher, qNameValidator) {
	const attrValues = this.extractAttributes(object);
	matcher.push(key, attrValues);
	if (this.checkStopNode(matcher)) {
		const rawContent = this.buildRawContent(object);
		const attrStr = this.buildAttributesForStopNode(object);
		matcher.pop();
		return this.buildObjectNode(rawContent, key, attrStr, level);
	}
	const result = this.j2x(object, level + 1, matcher, qNameValidator);
	matcher.pop();
	if (key[0] === "?") return this.buildTextValNode("", key, result.attrStr, level, matcher);
	else if (object[this.options.textNodeName] !== void 0 && Object.keys(object).length === 1) return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level, matcher);
	else return this.buildObjectNode(result.val, key, result.attrStr, level);
}
Builder.prototype.extractAttributes = function(obj) {
	if (!obj || typeof obj !== "object") return null;
	const attrValues = {};
	let hasAttrs = false;
	if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {
		const attrGroup = obj[this.options.attributesGroupName];
		for (let attrKey in attrGroup) {
			if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;
			const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix) ? attrKey.substring(this.options.attributeNamePrefix.length) : attrKey;
			attrValues[cleanKey] = escapeAttribute(attrGroup[attrKey]);
			hasAttrs = true;
		}
	} else for (let key in obj) {
		if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
		const attr = this.isAttribute(key);
		if (attr) {
			attrValues[attr] = escapeAttribute(obj[key]);
			hasAttrs = true;
		}
	}
	return hasAttrs ? attrValues : null;
};
Builder.prototype.buildRawContent = function(obj) {
	if (typeof obj === "string") return obj;
	if (typeof obj !== "object" || obj === null) return String(obj);
	if (obj[this.options.textNodeName] !== void 0) return obj[this.options.textNodeName];
	let content = "";
	for (let key in obj) {
		if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
		if (this.isAttribute(key)) continue;
		if (this.options.attributesGroupName && key === this.options.attributesGroupName) continue;
		const value = obj[key];
		if (key === this.options.textNodeName) content += value;
		else if (Array.isArray(value)) {
			for (let item of value) if (typeof item === "string" || typeof item === "number") content += `<${key}>${item}</${key}>`;
			else if (typeof item === "object" && item !== null) {
				const nestedContent = this.buildRawContent(item);
				const nestedAttrs = this.buildAttributesForStopNode(item);
				if (nestedContent === "") content += `<${key}${nestedAttrs}/>`;
				else content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;
			}
		} else if (typeof value === "object" && value !== null) {
			const nestedContent = this.buildRawContent(value);
			const nestedAttrs = this.buildAttributesForStopNode(value);
			if (nestedContent === "") content += `<${key}${nestedAttrs}/>`;
			else content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;
		} else content += `<${key}>${value}</${key}>`;
	}
	return content;
};
Builder.prototype.buildAttributesForStopNode = function(obj) {
	if (!obj || typeof obj !== "object") return "";
	let attrStr = "";
	if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {
		const attrGroup = obj[this.options.attributesGroupName];
		for (let attrKey in attrGroup) {
			if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;
			const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix) ? attrKey.substring(this.options.attributeNamePrefix.length) : attrKey;
			const val = attrGroup[attrKey];
			if (val === true && this.options.suppressBooleanAttributes) attrStr += " " + cleanKey;
			else attrStr += " " + cleanKey + "=\"" + escapeAttribute(val) + "\"";
		}
	} else for (let key in obj) {
		if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
		const attr = this.isAttribute(key);
		if (attr) {
			const val = obj[key];
			if (val === true && this.options.suppressBooleanAttributes) attrStr += " " + attr;
			else attrStr += " " + attr + "=\"" + escapeAttribute(val) + "\"";
		}
	}
	return attrStr;
};
Builder.prototype.buildObjectNode = function(val, key, attrStr, level) {
	if (val === "") {
		if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
		else return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
	} else if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
	else {
		let tagEndExp = "</" + key + this.tagEndChar;
		let piClosingChar = "";
		if (key[0] === "?") {
			piClosingChar = "?";
			tagEndExp = "";
		}
		if ((attrStr || attrStr === "") && val.indexOf("<") === -1) return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val + tagEndExp;
		else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) return this.indentate(level) + `<!--${safeComment(val)}-->` + this.newLine;
		else return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val + this.indentate(level) + tagEndExp;
	}
};
Builder.prototype.closeTag = function(key) {
	let closeTag = "";
	if (this.options.unpairedTags.indexOf(key) !== -1) {
		if (!this.options.suppressUnpairedNode) closeTag = "/";
	} else if (this.options.suppressEmptyNode) closeTag = "/";
	else closeTag = `></${key}`;
	return closeTag;
};
Builder.prototype.checkStopNode = function(matcher) {
	if (!this.stopNodeExpressions || this.stopNodeExpressions.length === 0) return false;
	for (let i = 0; i < this.stopNodeExpressions.length; i++) if (matcher.matches(this.stopNodeExpressions[i])) return true;
	return false;
};
Builder.prototype.buildTextValNode = function(val, key, attrStr, level, matcher) {
	if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
		const safeVal = safeCdata(val);
		return this.indentate(level) + `<![CDATA[${safeVal}]]>` + this.newLine;
	} else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
		const safeVal = safeComment(val);
		return this.indentate(level) + `<!--${safeVal}-->` + this.newLine;
	} else if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
	else {
		let textValue = this.options.tagValueProcessor(key, val);
		textValue = this.replaceEntitiesValue(textValue);
		if (textValue === "") return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
		else return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar;
	}
};
Builder.prototype.replaceEntitiesValue = function(textValue) {
	if (textValue && textValue.length > 0 && this.options.processEntities) for (let i = 0; i < this.options.entities.length; i++) {
		const entity = this.options.entities[i];
		textValue = textValue.replace(entity.regex, entity.val);
	}
	return textValue;
};
function indentate(level) {
	return this.options.indentBy.repeat(level);
}
function isAttribute(name) {
	if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) return name.substr(this.attrPrefixLen);
	else return false;
}
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js
var json2xml_default = Builder;
//#endregion
//#region node_modules/.pnpm/fast-xml-parser@5.10.1/node_modules/fast-xml-parser/src/fxp.js
var XMLValidator = { validate };
//#endregion
//#region node_modules/.pnpm/@azure+core-xml@1.6.0/node_modules/@azure/core-xml/dist/esm/xml.js
function getCommonOptions(options) {
	return {
		attributesGroupName: "$",
		textNodeName: options.xmlCharKey ?? "_",
		ignoreAttributes: false,
		suppressBooleanAttributes: false
	};
}
function getSerializerOptions(options = {}) {
	return {
		...getCommonOptions(options),
		attributeNamePrefix: "@_",
		format: true,
		suppressEmptyNode: true,
		indentBy: "",
		rootNodeName: options.rootName ?? "root",
		cdataPropName: options.cdataPropName ?? "__cdata"
	};
}
function getParserOptions(options = {}) {
	return {
		...getCommonOptions(options),
		parseAttributeValue: false,
		parseTagValue: false,
		attributeNamePrefix: "",
		stopNodes: options.stopNodes,
		processEntities: true,
		trimValues: false
	};
}
/**
* Converts given JSON object to XML string
* @param obj - JSON object to be converted into XML string
* @param opts - Options that govern the XML building of given JSON object
* `rootName` indicates the name of the root element in the resulting XML
*/
function stringifyXML(obj, opts = {}) {
	const parserOptions = getSerializerOptions(opts);
	const j2x = new json2xml_default(parserOptions);
	const node = { [parserOptions.rootNodeName]: obj };
	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>${j2x.build(node)}`.replace(/\n/g, "");
}
/**
* Converts given XML string into JSON
* @param str - String containing the XML content to be parsed into JSON
* @param opts - Options that govern the parsing of given xml string
* `includeRoot` indicates whether the root element is to be included or not in the output
*/
async function parseXML(str, opts = {}) {
	if (!str) throw new Error("Document is empty");
	const validation = XMLValidator.validate(str);
	if (validation !== true) throw validation;
	const parsedXml = new XMLParser(getParserOptions(opts)).parse(str);
	if (parsedXml["?xml"]) delete parsedXml["?xml"];
	if (!opts.includeRoot) {
		const key = Object.keys(parsedXml)[0];
		if (key !== void 0) {
			const value = parsedXml[key];
			return typeof value === "object" ? { ...value } : value;
		}
	}
	return parsedXml;
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/log.js
/**
* The `@azure/logger` configuration for this package.
*/
var logger$1 = createClientLogger("storage-blob");
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/BuffersStream.js
/**
* This class generates a readable stream from the data in an array of buffers.
*/
var BuffersStream = class extends Readable {
	buffers;
	byteLength;
	/**
	* The offset of data to be read in the current buffer.
	*/
	byteOffsetInCurrentBuffer;
	/**
	* The index of buffer to be read in the array of buffers.
	*/
	bufferIndex;
	/**
	* The total length of data already read.
	*/
	pushedBytesLength;
	/**
	* Creates an instance of BuffersStream that will emit the data
	* contained in the array of buffers.
	*
	* @param buffers - Array of buffers containing the data
	* @param byteLength - The total length of data contained in the buffers
	*/
	constructor(buffers, byteLength, options) {
		super(options);
		this.buffers = buffers;
		this.byteLength = byteLength;
		this.byteOffsetInCurrentBuffer = 0;
		this.bufferIndex = 0;
		this.pushedBytesLength = 0;
		let buffersLength = 0;
		for (const buf of this.buffers) buffersLength += buf.byteLength;
		if (buffersLength < this.byteLength) throw new Error("Data size shouldn't be larger than the total length of buffers.");
	}
	/**
	* Internal _read() that will be called when the stream wants to pull more data in.
	*
	* @param size - Optional. The size of data to be read
	*/
	_read(size) {
		if (this.pushedBytesLength >= this.byteLength) this.push(null);
		if (!size) size = this.readableHighWaterMark;
		const outBuffers = [];
		let i = 0;
		while (i < size && this.pushedBytesLength < this.byteLength) {
			const remainingDataInAllBuffers = this.byteLength - this.pushedBytesLength;
			const remainingCapacityInThisBuffer = this.buffers[this.bufferIndex].byteLength - this.byteOffsetInCurrentBuffer;
			const remaining = Math.min(remainingCapacityInThisBuffer, remainingDataInAllBuffers);
			if (remaining > size - i) {
				const end = this.byteOffsetInCurrentBuffer + size - i;
				outBuffers.push(this.buffers[this.bufferIndex].slice(this.byteOffsetInCurrentBuffer, end));
				this.pushedBytesLength += size - i;
				this.byteOffsetInCurrentBuffer = end;
				i = size;
				break;
			} else {
				const end = this.byteOffsetInCurrentBuffer + remaining;
				outBuffers.push(this.buffers[this.bufferIndex].slice(this.byteOffsetInCurrentBuffer, end));
				if (remaining === remainingCapacityInThisBuffer) {
					this.byteOffsetInCurrentBuffer = 0;
					this.bufferIndex++;
				} else this.byteOffsetInCurrentBuffer = end;
				this.pushedBytesLength += remaining;
				i += remaining;
			}
		}
		if (outBuffers.length > 1) this.push(Buffer.concat(outBuffers));
		else if (outBuffers.length === 1) this.push(outBuffers[0]);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/PooledBuffer.js
/**
* maxBufferLength is max size of each buffer in the pooled buffers.
*/
var maxBufferLength = buffer.constants.MAX_LENGTH;
/**
* This class provides a buffer container which conceptually has no hard size limit.
* It accepts a capacity, an array of input buffers and the total length of input data.
* It will allocate an internal "buffer" of the capacity and fill the data in the input buffers
* into the internal "buffer" serially with respect to the total length.
* Then by calling PooledBuffer.getReadableStream(), you can get a readable stream
* assembled from all the data in the internal "buffer".
*/
var PooledBuffer = class {
	/**
	* Internal buffers used to keep the data.
	* Each buffer has a length of the maxBufferLength except last one.
	*/
	buffers = [];
	/**
	* The total size of internal buffers.
	*/
	capacity;
	/**
	* The total size of data contained in internal buffers.
	*/
	_size;
	/**
	* The size of the data contained in the pooled buffers.
	*/
	get size() {
		return this._size;
	}
	constructor(capacity, buffers, totalLength) {
		this.capacity = capacity;
		this._size = 0;
		const bufferNum = Math.ceil(capacity / maxBufferLength);
		for (let i = 0; i < bufferNum; i++) {
			let len = i === bufferNum - 1 ? capacity % maxBufferLength : maxBufferLength;
			if (len === 0) len = maxBufferLength;
			this.buffers.push(Buffer.allocUnsafe(len));
		}
		if (buffers) this.fill(buffers, totalLength);
	}
	/**
	* Fill the internal buffers with data in the input buffers serially
	* with respect to the total length and the total capacity of the internal buffers.
	* Data copied will be shift out of the input buffers.
	*
	* @param buffers - Input buffers containing the data to be filled in the pooled buffer
	* @param totalLength - Total length of the data to be filled in.
	*
	*/
	fill(buffers, totalLength) {
		this._size = Math.min(this.capacity, totalLength);
		let i = 0;
		let j = 0;
		let targetOffset = 0;
		let sourceOffset = 0;
		let totalCopiedNum = 0;
		while (totalCopiedNum < this._size) {
			const source = buffers[i];
			const target = this.buffers[j];
			const copiedNum = source.copy(target, targetOffset, sourceOffset);
			totalCopiedNum += copiedNum;
			sourceOffset += copiedNum;
			targetOffset += copiedNum;
			if (sourceOffset === source.length) {
				i++;
				sourceOffset = 0;
			}
			if (targetOffset === target.length) {
				j++;
				targetOffset = 0;
			}
		}
		buffers.splice(0, i);
		if (buffers.length > 0) buffers[0] = buffers[0].slice(sourceOffset);
	}
	/**
	* Get the readable stream assembled from all the data in the internal buffers.
	*
	*/
	getReadableStream() {
		return new BuffersStream(this.buffers, this.size);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/BufferScheduler.js
/**
* This class accepts a Node.js Readable stream as input, and keeps reading data
* from the stream into the internal buffer structure, until it reaches maxBuffers.
* Every available buffer will try to trigger outgoingHandler.
*
* The internal buffer structure includes an incoming buffer array, and a outgoing
* buffer array. The incoming buffer array includes the "empty" buffers can be filled
* with new incoming data. The outgoing array includes the filled buffers to be
* handled by outgoingHandler. Every above buffer size is defined by parameter bufferSize.
*
* NUM_OF_ALL_BUFFERS = BUFFERS_IN_INCOMING + BUFFERS_IN_OUTGOING + BUFFERS_UNDER_HANDLING
*
* NUM_OF_ALL_BUFFERS lesser than or equal to maxBuffers
*
* PERFORMANCE IMPROVEMENT TIPS:
* 1. Input stream highWaterMark is better to set a same value with bufferSize
*    parameter, which will avoid Buffer.concat() operations.
* 2. concurrency should set a smaller value than maxBuffers, which is helpful to
*    reduce the possibility when a outgoing handler waits for the stream data.
*    in this situation, outgoing handlers are blocked.
*    Outgoing queue shouldn't be empty.
*/
var BufferScheduler = class {
	/**
	* Size of buffers in incoming and outgoing queues. This class will try to align
	* data read from Readable stream into buffer chunks with bufferSize defined.
	*/
	bufferSize;
	/**
	* How many buffers can be created or maintained.
	*/
	maxBuffers;
	/**
	* A Node.js Readable stream.
	*/
	readable;
	/**
	* OutgoingHandler is an async function triggered by BufferScheduler when there
	* are available buffers in outgoing array.
	*/
	outgoingHandler;
	/**
	* An internal event emitter.
	*/
	emitter = new EventEmitter();
	/**
	* Concurrency of executing outgoingHandlers. (0 lesser than concurrency lesser than or equal to maxBuffers)
	*/
	concurrency;
	/**
	* An internal offset marker to track data offset in bytes of next outgoingHandler.
	*/
	offset = 0;
	/**
	* An internal marker to track whether stream is end.
	*/
	isStreamEnd = false;
	/**
	* An internal marker to track whether stream or outgoingHandler returns error.
	*/
	isError = false;
	/**
	* How many handlers are executing.
	*/
	executingOutgoingHandlers = 0;
	/**
	* Encoding of the input Readable stream which has string data type instead of Buffer.
	*/
	encoding;
	/**
	* How many buffers have been allocated.
	*/
	numBuffers = 0;
	/**
	* Because this class doesn't know how much data every time stream pops, which
	* is defined by highWaterMarker of the stream. So BufferScheduler will cache
	* data received from the stream, when data in unresolvedDataArray exceeds the
	* blockSize defined, it will try to concat a blockSize of buffer, fill into available
	* buffers from incoming and push to outgoing array.
	*/
	unresolvedDataArray = [];
	/**
	* How much data consisted in unresolvedDataArray.
	*/
	unresolvedLength = 0;
	/**
	* The array includes all the available buffers can be used to fill data from stream.
	*/
	incoming = [];
	/**
	* The array (queue) includes all the buffers filled from stream data.
	*/
	outgoing = [];
	/**
	* Creates an instance of BufferScheduler.
	*
	* @param readable - A Node.js Readable stream
	* @param bufferSize - Buffer size of every maintained buffer
	* @param maxBuffers - How many buffers can be allocated
	* @param outgoingHandler - An async function scheduled to be
	*                                          triggered when a buffer fully filled
	*                                          with stream data
	* @param concurrency - Concurrency of executing outgoingHandlers (&gt;0)
	* @param encoding - [Optional] Encoding of Readable stream when it's a string stream
	*/
	constructor(readable, bufferSize, maxBuffers, outgoingHandler, concurrency, encoding) {
		if (bufferSize <= 0) throw new RangeError(`bufferSize must be larger than 0, current is ${bufferSize}`);
		if (maxBuffers <= 0) throw new RangeError(`maxBuffers must be larger than 0, current is ${maxBuffers}`);
		if (concurrency <= 0) throw new RangeError(`concurrency must be larger than 0, current is ${concurrency}`);
		this.bufferSize = bufferSize;
		this.maxBuffers = maxBuffers;
		this.readable = readable;
		this.outgoingHandler = outgoingHandler;
		this.concurrency = concurrency;
		this.encoding = encoding;
	}
	/**
	* Start the scheduler, will return error when stream of any of the outgoingHandlers
	* returns error.
	*
	*/
	async do() {
		return new Promise((resolve, reject) => {
			this.readable.on("data", (data) => {
				data = typeof data === "string" ? Buffer.from(data, this.encoding) : data;
				this.appendUnresolvedData(data);
				if (!this.resolveData()) this.readable.pause();
			});
			this.readable.on("error", (err) => {
				this.emitter.emit("error", err);
			});
			this.readable.on("end", () => {
				this.isStreamEnd = true;
				this.emitter.emit("checkEnd");
			});
			this.emitter.on("error", (err) => {
				this.isError = true;
				this.readable.pause();
				reject(err);
			});
			this.emitter.on("checkEnd", () => {
				if (this.outgoing.length > 0) {
					this.triggerOutgoingHandlers();
					return;
				}
				if (this.isStreamEnd && this.executingOutgoingHandlers === 0) {
					if (this.unresolvedLength > 0 && this.unresolvedLength < this.bufferSize) {
						const buffer = this.shiftBufferFromUnresolvedDataArray();
						this.outgoingHandler(() => buffer.getReadableStream(), buffer.size, this.offset).then(resolve).catch(reject);
					} else if (this.unresolvedLength >= this.bufferSize) return;
					else resolve();
				}
			});
		});
	}
	/**
	* Insert a new data into unresolved array.
	*
	* @param data -
	*/
	appendUnresolvedData(data) {
		this.unresolvedDataArray.push(data);
		this.unresolvedLength += data.length;
	}
	/**
	* Try to shift a buffer with size in blockSize. The buffer returned may be less
	* than blockSize when data in unresolvedDataArray is less than bufferSize.
	*
	*/
	shiftBufferFromUnresolvedDataArray(buffer) {
		if (!buffer) buffer = new PooledBuffer(this.bufferSize, this.unresolvedDataArray, this.unresolvedLength);
		else buffer.fill(this.unresolvedDataArray, this.unresolvedLength);
		this.unresolvedLength -= buffer.size;
		return buffer;
	}
	/**
	* Resolve data in unresolvedDataArray. For every buffer with size in blockSize
	* shifted, it will try to get (or allocate a buffer) from incoming, and fill it,
	* then push it into outgoing to be handled by outgoing handler.
	*
	* Return false when available buffers in incoming are not enough, else true.
	*
	* @returns Return false when buffers in incoming are not enough, else true.
	*/
	resolveData() {
		while (this.unresolvedLength >= this.bufferSize) {
			let buffer;
			if (this.incoming.length > 0) {
				buffer = this.incoming.shift();
				this.shiftBufferFromUnresolvedDataArray(buffer);
			} else if (this.numBuffers < this.maxBuffers) {
				buffer = this.shiftBufferFromUnresolvedDataArray();
				this.numBuffers++;
			} else return false;
			this.outgoing.push(buffer);
			this.triggerOutgoingHandlers();
		}
		return true;
	}
	/**
	* Try to trigger a outgoing handler for every buffer in outgoing. Stop when
	* concurrency reaches.
	*/
	async triggerOutgoingHandlers() {
		let buffer;
		do {
			if (this.executingOutgoingHandlers >= this.concurrency) return;
			buffer = this.outgoing.shift();
			if (buffer) this.triggerOutgoingHandler(buffer);
		} while (buffer);
	}
	/**
	* Trigger a outgoing handler for a buffer shifted from outgoing.
	*
	* @param buffer -
	*/
	async triggerOutgoingHandler(buffer) {
		const bufferLength = buffer.size;
		this.executingOutgoingHandlers++;
		this.offset += bufferLength;
		try {
			await this.outgoingHandler(() => buffer.getReadableStream(), bufferLength, this.offset - bufferLength);
		} catch (err) {
			this.emitter.emit("error", err);
			return;
		}
		this.executingOutgoingHandlers--;
		this.reuseBuffer(buffer);
		this.emitter.emit("checkEnd");
	}
	/**
	* Return buffer used by outgoing handler into incoming.
	*
	* @param buffer -
	*/
	reuseBuffer(buffer) {
		this.incoming.push(buffer);
		if (!this.isError && this.resolveData() && !this.isStreamEnd) this.readable.resume();
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/crc64.js
var NativeCRC64 = (() => {
	typeof document !== "undefined" && document.currentScript && document.currentScript.src;
	return (function(NativeCRC64) {
		NativeCRC64 = NativeCRC64 || {};
		var Module = typeof NativeCRC64 != "undefined" ? NativeCRC64 : {};
		var readyPromiseResolve;
		var readyPromiseReject;
		Module["ready"] = new Promise(function(resolve, reject) {
			readyPromiseResolve = resolve;
			readyPromiseReject = reject;
		});
		[
			"_malloc",
			"_free",
			"_emscripten_bind_VoidPtr___destroy___0",
			"_emscripten_bind_Crc64Hash_Crc64Hash_0",
			"_emscripten_bind_Crc64Hash_OnAppend_2",
			"_emscripten_bind_Crc64Hash_OnFinal_3",
			"_emscripten_bind_Crc64Hash___destroy___0",
			"_fflush",
			"onRuntimeInitialized"
		].forEach((prop) => {
			if (!Object.getOwnPropertyDescriptor(Module["ready"], prop)) Object.defineProperty(Module["ready"], prop, {
				get: () => abort("You are getting " + prop + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"),
				set: () => abort("You are setting " + prop + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js")
			});
		});
		var moduleOverrides = Object.assign({}, Module);
		var arguments_ = [];
		var ENVIRONMENT_IS_WEB = typeof window == "object";
		var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
		var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
		var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
		if (Module["ENVIRONMENT"]) throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");
		var scriptDirectory = "";
		function locateFile(path) {
			if (Module["locateFile"]) return Module["locateFile"](path, scriptDirectory);
			return scriptDirectory + path;
		}
		if (ENVIRONMENT_IS_NODE) {
			if (typeof process == "undefined" || !process.release || process.release.name !== "node") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
			if (process["argv"].length > 1) process["argv"][1].replace(/\\/g, "/");
			arguments_ = process["argv"].slice(2);
			process["on"]("uncaughtException", function(ex) {
				if (!(ex instanceof ExitStatus)) throw ex;
			});
			process["on"]("unhandledRejection", function(reason) {
				throw reason;
			});
			Module["inspect"] = function() {
				return "[Emscripten Module object]";
			};
		} else if (ENVIRONMENT_IS_SHELL) {
			if (typeof process == "object" && typeof __require === "function" || typeof window == "object" || typeof importScripts == "function") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
			if (typeof scriptArgs != "undefined") arguments_ = scriptArgs;
			else if (typeof arguments != "undefined") arguments_ = arguments;
			if (typeof quit == "function") {}
			if (typeof print != "undefined") {
				if (typeof console == "undefined") console = {};
				console.log = print;
				console.warn = console.error = typeof printErr != "undefined" ? printErr : print;
			}
		} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
			if (!(typeof window == "object" || typeof importScripts == "function")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
		} else throw new Error("environment detection error");
		var out = Module["print"] || console.log.bind(console);
		var err = Module["printErr"] || console.warn.bind(console);
		Object.assign(Module, moduleOverrides);
		moduleOverrides = null;
		checkIncomingModuleAPI();
		if (Module["arguments"]) arguments_ = Module["arguments"];
		legacyModuleProp("arguments", "arguments_");
		if (Module["thisProgram"]) Module["thisProgram"];
		legacyModuleProp("thisProgram", "thisProgram");
		if (Module["quit"]) Module["quit"];
		legacyModuleProp("quit", "quit_");
		assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");
		assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");
		assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");
		assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");
		assert(typeof Module["read"] == "undefined", "Module.read option was removed (modify read_ in JS)");
		assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)");
		assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)");
		assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify setWindowTitle in JS)");
		assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");
		legacyModuleProp("read", "read_");
		legacyModuleProp("readAsync", "readAsync");
		legacyModuleProp("readBinary", "readBinary");
		legacyModuleProp("setWindowTitle", "setWindowTitle");
		assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add 'shell' to `-sENVIRONMENT` to enable.");
		function legacyModuleProp(prop, newName) {
			if (!Object.getOwnPropertyDescriptor(Module, prop)) Object.defineProperty(Module, prop, {
				configurable: true,
				get: function() {
					abort("Module." + prop + " has been replaced with plain " + newName + " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
				}
			});
		}
		function ignoredModuleProp(prop) {
			if (Object.getOwnPropertyDescriptor(Module, prop)) abort("`Module." + prop + "` was supplied but `" + prop + "` not included in INCOMING_MODULE_JS_API");
		}
		function isExportedByForceFilesystem(name) {
			return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_unlink" || name === "addRunDependency" || name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";
		}
		function missingLibrarySymbol(sym) {
			if (typeof globalThis !== "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) Object.defineProperty(globalThis, sym, {
				configurable: true,
				get: function() {
					var msg = "`" + sym + "` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line";
					var librarySymbol = sym;
					if (!librarySymbol.startsWith("_")) librarySymbol = "$" + sym;
					msg += " (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE=" + librarySymbol + ")";
					if (isExportedByForceFilesystem(sym)) msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
					warnOnce(msg);
				}
			});
		}
		function unexportedRuntimeSymbol(sym) {
			if (!Object.getOwnPropertyDescriptor(Module, sym)) Object.defineProperty(Module, sym, {
				configurable: true,
				get: function() {
					var msg = "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)";
					if (isExportedByForceFilesystem(sym)) msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
					abort(msg);
				}
			});
		}
		if (Module["wasmBinary"]) Module["wasmBinary"];
		legacyModuleProp("wasmBinary", "wasmBinary");
		Module["noExitRuntime"];
		legacyModuleProp("noExitRuntime", "noExitRuntime");
		if (typeof WebAssembly != "object") abort("no native wasm support detected");
		var wasmMemory;
		var ABORT = false;
		/** @type {function(*, string=)} */
		function assert(condition, text) {
			if (!condition) abort("Assertion failed" + (text ? ": " + text : ""));
		}
		var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : void 0;
		/**
		* Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
		* array that contains uint8 values, returns a copy of that string as a
		* Javascript String object.
		* heapOrArray is either a regular array, or a JavaScript typed array view.
		* @param {number} idx
		* @param {number=} maxBytesToRead
		* @return {string}
		*/
		function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
			var endIdx = idx + maxBytesToRead;
			var endPtr = idx;
			while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
			if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
			var str = "";
			while (idx < endPtr) {
				var u0 = heapOrArray[idx++];
				if (!(u0 & 128)) {
					str += String.fromCharCode(u0);
					continue;
				}
				var u1 = heapOrArray[idx++] & 63;
				if ((u0 & 224) == 192) {
					str += String.fromCharCode((u0 & 31) << 6 | u1);
					continue;
				}
				var u2 = heapOrArray[idx++] & 63;
				if ((u0 & 240) == 224) u0 = (u0 & 15) << 12 | u1 << 6 | u2;
				else {
					if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte " + ptrToString(u0) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!");
					u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
				}
				if (u0 < 65536) str += String.fromCharCode(u0);
				else {
					var ch = u0 - 65536;
					str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
				}
			}
			return str;
		}
		/**
		* Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
		* emscripten HEAP, returns a copy of that string as a Javascript String object.
		*
		* @param {number} ptr
		* @param {number=} maxBytesToRead - An optional length that specifies the
		*   maximum number of bytes to read. You can omit this parameter to scan the
		*   string until the first \0 byte. If maxBytesToRead is passed, and the string
		*   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
		*   string will cut short at that byte index (i.e. maxBytesToRead will not
		*   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
		*   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
		*   JS JIT optimizations off, so it is worth to consider consistently using one
		* @return {string}
		*/
		function UTF8ToString(ptr, maxBytesToRead) {
			return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
		}
		var buffer;
		var HEAPU8;
		var HEAP32;
		var HEAPU32;
		function updateGlobalBufferAndViews(buf) {
			buffer = buf;
			Module["HEAP8"] = new Int8Array(buf);
			Module["HEAP16"] = new Int16Array(buf);
			Module["HEAP32"] = HEAP32 = new Int32Array(buf);
			Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
			Module["HEAPU16"] = new Uint16Array(buf);
			Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
			Module["HEAPF32"] = new Float32Array(buf);
			Module["HEAPF64"] = new Float64Array(buf);
		}
		var STACK_SIZE = 5242880;
		if (Module["STACK_SIZE"]) assert(STACK_SIZE === Module["STACK_SIZE"], "the stack size can no longer be determined at runtime");
		var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
		legacyModuleProp("INITIAL_MEMORY", "INITIAL_MEMORY");
		assert(INITIAL_MEMORY >= STACK_SIZE, "INITIAL_MEMORY should be larger than STACK_SIZE, was " + INITIAL_MEMORY + "! (STACK_SIZE=" + STACK_SIZE + ")");
		assert(typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != void 0 && Int32Array.prototype.set != void 0, "JS engine does not provide full typed array support");
		assert(!Module["wasmMemory"], "Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally");
		assert(INITIAL_MEMORY == 16777216, "Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically");
		var wasmTable;
		function writeStackCookie() {
			var max = _emscripten_stack_get_end();
			assert((max & 3) == 0);
			if (max == 0) max += 4;
			HEAPU32[max >> 2] = 34821223;
			HEAPU32[max + 4 >> 2] = 2310721022;
			HEAPU32[0] = 1668509029;
		}
		function checkStackCookie() {
			if (ABORT) return;
			var max = _emscripten_stack_get_end();
			if (max == 0) max += 4;
			var cookie1 = HEAPU32[max >> 2];
			var cookie2 = HEAPU32[max + 4 >> 2];
			if (cookie1 != 34821223 || cookie2 != 2310721022) abort("Stack overflow! Stack cookie has been overwritten at " + ptrToString(max) + ", expected hex dwords 0x89BACDFE and 0x2135467, but received " + ptrToString(cookie2) + " " + ptrToString(cookie1));
			if (HEAPU32[0] !== 1668509029) abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
		}
		(function() {
			var h16 = /* @__PURE__ */ new Int16Array(1);
			var h8 = new Int8Array(h16.buffer);
			h16[0] = 25459;
			if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)";
		})();
		var __ATPRERUN__ = [];
		var __ATINIT__ = [];
		var __ATPOSTRUN__ = [];
		var runtimeInitialized = false;
		function preRun() {
			if (Module["preRun"]) {
				if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
				while (Module["preRun"].length) addOnPreRun(Module["preRun"].shift());
			}
			callRuntimeCallbacks(__ATPRERUN__);
		}
		function initRuntime() {
			assert(!runtimeInitialized);
			runtimeInitialized = true;
			checkStackCookie();
			callRuntimeCallbacks(__ATINIT__);
		}
		function postRun() {
			checkStackCookie();
			if (Module["postRun"]) {
				if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
				while (Module["postRun"].length) addOnPostRun(Module["postRun"].shift());
			}
			callRuntimeCallbacks(__ATPOSTRUN__);
		}
		function addOnPreRun(cb) {
			__ATPRERUN__.unshift(cb);
		}
		function addOnInit(cb) {
			__ATINIT__.unshift(cb);
		}
		function addOnPostRun(cb) {
			__ATPOSTRUN__.unshift(cb);
		}
		assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
		assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
		assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
		assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
		var runDependencies = 0;
		var runDependencyWatcher = null;
		var dependenciesFulfilled = null;
		var runDependencyTracking = {};
		function addRunDependency(id) {
			runDependencies++;
			if (Module["monitorRunDependencies"]) Module["monitorRunDependencies"](runDependencies);
			if (id) {
				assert(!runDependencyTracking[id]);
				runDependencyTracking[id] = 1;
				if (runDependencyWatcher === null && typeof setInterval != "undefined") runDependencyWatcher = setInterval(function() {
					if (ABORT) {
						clearInterval(runDependencyWatcher);
						runDependencyWatcher = null;
						return;
					}
					var shown = false;
					for (var dep in runDependencyTracking) {
						if (!shown) {
							shown = true;
							err("still waiting on run dependencies:");
						}
						err("dependency: " + dep);
					}
					if (shown) err("(end of list)");
				}, 1e4);
			} else err("warning: run dependency added without ID");
		}
		function removeRunDependency(id) {
			runDependencies--;
			if (Module["monitorRunDependencies"]) Module["monitorRunDependencies"](runDependencies);
			if (id) {
				assert(runDependencyTracking[id]);
				delete runDependencyTracking[id];
			} else err("warning: run dependency removed without ID");
			if (runDependencies == 0) {
				if (runDependencyWatcher !== null) {
					clearInterval(runDependencyWatcher);
					runDependencyWatcher = null;
				}
				if (dependenciesFulfilled) {
					var callback = dependenciesFulfilled;
					dependenciesFulfilled = null;
					callback();
				}
			}
		}
		/** @param {string|number=} what */
		function abort(what) {
			if (Module["onAbort"]) Module["onAbort"](what);
			what = "Aborted(" + what + ")";
			err(what);
			ABORT = true;
			/** @suppress {checkTypes} */
			var e = new WebAssembly.RuntimeError(what);
			readyPromiseReject(e);
			throw e;
		}
		var FS = {
			error: function() {
				abort("Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM");
			},
			init: function() {
				FS.error();
			},
			createDataFile: function() {
				FS.error();
			},
			createPreloadedFile: function() {
				FS.error();
			},
			createLazyFile: function() {
				FS.error();
			},
			open: function() {
				FS.error();
			},
			mkdev: function() {
				FS.error();
			},
			registerDevice: function() {
				FS.error();
			},
			analyzePath: function() {
				FS.error();
			},
			loadFilesFromDB: function() {
				FS.error();
			},
			ErrnoError: function ErrnoError() {
				FS.error();
			}
		};
		Module["FS_createDataFile"] = FS.createDataFile;
		Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
		var dataURIPrefix = "data:application/octet-stream;base64,";
		function isDataURI(filename) {
			return filename.startsWith(dataURIPrefix);
		}
		function isFileURI(filename) {
			return filename.startsWith("file://");
		}
		/** @param {boolean=} fixedasm */
		function createExportWrapper(name, fixedasm) {
			return function() {
				var displayName = name;
				var asm = fixedasm;
				if (!fixedasm) asm = Module["asm"];
				assert(runtimeInitialized, "native function `" + displayName + "` called before runtime initialization");
				if (!asm[name]) assert(asm[name], "exported native function `" + displayName + "` not found");
				return asm[name].apply(null, arguments);
			};
		}
		var wasmBinaryFile = "crc64.wasm";
		if (!isDataURI(wasmBinaryFile)) wasmBinaryFile = locateFile(wasmBinaryFile);
		var binaryInString = [
			"AGFzbQEAAAABzYCAgAAMYAF/AX9gAAF/YAF/AGAAAGADf35/AX5gA39/fwBgBH9/f38AYAN/f38Bf2AFf39",
			"/f38Bf2AEf39/fwF/YAR/f35/AX5gBH9+f38BfwKPgYCAAAUDZW52BWFib3J0AAMDZW52FmVtc2NyaXB0ZW",
			"5fcmVzaXplX2hlYXAAABZ3YXNpX3NuYXBzaG90X3ByZXZpZXcxCGZkX2Nsb3NlAAAWd2FzaV9zbmFwc2hvd",
			"F9wcmV2aWV3MQhmZF93cml0ZQAJFndhc2lfc25hcHNob3RfcHJldmlldzEHZmRfc2VlawAIA62AgIAALAMF",
			"BgIBAAUGAgEBAAACAAIAAAAHBAQCAgEDAAIAAQIBAQIAAQMBAQEACggLBIWAgIAAAXABBAQFh4CAgAABAYA",
			"CgIACBsiAgIAACn8BQYCAwAILfwFBAAt/AUEAC38BQQALfwBBnJHBAgt/AEGwkcECC38AQZyRwQILfwBBsJ",
			"HBAgt/AEGwkcECC38AQZKSwQILB/qEgIAAGwZtZW1vcnkCABFfX3dhc21fY2FsbF9jdG9ycwAFJWVtc2Nya",
			"XB0ZW5fYmluZF9Wb2lkUHRyX19fZGVzdHJveV9fXzAACCVlbXNjcmlwdGVuX2JpbmRfQ3JjNjRIYXNoX0Ny",
			"YzY0SGFzaF8wAAkkZW1zY3JpcHRlbl9iaW5kX0NyYzY0SGFzaF9PbkFwcGVuZF8yAAsjZW1zY3JpcHRlbl9",
			"iaW5kX0NyYzY0SGFzaF9PbkZpbmFsXzMADCdlbXNjcmlwdGVuX2JpbmRfQ3JjNjRIYXNoX19fZGVzdHJveV",
			"9fXzAADRtfX2VtX2xpYl9kZXBzX3dlYmlkbF9iaW5kZXIDBCFfX2VtX2pzX19hcnJheV9ib3VuZHNfY2hlY",
			"2tfZXJyb3IDBRlfX2luZGlyZWN0X2Z1bmN0aW9uX3RhYmxlAQAQX19lcnJub19sb2NhdGlvbgAPBmZmbHVz",
			"aAAtBm1hbGxvYwARBGZyZWUAEhVlbXNjcmlwdGVuX3N0YWNrX2luaXQAKRllbXNjcmlwdGVuX3N0YWNrX2d",
			"ldF9mcmVlACoZZW1zY3JpcHRlbl9zdGFja19nZXRfYmFzZQArGGVtc2NyaXB0ZW5fc3RhY2tfZ2V0X2VuZA",
			"AsCXN0YWNrU2F2ZQAlDHN0YWNrUmVzdG9yZQAmCnN0YWNrQWxsb2MAJxxlbXNjcmlwdGVuX3N0YWNrX2dld",
			"F9jdXJyZW50ACgTX19zdGFydF9lbV9saWJfZGVwcwMGEl9fc3RvcF9lbV9saWJfZGVwcwMHDV9fc3RhcnRf",
			"ZW1fanMDCAxfX3N0b3BfZW1fanMDCQxkeW5DYWxsX2ppamkALwmJgICAAAEAQQELAxYYGgqtkYGAACwEABA",
			"pC81IAvcCf6EFfiMAIQNBgAEhBCADIARrIQUgBSAANgJ8IAUgATYCeCAFIAI2AnQgBSgCfCEGIAUoAnghBy",
			"AFIAc2AnAgBSgCdCEIIAghCSAJrCH6AiAGKQMIIfsCIPsCIPoCfCH8AiAGIPwCNwMIIAYpAwAh/QJCfyH+A",
			"iD9AiD+AoUh/wIgBSD/AjcDaEIAIYADIAUggAM3A2AgBSgCdCEKIAUoAnQhC0EgIQwgCyAMbyENIAogDWsh",
			"DiAFIA42AlwgBSgCXCEPQcAAIRAgDyERIBAhEiARIBJPIRNBASEUIBMgFHEhFQJAIBVFDQAgBSgCcCEWIAU",
			"gFjYCWEIAIYEDIAUggQM3A1BCACGCAyAFIIIDNwNIQgAhgwMgBSCDAzcDQEIAIYQDIAUghAM3AzggBSkDYC",
			"GFAyAFKAJcIRcgFyEYIBitIYYDIIUDIIYDfCGHA0IgIYgDIIcDIIgDfSGJAyAFIIkDNwMwIAUoAlwhGSAFK",
			"AJ0IRogGiAZayEbIAUgGzYCdCAFKQNoIYoDIAUgigM3A1ACQANAIAUpA2AhiwMgBSkDMCGMAyCLAyGNAyCM",
			"AyGOAyCNAyCOA1QhHEEBIR0gHCAdcSEeIB5FDQEgBSgCWCEfIB8pAwAhjwMgBSkDUCGQAyCPAyCQA4UhkQM",
			"gBSCRAzcDKCAFKAJYISAgICkDCCGSAyAFKQNIIZMDIJIDIJMDhSGUAyAFIJQDNwMgIAUoAlghISAhKQMQIZ",
			"UDIAUpA0AhlgMglQMglgOFIZcDIAUglwM3AxggBSgCWCEiICIpAxghmAMgBSkDOCGZAyCYAyCZA4UhmgMgB",
			"SCaAzcDECAFKQMoIZsDQv8BIZwDIJsDIJwDgyGdA0KADiGeAyCdAyCeA3whnwMgnwOnISNBgIDAAiEkQQMh",
			"JSAjICV0ISYgJCAmaiEnICcpAwAhoAMgBSCgAzcDUCAFKQMoIaEDQgghogMgoQMgogOIIaMDIAUgowM3Ayg",
			"gBSkDICGkA0L/ASGlAyCkAyClA4MhpgNCgA4hpwMgpgMgpwN8IagDIKgDpyEoQYCAwAIhKUEDISogKCAqdC",
			"ErICkgK2ohLCAsKQMAIakDIAUgqQM3A0ggBSkDICGqA0IIIasDIKoDIKsDiCGsAyAFIKwDNwMgIAUpAxghr",
			"QNC/wEhrgMgrQMgrgODIa8DQoAOIbADIK8DILADfCGxAyCxA6chLUGAgMACIS5BAyEvIC0gL3QhMCAuIDBq",
			"ITEgMSkDACGyAyAFILIDNwNAIAUpAxghswNCCCG0AyCzAyC0A4ghtQMgBSC1AzcDGCAFKQMQIbYDQv8BIbc",
			"DILYDILcDgyG4A0KADiG5AyC4AyC5A3whugMgugOnITJBgIDAAiEzQQMhNCAyIDR0ITUgMyA1aiE2IDYpAw",
			"AhuwMgBSC7AzcDOCAFKQMQIbwDQgghvQMgvAMgvQOIIb4DIAUgvgM3AxAgBSkDKCG/A0L/ASHAAyC/AyDAA",
			"4MhwQNCgAwhwgMgwQMgwgN8IcMDIMMDpyE3QYCAwAIhOEEDITkgNyA5dCE6IDggOmohOyA7KQMAIcQDIAUp",
			"A1AhxQMgxQMgxAOFIcYDIAUgxgM3A1AgBSkDKCHHA0IIIcgDIMcDIMgDiCHJAyAFIMkDNwMoIAUpAyAhygN",
			"C/wEhywMgygMgywODIcwDQoAMIc0DIMwDIM0DfCHOAyDOA6chPEGAgMACIT1BAyE+IDwgPnQhPyA9ID9qIU",
			"AgQCkDACHPAyAFKQNIIdADINADIM8DhSHRAyAFINEDNwNIIAUpAyAh0gNCCCHTAyDSAyDTA4gh1AMgBSDUA",
			"zcDICAFKQMYIdUDQv8BIdYDINUDINYDgyHXA0KADCHYAyDXAyDYA3wh2QMg2QOnIUFBgIDAAiFCQQMhQyBB",
			"IEN0IUQgQiBEaiFFIEUpAwAh2gMgBSkDQCHbAyDbAyDaA4Uh3AMgBSDcAzcDQCAFKQMYId0DQggh3gMg3QM",
			"g3gOIId8DIAUg3wM3AxggBSkDECHgA0L/ASHhAyDgAyDhA4Mh4gNCgAwh4wMg4gMg4wN8IeQDIOQDpyFGQY",
			"CAwAIhR0EDIUggRiBIdCFJIEcgSWohSiBKKQMAIeUDIAUpAzgh5gMg5gMg5QOFIecDIAUg5wM3AzggBSkDE",
			"CHoA0IIIekDIOgDIOkDiCHqAyAFIOoDNwMQIAUpAygh6wNC/wEh7AMg6wMg7AODIe0DQoAKIe4DIO0DIO4D",
			"fCHvAyDvA6chS0GAgMACIUxBAyFNIEsgTXQhTiBMIE5qIU8gTykDACHwAyAFKQNQIfEDIPEDIPADhSHyAyA",
			"FIPIDNwNQIAUpAygh8wNCCCH0AyDzAyD0A4gh9QMgBSD1AzcDKCAFKQMgIfYDQv8BIfcDIPYDIPcDgyH4A0",
			"KACiH5AyD4AyD5A3wh+gMg+gOnIVBBgIDAAiFRQQMhUiBQIFJ0IVMgUSBTaiFUIFQpAwAh+wMgBSkDSCH8A",
			"yD8AyD7A4Uh/QMgBSD9AzcDSCAFKQMgIf4DQggh/wMg/gMg/wOIIYAEIAUggAQ3AyAgBSkDGCGBBEL/ASGC",
			"BCCBBCCCBIMhgwRCgAohhAQggwQghAR8IYUEIIUEpyFVQYCAwAIhVkEDIVcgVSBXdCFYIFYgWGohWSBZKQM",
			"AIYYEIAUpA0AhhwQghwQghgSFIYgEIAUgiAQ3A0AgBSkDGCGJBEIIIYoEIIkEIIoEiCGLBCAFIIsENwMYIA",
			"UpAxAhjARC/wEhjQQgjAQgjQSDIY4EQoAKIY8EII4EII8EfCGQBCCQBKchWkGAgMACIVtBAyFcIFogXHQhX",
			"SBbIF1qIV4gXikDACGRBCAFKQM4IZIEIJIEIJEEhSGTBCAFIJMENwM4IAUpAxAhlARCCCGVBCCUBCCVBIgh",
			"lgQgBSCWBDcDECAFKQMoIZcEQv8BIZgEIJcEIJgEgyGZBEKACCGaBCCZBCCaBHwhmwQgmwSnIV9BgIDAAiF",
			"gQQMhYSBfIGF0IWIgYCBiaiFjIGMpAwAhnAQgBSkDUCGdBCCdBCCcBIUhngQgBSCeBDcDUCAFKQMoIZ8EQg",
			"ghoAQgnwQgoASIIaEEIAUgoQQ3AyggBSkDICGiBEL/ASGjBCCiBCCjBIMhpARCgAghpQQgpAQgpQR8IaYEI",
			"KYEpyFkQYCAwAIhZUEDIWYgZCBmdCFnIGUgZ2ohaCBoKQMAIacEIAUpA0ghqAQgqAQgpwSFIakEIAUgqQQ3",
			"A0ggBSkDICGqBEIIIasEIKoEIKsEiCGsBCAFIKwENwMgIAUpAxghrQRC/wEhrgQgrQQgrgSDIa8EQoAIIbA",
			"EIK8EILAEfCGxBCCxBKchaUGAgMACIWpBAyFrIGkga3QhbCBqIGxqIW0gbSkDACGyBCAFKQNAIbMEILMEIL",
			"IEhSG0BCAFILQENwNAIAUpAxghtQRCCCG2BCC1BCC2BIghtwQgBSC3BDcDGCAFKQMQIbgEQv8BIbkEILgEI",
			"LkEgyG6BEKACCG7BCC6BCC7BHwhvAQgvASnIW5BgIDAAiFvQQMhcCBuIHB0IXEgbyBxaiFyIHIpAwAhvQQg",
			"BSkDOCG+BCC+BCC9BIUhvwQgBSC/BDcDOCAFKQMQIcAEQgghwQQgwAQgwQSIIcIEIAUgwgQ3AxAgBSkDKCH",
			"DBEL/ASHEBCDDBCDEBIMhxQRCgAYhxgQgxQQgxgR8IccEIMcEpyFzQYCAwAIhdEEDIXUgcyB1dCF2IHQgdm",
			"ohdyB3KQMAIcgEIAUpA1AhyQQgyQQgyASFIcoEIAUgygQ3A1AgBSkDKCHLBEIIIcwEIMsEIMwEiCHNBCAFI",
			"M0ENwMoIAUpAyAhzgRC/wEhzwQgzgQgzwSDIdAEQoAGIdEEINAEINEEfCHSBCDSBKcheEGAgMACIXlBAyF6",
			"IHggenQheyB5IHtqIXwgfCkDACHTBCAFKQNIIdQEINQEINMEhSHVBCAFINUENwNIIAUpAyAh1gRCCCHXBCD",
			"WBCDXBIgh2AQgBSDYBDcDICAFKQMYIdkEQv8BIdoEINkEINoEgyHbBEKABiHcBCDbBCDcBHwh3QQg3QSnIX",
			"1BgIDAAiF+QQMhfyB9IH90IYABIH4ggAFqIYEBIIEBKQMAId4EIAUpA0Ah3wQg3wQg3gSFIeAEIAUg4AQ3A",
			"0AgBSkDGCHhBEIIIeIEIOEEIOIEiCHjBCAFIOMENwMYIAUpAxAh5ARC/wEh5QQg5AQg5QSDIeYEQoAGIecE",
			"IOYEIOcEfCHoBCDoBKchggFBgIDAAiGDAUEDIYQBIIIBIIQBdCGFASCDASCFAWohhgEghgEpAwAh6QQgBSk",
			"DOCHqBCDqBCDpBIUh6wQgBSDrBDcDOCAFKQMQIewEQggh7QQg7AQg7QSIIe4EIAUg7gQ3AxAgBSkDKCHvBE",
			"L/ASHwBCDvBCDwBIMh8QRCgAQh8gQg8QQg8gR8IfMEIPMEpyGHAUGAgMACIYgBQQMhiQEghwEgiQF0IYoBI",
			"IgBIIoBaiGLASCLASkDACH0BCAFKQNQIfUEIPUEIPQEhSH2BCAFIPYENwNQIAUpAygh9wRCCCH4BCD3BCD4",
			"BIgh+QQgBSD5BDcDKCAFKQMgIfoEQv8BIfsEIPoEIPsEgyH8BEKABCH9BCD8BCD9BHwh/gQg/gSnIYwBQYC",
			"AwAIhjQFBAyGOASCMASCOAXQhjwEgjQEgjwFqIZABIJABKQMAIf8EIAUpA0ghgAUggAUg/wSFIYEFIAUggQ",
			"U3A0ggBSkDICGCBUIIIYMFIIIFIIMFiCGEBSAFIIQFNwMgIAUpAxghhQVC/wEhhgUghQUghgWDIYcFQoAEI",
			"YgFIIcFIIgFfCGJBSCJBachkQFBgIDAAiGSAUEDIZMBIJEBIJMBdCGUASCSASCUAWohlQEglQEpAwAhigUg",
			"BSkDQCGLBSCLBSCKBYUhjAUgBSCMBTcDQCAFKQMYIY0FQgghjgUgjQUgjgWIIY8FIAUgjwU3AxggBSkDECG",
			"QBUL/ASGRBSCQBSCRBYMhkgVCgAQhkwUgkgUgkwV8IZQFIJQFpyGWAUGAgMACIZcBQQMhmAEglgEgmAF0IZ",
			"kBIJcBIJkBaiGaASCaASkDACGVBSAFKQM4IZYFIJYFIJUFhSGXBSAFIJcFNwM4IAUpAxAhmAVCCCGZBSCYB",
			"SCZBYghmgUgBSCaBTcDECAFKQMoIZsFQv8BIZwFIJsFIJwFgyGdBUKAAiGeBSCdBSCeBXwhnwUgnwWnIZsB",
			"QYCAwAIhnAFBAyGdASCbASCdAXQhngEgnAEgngFqIZ8BIJ8BKQMAIaAFIAUpA1AhoQUgoQUgoAWFIaIFIAU",
			"gogU3A1AgBSkDKCGjBUIIIaQFIKMFIKQFiCGlBSAFIKUFNwMoIAUpAyAhpgVC/wEhpwUgpgUgpwWDIagFQo",
			"ACIakFIKgFIKkFfCGqBSCqBachoAFBgIDAAiGhAUEDIaIBIKABIKIBdCGjASChASCjAWohpAEgpAEpAwAhq",
			"wUgBSkDSCGsBSCsBSCrBYUhrQUgBSCtBTcDSCAFKQMgIa4FQgghrwUgrgUgrwWIIbAFIAUgsAU3AyAgBSkD",
			"GCGxBUL/ASGyBSCxBSCyBYMhswVCgAIhtAUgswUgtAV8IbUFILUFpyGlAUGAgMACIaYBQQMhpwEgpQEgpwF",
			"0IagBIKYBIKgBaiGpASCpASkDACG2BSAFKQNAIbcFILcFILYFhSG4BSAFILgFNwNAIAUpAxghuQVCCCG6BS",
			"C5BSC6BYghuwUgBSC7BTcDGCAFKQMQIbwFQv8BIb0FILwFIL0FgyG+BUKAAiG/BSC+BSC/BXwhwAUgwAWnI",
			"aoBQYCAwAIhqwFBAyGsASCqASCsAXQhrQEgqwEgrQFqIa4BIK4BKQMAIcEFIAUpAzghwgUgwgUgwQWFIcMF",
			"IAUgwwU3AzggBSkDECHEBUIIIcUFIMQFIMUFiCHGBSAFIMYFNwMQIAUpAyghxwVC/wEhyAUgxwUgyAWDIck",
			"FQgAhygUgyQUgygV8IcsFIMsFpyGvAUGAgMACIbABQQMhsQEgrwEgsQF0IbIBILABILIBaiGzASCzASkDAC",
			"HMBSAFKQNQIc0FIM0FIMwFhSHOBSAFIM4FNwNQIAUpAyAhzwVC/wEh0AUgzwUg0AWDIdEFQgAh0gUg0QUg0",
			"gV8IdMFINMFpyG0AUGAgMACIbUBQQMhtgEgtAEgtgF0IbcBILUBILcBaiG4ASC4ASkDACHUBSAFKQNIIdUF",
			"INUFINQFhSHWBSAFINYFNwNIIAUpAxgh1wVC/wEh2AUg1wUg2AWDIdkFQgAh2gUg2QUg2gV8IdsFINsFpyG",
			"5AUGAgMACIboBQQMhuwEguQEguwF0IbwBILoBILwBaiG9ASC9ASkDACHcBSAFKQNAId0FIN0FINwFhSHeBS",
			"AFIN4FNwNAIAUpAxAh3wVC/wEh4AUg3wUg4AWDIeEFQgAh4gUg4QUg4gV8IeMFIOMFpyG+AUGAgMACIb8BQ",
			"QMhwAEgvgEgwAF0IcEBIL8BIMEBaiHCASDCASkDACHkBSAFKQM4IeUFIOUFIOQFhSHmBSAFIOYFNwM4IAUp",
			"A2Ah5wVCICHoBSDnBSDoBXwh6QUgBSDpBTcDYCAFKAJYIcMBQSAhxAEgwwEgxAFqIcUBIAUgxQE2AlgMAAs",
			"AC0IAIeoFIAUg6gU3A2ggBSgCWCHGASDGASkDACHrBSAFKQNQIewFIOsFIOwFhSHtBSAFKQNoIe4FIO4FIO",
			"0FhSHvBSAFIO8FNwNoIAUpA2gh8AVCCCHxBSDwBSDxBYgh8gUgBSkDaCHzBUL/ASH0BSDzBSD0BYMh9QUg9",
			"QWnIccBQYCAwQIhyAFBAyHJASDHASDJAXQhygEgyAEgygFqIcsBIMsBKQMAIfYFIPIFIPYFhSH3BSAFIPcF",
			"NwNoIAUpA2gh+AVCCCH5BSD4BSD5BYgh+gUgBSkDaCH7BUL/ASH8BSD7BSD8BYMh/QUg/QWnIcwBQYCAwQI",
			"hzQFBAyHOASDMASDOAXQhzwEgzQEgzwFqIdABINABKQMAIf4FIPoFIP4FhSH/BSAFIP8FNwNoIAUpA2ghgA",
			"ZCCCGBBiCABiCBBoghggYgBSkDaCGDBkL/ASGEBiCDBiCEBoMhhQYghQanIdEBQYCAwQIh0gFBAyHTASDRA",
			"SDTAXQh1AEg0gEg1AFqIdUBINUBKQMAIYYGIIIGIIYGhSGHBiAFIIcGNwNoIAUpA2ghiAZCCCGJBiCIBiCJ",
			"BoghigYgBSkDaCGLBkL/ASGMBiCLBiCMBoMhjQYgjQanIdYBQYCAwQIh1wFBAyHYASDWASDYAXQh2QEg1wE",
			"g2QFqIdoBINoBKQMAIY4GIIoGII4GhSGPBiAFII8GNwNoIAUpA2ghkAZCCCGRBiCQBiCRBoghkgYgBSkDaC",
			"GTBkL/ASGUBiCTBiCUBoMhlQYglQanIdsBQYCAwQIh3AFBAyHdASDbASDdAXQh3gEg3AEg3gFqId8BIN8BK",
			"QMAIZYGIJIGIJYGhSGXBiAFIJcGNwNoIAUpA2ghmAZCCCGZBiCYBiCZBoghmgYgBSkDaCGbBkL/ASGcBiCb",
			"BiCcBoMhnQYgnQanIeABQYCAwQIh4QFBAyHiASDgASDiAXQh4wEg4QEg4wFqIeQBIOQBKQMAIZ4GIJoGIJ4",
			"GhSGfBiAFIJ8GNwNoIAUpA2ghoAZCCCGhBiCgBiChBoghogYgBSkDaCGjBkL/ASGkBiCjBiCkBoMhpQYgpQ",
			"anIeUBQYCAwQIh5gFBAyHnASDlASDnAXQh6AEg5gEg6AFqIekBIOkBKQMAIaYGIKIGIKYGhSGnBiAFIKcGN",
			"wNoIAUpA2ghqAZCCCGpBiCoBiCpBoghqgYgBSkDaCGrBkL/ASGsBiCrBiCsBoMhrQYgrQanIeoBQYCAwQIh",
			"6wFBAyHsASDqASDsAXQh7QEg6wEg7QFqIe4BIO4BKQMAIa4GIKoGIK4GhSGvBiAFIK8GNwNoIAUoAlgh7wE",
			"g7wEpAwghsAYgBSkDSCGxBiCwBiCxBoUhsgYgBSkDaCGzBiCzBiCyBoUhtAYgBSC0BjcDaCAFKQNoIbUGQg",
			"ghtgYgtQYgtgaIIbcGIAUpA2ghuAZC/wEhuQYguAYguQaDIboGILoGpyHwAUGAgMECIfEBQQMh8gEg8AEg8",
			"gF0IfMBIPEBIPMBaiH0ASD0ASkDACG7BiC3BiC7BoUhvAYgBSC8BjcDaCAFKQNoIb0GQgghvgYgvQYgvgaI",
			"Ib8GIAUpA2ghwAZC/wEhwQYgwAYgwQaDIcIGIMIGpyH1AUGAgMECIfYBQQMh9wEg9QEg9wF0IfgBIPYBIPg",
			"BaiH5ASD5ASkDACHDBiC/BiDDBoUhxAYgBSDEBjcDaCAFKQNoIcUGQgghxgYgxQYgxgaIIccGIAUpA2ghyA",
			"ZC/wEhyQYgyAYgyQaDIcoGIMoGpyH6AUGAgMECIfsBQQMh/AEg+gEg/AF0If0BIPsBIP0BaiH+ASD+ASkDA",
			"CHLBiDHBiDLBoUhzAYgBSDMBjcDaCAFKQNoIc0GQgghzgYgzQYgzgaIIc8GIAUpA2gh0AZC/wEh0QYg0AYg",
			"0QaDIdIGINIGpyH/AUGAgMECIYACQQMhgQIg/wEggQJ0IYICIIACIIICaiGDAiCDAikDACHTBiDPBiDTBoU",
			"h1AYgBSDUBjcDaCAFKQNoIdUGQggh1gYg1QYg1gaIIdcGIAUpA2gh2AZC/wEh2QYg2AYg2QaDIdoGINoGpy",
			"GEAkGAgMECIYUCQQMhhgIghAIghgJ0IYcCIIUCIIcCaiGIAiCIAikDACHbBiDXBiDbBoUh3AYgBSDcBjcDa",
			"CAFKQNoId0GQggh3gYg3QYg3gaIId8GIAUpA2gh4AZC/wEh4QYg4AYg4QaDIeIGIOIGpyGJAkGAgMECIYoC",
			"QQMhiwIgiQIgiwJ0IYwCIIoCIIwCaiGNAiCNAikDACHjBiDfBiDjBoUh5AYgBSDkBjcDaCAFKQNoIeUGQgg",
			"h5gYg5QYg5gaIIecGIAUpA2gh6AZC/wEh6QYg6AYg6QaDIeoGIOoGpyGOAkGAgMECIY8CQQMhkAIgjgIgkA",
			"J0IZECII8CIJECaiGSAiCSAikDACHrBiDnBiDrBoUh7AYgBSDsBjcDaCAFKQNoIe0GQggh7gYg7QYg7gaII",
			"e8GIAUpA2gh8AZC/wEh8QYg8AYg8QaDIfIGIPIGpyGTAkGAgMECIZQCQQMhlQIgkwIglQJ0IZYCIJQCIJYC",
			"aiGXAiCXAikDACHzBiDvBiDzBoUh9AYgBSD0BjcDaCAFKAJYIZgCIJgCKQMQIfUGIAUpA0Ah9gYg9QYg9ga",
			"FIfcGIAUpA2gh+AYg+AYg9waFIfkGIAUg+QY3A2ggBSkDaCH6BkIIIfsGIPoGIPsGiCH8BiAFKQNoIf0GQv",
			"8BIf4GIP0GIP4GgyH/BiD/BqchmQJBgIDBAiGaAkEDIZsCIJkCIJsCdCGcAiCaAiCcAmohnQIgnQIpAwAhg",
			"Acg/AYggAeFIYEHIAUggQc3A2ggBSkDaCGCB0IIIYMHIIIHIIMHiCGEByAFKQNoIYUHQv8BIYYHIIUHIIYH",
			"gyGHByCHB6chngJBgIDBAiGfAkEDIaACIJ4CIKACdCGhAiCfAiChAmohogIgogIpAwAhiAcghAcgiAeFIYk",
			"HIAUgiQc3A2ggBSkDaCGKB0IIIYsHIIoHIIsHiCGMByAFKQNoIY0HQv8BIY4HII0HII4HgyGPByCPB6chow",
			"JBgIDBAiGkAkEDIaUCIKMCIKUCdCGmAiCkAiCmAmohpwIgpwIpAwAhkAcgjAcgkAeFIZEHIAUgkQc3A2ggB",
			"SkDaCGSB0IIIZMHIJIHIJMHiCGUByAFKQNoIZUHQv8BIZYHIJUHIJYHgyGXByCXB6chqAJBgIDBAiGpAkED",
			"IaoCIKgCIKoCdCGrAiCpAiCrAmohrAIgrAIpAwAhmAcglAcgmAeFIZkHIAUgmQc3A2ggBSkDaCGaB0IIIZs",
			"HIJoHIJsHiCGcByAFKQNoIZ0HQv8BIZ4HIJ0HIJ4HgyGfByCfB6chrQJBgIDBAiGuAkEDIa8CIK0CIK8CdC",
			"GwAiCuAiCwAmohsQIgsQIpAwAhoAcgnAcgoAeFIaEHIAUgoQc3A2ggBSkDaCGiB0IIIaMHIKIHIKMHiCGkB",
			"yAFKQNoIaUHQv8BIaYHIKUHIKYHgyGnByCnB6chsgJBgIDBAiGzAkEDIbQCILICILQCdCG1AiCzAiC1Amoh",
			"tgIgtgIpAwAhqAcgpAcgqAeFIakHIAUgqQc3A2ggBSkDaCGqB0IIIasHIKoHIKsHiCGsByAFKQNoIa0HQv8",
			"BIa4HIK0HIK4HgyGvByCvB6chtwJBgIDBAiG4AkEDIbkCILcCILkCdCG6AiC4AiC6AmohuwIguwIpAwAhsA",
			"cgrAcgsAeFIbEHIAUgsQc3A2ggBSkDaCGyB0IIIbMHILIHILMHiCG0ByAFKQNoIbUHQv8BIbYHILUHILYHg",
			"yG3ByC3B6chvAJBgIDBAiG9AkEDIb4CILwCIL4CdCG/AiC9AiC/AmohwAIgwAIpAwAhuAcgtAcguAeFIbkH",
			"IAUguQc3A2ggBSgCWCHBAiDBAikDGCG6ByAFKQM4IbsHILoHILsHhSG8ByAFKQNoIb0HIL0HILwHhSG+ByA",
			"FIL4HNwNoIAUpA2ghvwdCCCHAByC/ByDAB4ghwQcgBSkDaCHCB0L/ASHDByDCByDDB4MhxAcgxAenIcICQY",
			"CAwQIhwwJBAyHEAiDCAiDEAnQhxQIgwwIgxQJqIcYCIMYCKQMAIcUHIMEHIMUHhSHGByAFIMYHNwNoIAUpA",
			"2ghxwdCCCHIByDHByDIB4ghyQcgBSkDaCHKB0L/ASHLByDKByDLB4MhzAcgzAenIccCQYCAwQIhyAJBAyHJ",
			"AiDHAiDJAnQhygIgyAIgygJqIcsCIMsCKQMAIc0HIMkHIM0HhSHOByAFIM4HNwNoIAUpA2ghzwdCCCHQByD",
			"PByDQB4gh0QcgBSkDaCHSB0L/ASHTByDSByDTB4Mh1Acg1AenIcwCQYCAwQIhzQJBAyHOAiDMAiDOAnQhzw",
			"IgzQIgzwJqIdACINACKQMAIdUHINEHINUHhSHWByAFINYHNwNoIAUpA2gh1wdCCCHYByDXByDYB4gh2QcgB",
			"SkDaCHaB0L/ASHbByDaByDbB4Mh3Acg3AenIdECQYCAwQIh0gJBAyHTAiDRAiDTAnQh1AIg0gIg1AJqIdUC",
			"INUCKQMAId0HINkHIN0HhSHeByAFIN4HNwNoIAUpA2gh3wdCCCHgByDfByDgB4gh4QcgBSkDaCHiB0L/ASH",
			"jByDiByDjB4Mh5Acg5AenIdYCQYCAwQIh1wJBAyHYAiDWAiDYAnQh2QIg1wIg2QJqIdoCINoCKQMAIeUHIO",
			"EHIOUHhSHmByAFIOYHNwNoIAUpA2gh5wdCCCHoByDnByDoB4gh6QcgBSkDaCHqB0L/ASHrByDqByDrB4Mh7",
			"Acg7AenIdsCQYCAwQIh3AJBAyHdAiDbAiDdAnQh3gIg3AIg3gJqId8CIN8CKQMAIe0HIOkHIO0HhSHuByAF",
			"IO4HNwNoIAUpA2gh7wdCCCHwByDvByDwB4gh8QcgBSkDaCHyB0L/ASHzByDyByDzB4Mh9Acg9AenIeACQYC",
			"AwQIh4QJBAyHiAiDgAiDiAnQh4wIg4QIg4wJqIeQCIOQCKQMAIfUHIPEHIPUHhSH2ByAFIPYHNwNoIAUpA2",
			"gh9wdCCCH4ByD3ByD4B4gh+QcgBSkDaCH6B0L/ASH7ByD6ByD7B4Mh/Acg/AenIeUCQYCAwQIh5gJBAyHnA",
			"iDlAiDnAnQh6AIg5gIg6AJqIekCIOkCKQMAIf0HIPkHIP0HhSH+ByAFIP4HNwNoIAUpA2Ah/wdCICGACCD/",
			"ByCACHwhgQggBSCBCDcDYAtCACGCCCAFIIIINwMIAkADQCAFKQMIIYMIIAUoAnQh6gIg6gIh6wIg6wKsIYQ",
			"IIIMIIYUIIIQIIYYIIIUIIIYIVCHsAkEBIe0CIOwCIO0CcSHuAiDuAkUNASAFKQNoIYcIQgghiAgghwggiA",
			"iIIYkIIAUpA2ghigggBSgCcCHvAiAFKQNgIYsIIIsIpyHwAiDvAiDwAmoh8QIg8QItAAAh8gJB/wEh8wIg8",
			"gIg8wJxIfQCIPQCrSGMCCCKCCCMCIUhjQhC/wEhjgggjQggjgiDIY8III8IpyH1AkGAgMECIfYCQQMh9wIg",
			"9QIg9wJ0IfgCIPYCIPgCaiH5AiD5AikDACGQCCCJCCCQCIUhkQggBSCRCDcDaCAFKQMIIZIIQgEhkwggkgg",
			"gkwh8IZQIIAUglAg3AwggBSkDYCGVCEIBIZYIIJUIIJYIfCGXCCAFIJcINwNgDAALAAsgBSkDaCGYCEJ/IZ",
			"kIIJgIIJkIhSGaCCAGIJoINwMADwudAgIcfwV+IwAhBEEgIQUgBCAFayEGIAYkACAGIAA2AhwgBiABNgIYI",
			"AYgAjYCFCAGIAM2AhAgBigCHCEHIAYoAhghCCAGKAIUIQkgByAIIAkQBiAGKAIQIQogBiAKNgIMQQAhCyAG",
			"IAs2AggCQANAIAYoAgghDEEIIQ0gDCEOIA0hDyAOIA9JIRBBASERIBAgEXEhEiASRQ0BIAcpAwAhICAGKAI",
			"IIRNBAyEUIBMgFHQhFSAVIRYgFq0hISAgICGIISJC/wEhIyAiICODISQgJKchFyAGKAIMIRggBigCCCEZIB",
			"ggGWohGiAaIBc6AAAgBigCCCEbQQEhHCAbIBxqIR0gBiAdNgIIDAALAAtBICEeIAYgHmohHyAfJAAPC14BD",
			"H8jACEBQRAhAiABIAJrIQMgAyQAIAMgADYCDCADKAIMIQRBACEFIAQhBiAFIQcgBiAHRiEIQQEhCSAIIAlx",
			"IQoCQCAKDQAgBBAUC0EQIQsgAyALaiEMIAwkAA8LNQIEfwF+QRAhACAAEBMhAUIAIQQgASAENwMAQQghAiA",
			"BIAJqIQMgAyAENwMAIAEQChogAQ8LPAIEfwJ+IwAhAUEQIQIgASACayEDIAMgADYCDCADKAIMIQRCACEFIA",
			"QgBTcDAEIAIQYgBCAGNwMIIAQPC1kBCH8jACEDQRAhBCADIARrIQUgBSQAIAUgADYCDCAFIAE2AgggBSACN",
			"gIEIAUoAgwhBiAFKAIIIQcgBSgCBCEIIAYgByAIEAZBECEJIAUgCWohCiAKJAAPC2kBCX8jACEEQRAhBSAE",
			"IAVrIQYgBiQAIAYgADYCDCAGIAE2AgggBiACNgIEIAYgAzYCACAGKAIMIQcgBigCCCEIIAYoAgQhCSAGKAI",
			"AIQogByAIIAkgChAHQRAhCyAGIAtqIQwgDCQADwteAQx/IwAhAUEQIQIgASACayEDIAMkACADIAA2AgwgAy",
			"gCDCEEQQAhBSAEIQYgBSEHIAYgB0YhCEEBIQkgCCAJcSEKAkAgCg0AIAQQFAtBECELIAMgC2ohDCAMJAAPC",
			"wcAPwBBEHQLBwBBlJLBAgtUAQJ/QQAoAoCQwQIiASAAQQdqQXhxIgJqIQACQAJAIAJFDQAgACABTQ0BCwJA",
			"IAAQDk0NACAAEAFFDQELQQAgADYCgJDBAiABDwsQD0EwNgIAQX8LviwBC38jAEEQayIBJAACQAJAAkACQAJ",
			"AAkACQAJAAkACQAJAAkACQAJAAkAgAEH0AUsNAAJAQQAoApiSwQIiAkEQIABBC2pBeHEgAEELSRsiA0EDdi",
			"IEdiIAQQNxRQ0AAkACQCAAQX9zQQFxIARqIgVBA3QiBEHAksECaiIAIARByJLBAmooAgAiBCgCCCIDRw0AQ",
			"QAgAkF+IAV3cTYCmJLBAgwBCyADIAA2AgwgACADNgIICyAEQQhqIQAgBCAFQQN0IgVBA3I2AgQgBCAFaiIE",
			"IAQoAgRBAXI2AgQMDwsgA0EAKAKgksECIgZNDQECQCAARQ0AAkACQCAAIAR0QQIgBHQiAEEAIABrcnEiAEE",
			"AIABrcWgiBEEDdCIAQcCSwQJqIgUgAEHIksECaigCACIAKAIIIgdHDQBBACACQX4gBHdxIgI2ApiSwQIMAQ",
			"sgByAFNgIMIAUgBzYCCAsgACADQQNyNgIEIAAgA2oiByAEQQN0IgQgA2siBUEBcjYCBCAAIARqIAU2AgACQ",
			"CAGRQ0AIAZBeHFBwJLBAmohA0EAKAKsksECIQQCQAJAIAJBASAGQQN2dCIIcQ0AQQAgAiAIcjYCmJLBAiAD",
			"IQgMAQsgAygCCCEICyADIAQ2AgggCCAENgIMIAQgAzYCDCAEIAg2AggLIABBCGohAEEAIAc2AqySwQJBACA",
			"FNgKgksECDA8LQQAoApySwQIiCUUNASAJQQAgCWtxaEECdEHIlMECaigCACIHKAIEQXhxIANrIQQgByEFAk",
			"ADQAJAIAUoAhAiAA0AIAVBFGooAgAiAEUNAgsgACgCBEF4cSADayIFIAQgBSAESSIFGyEEIAAgByAFGyEHI",
			"AAhBQwACwALIAcoAhghCgJAIAcoAgwiCCAHRg0AIAcoAggiAEEAKAKoksECSRogACAINgIMIAggADYCCAwO",
			"CwJAIAdBFGoiBSgCACIADQAgBygCECIARQ0DIAdBEGohBQsDQCAFIQsgACIIQRRqIgUoAgAiAA0AIAhBEGo",
			"hBSAIKAIQIgANAAsgC0EANgIADA0LQX8hAyAAQb9/Sw0AIABBC2oiAEF4cSEDQQAoApySwQIiBkUNAEEAIQ",
			"sCQCADQYACSQ0AQR8hCyADQf///wdLDQAgA0EmIABBCHZnIgBrdkEBcSAAQQF0a0E+aiELC0EAIANrIQQCQ",
			"AJAAkACQCALQQJ0QciUwQJqKAIAIgUNAEEAIQBBACEIDAELQQAhACADQQBBGSALQQF2ayALQR9GG3QhB0EA",
			"IQgDQAJAIAUoAgRBeHEgA2siAiAETw0AIAIhBCAFIQggAg0AQQAhBCAFIQggBSEADAMLIAAgBUEUaigCACI",
			"CIAIgBSAHQR12QQRxakEQaigCACIFRhsgACACGyEAIAdBAXQhByAFDQALCwJAIAAgCHINAEEAIQhBAiALdC",
			"IAQQAgAGtyIAZxIgBFDQMgAEEAIABrcWhBAnRByJTBAmooAgAhAAsgAEUNAQsDQCAAKAIEQXhxIANrIgIgB",
			"EkhBwJAIAAoAhAiBQ0AIABBFGooAgAhBQsgAiAEIAcbIQQgACAIIAcbIQggBSEAIAUNAAsLIAhFDQAgBEEA",
			"KAKgksECIANrTw0AIAgoAhghCwJAIAgoAgwiByAIRg0AIAgoAggiAEEAKAKoksECSRogACAHNgIMIAcgADY",
			"CCAwMCwJAIAhBFGoiBSgCACIADQAgCCgCECIARQ0DIAhBEGohBQsDQCAFIQIgACIHQRRqIgUoAgAiAA0AIA",
			"dBEGohBSAHKAIQIgANAAsgAkEANgIADAsLAkBBACgCoJLBAiIAIANJDQBBACgCrJLBAiEEAkACQCAAIANrI",
			"gVBEEkNAEEAIAU2AqCSwQJBACAEIANqIgc2AqySwQIgByAFQQFyNgIEIAQgAGogBTYCACAEIANBA3I2AgQM",
			"AQtBAEEANgKsksECQQBBADYCoJLBAiAEIABBA3I2AgQgBCAAaiIAIAAoAgRBAXI2AgQLIARBCGohAAwNCwJ",
			"AQQAoAqSSwQIiByADTQ0AQQAgByADayIENgKkksECQQBBACgCsJLBAiIAIANqIgU2ArCSwQIgBSAEQQFyNg",
			"IEIAAgA0EDcjYCBCAAQQhqIQAMDQsCQAJAQQAoAvCVwQJFDQBBACgC+JXBAiEEDAELQQBCfzcC/JXBAkEAQ",
			"oCggICAgAQ3AvSVwQJBACABQQxqQXBxQdiq1aoFczYC8JXBAkEAQQA2AoSWwQJBAEEANgLUlcECQYAgIQQL",
			"QQAhACAEIANBL2oiBmoiAkEAIARrIgtxIgggA00NDEEAIQACQEEAKALQlcECIgRFDQBBACgCyJXBAiIFIAh",
			"qIgkgBU0NDSAJIARLDQ0LAkACQEEALQDUlcECQQRxDQACQAJAAkACQAJAQQAoArCSwQIiBEUNAEHYlcECIQ",
			"ADQAJAIAAoAgAiBSAESw0AIAUgACgCBGogBEsNAwsgACgCCCIADQALC0EAEBAiB0F/Rg0DIAghAgJAQQAoA",
			"vSVwQIiAEF/aiIEIAdxRQ0AIAggB2sgBCAHakEAIABrcWohAgsgAiADTQ0DAkBBACgC0JXBAiIARQ0AQQAo",
			"AsiVwQIiBCACaiIFIARNDQQgBSAASw0ECyACEBAiACAHRw0BDAULIAIgB2sgC3EiAhAQIgcgACgCACAAKAI",
			"EakYNASAHIQALIABBf0YNAQJAIANBMGogAksNACAAIQcMBAsgBiACa0EAKAL4lcECIgRqQQAgBGtxIgQQEE",
			"F/Rg0BIAQgAmohAiAAIQcMAwsgB0F/Rw0CC0EAQQAoAtSVwQJBBHI2AtSVwQILIAgQECEHQQAQECEAIAdBf",
			"0YNBSAAQX9GDQUgByAATw0FIAAgB2siAiADQShqTQ0FC0EAQQAoAsiVwQIgAmoiADYCyJXBAgJAIABBACgC",
			"zJXBAk0NAEEAIAA2AsyVwQILAkACQEEAKAKwksECIgRFDQBB2JXBAiEAA0AgByAAKAIAIgUgACgCBCIIakY",
			"NAiAAKAIIIgANAAwFCwALAkACQEEAKAKoksECIgBFDQAgByAATw0BC0EAIAc2AqiSwQILQQAhAEEAIAI2At",
			"yVwQJBACAHNgLYlcECQQBBfzYCuJLBAkEAQQAoAvCVwQI2ArySwQJBAEEANgLklcECA0AgAEEDdCIEQciSw",
			"QJqIARBwJLBAmoiBTYCACAEQcySwQJqIAU2AgAgAEEBaiIAQSBHDQALQQAgAkFYaiIAQXggB2tBB3FBACAH",
			"QQhqQQdxGyIEayIFNgKkksECQQAgByAEaiIENgKwksECIAQgBUEBcjYCBCAHIABqQSg2AgRBAEEAKAKAlsE",
			"CNgK0ksECDAQLIAAtAAxBCHENAiAEIAVJDQIgBCAHTw0CIAAgCCACajYCBEEAIARBeCAEa0EHcUEAIARBCG",
			"pBB3EbIgBqIgU2ArCSwQJBAEEAKAKkksECIAJqIgcgAGsiADYCpJLBAiAFIABBAXI2AgQgBCAHakEoNgIEQ",
			"QBBACgCgJbBAjYCtJLBAgwDC0EAIQgMCgtBACEHDAgLAkAgB0EAKAKoksECIghPDQBBACAHNgKoksECIAch",
			"CAsgByACaiEFQdiVwQIhAAJAAkACQAJAA0AgACgCACAFRg0BIAAoAggiAA0ADAILAAsgAC0ADEEIcUUNAQt",
			"B2JXBAiEAA0ACQCAAKAIAIgUgBEsNACAFIAAoAgRqIgUgBEsNAwsgACgCCCEADAALAAsgACAHNgIAIAAgAC",
			"gCBCACajYCBCAHQXggB2tBB3FBACAHQQhqQQdxG2oiCyADQQNyNgIEIAVBeCAFa0EHcUEAIAVBCGpBB3Eba",
			"iICIAsgA2oiA2shAAJAIAIgBEcNAEEAIAM2ArCSwQJBAEEAKAKkksECIABqIgA2AqSSwQIgAyAAQQFyNgIE",
			"DAgLAkAgAkEAKAKsksECRw0AQQAgAzYCrJLBAkEAQQAoAqCSwQIgAGoiADYCoJLBAiADIABBAXI2AgQgAyA",
			"AaiAANgIADAgLIAIoAgQiBEEDcUEBRw0GIARBeHEhBgJAIARB/wFLDQAgAigCCCIFIARBA3YiCEEDdEHAks",
			"ECaiIHRhoCQCACKAIMIgQgBUcNAEEAQQAoApiSwQJBfiAId3E2ApiSwQIMBwsgBCAHRhogBSAENgIMIAQgB",
			"TYCCAwGCyACKAIYIQkCQCACKAIMIgcgAkYNACACKAIIIgQgCEkaIAQgBzYCDCAHIAQ2AggMBQsCQCACQRRq",
			"IgUoAgAiBA0AIAIoAhAiBEUNBCACQRBqIQULA0AgBSEIIAQiB0EUaiIFKAIAIgQNACAHQRBqIQUgBygCECI",
			"EDQALIAhBADYCAAwEC0EAIAJBWGoiAEF4IAdrQQdxQQAgB0EIakEHcRsiCGsiCzYCpJLBAkEAIAcgCGoiCD",
			"YCsJLBAiAIIAtBAXI2AgQgByAAakEoNgIEQQBBACgCgJbBAjYCtJLBAiAEIAVBJyAFa0EHcUEAIAVBWWpBB",
			"3EbakFRaiIAIAAgBEEQakkbIghBGzYCBCAIQRBqQQApAuCVwQI3AgAgCEEAKQLYlcECNwIIQQAgCEEIajYC",
			"4JXBAkEAIAI2AtyVwQJBACAHNgLYlcECQQBBADYC5JXBAiAIQRhqIQADQCAAQQc2AgQgAEEIaiEHIABBBGo",
			"hACAHIAVJDQALIAggBEYNACAIIAgoAgRBfnE2AgQgBCAIIARrIgdBAXI2AgQgCCAHNgIAAkAgB0H/AUsNAC",
			"AHQXhxQcCSwQJqIQACQAJAQQAoApiSwQIiBUEBIAdBA3Z0IgdxDQBBACAFIAdyNgKYksECIAAhBQwBCyAAK",
			"AIIIQULIAAgBDYCCCAFIAQ2AgwgBCAANgIMIAQgBTYCCAwBC0EfIQACQCAHQf///wdLDQAgB0EmIAdBCHZn",
			"IgBrdkEBcSAAQQF0a0E+aiEACyAEIAA2AhwgBEIANwIQIABBAnRByJTBAmohBQJAAkACQEEAKAKcksECIgh",
			"BASAAdCICcQ0AQQAgCCACcjYCnJLBAiAFIAQ2AgAgBCAFNgIYDAELIAdBAEEZIABBAXZrIABBH0YbdCEAIA",
			"UoAgAhCANAIAgiBSgCBEF4cSAHRg0CIABBHXYhCCAAQQF0IQAgBSAIQQRxaiICQRBqKAIAIggNAAsgAkEQa",
			"iAENgIAIAQgBTYCGAsgBCAENgIMIAQgBDYCCAwBCyAFKAIIIgAgBDYCDCAFIAQ2AgggBEEANgIYIAQgBTYC",
			"DCAEIAA2AggLQQAoAqSSwQIiACADTQ0AQQAgACADayIENgKkksECQQBBACgCsJLBAiIAIANqIgU2ArCSwQI",
			"gBSAEQQFyNgIEIAAgA0EDcjYCBCAAQQhqIQAMCAsQD0EwNgIAQQAhAAwHC0EAIQcLIAlFDQACQAJAIAIgAi",
			"gCHCIFQQJ0QciUwQJqIgQoAgBHDQAgBCAHNgIAIAcNAUEAQQAoApySwQJBfiAFd3E2ApySwQIMAgsgCUEQQ",
			"RQgCSgCECACRhtqIAc2AgAgB0UNAQsgByAJNgIYAkAgAigCECIERQ0AIAcgBDYCECAEIAc2AhgLIAJBFGoo",
			"AgAiBEUNACAHQRRqIAQ2AgAgBCAHNgIYCyAGIABqIQAgAiAGaiICKAIEIQQLIAIgBEF+cTYCBCADIABBAXI",
			"2AgQgAyAAaiAANgIAAkAgAEH/AUsNACAAQXhxQcCSwQJqIQQCQAJAQQAoApiSwQIiBUEBIABBA3Z0IgBxDQ",
			"BBACAFIAByNgKYksECIAQhAAwBCyAEKAIIIQALIAQgAzYCCCAAIAM2AgwgAyAENgIMIAMgADYCCAwBC0EfI",
			"QQCQCAAQf///wdLDQAgAEEmIABBCHZnIgRrdkEBcSAEQQF0a0E+aiEECyADIAQ2AhwgA0IANwIQIARBAnRB",
			"yJTBAmohBQJAAkACQEEAKAKcksECIgdBASAEdCIIcQ0AQQAgByAIcjYCnJLBAiAFIAM2AgAgAyAFNgIYDAE",
			"LIABBAEEZIARBAXZrIARBH0YbdCEEIAUoAgAhBwNAIAciBSgCBEF4cSAARg0CIARBHXYhByAEQQF0IQQgBS",
			"AHQQRxaiIIQRBqKAIAIgcNAAsgCEEQaiADNgIAIAMgBTYCGAsgAyADNgIMIAMgAzYCCAwBCyAFKAIIIgAgA",
			"zYCDCAFIAM2AgggA0EANgIYIAMgBTYCDCADIAA2AggLIAtBCGohAAwCCwJAIAtFDQACQAJAIAggCCgCHCIF",
			"QQJ0QciUwQJqIgAoAgBHDQAgACAHNgIAIAcNAUEAIAZBfiAFd3EiBjYCnJLBAgwCCyALQRBBFCALKAIQIAh",
			"GG2ogBzYCACAHRQ0BCyAHIAs2AhgCQCAIKAIQIgBFDQAgByAANgIQIAAgBzYCGAsgCEEUaigCACIARQ0AIA",
			"dBFGogADYCACAAIAc2AhgLAkACQCAEQQ9LDQAgCCAEIANqIgBBA3I2AgQgCCAAaiIAIAAoAgRBAXI2AgQMA",
			"QsgCCADQQNyNgIEIAggA2oiByAEQQFyNgIEIAcgBGogBDYCAAJAIARB/wFLDQAgBEF4cUHAksECaiEAAkAC",
			"QEEAKAKYksECIgVBASAEQQN2dCIEcQ0AQQAgBSAEcjYCmJLBAiAAIQQMAQsgACgCCCEECyAAIAc2AgggBCA",
			"HNgIMIAcgADYCDCAHIAQ2AggMAQtBHyEAAkAgBEH///8HSw0AIARBJiAEQQh2ZyIAa3ZBAXEgAEEBdGtBPm",
			"ohAAsgByAANgIcIAdCADcCECAAQQJ0QciUwQJqIQUCQAJAAkAgBkEBIAB0IgNxDQBBACAGIANyNgKcksECI",
			"AUgBzYCACAHIAU2AhgMAQsgBEEAQRkgAEEBdmsgAEEfRht0IQAgBSgCACEDA0AgAyIFKAIEQXhxIARGDQIg",
			"AEEddiEDIABBAXQhACAFIANBBHFqIgJBEGooAgAiAw0ACyACQRBqIAc2AgAgByAFNgIYCyAHIAc2AgwgByA",
			"HNgIIDAELIAUoAggiACAHNgIMIAUgBzYCCCAHQQA2AhggByAFNgIMIAcgADYCCAsgCEEIaiEADAELAkAgCk",
			"UNAAJAAkAgByAHKAIcIgVBAnRByJTBAmoiACgCAEcNACAAIAg2AgAgCA0BQQAgCUF+IAV3cTYCnJLBAgwCC",
			"yAKQRBBFCAKKAIQIAdGG2ogCDYCACAIRQ0BCyAIIAo2AhgCQCAHKAIQIgBFDQAgCCAANgIQIAAgCDYCGAsg",
			"B0EUaigCACIARQ0AIAhBFGogADYCACAAIAg2AhgLAkACQCAEQQ9LDQAgByAEIANqIgBBA3I2AgQgByAAaiI",
			"AIAAoAgRBAXI2AgQMAQsgByADQQNyNgIEIAcgA2oiBSAEQQFyNgIEIAUgBGogBDYCAAJAIAZFDQAgBkF4cU",
			"HAksECaiEDQQAoAqySwQIhAAJAAkBBASAGQQN2dCIIIAJxDQBBACAIIAJyNgKYksECIAMhCAwBCyADKAIII",
			"QgLIAMgADYCCCAIIAA2AgwgACADNgIMIAAgCDYCCAtBACAFNgKsksECQQAgBDYCoJLBAgsgB0EIaiEACyAB",
			"QRBqJAAgAAuDDQEHfwJAIABFDQAgAEF4aiIBIABBfGooAgAiAkF4cSIAaiEDAkAgAkEBcQ0AIAJBA3FFDQE",
			"gASABKAIAIgJrIgFBACgCqJLBAiIESQ0BIAIgAGohAAJAAkACQCABQQAoAqySwQJGDQACQCACQf8BSw0AIA",
			"EoAggiBCACQQN2IgVBA3RBwJLBAmoiBkYaAkAgASgCDCICIARHDQBBAEEAKAKYksECQX4gBXdxNgKYksECD",
			"AULIAIgBkYaIAQgAjYCDCACIAQ2AggMBAsgASgCGCEHAkAgASgCDCIGIAFGDQAgASgCCCICIARJGiACIAY2",
			"AgwgBiACNgIIDAMLAkAgAUEUaiIEKAIAIgINACABKAIQIgJFDQIgAUEQaiEECwNAIAQhBSACIgZBFGoiBCg",
			"CACICDQAgBkEQaiEEIAYoAhAiAg0ACyAFQQA2AgAMAgsgAygCBCICQQNxQQNHDQJBACAANgKgksECIAMgAk",
			"F+cTYCBCABIABBAXI2AgQgAyAANgIADwtBACEGCyAHRQ0AAkACQCABIAEoAhwiBEECdEHIlMECaiICKAIAR",
			"w0AIAIgBjYCACAGDQFBAEEAKAKcksECQX4gBHdxNgKcksECDAILIAdBEEEUIAcoAhAgAUYbaiAGNgIAIAZF",
			"DQELIAYgBzYCGAJAIAEoAhAiAkUNACAGIAI2AhAgAiAGNgIYCyABQRRqKAIAIgJFDQAgBkEUaiACNgIAIAI",
			"gBjYCGAsgASADTw0AIAMoAgQiAkEBcUUNAAJAAkACQAJAAkAgAkECcQ0AAkAgA0EAKAKwksECRw0AQQAgAT",
			"YCsJLBAkEAQQAoAqSSwQIgAGoiADYCpJLBAiABIABBAXI2AgQgAUEAKAKsksECRw0GQQBBADYCoJLBAkEAQ",
			"QA2AqySwQIPCwJAIANBACgCrJLBAkcNAEEAIAE2AqySwQJBAEEAKAKgksECIABqIgA2AqCSwQIgASAAQQFy",
			"NgIEIAEgAGogADYCAA8LIAJBeHEgAGohAAJAIAJB/wFLDQAgAygCCCIEIAJBA3YiBUEDdEHAksECaiIGRho",
			"CQCADKAIMIgIgBEcNAEEAQQAoApiSwQJBfiAFd3E2ApiSwQIMBQsgAiAGRhogBCACNgIMIAIgBDYCCAwECy",
			"ADKAIYIQcCQCADKAIMIgYgA0YNACADKAIIIgJBACgCqJLBAkkaIAIgBjYCDCAGIAI2AggMAwsCQCADQRRqI",
			"gQoAgAiAg0AIAMoAhAiAkUNAiADQRBqIQQLA0AgBCEFIAIiBkEUaiIEKAIAIgINACAGQRBqIQQgBigCECIC",
			"DQALIAVBADYCAAwCCyADIAJBfnE2AgQgASAAQQFyNgIEIAEgAGogADYCAAwDC0EAIQYLIAdFDQACQAJAIAM",
			"gAygCHCIEQQJ0QciUwQJqIgIoAgBHDQAgAiAGNgIAIAYNAUEAQQAoApySwQJBfiAEd3E2ApySwQIMAgsgB0",
			"EQQRQgBygCECADRhtqIAY2AgAgBkUNAQsgBiAHNgIYAkAgAygCECICRQ0AIAYgAjYCECACIAY2AhgLIANBF",
			"GooAgAiAkUNACAGQRRqIAI2AgAgAiAGNgIYCyABIABBAXI2AgQgASAAaiAANgIAIAFBACgCrJLBAkcNAEEA",
			"IAA2AqCSwQIPCwJAIABB/wFLDQAgAEF4cUHAksECaiECAkACQEEAKAKYksECIgRBASAAQQN2dCIAcQ0AQQA",
			"gBCAAcjYCmJLBAiACIQAMAQsgAigCCCEACyACIAE2AgggACABNgIMIAEgAjYCDCABIAA2AggPC0EfIQICQC",
			"AAQf///wdLDQAgAEEmIABBCHZnIgJrdkEBcSACQQF0a0E+aiECCyABIAI2AhwgAUIANwIQIAJBAnRByJTBA",
			"mohBAJAAkACQAJAQQAoApySwQIiBkEBIAJ0IgNxDQBBACAGIANyNgKcksECIAQgATYCACABIAQ2AhgMAQsg",
			"AEEAQRkgAkEBdmsgAkEfRht0IQIgBCgCACEGA0AgBiIEKAIEQXhxIABGDQIgAkEddiEGIAJBAXQhAiAEIAZ",
			"BBHFqIgNBEGooAgAiBg0ACyADQRBqIAE2AgAgASAENgIYCyABIAE2AgwgASABNgIIDAELIAQoAggiACABNg",
			"IMIAQgATYCCCABQQA2AhggASAENgIMIAEgADYCCAtBAEEAKAK4ksECQX9qIgFBfyABGzYCuJLBAgsLMQEBf",
			"yAAQQEgABshAQJAA0AgARARIgANAQJAECIiAEUNACAAEQMADAELCxAAAAsgAAsGACAAEBILBAAgAAsLACAA",
			"KAI8EBUQAgsVAAJAIAANAEEADwsQDyAANgIAQX8L4wIBB38jAEEgayIDJAAgAyAAKAIcIgQ2AhAgACgCFCE",
			"FIAMgAjYCHCADIAE2AhggAyAFIARrIgE2AhQgASACaiEGIANBEGohBEECIQcCQAJAAkACQAJAIAAoAjwgA0",
			"EQakECIANBDGoQAxAXRQ0AIAQhBQwBCwNAIAYgAygCDCIBRg0CAkAgAUF/Sg0AIAQhBQwECyAEIAEgBCgCB",
			"CIISyIJQQN0aiIFIAUoAgAgASAIQQAgCRtrIghqNgIAIARBDEEEIAkbaiIEIAQoAgAgCGs2AgAgBiABayEG",
			"IAUhBCAAKAI8IAUgByAJayIHIANBDGoQAxAXRQ0ACwsgBkF/Rw0BCyAAIAAoAiwiATYCHCAAIAE2AhQgACA",
			"BIAAoAjBqNgIQIAIhAQwBC0EAIQEgAEEANgIcIABCADcDECAAIAAoAgBBIHI2AgAgB0ECRg0AIAIgBSgCBG",
			"shAQsgA0EgaiQAIAELNwEBfyMAQRBrIgMkACAAIAEgAkH/AXEgA0EIahAwEBchAiADKQMIIQEgA0EQaiQAQ",
			"n8gASACGwsNACAAKAI8IAEgAhAZCwIACwIACw4AQZCWwQIQG0GUlsECCwkAQZCWwQIQHAsEAEEBCwIACwcA",
			"IAAoAgALCQBBnJbBAhAhCwYAIAAkAQsEACMBCwQAIwALBgAgACQACxIBAn8jACAAa0FwcSIBJAAgAQsEACM",
			"ACxMAQYCAwAIkA0EAQQ9qQXBxJAILBwAjACMCawsEACMDCwQAIwILuAIBA38CQCAADQBBACEBAkBBACgCmJ",
			"bBAkUNAEEAKAKYlsECEC0hAQsCQEEAKAKYkcECRQ0AQQAoApiRwQIQLSABciEBCwJAEB0oAgAiAEUNAANAQ",
			"QAhAgJAIAAoAkxBAEgNACAAEB8hAgsCQCAAKAIUIAAoAhxGDQAgABAtIAFyIQELAkAgAkUNACAAECALIAAo",
			"AjgiAA0ACwsQHiABDwtBACECAkAgACgCTEEASA0AIAAQHyECCwJAAkACQCAAKAIUIAAoAhxGDQAgAEEAQQA",
			"gACgCJBEHABogACgCFA0AQX8hASACDQEMAgsCQCAAKAIEIgEgACgCCCIDRg0AIAAgASADa6xBASAAKAIoEQ",
			"QAGgtBACEBIABBADYCHCAAQgA3AxAgAEIANwIEIAJFDQELIAAQIAsgAQsNACABIAIgAyAAEQQACyMBAX4gA",
			"CABIAKtIAOtQiCGhCAEEC4hBSAFQiCIpxAjIAWnCxMAIAAgAacgAUIgiKcgAiADEAQLC7aSgYAABABBgIDA",
			"AguAkAEAAAAAAAAAADGyfhfBM8W4CfdqdtFBU0U4RRRhEHKW/RLu1eyig6aKI1yr+2OwYzIbGb+ac8L1zyq",
			"rwY2y8TB3T088gRYhlCF+/UKW1xJRmUa4VvfHYMdkdwoo4AZTAtxdoelttKIyq2wTl3p1kfcTVFaDG2XjYe",
			"5l5P0MpNCkVp6eeAItQihDrywGFexx7fuXaRJ0/AN7BqbbbGM9ML6+jHCt7o/Bjsm9wtP5TvJLcYWHx5heg",
			"N2MtDW5j5+zGDTR0USDO2O8YuBjOpT6UHna2CYu9eoi7yfplFDiKxEqn8M/kW+Z4Bro8o3veFjT31DKyPsZ",
			"SKFJrft6hQ6JkowVPD3xBFqEUIYNj48Tm7eVPjXKm3KLxQPDBHjlZUr2xnsu0yTo+Af2DB9hWv85NDO0JyR",
			"OnilGpUkWljCJ6HVg8XNyzYVMpcSnQsCzko2WAR96hafzneSX4ks32eRc11JaYZwYae4mYi1QLmZ+LxWnlW",
			"hrch8/ZzFoWdkMCP5U9NCio4kGd8Z4xZMR9xG29b19q1TjcKaHK4Ca5p1nZ7TuOLBNXOrVRd5Pgf8i/RR2G",
			"/e5ujacBASNCogISIvFN0iy7ey1h2Hn7OTcXsuQoNQpXOQb3/Gwpr+h1amh5nGVehn/AmBrw2RKbs6wHnwC",
			"V4/W9vUKHRIlGSvHR3QK0xbckxPpdVHnLng4IlsLRiYdvYAaHh8nNm8rfSusYTD3XO7FAQegvUWt3rIwtd6",
			"qhJ4bCgjwysuU7I33OUK03FXfSE9cpknQ8Q/sGW0UN8cwPCmhVVEjpiBOv1xk412x4X165E5InDxTjEqTf/",
			"riK5K/jytHv/ZKgs0Z1nYNiF1D/txujXcNU8psUHu8xXNEC1+Vw4SAZyUbLQM+tTIZMtoexoafmdi/aO/28",
			"a4rpqip3DNJlm6yybmupbSn3MzeeJ1gDMI4MdLcTcRa84pPxR1+AeLLz1ukDQyXH/p9JbPMP1Kn0NbkPn7O",
			"YtDhZJopv/2naNkhjkivjzGV6JPwX2689C0v1IRVvaoovh5m+kJ8me0GJiPuI2zre/sXkZA0rdi+Qz06Ubk",
			"fKY40DIgvrt4aS4w0zTvPzmjdcQV/RdgPWxjJYJu41KuLvJ9RKcbDarh5J2ls0qJ6yu/aWN6stbv5KmJydW",
			"04CQgaFUPHEy/IO9+te4IHTthJSVBKMHlZGXqM6LFK/FeQ6AD9gPiCQFHbxUW4vZYhQalTuIkP6DaAmpYAo",
			"6QpuzJrpneSFles81hjz6pTQ83jKvUym+E92iIZMIr+BcDWhsmU3M+3vsFH+lFk9/KqoFeIx5nGQNS3lrsC",
			"IezrFTokSjJW3VlrLeV59+7lHH9M9QthE9SuAVs0OKSrJtLros5d8HAXYJW1D241yC8lgdQfHKM1Hpf/w94",
			"vZo00PD5ObN5W+gWOQFmt7ZNCPctUOL2fBb8MeSovfKzAB2md1yPYfGRRWC+pNBlPoelgar1VCT03FFHYw0",
			"LIDvKse3MCz3r/wttKwXzYu8wHY3KEaLmrvpGeQzYWrmqNVCa4TJOg4x/YM4n+7bciLB2Lsbv51jJei3aAC",
			"YfB821OzqqiRkxBnH65mxA4W4CvuwGjVSw6kN0t/JLnUi1R7uhE9wOvIfU+TBLGsdE2NA2Jqv70xVckfx9X",
			"z0a7QOVM2u/l7XrNV73qmNRfBNqWji8g7BoQu4b8ud3dqG6sR898ZRrvGqaU2aD2K11ksVXqZU4TGHDQRZj",
			"zsyKqDseEqzYLCAHPSjZaBnw5s7Fd92nDxAH2pTznG1U5METbKyYokIFVoCYngvg012QSWDBDy/FvXFdMUV",
			"O5Z5Jt5TJGkoqiKkdO88sge5JddvyN3OFIV+VOuZm98TrBGH8L56owCQSghHFipLmbiLW1wxyzeKhNDY2GC",
			"NJo2tvwvDR2xanpHkiWn7dIGxguP6ctyV/aK+uHn2jdPspZfXqu2qMpC2q4wss+XiWvuhyU+owgMm6J2SzC",
			"yTRTfvtP0fN7SkS/yIpp2dCLyQ05uh7oYvXezAp/ptAn4b/ceOlb4ZWfqB1LLOM1O57zKXOISASJ4OToQE3",
			"wPMz0hfgy2w0NfoqSOQEetSfVSx+L8C7CFmc1CErD63ouIiFpWrF9hx+QX36bgrg/enSicj9SHGlLxtxl/m",
			"HZ0XODyATuE08sQjG2Ey8gipRomneendG641koCYlc4n9bYW0d6EyQ6aZQ32P/jaMsHqul5vEEMaALmheY5",
			"sUCZbOiUoyH1XDzTpPg8pAUQzb2uUszHaayBoGI+U0KZ4HDObC8WWt381XEgQ4nfLbAkHzk6tpwEhA0KtVY",
			"pGfTI/GS7R2wBsNRZ2/cr84RAmKi1/YED5ywk5Kgx7Zxi3GgVxj/82XqYdLB5c5BG/2g4QRdCQZv93P32M4",
			"4tBHgssQddgDxBYGitouLMUN7lmOFTjMb6Lob0XR+RCpaxAwQR7v8Eh/QbQA1LQEjra56wQbouUZJU3Zl1k",
			"zvd/stYaTliVdPvjkAtJcfqn4MRxd1pNoSVKeGmsdV6mVlFfiNBmYv3V1Q7OwWFLkgbOKS+9cnfJiXmBf1X",
			"rXwjaYqaeKfhjU1nm99g4/0o8iv3QOUTsdmcIV2whn8NlYHtMS8Dj0Fk7+MgahvLXcFQr0z1njsRMD62Ncr",
			"dEiUZKzpZVVjiaehFNEgQQKZ1Tfp4JI/FVjm8lHKOf6Y6hfCJvuLgI8rJAeew86U7jtWkWPyfOr5+mVU2wA",
			"AAAAAAAAASEfgaLc09/b7HVeJPU832bNat+GKe8Avnag5Sii4t4bV79kin4xAcGa1bsMV94BfLvKOq6LDd6",
			"lRwuTMA1a2ORmFBKS0YkHPqt+zRT4ZgeDimFMtiS12Fsxq3YYr7gG/hC097pza9kk3d4oPFqE2Zn8wamehl",
			"cGQooTJmQesbHPqwynxsJibhVmZnhA641uqEd5+eI3XrFw/LPDTLxTb9XdrELuYICwDxDGnWhJb7CyMdkcy",
			"pW8b2vNGLVUE+tpKuwHNPbPOLbwIW3rcObXtk0AcmrSOgRplbu4UHyxCbcwmqfR3m3aaOpXzQ5YRDVoV3bS",
			"j/qY5reNECZMzD1jZ5gxOc1u4bC4QvxTEujIX7j/3UyTShSMZydmhqnkn4G5gkeZKEZDUmZYivP3wGq9ZuW",
			"r7HZitm65PFct3/wwOb99djJeXuzqYKe7WIHYxQVgGppHAHoZ1r/CIY061JLbYWcAkrt2Tgi+vc34ZPBn57",
			"4A7OflUrs0YduaNWqoI9LWVrsq6wr/AQmMdkA0jNbuCTFXX7UuCj3W6eyVj4CBMAhMzYoOIl3j15YA4NGkd",
			"AzXKyH/UAao3wjy3T75mC6IDrP8IXg68lvRaTFLp7zbtNHUEFQmHgdnDgyrnhywjGrQqYqBnRJQuQ9zR+tC",
			"lHlWD85m9MM2pYXQF44GxP02Wa/mrxlFX+qKcDxic5rZw2VwgUNsG3sftq9Z+KYh1ZS7cfzZuaB3SGiuJhT",
			"Tf/Fhh66bNcz+U71UcULJDVfNOwN3A+gS1m/n0KjZJXgJ6c4/qGQEZ4hLEux3vL+tsuWZ4akZnrIzR0Uyds",
			"NT2OzBbN12fnLHbWOwDqmlBBXimSjoHiglCmM79DvB8uhgvL3d1MFPyX89HwEHHpdytQexigrAMlOqhhNW2",
			"R/onsBZlX82H1W/39g3o+XAjEMecaklssbNYgHwC/lhGRevay+N0I4Zqo50ri8MXcZyNb6UgYdQGNcUoRUj",
			"W4PHDdnLyqVybMew+NRLB66/GGqeIIgxCzrIf78/CZPX6RelclXWFf4GFxhTSle3ItXIwOiAbRmp2BZlyZ/",
			"su3ULyb8E9TM9XOTJAiXqsp+ANxbb2SsbAQZgEJr4NJqj2rPPQDVeRSXzXM/9FEHEhy+PECWvi/4ppILOgI",
			"6Uf4t4URFaQ/6gDVG+Eedi4SGvjW3OPBQzrlUVi3mxNSwv98lYpmv4RvBx4Lem1tlZcdM8ZHkOYpNLfbdpp",
			"6tDjMrfa7p4cY7mFVlCVXjMr/mU+56GpxVTOD1lGNGhVHInvMfEAn6Ov01jQe3tfjOeUuLjMT6h6yWY2E26",
			"M39OBIdZ72bgoJTJ7YZpTw+gKejyB8uT3H/ytkPQnyQoOxuXXFE9+PvkwVo2jrvRFOR8eykPGQ3HO6TA4zW",
			"3hsrlAeH8tBVaGTrbLJZrk3P2OmYNieoxryXlv/FIQ68pcuP+0FfCDfWhPCQdPR2L3E48mTwinCkAneNBh+",
			"imh4uQPeSm9yclV0PiPmud+KN+rOKDSoJ5AaJ/PVg8UPb7OpmK1R1Pd1nmSlUP0CWo38+lVbLxOil9E3aKa",
			"krwE9OYe1TPa++ScUSoixWmhU33bUeLqIeazFWxlFRxe1tlyzfDUjBaRORp6xCN6pcuO+/C/41XtjG6TR4s",
			"Uo8N+4DjlSGMKizkAUFJ8lPw4Y7ex2AdU03AkV9lvM6Ml6ZlnFMZS1yCh3od8cWYg1hKEMJ37HeD5WsPQ9U",
			"wpFw90MV5e7upgpjx2vjZZ3pdQjywJ19OlV3/Ha+m/ZJGgibhbg9jFBGEZ8BxjsHIwlu9DRtRR+EtWwAsBN",
			"DlPf6E2JfO6ku281p9ttFr6Woghad7u7RvQ8+FGlqkNc2fHFrBLHa6Nwf67UwNaTuV2ykylsAD5BPyxjIr4",
			"RxlsS4V7fNa1l8fpRgzVnvJ3r15y+yMtqMBO1Ak7DGXvICZjPcz6Gt9KQcKoDWpSmKopdZz6nOHCHcj/5zq",
			"zqYX9oEjTzUWHd3ML6hC67M8wk2NdJE0afGokgtdfjTU0LcTqYGt6w04RRRiEnGU/BlalcDOoksm1DBKRud",
			"NS5v1L8vkO56UQ07l8Uqwk0rmb/pw6GxAlTyikK9uRa+VgYOPLsyZfEpYf06HUh8rTBleUQbww/iTw5M72X",
			"bqF5N+siRY1DbETKYJ7mJ6vcmSAyjx49hhGk3Z5Zs8Xkj1TWTEhL38lCaSv7JWMgYMwCUyk0mzpNAT+uheI",
			"2wi+fz6VX887YAlLyWNxPbXLq4i+yjl6VaMcvEk8iiDiQpbHiRPCZwIqIfN+5b1XaE2AZr919RCIJTdSSIN",
			"GSj/EvSmIrA4N36wKHX9aIP9RB6jeCPNouLFvH+r/BdviBo6VkT8qk6Xm5iKlyNwKGNYri8S82UJfNkM88E",
			"sv8QWBoraLiwC5QmHKAb989pew72GjfAtf3/cPCRRI/KlsrbjonjM8hiTqWIApB8twW9oy54iSCuATndKPP",
			"6b9FqDHZW613T056ICFBgLpys/GcgutoCq9Zo4168UXHkqQPW9cJJ1lir91KLxMKlF9SaicH7KMaNCq4Nv/",
			"2jtcJ1xTgUg7sSfncxvGqFMGExCFNTQm+KTQZyx9c8aQE+SQ2s4pcXGZn1D1hm6RGS6rpwP5Xvt+jz5mk7E",
			"ZGxY4CpFlAkOs97JxUUpKBEyfBUWmvGT2wjSnhtEVLLEiXBCyJuOf65W9msnmzNesddUt/RE6AAAAAAAAAA",
			"BdMxKlPcGwcbpmJEp7gmHj51U270ZD0ZIfXt/MpSIa8kJtzWmY46qDpTj7ht6gexH4C+kj42HLYFUvKcEYY",
			"+3QCBw7ZCWiXaHvSQ2LY+GMM7J6Hy5eIDxCSnH2Db1B9yIXQuSogIBHU/AX0kfGw5bBrSTA4vsCJrDBzcXa",
			"YuADlZz+139fIbPke6vhkBliYnYmmPM1JKPSB96TGhbHwhlng6AIs/oDqRZk9T5cvEB4hDnGLPmBgcj1lOL",
			"sG3qD7kXJ0f6+R0JeNC6EyFEBAY+mc7fa9DzAP9eLvDPX36H0t9aPIXLiYETGMdoXnaQjlVRs6QU4meIlJe",
			"kIHO2W5t4etDsOSKsnbm9Tbjin7WS//Q5dKgLQpQ+M9lbDITPExOyrZdGEDgV0nUww52tIRqUPEQP1znWHF",
			"X68JzUsjoUzzuEUJ4mzRIO/BkERZvUHUi1bcgPDyMbiXKN56uArpyk8/kr4RRZmmU0ZH86qUCVI30Qs3A9t",
			"5PiuKMXZN/QG3Yt19suSycdt+pKj/X2PhLxoz5Dv2LJFDBk3mwb7USTHeWqoFF5s5XcIjf0isSqmpprQzjA",
			"UF2cW633q8PbsZTBbINniU9GkgCrHjNS8l+dRuJq/xhmqJuHJYrQvOklHKqk/hz2fdIaa2NjSC3AyxUtKhe",
			"EZ1Q8E+zvSETjaLc29PY8iKn8QDA1MaHcckFZP3N41RA41a45sr81P5xaI76fPkHz1s7UuF753KcNc823GL",
			"Coa0fnOrHZdhz4RGzWuUO3aDQO+CG/gnD1YNVFOLDEOYGsn9HPtgX+YYM7XkIxKH8VT3HKtTfpuIgbqnesO",
			"K/x/Nfg41s+bjRPc/QBPLb6oTu/vpXLsDtmputlKNK/fS/SJy+8Jbm86DIIizOoPpFpRsTBp184UK7bkBoa",
			"RjcW569cUI6xMdchG89TBV05TeBvAxmRqj+MJ/JXwiyzMMpuhpuIuEQ2C6lmtCw3ybEmKBJ4ZqM+t+fvjyy",
			"9Hie4oab74PeK0L5gYOxkkN7srYyNmKjaShurTUoF/AH3AqQLA3EwS2P1osrEkR/v7Hgl50Xl06V4jyMmgn",
			"iHfsWWLGDLDEs0UWEqoQ242DfajSI7zMwUfU56JPoLUUCm82MrvEIljOxnlC19hcWjSOgZqlAEsW8CfO6sk",
			"cMsO9nB96PXilj3k1UApRZP61OHt2ctgtqfn80jkCtDHQLLFp6JJAVUdgdcCn4ixJOWKPiF86XpEuLkshEE",
			"oyjVf7BprB2sbpwLfCM46qqvWr/vILMGojWbyyNqJ/Gk9FxWd7Ga6KuyFSK7+w4frXPSwpRfgZIqXlO2WBU",
			"VZSyflCsMzqh8I9ndX8CEPIslGBqQjcLRbmnt7+RBiEWZbywoeRVT+IBgamEN2Rlsd2arpu32veP64YYnmT",
			"r3dw3nR+AEbizKFOgBqXCiZl7j7sBvxDFl1Q/mWq6w/S9B+OCbaS2p9Pzh790gWWW+aBbpHOe5Shrnm24xZ",
			"s2GUHNsaPChUNKLznVntugkHsFagmF3LZe61bjl6eO443afLBLvIn9+IkSRC+BkNgruDgX85qXx6sGqinFh",
			"iHCeDeAehmdJtwNZO6OfaA/+d5VxN2huzjjDBnK8hGZU+bfKOChzYJU+Kp7jlWpv03deUqkBnWkSsL59DY4",
			"Q7j8xyrFHGufo/vZX5Zyn/ue4vyMp1jMJ4Xl5NK2xZzXylZRAYfvzwvRUU901IE7b+xIaqflq2iz9091J1s",
			"5VoXr+XD0ahMFWfD+boE5ffE9zedLUghXouHW4FGARFmNUfSLVFN1c96N74xKJiYdKunSlW/1Fzd5NcmScH",
			"WppUcD1SR1ppiPFN/OI2vTy+Hgu/M6TgD6y7Nn6D1YzmqYOvnKbw0dW7JpJdFoE2gI3J1B7HE2uzn2zp33d",
			"ik7h2Twq+vALOi2TqN38McyneUgVxPN3hdO1AoEz9bZDZyYBCt/9LIIT6kueKPvtRY6+kCMx9KsM+nLat8b",
			"yassaXX44S3VHSm6RNKy8c4aN88XvEaV8wMSHCaWFUnoBAdjJIbnZXxkYrAVrLS5Z2N8xUbCQN1aelkWd+g",
			"TAUF9RpbJei03XctDRfhQfutGzF0wqz6Kj3vVeOOaFNlTYNJiMdYa9uNCuWfi5zClP1m+eZe0XlFbZKdcRI",
			"V0Aod/oEPEO+Y8sWMWRhcKzG9teBFYYlmimwlFCH2xaIjI1V4Pa3/420FLfF0+rMnxEpdnWiDZmp/m81pDB",
			"QqrtbUvQUQaihUnixld8h9ZJA3YxUb1ASx3Yyyhe+wk/0ZJf31g6z4tCkdQzUKAO/47bQMRWYcli2gD93Vk",
			"ngBYWSmkqX+ZH9jnu5qfYy8aC9aRyUN4KAR+hf89J0UxIa201W77XjY586VIPgsRhYwglGJt1wqCklXHDJm",
			"zN5u3hvYmym8snKgGSLT0WTAqrdV5nqeFKy2zoCrwU+EWNJZzG9oAPQ0zjKFX1C+NL1iJcmb+fFE0X5cHNZ",
			"CINQlGstQEutvpEkGtVLoo5d8O96iHiwK2AxXwtvLYbEJnKOmTIelGEbsz7oXveRWYJRG80DxIP8v5CrvOS",
			"RtRP503ouuaKntsQSyl9BqU6VJ3MBPxyaXDAasrFO+89q31zxYNym/Hh6YTDQrQvYuJiaMvYdVuuqPafzRm",
			"yxvpzS4bCX/uyNjnfccSePFIZnVD8Q7O9JtXXxAtFcnq7gQx5Eko0M89NRu3lTPX0AAAAAAAAAAF6RFQ9Ib",
			"Nu/17G8RsP+b0uJIKlJi5K09K5jeY2G/d+W8PJsgs6RBCl50sXLRQOw3SdD0MQNb2tiN1RlQl7dZhlpxXBN",
			"FrG9puDl2QSdIwlSvnTMC9VP0u2ZNxzP2CC5j8emCcCQTGIwToagiRve1sQQF7WGU7INe26oyoS8us0yMDn",
			"fi/TWFo25GXbCf0SieeeIY803KHnGwMuzCTpHEqSeWqYGcivJGxd6D0/5uX3vSesaQLHVplBZ/K/G4merKw",
			"dtusmqC3CUjk0TgCGZxGDQ3AaPafUf3/ef1ktkmnS9qQ7DRCz2rwIgLmoNp2Qb9n6/fwLvCMBJ3FCVCXl1m",
			"2WCwYAGMRlA2gvhKU+6i/QuVXA8QPLnL5FyM+yE/4hE8yyi+Yu35J9MpYJQwjx2K7j7E0XNdBrwB+sE8Esn",
			"qP18tZXlRG/EJsM8tUwN5FaSN2IkWQKsOkmIRWeJxqFVIuob9pzJ6Tn5VZLWNYBiq02hzEcgjyrHlh6y+F+",
			"Nxc9WV+xpSoKNo43oZUnjywYxORw72PbETl3ioxybJgBDMonBQgozDwteUn7LKppGgMzmipW7j0nIoD01ha",
			"w6z5sSME7bPS/A037r8VIdholY7F8FDIyThhCAhLorz0NCHe/v2HVeVk1VgzRn/H7/BN4RgJOi7+oLln1bL",
			"LihKhPy6jbL5jA/HLqG7XRvEJZVMRRZgDGBg1p5eII/FsJTnnQX6V1IU0aRPHsy4sFz79i36YYWn+L61/+F",
			"XamP9U9RrDdQ0tFkWl7kW4ttWETzF2/JP5kG1eYYJ6XkJiGWNtwqyo9Efwcj02KmVPv2J4qa6TTgD6i2n5W",
			"hWDuw1gngl05Q+/mImPWYBjwgRgG4XNGNrpSyXylJ3sXCTw14apkayK0kbyb7jBWAwf/Qr9slXAtTSyTxSj",
			"BTQz+Qm+FdhdUQjZ3gv8yQ2ljhRl827DmT03Pyq2h9LJybHykUTz78WJZwQnYRr+lX3hyZyZiPQB5Vji09x",
			"h5VER3i9oJk8b8ai5+trjpgqhXD83YRs0ADXEhhwuXt0RZTAA0ZWsqSxpcNYnI4lAPTmEUOqYcdI3rRzpwd",
			"c0Oyb96G8MbMU6XaWNVCy7cNNM9XnS4QCIQUZh4WvKT82oVzEV7Qf0P9xqPVU78UIaNXttob08+eKncfk5B",
			"Be2p05gqc2C2g1QpZdZ43JWCcVMhgkX9JuyPd6MnY9NsP14N53Ne8t9RopDoME7HYvwr6qxkc+bRktXOLsF",
			"VyJtBBLRqlWjpKC/49DRDcafgGhWOcBdMhlN066rysmqoGac60LbmV4mqycZNuaVHvBdkTzf98XqdpAqxE3",
			"9UXLPu2WBpOwBhkl23nG9DCfrfztKJFQddx/59vHcxhfjh0DdvpkvBrNzxhAFa1s7vzMQ5rNOsirvx5YrCL",
			"YgIHtfLwBH88kxK6upzfwCyEpzzpLtK7chWyM6FCCQT7NRt6KtC98KWkDnVivGZPgufesW/TDS3cdsu+J7/",
			"WklVWYvesLWJmC8d3+ORBudl1eAj6C0l5kCvpHfVDJaIvosm0vMi3Ftv8WKGzgNvNZNsbcXeNtKYGhYpkeM",
			"XYfbkMqs0xTkrJTVI72D4GJhLyQixtuFWUH4kcvXi3HfjENpWd0f6WanDCywzE8d4Gq33sTxQ102nAH7LeA",
			"TqbBRugO/6ocxCXr1Rlb718WPt068eAV3fOhi/HmRFCeIbq9HgQMesxDXhAjE6g/j5FFJszaeMu+kh78FE3",
			"cjv1ABcr7r5SkryLhZ8a4MOHs8PpRKXw1DI1kFtJ3q5FJzrYN5JhJ2WOc1OlJpV59Jt8G8n9Kl63S7gWppZ",
			"IACZet17KTfeJBvf+1Vj5A9eX4vGdNCK8qSid83I84vX3uYj8OlA5Sn6ZIbWxwo2+IAg0uvmuVgEHS+R+9M",
			"E9Y1na8XG8rebc0PpYODc/UiiOa003f1OJl558+LEs4YTswO3tvmSNX1NJzUT37x/rpxdcUfinczAYMB+BP",
			"KocW3pujpQz4nCAxeeuPXpp4jQxuT8odSGO746jcehtRRmCaf3g/WINdVnWdMBUK4bn7SIqUUEkzos2nQ0S",
			"keDD5F3/U4OE74uIhkDaoy2mABoytIQyOKlIdukLlCWNLxvE5HDKtJggU6g/z0OUMWnYOos7HQUkZpBWUIQ",
			"6RvSinTk75mTX4a3VVeBZ7fdI5F7HVK2zZl3rFquPEs3ZIun5o09bk0g35rHPlOQaaJ6vOl0gEET5i6ByMf",
			"uvY7pbZH9ekM09K05rNzJLcrQL5yK8oP+G6pryLfTMJDn6jUerp34pQqQcUqTvEvL9LTz77WSARglzre7iL",
			"OydtlTuPiYhg/bUCn8rKWnvLWuDX4Jg4n2Zn93Ol2+qEUIgfyF9ZDxsGQwhsGhrdADCs6iQwSL/knZH9gHU",
			"Lbf+rfjRQgTpupHGmo/TEeby/R0lBvO4r3lvqdFYYq2gMQNybkh1GCZisX8VFuQNKSrdpKqfxKRgoU8QXsF",
			"VsW/pI8vh5hZhq+RMoIO4h3SkrCB7PDGn3e0nss/IbzbI4m/eFHcRibfggNbUPk8You/Iug+BxjgLpkMou3",
			"WYqR6pC0Rgyr/qzm0GKwuo4XvbYk5H0BdoW3IrxdVk4zbKZySNub9cJt3Sot4Lsid4TMetlmdpmPFsbuQd9",
			"d1sr/1761WZBtOIvqsvWPZtsdYvviAQmrYOXw8XaZsIAvoBngJm02TZRQAAAAAAAAAAdw3hKr0Wpj7uGsJV",
			"ei1MfZkXI3/HO+pD3DWEq/RamPqrOGWBSUw+xDIvRv6Od9SHRSKn1DNhcrnT+J8PupPpwaT1fiUHhU//PeJ",
			"dWsC+pbxK77xwfagDgg/NG6ROyXE7eMD6jvPf1wXh19nxNOQ9RpbaONuJ8pt4zWKoRycBCre6b0ltmhesiS",
			"N4ahJdLEbKVHWLOOA64PQRVyzs01uSTWZazcZuTTRz/03uual23jCIQA+TFGB4Dh6aN0idkuN2aZfWYiCER",
			"UjwgPUd57+vC4eNFDdaqQk1wq+z42nIe4y1olLJ1N7dsiy1cbYT5TfxW7iQnK7zkc/xVsfXHSTNWoZbJv2g",
			"MmtkH0wFgmcJgSdoQeSo2h8nGS1jQ3zpflWgWm6iVlRo857DeYEpk1MZ3bR0YAMuRb/jIq5Y2Ke3JJtVo7n",
			"yGqGCpcy0mo3dmmjmu7l7p2CMztj+m9xzU+28YYmWPVnu+xpfEIEeJinA8BxnjP8MlNZWIjw0b5A6JcftSz",
			"mOuoczYdPSLq3FQAiLkKUjTO/9Hi2u4AHrO85/XxeXDAoRc2n5KQ4bKW60UhNqeRbIRAlEtVTvzPCfgLYuL",
			"JjBEbU9oIgSAdYyyvqbYlF229PgR43EbzP5dDR07LbWRPSVHsn6EOjd47ZhDsH6q6ruV0uz11yV4q2OrztI",
			"mrWVoG+Fhl48iwy3TPpBZdbIe7qt0PxzcPY+mAoEzxICT0mV6y5yBKRx0ILIUbU/TjKnjyl7CCnoDDFVEaC",
			"B23N0RljwijzN1UrfT9P1+/Y/CahCMt9G4Jk37WCVC3WB646abXQhyJdNsAN6V14PrKfzdHe2dLK6Ac0vzy",
			"boHEmQAljCx8KhXzY8wdXkvWZk3H+22AWX23J6QfP6okPoEwj4hPdDaVUFrsYd4GAWkj5EhWrtgTwvKOK7/",
			"De556baecOLOljNG8zf/RIte7Lc9zW+ZSCamGHhk4AgAj1MUoDhOVcP3GbvlkcHzhj/GSitrUS5FR4zlbsL",
			"ehP7SXgmbFfvZPaoUpt68dH94YstXEEbkorsagfhV72sz87N09I2zxW4wyz5byBpKyHUD4aoG4NoVtnurBU",
			"NJVbAA9Z3nP++LrcON10h6RgQLhkUIubS8lNZFPUIW8RUbRw2UtxopSbUazuz9tWzgOryLJCJEohqqYUhca",
			"OvnsyX3pnhPwFtXViplAAVvHv7ZjCDI2p7QBElR47CQMZWtxsCrGWU9TfFonWhhL5IIWOc7LanwY8aid+bu",
			"0brMgwv4Q1hfjC7/rSZemyfGgboEqfje7xlwdP45JR2XU98xV7a0VT6m0+kLGOmWRux8rKKXT9OOM41iWAe",
			"SEPZ5IifxiCvyIoHJLbtX9jFay2ZoEthQdJIUl6boSI236l4440HHHP9DqzQ7HWlBPDvhm3605ud58z5qsE",
			"52OrqLdMX15/mfDAVCJ4lBJ4LPfQiIzOioJIq113kCEjj5Sc2d1ke7t2gBZGjan+cZNcIcInXaTpaTh9T9h",
			"BS0Bk5ErLcrUR2J2KqIkADt+foFafDar6hQdaMsOAVeZqrlfu9AT/EjA2rvp+m6/ftfxLJkkfBSvvZLFCFZ",
			"L6NwDNvJ4iFlDDWlVGxUr1PuSQOKcZfXGUEMqgXX0h/GsMJQlQoRZ4wfh/kam1nOeRNfpbTGmrYzvBoMO2D",
			"ffuxN1ParvRwGpuKRXyQXp5N0DmSIAUpk6z6hISGO7CEj4VDv2x4x4lur/6pykaCq8l7zci4//WmKFFw3h7",
			"BbLELLrfl9IIbvOoECvNSvI1m0t+DAcnE+msz9T4Xb/pjfBCK+SyFuRRx8aBEOiOHUVNWdHdbUT4mXrdeyk",
			"33AL9JlCENdh1DyER1C7Bgu32T/OWXHpMqsuTxBL2jhYyMfeYnwmS+Zs8K68bo2ajA8U/JYTzqybJIOMSAF",
			"lffFHah06NpkOT+NdbeQkMt8lgLQAR6mKQAw3M3CZuyGRZlTa4euM3eLY8O2RNZ52M7KTCcMf4zUFpbies8",
			"HxntTP23cis8Zip3F/QFJt1Ml2Gxyk1lBKgf/nfqOmjlgqLo0dSjf8b9ZdM7l9RyJ9fYxZ2pkVCAA+uk7xD",
			"mXWEpVrJJLn9KQlaRiaNtCEejfCyfBVOenZunpW2eK+mQeo0YezgVcIdZ8t9A0lYHirjYYlZ0aEKoHwxRNw",
			"bRNaX+JuwhoO+sst1ZKxpKrNu/PHOWDOySgAes7zj/fV33Ck3FhenbY24dbrpC0jEgGRCPkP/Elx5cMihEz",
			"KXlpys/yW5xs0OZsijqEbaIqdrFJQs7C54P5FP/M+CCbJScJPLSyj96MqK95fG1+EHY4croEJ9FV37fj8q3",
			"S3Y2DGb4x1ZhyyCqWGHQdR4MG0AbFt2UNLEN5iW8M8N/Atq6sMs+IlW/zByOUikBKnj39s0lJOAAxeFQ82A",
			"GR9T2gCJKFwum/kuWhHSOHIWBjK1uN/kRZKsxu8gJb8tccLhJU3EYxr1aBV/1T4HRniXCZB8M9tx/D39yuT",
			"Kz/tjbTBPLi8TzOfHxBW21XeQajjY+h/Yq6fukiyghyHFRazgl27AHBlyKEpjNFjmfS6ltX/b8euhGSEfi4",
			"FpErWTvk9GBKP3aaQ65bJeOw0N+LcarrGSANHPM7Ba6wr6iqfQ3n0hZxtWkFR0iXv/4TLM2YuVlFbs7vtdI",
			"WHOzhX6ccJxrEsE8CZGRttYEZwKQhrLJET+NQeeLU+OsKSt/AAAAAAAAAADlUZmWzImUFsqjMi2ZEyktL/K",
			"ru1WavTuUR2VaMidSWnEW/Mz+rsZMXuRXd6s0e3e7tc7hZ73vYSiPyrRkTqS0zd5TIqjHMKLiLPiZ/V2NmQ",
			"d9YQ8x1BmPvMiv7lZp9u5ZmTZ4muBi+HZrncPPet/DkzoEVQPzS9U7jQIxmrqRXd7cm6dWMwVL8S4wHAOpu",
			"HAUf6mKzyAsZq/KZ2uoncMHSpv+/WQUVxFlaVVGMY7qKoA4zND9B348EwLIhf70Nen2U1ETMn2h/9mh+qhn",
			"5xzEPPBjPqtuiNKHRa3fzNNns2IUNEkAWvOlTeaf8lXATp6otwZkmUnaiHYaBWI0dSO7k0uc9Pj8t628uTd",
			"PrWYKllnortlh756A4l1gOAZSceEHDPmuytvl9yj+UhWfQVjMza/Lg1PIzNpelc/WUDuHD7vEVkCcshMZlD",
			"b9+8koriJxZ2RtBaE6NMrSqoxiHNVVL4MzGq6VQUMAcZih+w/8eOUgATc3hmhuTZcHU67Psuaoxp7FYkYm8",
			"Ic0NX433JvLYmWs6PtVD93Z0GIJnOjgvDyB+59QYXSqE3NQJAX7yZH2IsmyyXJdh2UYzefKgRZSgElUcQYI",
			"gkSvu//KU5I/f0rqZlyfG6tp8V+ovfimRAgUDjErNC/QHjv8mpBhtW0l3q0DBq08+TOHp52cO8yfQmL2BAr",
			"3RQtUTQSvsaLftm+oVTYnblYieRPg+MYJ680Y9rFhUMViWQ7ZQ8rrkPjkNTwSU31ccXAjryhXKF+CO/ZKec",
			"6+kwuv4GWLZQXGkRLbgNr8kwoYhs07bzJybaVprN4+q+ShLP268cwAX/S2QIEUnZnJOD/Ul7wqn62hdg4fW",
			"XsGO23/mgl2ia2AOGUnMpPYNBb07LMkKG3695NRXEXNPGNhX9jIU+LOyNoKQnVoB59RTMbL4X6UpVUZxTiq",
			"q3H0zI8JsT69XgZnNFwrg4a7V/6ikKIXkADiMEP3H/jx5bOp1TuWbOfKQQJubgzR3C8Qm/iihUXK8b2Y/g+",
			"5vPkU7AFowzAo7zseqtOWqpXU3k8zRVojAcJl+v2kPZ7uo4CrZDLxF3q1r1nPiaSNx45KCFYfaARTmNkyUk",
			"pr9xhNPGPL3Kd+jFsTkWBn8uQxYPbA+fE+baV2TXU3EFnQSheoJK6GlVneAYfWBT3Aw2M6YoecqwxK9yzKM",
			"JrPlQMtpC9hA1lZirmyAJOo4gwQBInlwjF0wJmQn153/5WnJH/+uyZmA2ut6+iU1M24PjdW03GFVC7yvsLF",
			"4r9Qe/FNiRAH7sntPcQdBigcYlZoXqA9zU37wKTXNCt2+DUhw2rbSpOprLcP409cvFsHDFp58mdZCp6alvB",
			"mcQ5POzl3mD+F6x6ir7sRq5PE7AkU7osWqCG9kIIiAoK+mgheY0W/bd9/Wcf1iTb5yVCrbE7crETytfr12B",
			"Al0OQmwPGNE9abMcORaBvfXw8n7GPDoIrFshwJMlo2RkwmCrKHlNch8clrV9YNQe14XX14JKb6uOLgRp11P",
			"2x0a3RQNcI5CO0irtjQk6CeIas6zv9hCyV0MYf1GjCSs7i4E+OhhVxS3wX8gkTUxcQTjGiUayZuf0YW1a+O",
			"d/fpip9BuR1N87yJbAps+BxqKkXlnnrX7sGREH8jQTK/WAfc9rdXiQqW5rtLWDZsWw9wd8LMIEOppMsiWHE",
			"bpvg9Xe7R5Q14VT5bQ+0cPp0Ep82PZIgosvYMdtr+NRNXp5XgFnehBewSWwFxyk5kCUPCl71D2nImsWks6N",
			"lnScPg8LokUPNfUNr07yejuIq1i2156yosnJp5xsK+sJGnfyhfVHI5BbHEnZG1FYTq0CHMCCPZDX7GDj6jm",
			"IyXw/3rbzoOQB5X60PYPGrZV41jpoml/BXeGXWJew5HQESkTmwql9GMzTBY159ZMOtw3zkyzsCmJ/lLLx08",
			"ax1yY/YU+G3yi77qYgJrV/bevRkp144Gb0hxkL3BofTE8yQKAPpEpV1l6IOU7P8Qk4SPPnuNGkEKEkO375s",
			"1s6GpFi1SoNDiOD/apMa2ieimpUxUoMdsuT8zgN000UNLlIjVR4nqphoNHhnOHfwdr8P/fnPynfj+Wmmy+m",
			"aL1wzx0udg27AyXWhEK+lPpqFnbBEoGgRzRDb1h+STkGVrxF48sQktXo6Vx6p9gLlINSAJSxo9VinQcZDd1",
			"rTCP/+DO2aDLn8EGtKi8E+n6xKyZaSU1u4xmlc0PQIaZ6WMeMaWuU/9GLedlw8vg3SMoSYiwc7kyWPAw3NY",
			"WChA99bsgfPjfdpK7QnQanWxU977mupuILKglS5/u/e2fikBOFBJXA0rs7wDtRjFm+c6KBUOrQt6gIfHdOv",
			"8kuxMDlNixA45VxmU7lkhX6DB1R16T//yo8d4IYN8GqM6UbSoF2o1UZHq4TKqUdAACHwtuz5Ha7XGnUoG0S",
			"aO5F8Lho9FMKEW9LDTFfgLREdtJh+cbB3XfWlzHG8nyDIs8OXQ5rPeHd5bXoV8DuX4j8LISfWa80M6DCkuS",
			"HWSpmuVv+LB4YSJmT4Et1tcv2zIp5J70sipxH+h9uKbEiEhLjhgLhKGNw7ck9t7iDsM640KTbcBrxpQOMSs",
			"0LxAe7VpXTocNdRtmpv2gUmvaVZ/ym8XhSb9QOzwa0KG1baVCaHy1EpcIoMmU1lvH8afuMMCwPnTTwuueLc",
			"OGLTy5M+d5peOeHtw2bIUPDUt4c3iV0Wlo+FoWfQAAAAAAAAAAH+du6PRNu0K/jp3R6Nt2hWBp8zkcls3H/",
			"x17o5G27Qrg+hVLZftWSECT5nJ5bZuPn3SImo0gIM0+OvcHY22aVeHdme+XICEXQbRq1ou27NCeUwQ+f/tX",
			"kgEnjKTy23dfHsDiTAaWzB2+qRF1GgAB2mFOf53uTbqY/DXuTsabdOuj0oCmMtbPqQO7c58uQAJu3Fwdd9o",
			"NuSxDKJXtVy2Z4VzP+wWjYCKj/KYIPL/272QjQWbUS7tUJoIPGUml9u6+Xeh3oVG7Vfz9gYSYTS2YOyJm6n",
			"C5YCN5vRJi6jRAA7Si9QwCwA249gKc/zvcm3Ux3XuR0yjWznNizzkL2f8f2n0oV+MtsqSY3UGk2jEkaV8Cp",
			"soyxWnSHZ3SQqhISfLQgjUsQLwESZIiXN95oJKEVf27sZFU3z8XXPXODLqShY+DEqDkTt8+zSN7U91SSfMK",
			"/Jw9NaYESEhj6LWvKyRohXwP20ffadPH3GYofsP/HgADgUaWN7KlQp7610UfZGsxwR25resp0HNhdEqU978",
			"dtL6TJHwD8qb2Iees5o7Shjs+AMIOep89eZ5pMTdmCfC+QY5f35JES/zgwCBCfAnxZD8nTqqIREomn069k5",
			"TSh+FAqdN7YJ88o9/dW+HtvxxuwDo1CRnypyxgU8YwBWRq67+0qNjxKdGpBZ5yF/O+P/SaeRz/B/OEtjoQ7",
			"8YbZUlx5feBLu8o8jN6gwm0YgjS/mVkZ1yWRWm8xQ2UZYrTpHsa6vqNfp4fObukhRCQ06WhZEPr+GSeHuPE",
			"KhjBeAjTJBvNdimMRWhmhLn+swFlSKubXpBb9Sjz6Ts3Y2Lpvj4u5NANih3zhWx5q5xZNSVLHyZM8rHBaPB",
			"dhiUBiN3+PZpZwm9gKbOG2Ma25/qkk6YV2VGJElDeHVd5OHorTEjQkKbfFMO4BWvSB5FrXlZI0UrYdgW2og",
			"VqCHgf9o++k6fPp/iYZ0reHI04jBD9x/48QCdrfhUzs4cChwKNLC8lSsVY5ePE22jxh+dRSxwqQSAu+LYl9",
			"N4Mm2xY39bNwppWq4c4uCU21+3pGEwwv7v3zSQHq15XT7p2ZqfCrW5TLLuheCXDhqdhAOPZa7wbSSy6ewaM",
			"0vO9YQE5puUhyqH3zP55Ak8iVbp3vOZ2x7jYmldx+ZGpUCzX7DNZ+FppMEEh9IYfNIHEDJq2G2SlUuzaVMV",
			"Eg8u6GJfvh+TqOIMEASJAOw1Wa/BMmQKked7xfWy5z7uesBmJIQKNG/dDIJW3z0rEEC3IYfp0CGVeUlWPt8",
			"6Qurk8vXv6ddIa0M+EZ2y4FcU3oWyTIQNXWkMp9h4BI5pFpEce6kyY2OXNtCf22lUfOirazwKX7l2R2EH58",
			"/XJpE4/LxEHuHLm7lbcKBsuvyExsbLA72MEY67FOlpiQySusSJUspYOn+wRS6eLiphSK86syWN+1elpb+K2",
			"/pCYU/GwBdgWZNXosxBsKy94QyV0z4tFx4wOnjZQ/81dAS6++08Yo7X1YwW573FQjOn1yH4wlj5kHbhzPK3",
			"tr7c1br1P8grBX8EjBg1SYzJm3bXLyo2EXI4p+HCIEvDUFKTYUEUNF7r8UJXrB61+ScVMAybAcpknLbhOnY",
			"LT11iwVgMnGgwwNliiTpxYrFnFYb7YUZ9zvquJSpXq3ezKIxPHtcoQ8y1N+zP4cVJTRL7CL268lYyj0CrbI",
			"wfXMxd48ioK1n4s8BYa3kdtPIyZ5SPC0aD7U36LyzacG7nMCgNRu7w7dNPtbblP8YA2c4SegFNnTfGsY/Bo",
			"pyr2sw0tj/VJZ0wr0srhHb0q92lyoxIkobw6rq1EfMxV8YHsMjD0VtjRoSEt15q+LJwaY42+aYcwCtekUlk",
			"Hb8RHbObPIpa87JGilZDF+FQY3BnXMKwLbQRK1BDvS2WF8AdvUnA/7R99J0+fb9iD94lq9N3PsXDOlfw5Gh",
			"BWHiZhsYJYsRhhu4/8OMBu/w9Te7GDgs6W/GpnJ05FEXGSgpNq9QeOBRoYHkrVypHidPDqB26IMYuHyfaRo",
			"0/ubOkhAtwYDVRGM+4AS/ZQy6FdBvQGTRJryK4/6JCA1bQvwNcc3TuXK1tITZH9G1o0vCalZbCgGJTV1Zx5",
			"Jm3fSzK7dI1r1p3qfMTpYyZsBTWbqgGXa9dHlfJZOIv9GoBKFTfQf7ChwtVhv0rykIEPyobRogbdOk1q7yK",
			"bGkv3irUITHPuBkzIKHPdoMbQgrt3lLNIMp05+df9QHEuC/Q+CBoumdpGT3yXbqYDV2ZvsYiJyOujK9TzKO",
			"A70r+9GTT3B1U6S/CidlZJKqelvRjuia5ET1Hwo6wpx7d2TWZua/Yg2Z65K9UpaVRRBDQL9eR2sz/swEZOp",
			"tbazNXc0INhCT2iPSidOCO2iQrl2bTpiqluZA0t+VLICQeXNDFvnw/W4PncxSIkTUmUcUZIAgSAVnMfrrxP",
			"v8L2GuyXoNlyBSn9gn9UlMlHiLP94rrZc99XVJMKTpTInfc9YDNSAgVaKNoO26ZPvhi3roZBK2+e1ahJ6Kn",
			"fIiWXCCAbkMO06FDXx3V4N/lTEkq85KsfL51hFVuKQ+tiJiO1Mnl69/Tr5GrVF5IDuVCm9aGfCI6ZcGvqRv",
			"HgetTLKUovAtlmQgbulchsMZIPvaw0hhOsfEIHNOthfUSID7x2SwiOfZSZcbGU7+CVYNTK8wubaA/t9Oo+F",
			"HwG5xm5UXy0FfXeBS+cu2vymzbxYif5wAAAAAAAAAAAPUEklguvLBreZ584nqhVWuMmu66VB3l1vI8+cT1Q",
			"qvWBzhrnNv+G72LooUmj+P+vX6mF36hX07Hdu6q2s1cYseD6jiC4+DSrA9w1ji3/Tes+nREYJlBhxGE0lMe",
			"OB7JEXHWwUYWonl6/Uwv/EK/nHoISL2kbAMsju3cVbWbucSOGNjH7bUFdOWUQilX4RiR5WFGuw/PpCFYH+C",
			"scW77b1jq5D4pQEffM2Z+0JMUWjozk3pCyzrmikmbMv9vVuWmSW42bTd4WRYi4qyDjSxE8yIXqBHVAvhDn2",
			"kOBqujpw2fnAqU840bvfQQkHpJ2QZY9OWU6BH3uuh3SC7zORGqvXe9KmFhPxYNHDGwj9trC+gcxLQdg0W3W",
			"KG6Egr95OgWoU8WmKXKVKbKw4x2H55JQ8o2iORHsPXzsD7AWePc9t+wy8TLu/JKb9tHXiUBpleK27Jat1mI",
			"6zpmzPygJym0dGY5+DJ/BwjEDbVi3MVTFSENQGZOnX2pkfml8qaMihN5+VD2NNSkr8mS3GzabvCyLJIpaEg",
			"23g6cL1fOX0h/UdIvosrNEFHtYkQuUCOqBfCHRNtUsfIrTDc+0xwMVkdPGz4mGJ4OafOrVaqCcLQ97k5VX4",
			"bi7BNS/ughIPWSsg2w6NQkZ8qcsQCDWL6JcMis5YOtuhso5hBVhQPLviAEjU+F9s8seCox/+56VcLCfiwa7",
			"o9RUJpQkKpT8fdH5PHP5FME89W833NUOIhpOwaLbrE4fW2pXqXSAUJ1JRT6ydEtQoAhhqLnbZ0pDLtoGLNw",
			"eCn5v/pAnczIlIcZ7T48k4aUch1/ZhIvNv/+h5HcRjLT/wuDA4RojmML7hfrlZ80iwsbE3nNsYg7YJeJl3f",
			"lld5gYo0FL8spbt0cKxJRanYg3ekvgAlEypC2ZbVusxDXdbaQsfzrPmvFzJj5QU9SaOnMbf3TF3zUWafhZz",
			"2tKMm8pxRjr/UGdQwaasW4i6cqQhqfwSrTiZbycRNbxGndixdx5l9WMfM3p/JL5U0ZFSfy8r7h30E7m0KZM",
			"nsx+2+Gp5nHf6OjQToXJLnZtN3gZVkkTN0mhc7Z6U/AR8g/msQMTzVDWme0eLw1PQvnw9h7kDXID3Wb9scg",
			"XkSVmyGi2sVesZEJeYxmdePPNx4HLTk74zozjF8DhYuItqli5VeYbohDrfC9eSTefKY5GKyOnjZ8Uz2K9KA",
			"ihhffp2RO9D9jFyqj9hbag9OqVAXhaHvcnaqhAXMwVWAtwS2bnYoBfcjB2J8P0i/BeLvQ17J2Q8JUuyXTIC",
			"5tfuTQqUnOlDljAdBcTVzMF9+xbSLrS7K2gP9t1+/Z6pg8TwZbdTdQzCGqBq5xpQjinRoKB5Z9QQganwryk",
			"u8ZJqYvYX4IAaNyu8phiwyT+1wHetz1qoSF/Vg03ACuFt3T5IS3jDT4Z4f5Ybd5MGo/qUXRzXF415vFRv3N",
			"hHxFw+v6TaYI5qt5v+eopv3iOSGRWxgbg0QuXzAEVht2QLwHHrjmcPraUr1KpQNwD97A5WQZs4TqSij0k6N",
			"bhB9Ouqy9H+vvk9RUFukCDu9m0MZOx76+Uhh20TBm4fBS7XJDaEhdQDlh6K3SHEClOZTsP4oy/BVDnKSCLl",
			"7/OUNpoBB2cEOJKOU6/swkXmwoED5slAri3JVumHvqq72SlZuc6bKFASL+FwYHCNEcx/7iApVQ/6B3fU+4j",
			"ngZsCJ9urwcIDcMkhY2JvKaYxF3FsMiYMJNrcervYR3vOzyiatIgOXkwk45wMQaC16WU9zAMR6ZBrjvbLo5",
			"ViSi1OxAusxStvr6UPDRQMhYQK5NFdG1zMoYgPGlbMtq3WYhrutsPm5PPg8SWwey9KGEWw++B0fwM9x1sw7",
			"zomTbzYIJ5vNXYEmVrLVWmNv6py/4qLOYLv41d9YUAyVQWCIJd0tNJaVcsFFZ9/1OKcZe6w3qGE7cwsyzI1",
			"aoNNSKcRdPVYQ0IY7jT2HpNF+tFA31NfTRX1gQn60bSGHiJraI07oXL+LTshqLlKufiV8o9DHAtnqJqixma",
			"e4Kyo8EXcNhDJfQj/FZUTkiK2DkfcO/g3Y2heSIxy3bWIo1WfZhOqX51XtZA2Wo/ddpyzKP/0ZHg3QuMnr7",
			"1B+tyJ5IcrNpu8HLskiHt/vj73cCIwstFVm7aucj/imHAZXWV56Aj5B/NIkZnnWLAicaNan1+RHsnU4oTPU",
			"MFX7FYJT8AemBltSXLhQBHIUEjLmSpGqQH+o27Y9BamUbeG7DM/HXG71vEGJsv9fuuf1ITNAPvGIjE/IYze",
			"q8lyeBqjZxWsafbzwOWnJ2xmprrlZ0zsat5vFA7CDTI60T9dK0Dm+TEG1TxcqvMN0QmFdXkoGMbXsUzbko1",
			"ZGIe+HJK3D7LTj4THMwWB09bfi5d6IAM4HdkzXtTLpnnDiTwOne4kkgiC6+T8mc6H/GLktLW8TGw3ZFx9G1",
			"fpLek0Uy1ScmvGIjPzqdmoLQYQ8/z5kI2v7dv1RDA+ZgqsBaVLYHdDiEfOrpyKFjRiUjpOk9pfEeC58UgrE",
			"/H6RfgvGCRDuN/HE+QXahr2XthoSpdlSr97WoOBkd2DEZD/wl/B0tNYtX0plMoFOTnClzxgKgppcOcV16ss",
			"sqDeDLCWdXy98JcpMn2+ex10HPN0vYy7EiRV1vZWR72q7fs9UxeZ7aW9shjR/FLmclfTbzvppgZ9B5pKuQJ",
			"tAMXONKEcQ7NQyp59hJ6oeFAAAAAAAAAAB5iTUwyPBuf/ISa2CQ4d3+i5teUFgRs4GPtkGYc+ViyfY/dKi7",
			"FQy2faQq+OMEvzcELR/IK/TRSHX+FGi07BymDHchWHwcctmH7H8IJA3BWP5lSjjs/a8n+khV8McJfm+DwWD",
			"AD/kQEAhaPpBX6KORcdMLoJ8Yze6Bb76IO//gePjmi7jzD44Hc33V6KsePYYK9ODYY+5T+Q7Z/xBIGoKxd1",
			"DKIIDq7M78y5Rw2PtfT4VCoUAQCzEw9JGq4I8T/N6NGJ/QR+OSoQaDwYAf8iEgfwr0sNcCT197J+t4/PaeF",
			"wKu3kg0BvBoiTWAGGwXQ+nwvLUopOctlgLffBF3/sHxe1ZJIb8Or47wzRdx5x8cD4lEIkEv73JwjWk9iQQb",
			"ozj04Ai5zOvNR397VumU+n7GBvJj2VwKELl3IWh5wxLdVw6oXUkL4rMohTMDGVPzAKn8ujYpmwNu1viXKeG",
			"w97+egR4c0XgH0eEKhUKBIBZiYHMMd7Ho5gwfg7DCmUwBIYn6OfephPFP9nGiqfnc4Px3CCucyRQQkggMBo",
			"MBP+RDQHWPtjH3FC0//hToYa8Fnr6Hnd1RZ/XwwfZO1vH47T0vj8fjwTAdU1AEXL2RaAzg0X3ViKGg/I6ue",
			"fiXaYsIX+YAcaJZQ/gxmYvq/Akb6YIY8mPJOdMZ7GdvLW56vdpa1xakW0p1KjSonT8FGi07hynktjAq5cvp",
			"VuCbL+LOPzgemRIa0gbPVmESiUSCXt7l4GsAcbKWLoufGtN6Egk2RnFjWk8iwcYoDujBEXKZ15uPkUgkQlE",
			"n9fCVZTuKetMkuOzsDrqyI0rHZ3dQ6uoy+UYe/mXaIsKXOe5C0PKGJbqvl8vlwk7V1NAcULuSFsRnUWXZjq",
			"LeNAkuYfSRavXA2GYYfaRaPTC2GZPm+gplIQWY6m/POq3Ra+ebvMSaMsmmCeI18ar6Och2aa6v+qIoe/cQJ",
			"5rKatgViBQKhQJBLMTAbYOwMoncqr/mGO5i0c0ZPp+R21IZPXdBbfISa8okmyYUeydbAtT1WZ/geQtaxUbY",
			"5mlMO5I1KKfiRFPzucH575vNZsNxMZeQEFY4kykgJBFp3w2j4dBKbhgMBgN+yIeAYYUzM7Y46f/qHm1j7il",
			"afpOXWFMm2TQBl7pHmw0t5UnuM3Krxd2LNmWoLPudzDi3HCEZy1U8Vsjsnazj8dt7XpUUmdM5KxUhHo/Hg2",
			"E6pqBnBvKzqcrI32Mr7XuCPhmXGqLYS0rOd+iROYYbEt/EaeiwsyvaL6oWmWO4i0U3Z/jg6o27jccJh2tx0",
			"+vV1roGEvjm2x0m1HkW1fkTNtIFMW9czCP+ImtO5MeSc6Yz2M+dTqdDbsO2sLXJS6wpk2yazEB+nOFjAuVH",
			"2yDMuXKxZD5SFfxxgt8bOn8KNFp2DlND9j8EkoZgLMhtYVTKl9OtseRUZAJnvdLAN1/EnX9wPLm+avRVjx5",
			"DMiU0pA2ercJLrAGUxW7DvU+BHlzumhL1NggrbCZqfIq9k3U8fnvPC8QaQAy2i6F0NKb1JBJsjOJNL8AU2p",
			"zinca0nkSCjVEcvz2rdEp9P2O7ELS8YYnuK8KZgYypeYBUSQLf3PFoM9Uwi+rsOZhdqkFY4UymgJBEONHUf",
			"G5w/juzSoosNmFNusrDvxz+kSPFzu6g1NVl8o23Z5XkHZWc8jz8y7RFhC9zRXX+hI10QQy3Fje9Xm2ta86f",
			"Ao2WncMURQRc3c6McJU8jWntBnwe6jigdiUtiM+iQSlDFeV4od3Ksh1FvWkSXLM7KHV1mXwjwugj1eqBsc2",
			"7YRblInHfsjD6SLV6YGwzSXN9hbKQAkxNXmJNmWTTBDTXV31RlL17v0wJLQmFDvrGxTwdwXVghTZ5iTVlkk",
			"0TT/C8Ba1iI2zEa+JV9XOQ7b3i12U9g/6Suc/IrRZ3L9rARv2d3odBpUvdo82GlvIkMlSW/U5mnFtDh51d0",
			"X5RtToOqG0Zjj/KsZX2PUGfjEvIHMMNiW/iNMwx3MWimzN8tbjp9WprXQM+I7elMnrugkeqgpX6ioD92uQl",
			"1pRJNk2jbRDmXLlYMij2TrYEqOuzUX97hsxYhcxVUmRO56xUhCzbUX4vXDr7p0APLndNiXreyToev73nBa8",
			"aMb4gpSrr1pMEjuhVRJRdCFresET3FSSBb+54tJlqIKxwJlNASCJZJUUWm7AmXdK+G0bDoZXcqzcudgtR+6",
			"Nbi5ter7bWNSICrm5nRrhKqZnwPj9XC8vQEMUO96dltNQ92sbcU7T8rbTv9hSj2oMmL7GmTLJpAl+mhJaEQ",
			"gd9LnWPNhtaypNX/LoG06qk7Nxn5FaLuxdtpe7RZkNLeRKhw86uaL+oWthK+56gT8YlU9GlzvhedaQqWJD+",
			"MK4b29g7Wcfjt/e8obJs9ytHmcMqKTKnc1YqQlOgB5e7pkQ9V40YX5BSlXUuBC1vWKL7CqWfcz8As0iL3BZ",
			"GD8hDJvStxU2vV1vrGtRMeJ+fq4VlX9cmz8e6NuQmXhP/D0pYmyJzDDckvonTW/o5B+xO56zQYWdXtF9ULa",
			"noUmd8rzpSWVTnT9hIF8Qg3dJ/ELh5u6tGjC9Iqco60s+5H4BZpEXW4qbXq611Da9rk+djXRtyJPDNtztMq",
			"PNdefiH87zGjCyq8ydspAtiVSPGF6RUZR3euJhH/EXWnKcxrXc0tbjjoxyyvx9BaavalYeP17EH1FEO2d+P",
			"oLRVKIfs70dQ2ioAQYCQwQILnAEgS1AAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
			"AAAIAAAADAAAAEEtQAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAD//////////wAAAAAAAAAAAAAAAA",
			"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhIUAAAQZyRwQILFCRpb",
			"nRBcnJheUZyb21TdHJpbmcAAEGwkcECC2Ioc2l6ZV90IGlkeCwgc2l6ZV90IHNpemUpPDo6PnsgdGhyb3cg",
			"J0FycmF5IGluZGV4ICcgKyBpZHggKyAnIG91dCBvZiBib3VuZHM6IFswLCcgKyBzaXplICsgJyknOyB9AA=="
		].join("");
		function _base64ToArrayBuffer(base64) {
			var binary_string = window.atob(base64);
			var len = binary_string.length;
			var bytes = new Uint8Array(len);
			for (var i = 0; i < len; i++) bytes[i] = binary_string.charCodeAt(i);
			return bytes;
		}
		function getBinary(file) {
			if (typeof Buffer == "function") return Buffer.from(binaryInString, "base64");
			else return _base64ToArrayBuffer(binaryInString);
		}
		function getBinaryPromise() {
			return Promise.resolve().then(function() {
				return getBinary(wasmBinaryFile);
			});
		}
		function createWasm() {
			var info = {
				"env": asmLibraryArg,
				"wasi_snapshot_preview1": asmLibraryArg
			};
			/** @param {WebAssembly.Module=} module*/
			function receiveInstance(instance, module) {
				Module["asm"] = instance.exports;
				wasmMemory = Module["asm"]["memory"];
				assert(wasmMemory, "memory not found in wasm exports");
				updateGlobalBufferAndViews(wasmMemory.buffer);
				wasmTable = Module["asm"]["__indirect_function_table"];
				assert(wasmTable, "table not found in wasm exports");
				addOnInit(Module["asm"]["__wasm_call_ctors"]);
				removeRunDependency("wasm-instantiate");
			}
			addRunDependency("wasm-instantiate");
			var trueModule = Module;
			function receiveInstantiationResult(result) {
				assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
				trueModule = null;
				receiveInstance(result["instance"]);
			}
			function instantiateArrayBuffer(receiver) {
				return getBinaryPromise().then(function(binary) {
					return WebAssembly.instantiate(binary, info);
				}).then(function(instance) {
					return instance;
				}).then(receiver, function(reason) {
					err("failed to asynchronously prepare wasm: " + reason);
					if (isFileURI(wasmBinaryFile)) err("warning: Loading from a file URI (" + wasmBinaryFile + ") is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing");
					abort(reason);
				});
			}
			function instantiateAsync() {
				return instantiateArrayBuffer(receiveInstantiationResult);
			}
			if (Module["instantiateWasm"]) try {
				return Module["instantiateWasm"](info, receiveInstance);
			} catch (e) {
				err("Module.instantiateWasm callback failed with error: " + e);
				readyPromiseReject(e);
			}
			instantiateAsync().catch(readyPromiseReject);
			return {};
		}
		function array_bounds_check_error(idx, size) {
			throw "Array index " + idx + " out of bounds: [0," + size + ")";
		}
		/** @constructor */
		function ExitStatus(status) {
			this.name = "ExitStatus";
			this.message = "Program terminated with exit(" + status + ")";
			this.status = status;
		}
		function callRuntimeCallbacks(callbacks) {
			while (callbacks.length > 0) callbacks.shift()(Module);
		}
		function ptrToString(ptr) {
			return "0x" + ptr.toString(16).padStart(8, "0");
		}
		function warnOnce(text) {
			if (!warnOnce.shown) warnOnce.shown = {};
			if (!warnOnce.shown[text]) {
				warnOnce.shown[text] = 1;
				if (ENVIRONMENT_IS_NODE) text = "warning: " + text;
				err(text);
			}
		}
		function _abort() {
			abort("native code called abort()");
		}
		function getHeapMax() {
			return 2147483648;
		}
		function emscripten_realloc_buffer(size) {
			try {
				wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
				updateGlobalBufferAndViews(wasmMemory.buffer);
				return 1;
			} catch (e) {
				err("emscripten_realloc_buffer: Attempted to grow heap from " + buffer.byteLength + " bytes to " + size + " bytes, but got error: " + e);
			}
		}
		function _emscripten_resize_heap(requestedSize) {
			var oldSize = HEAPU8.length;
			requestedSize = requestedSize >>> 0;
			assert(requestedSize > oldSize);
			var maxHeapSize = getHeapMax();
			if (requestedSize > maxHeapSize) {
				err("Cannot enlarge memory, asked to go up to " + requestedSize + " bytes, but the limit is " + maxHeapSize + " bytes!");
				return false;
			}
			let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
			for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
				var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
				overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
				var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
				if (emscripten_realloc_buffer(newSize)) return true;
			}
			err("Failed to grow the heap from " + oldSize + " bytes to " + newSize + " bytes, not enough memory!");
			return false;
		}
		var SYSCALLS = {
			varargs: void 0,
			get: function() {
				assert(SYSCALLS.varargs != void 0);
				SYSCALLS.varargs += 4;
				return HEAP32[SYSCALLS.varargs - 4 >> 2];
			},
			getStr: function(ptr) {
				return UTF8ToString(ptr);
			}
		};
		function _fd_close(fd) {
			abort("fd_close called without SYSCALLS_REQUIRE_FILESYSTEM");
		}
		function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
			return 70;
		}
		var printCharBuffers = [
			null,
			[],
			[]
		];
		function printChar(stream, curr) {
			var buffer = printCharBuffers[stream];
			assert(buffer);
			if (curr === 0 || curr === 10) {
				(stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
				buffer.length = 0;
			} else buffer.push(curr);
		}
		function _fd_write(fd, iov, iovcnt, pnum) {
			var num = 0;
			for (var i = 0; i < iovcnt; i++) {
				var ptr = HEAPU32[iov >> 2];
				var len = HEAPU32[iov + 4 >> 2];
				iov += 8;
				for (var j = 0; j < len; j++) printChar(fd, HEAPU8[ptr + j]);
				num += len;
			}
			HEAPU32[pnum >> 2] = num;
			return 0;
		}
		function checkIncomingModuleAPI() {
			ignoredModuleProp("fetchSettings");
		}
		var asmLibraryArg = {
			"abort": _abort,
			"array_bounds_check_error": array_bounds_check_error,
			"emscripten_resize_heap": _emscripten_resize_heap,
			"fd_close": _fd_close,
			"fd_seek": _fd_seek,
			"fd_write": _fd_write
		};
		createWasm();
		Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors");
		/** @type {function(...*):?} */
		var _emscripten_bind_VoidPtr___destroy___0 = Module["_emscripten_bind_VoidPtr___destroy___0"] = createExportWrapper("emscripten_bind_VoidPtr___destroy___0");
		/** @type {function(...*):?} */
		var _emscripten_bind_Crc64Hash_Crc64Hash_0 = Module["_emscripten_bind_Crc64Hash_Crc64Hash_0"] = createExportWrapper("emscripten_bind_Crc64Hash_Crc64Hash_0");
		/** @type {function(...*):?} */
		var _emscripten_bind_Crc64Hash_OnAppend_2 = Module["_emscripten_bind_Crc64Hash_OnAppend_2"] = createExportWrapper("emscripten_bind_Crc64Hash_OnAppend_2");
		/** @type {function(...*):?} */
		var _emscripten_bind_Crc64Hash_OnFinal_3 = Module["_emscripten_bind_Crc64Hash_OnFinal_3"] = createExportWrapper("emscripten_bind_Crc64Hash_OnFinal_3");
		/** @type {function(...*):?} */
		var _emscripten_bind_Crc64Hash___destroy___0 = Module["_emscripten_bind_Crc64Hash___destroy___0"] = createExportWrapper("emscripten_bind_Crc64Hash___destroy___0");
		Module["___errno_location"] = createExportWrapper("__errno_location");
		Module["_fflush"] = createExportWrapper("fflush");
		Module["_malloc"] = createExportWrapper("malloc");
		Module["_free"] = createExportWrapper("free");
		/** @type {function(...*):?} */
		var _emscripten_stack_init = Module["_emscripten_stack_init"] = function() {
			return (_emscripten_stack_init = Module["_emscripten_stack_init"] = Module["asm"]["emscripten_stack_init"]).apply(null, arguments);
		};
		/** @type {function(...*):?} */
		var _emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = function() {
			return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments);
		};
		/** @type {function(...*):?} */
		var _emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = function() {
			return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments);
		};
		/** @type {function(...*):?} */
		var _emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = function() {
			return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments);
		};
		Module["stackSave"] = createExportWrapper("stackSave");
		Module["stackRestore"] = createExportWrapper("stackRestore");
		Module["stackAlloc"] = createExportWrapper("stackAlloc");
		/** @type {function(...*):?} */
		var _emscripten_stack_get_current = Module["_emscripten_stack_get_current"] = function() {
			return (_emscripten_stack_get_current = Module["_emscripten_stack_get_current"] = Module["asm"]["emscripten_stack_get_current"]).apply(null, arguments);
		};
		Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji");
		Module["___start_em_js"] = 5261488;
		Module["___stop_em_js"] = 5261586;
		[
			"run",
			"UTF8ArrayToString",
			"UTF8ToString",
			"stringToUTF8Array",
			"stringToUTF8",
			"lengthBytesUTF8",
			"addOnPreRun",
			"addOnInit",
			"addOnPreMain",
			"addOnExit",
			"addOnPostRun",
			"addRunDependency",
			"removeRunDependency",
			"FS_createFolder",
			"FS_createPath",
			"FS_createDataFile",
			"FS_createPreloadedFile",
			"FS_createLazyFile",
			"FS_createLink",
			"FS_createDevice",
			"FS_unlink",
			"getLEB",
			"getFunctionTables",
			"alignFunctionTables",
			"registerFunctions",
			"prettyPrint",
			"getCompilerSetting",
			"out",
			"err",
			"callMain",
			"abort",
			"keepRuntimeAlive",
			"wasmMemory",
			"stackAlloc",
			"stackSave",
			"stackRestore",
			"getTempRet0",
			"setTempRet0",
			"writeStackCookie",
			"checkStackCookie",
			"ptrToString",
			"zeroMemory",
			"stringToNewUTF8",
			"exitJS",
			"getHeapMax",
			"emscripten_realloc_buffer",
			"ENV",
			"ERRNO_CODES",
			"ERRNO_MESSAGES",
			"setErrNo",
			"inetPton4",
			"inetNtop4",
			"inetPton6",
			"inetNtop6",
			"readSockaddr",
			"writeSockaddr",
			"DNS",
			"getHostByName",
			"Protocols",
			"Sockets",
			"getRandomDevice",
			"warnOnce",
			"traverseStack",
			"UNWIND_CACHE",
			"convertPCtoSourceLocation",
			"readEmAsmArgsArray",
			"readEmAsmArgs",
			"runEmAsmFunction",
			"runMainThreadEmAsm",
			"jstoi_q",
			"jstoi_s",
			"getExecutableName",
			"listenOnce",
			"autoResumeAudioContext",
			"dynCallLegacy",
			"getDynCaller",
			"dynCall",
			"handleException",
			"runtimeKeepalivePush",
			"runtimeKeepalivePop",
			"callUserCallback",
			"maybeExit",
			"safeSetTimeout",
			"asmjsMangle",
			"asyncLoad",
			"alignMemory",
			"mmapAlloc",
			"writeI53ToI64",
			"writeI53ToI64Clamped",
			"writeI53ToI64Signaling",
			"writeI53ToU64Clamped",
			"writeI53ToU64Signaling",
			"readI53FromI64",
			"readI53FromU64",
			"convertI32PairToI53",
			"convertI32PairToI53Checked",
			"convertU32PairToI53",
			"getCFunc",
			"ccall",
			"cwrap",
			"uleb128Encode",
			"sigToWasmTypes",
			"generateFuncType",
			"convertJsFunctionToWasm",
			"freeTableIndexes",
			"functionsInTableMap",
			"getEmptyTableSlot",
			"updateTableMap",
			"addFunction",
			"removeFunction",
			"reallyNegative",
			"unSign",
			"strLen",
			"reSign",
			"formatString",
			"setValue",
			"getValue",
			"PATH",
			"PATH_FS",
			"intArrayFromString",
			"intArrayToString",
			"AsciiToString",
			"stringToAscii",
			"UTF16Decoder",
			"UTF16ToString",
			"stringToUTF16",
			"lengthBytesUTF16",
			"UTF32ToString",
			"stringToUTF32",
			"lengthBytesUTF32",
			"allocateUTF8",
			"allocateUTF8OnStack",
			"writeStringToMemory",
			"writeArrayToMemory",
			"writeAsciiToMemory",
			"SYSCALLS",
			"getSocketFromFD",
			"getSocketAddress",
			"JSEvents",
			"registerKeyEventCallback",
			"specialHTMLTargets",
			"maybeCStringToJsString",
			"findEventTarget",
			"findCanvasEventTarget",
			"getBoundingClientRect",
			"fillMouseEventData",
			"registerMouseEventCallback",
			"registerWheelEventCallback",
			"registerUiEventCallback",
			"registerFocusEventCallback",
			"fillDeviceOrientationEventData",
			"registerDeviceOrientationEventCallback",
			"fillDeviceMotionEventData",
			"registerDeviceMotionEventCallback",
			"screenOrientation",
			"fillOrientationChangeEventData",
			"registerOrientationChangeEventCallback",
			"fillFullscreenChangeEventData",
			"registerFullscreenChangeEventCallback",
			"JSEvents_requestFullscreen",
			"JSEvents_resizeCanvasForFullscreen",
			"registerRestoreOldStyle",
			"hideEverythingExceptGivenElement",
			"restoreHiddenElements",
			"setLetterbox",
			"currentFullscreenStrategy",
			"restoreOldWindowedStyle",
			"softFullscreenResizeWebGLRenderTarget",
			"doRequestFullscreen",
			"fillPointerlockChangeEventData",
			"registerPointerlockChangeEventCallback",
			"registerPointerlockErrorEventCallback",
			"requestPointerLock",
			"fillVisibilityChangeEventData",
			"registerVisibilityChangeEventCallback",
			"registerTouchEventCallback",
			"fillGamepadEventData",
			"registerGamepadEventCallback",
			"registerBeforeUnloadEventCallback",
			"fillBatteryEventData",
			"battery",
			"registerBatteryEventCallback",
			"setCanvasElementSize",
			"getCanvasElementSize",
			"demangle",
			"demangleAll",
			"jsStackTrace",
			"stackTrace",
			"ExitStatus",
			"getEnvStrings",
			"checkWasiClock",
			"flush_NO_FILESYSTEM",
			"dlopenMissingError",
			"createDyncallWrapper",
			"setImmediateWrapped",
			"clearImmediateWrapped",
			"polyfillSetImmediate",
			"uncaughtExceptionCount",
			"exceptionLast",
			"exceptionCaught",
			"ExceptionInfo",
			"exception_addRef",
			"exception_decRef",
			"Browser",
			"setMainLoop",
			"wget",
			"FS",
			"MEMFS",
			"TTY",
			"PIPEFS",
			"SOCKFS",
			"_setNetworkCallback",
			"tempFixedLengthArray",
			"miniTempWebGLFloatBuffers",
			"heapObjectForWebGLType",
			"heapAccessShiftForWebGLHeap",
			"GL",
			"emscriptenWebGLGet",
			"computeUnpackAlignedImageSize",
			"emscriptenWebGLGetTexPixelData",
			"emscriptenWebGLGetUniform",
			"webglGetUniformLocation",
			"webglPrepareUniformLocationsBeforeFirstUse",
			"webglGetLeftBracePos",
			"emscriptenWebGLGetVertexAttrib",
			"writeGLArray",
			"AL",
			"SDL_unicode",
			"SDL_ttfContext",
			"SDL_audio",
			"SDL",
			"SDL_gfx",
			"GLUT",
			"EGL",
			"GLFW_Window",
			"GLFW",
			"GLEW",
			"IDBStore",
			"runAndAbortIfError",
			"ALLOC_NORMAL",
			"ALLOC_STACK",
			"allocate"
		].forEach(unexportedRuntimeSymbol);
		[
			"zeroMemory",
			"stringToNewUTF8",
			"exitJS",
			"setErrNo",
			"inetPton4",
			"inetNtop4",
			"inetPton6",
			"inetNtop6",
			"readSockaddr",
			"writeSockaddr",
			"getHostByName",
			"getRandomDevice",
			"traverseStack",
			"convertPCtoSourceLocation",
			"readEmAsmArgs",
			"runEmAsmFunction",
			"runMainThreadEmAsm",
			"jstoi_q",
			"jstoi_s",
			"getExecutableName",
			"listenOnce",
			"autoResumeAudioContext",
			"dynCallLegacy",
			"getDynCaller",
			"dynCall",
			"handleException",
			"runtimeKeepalivePush",
			"runtimeKeepalivePop",
			"callUserCallback",
			"maybeExit",
			"safeSetTimeout",
			"asmjsMangle",
			"asyncLoad",
			"alignMemory",
			"mmapAlloc",
			"writeI53ToI64",
			"writeI53ToI64Clamped",
			"writeI53ToI64Signaling",
			"writeI53ToU64Clamped",
			"writeI53ToU64Signaling",
			"readI53FromI64",
			"readI53FromU64",
			"convertI32PairToI53",
			"convertU32PairToI53",
			"getCFunc",
			"ccall",
			"cwrap",
			"uleb128Encode",
			"sigToWasmTypes",
			"generateFuncType",
			"convertJsFunctionToWasm",
			"getEmptyTableSlot",
			"updateTableMap",
			"addFunction",
			"removeFunction",
			"reallyNegative",
			"unSign",
			"strLen",
			"reSign",
			"formatString",
			"intArrayToString",
			"AsciiToString",
			"stringToAscii",
			"UTF16ToString",
			"stringToUTF16",
			"lengthBytesUTF16",
			"UTF32ToString",
			"stringToUTF32",
			"lengthBytesUTF32",
			"allocateUTF8",
			"allocateUTF8OnStack",
			"writeStringToMemory",
			"writeArrayToMemory",
			"writeAsciiToMemory",
			"getSocketFromFD",
			"getSocketAddress",
			"registerKeyEventCallback",
			"maybeCStringToJsString",
			"findEventTarget",
			"findCanvasEventTarget",
			"getBoundingClientRect",
			"fillMouseEventData",
			"registerMouseEventCallback",
			"registerWheelEventCallback",
			"registerUiEventCallback",
			"registerFocusEventCallback",
			"fillDeviceOrientationEventData",
			"registerDeviceOrientationEventCallback",
			"fillDeviceMotionEventData",
			"registerDeviceMotionEventCallback",
			"screenOrientation",
			"fillOrientationChangeEventData",
			"registerOrientationChangeEventCallback",
			"fillFullscreenChangeEventData",
			"registerFullscreenChangeEventCallback",
			"JSEvents_requestFullscreen",
			"JSEvents_resizeCanvasForFullscreen",
			"registerRestoreOldStyle",
			"hideEverythingExceptGivenElement",
			"restoreHiddenElements",
			"setLetterbox",
			"softFullscreenResizeWebGLRenderTarget",
			"doRequestFullscreen",
			"fillPointerlockChangeEventData",
			"registerPointerlockChangeEventCallback",
			"registerPointerlockErrorEventCallback",
			"requestPointerLock",
			"fillVisibilityChangeEventData",
			"registerVisibilityChangeEventCallback",
			"registerTouchEventCallback",
			"fillGamepadEventData",
			"registerGamepadEventCallback",
			"registerBeforeUnloadEventCallback",
			"fillBatteryEventData",
			"battery",
			"registerBatteryEventCallback",
			"setCanvasElementSize",
			"getCanvasElementSize",
			"demangle",
			"demangleAll",
			"jsStackTrace",
			"stackTrace",
			"getEnvStrings",
			"checkWasiClock",
			"createDyncallWrapper",
			"setImmediateWrapped",
			"clearImmediateWrapped",
			"polyfillSetImmediate",
			"ExceptionInfo",
			"exception_addRef",
			"exception_decRef",
			"setMainLoop",
			"_setNetworkCallback",
			"heapObjectForWebGLType",
			"heapAccessShiftForWebGLHeap",
			"emscriptenWebGLGet",
			"computeUnpackAlignedImageSize",
			"emscriptenWebGLGetTexPixelData",
			"emscriptenWebGLGetUniform",
			"webglGetUniformLocation",
			"webglPrepareUniformLocationsBeforeFirstUse",
			"webglGetLeftBracePos",
			"emscriptenWebGLGetVertexAttrib",
			"writeGLArray",
			"SDL_unicode",
			"SDL_ttfContext",
			"SDL_audio",
			"GLFW_Window",
			"runAndAbortIfError",
			"ALLOC_NORMAL",
			"ALLOC_STACK",
			"allocate"
		].forEach(missingLibrarySymbol);
		var calledRun;
		dependenciesFulfilled = function runCaller() {
			if (!calledRun) run();
			if (!calledRun) dependenciesFulfilled = runCaller;
		};
		function stackCheckInit() {
			_emscripten_stack_init();
			writeStackCookie();
		}
		/** @type {function(Array=)} */
		function run(args) {
			args = args || arguments_;
			if (runDependencies > 0) return;
			stackCheckInit();
			preRun();
			if (runDependencies > 0) return;
			function doRun() {
				if (calledRun) return;
				calledRun = true;
				Module["calledRun"] = true;
				if (ABORT) return;
				initRuntime();
				readyPromiseResolve(Module);
				if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
				assert(!Module["_main"], "compiled without a main, but one is present. if you added it from JS, use Module[\"onRuntimeInitialized\"]");
				postRun();
			}
			if (Module["setStatus"]) {
				Module["setStatus"]("Running...");
				setTimeout(function() {
					setTimeout(function() {
						Module["setStatus"]("");
					}, 1);
					doRun();
				}, 1);
			} else doRun();
			checkStackCookie();
		}
		if (Module["preInit"]) {
			if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
			while (Module["preInit"].length > 0) Module["preInit"].pop()();
		}
		run();
		/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
		function WrapperObject() {}
		WrapperObject.prototype = Object.create(WrapperObject.prototype);
		WrapperObject.prototype.constructor = WrapperObject;
		WrapperObject.prototype.__class__ = WrapperObject;
		WrapperObject.__cache__ = {};
		Module["WrapperObject"] = WrapperObject;
		/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant)
		@param {*=} __class__ */
		function getCache(__class__) {
			return (__class__ || WrapperObject).__cache__;
		}
		Module["getCache"] = getCache;
		/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant)
		@param {*=} __class__ */
		function wrapPointer(ptr, __class__) {
			var cache = getCache(__class__);
			var ret = cache[ptr];
			if (ret) return ret;
			ret = Object.create((__class__ || WrapperObject).prototype);
			ret.ptr = ptr;
			return cache[ptr] = ret;
		}
		Module["wrapPointer"] = wrapPointer;
		/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
		function castObject(obj, __class__) {
			return wrapPointer(obj.ptr, __class__);
		}
		Module["castObject"] = castObject;
		Module["NULL"] = wrapPointer(0);
		/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
		function destroy(obj) {
			if (!obj["__destroy__"]) throw "Error: Cannot destroy object. (Did you create it yourself?)";
			obj["__destroy__"]();
			delete getCache(obj.__class__)[obj.ptr];
		}
		Module["destroy"] = destroy;
		/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
		function compare(obj1, obj2) {
			return obj1.ptr === obj2.ptr;
		}
		Module["compare"] = compare;
		/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
		function getPointer(obj) {
			return obj.ptr;
		}
		Module["getPointer"] = getPointer;
		/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
		function getClass(obj) {
			return obj.__class__;
		}
		Module["getClass"] = getClass;
		/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
		var ensureCache = {
			buffer: 0,
			size: 0,
			pos: 0,
			temps: [],
			needed: 0,
			prepare: function() {
				if (ensureCache.needed) {
					for (var i = 0; i < ensureCache.temps.length; i++) Module["_free"](ensureCache.temps[i]);
					ensureCache.temps.length = 0;
					Module["_free"](ensureCache.buffer);
					ensureCache.buffer = 0;
					ensureCache.size += ensureCache.needed;
					ensureCache.needed = 0;
				}
				if (!ensureCache.buffer) {
					ensureCache.size += 128;
					ensureCache.buffer = Module["_malloc"](ensureCache.size);
					assert(ensureCache.buffer);
				}
				ensureCache.pos = 0;
			},
			alloc: function(array, view) {
				assert(ensureCache.buffer);
				var bytes = view.BYTES_PER_ELEMENT;
				var len = array.length * bytes;
				len = len + 7 & -8;
				var ret;
				if (ensureCache.pos + len >= ensureCache.size) {
					assert(len > 0);
					ensureCache.needed += len;
					ret = Module["_malloc"](len);
					ensureCache.temps.push(ret);
				} else {
					ret = ensureCache.buffer + ensureCache.pos;
					ensureCache.pos += len;
				}
				return ret;
			},
			copy: function(array, view, offset) {
				offset >>>= 0;
				switch (view.BYTES_PER_ELEMENT) {
					case 2:
						offset >>>= 1;
						break;
					case 4:
						offset >>>= 2;
						break;
					case 8: offset >>>= 3;
				}
				for (var i = 0; i < array.length; i++) view[offset + i] = array[i];
			}
		};
		/** @suppress {undefinedVars, duplicate} @this{Object} */ function VoidPtr() {
			throw "cannot construct a VoidPtr, no constructor in IDL";
		}
		VoidPtr.prototype = Object.create(WrapperObject.prototype);
		VoidPtr.prototype.constructor = VoidPtr;
		VoidPtr.prototype.__class__ = VoidPtr;
		VoidPtr.__cache__ = {};
		Module["VoidPtr"] = VoidPtr;
		VoidPtr.prototype["__destroy__"] = VoidPtr.prototype.__destroy__ = function() {
			var self = this.ptr;
			_emscripten_bind_VoidPtr___destroy___0(self);
		};
		/** @suppress {undefinedVars, duplicate} @this{Object} */ function Crc64Hash() {
			this.ptr = _emscripten_bind_Crc64Hash_Crc64Hash_0();
			getCache(Crc64Hash)[this.ptr] = this;
		}
		Crc64Hash.prototype = Object.create(WrapperObject.prototype);
		Crc64Hash.prototype.constructor = Crc64Hash;
		Crc64Hash.prototype.__class__ = Crc64Hash;
		Crc64Hash.__cache__ = {};
		Module["Crc64Hash"] = Crc64Hash;
		Crc64Hash.prototype["OnAppend"] = Crc64Hash.prototype.OnAppend = function(data, length) {
			var self = this.ptr;
			if (data && typeof data === "object") data = data.ptr;
			if (length && typeof length === "object") length = length.ptr;
			_emscripten_bind_Crc64Hash_OnAppend_2(self, data, length);
		};
		Crc64Hash.prototype["OnFinal"] = Crc64Hash.prototype.OnFinal = function(data, length, result) {
			var self = this.ptr;
			if (data && typeof data === "object") data = data.ptr;
			if (length && typeof length === "object") length = length.ptr;
			if (result && typeof result === "object") result = result.ptr;
			_emscripten_bind_Crc64Hash_OnFinal_3(self, data, length, result);
		};
		Crc64Hash.prototype["__destroy__"] = Crc64Hash.prototype.__destroy__ = function() {
			var self = this.ptr;
			_emscripten_bind_Crc64Hash___destroy___0(self);
		};
		return NativeCRC64.ready;
	});
})();
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/StorageCRC64Calculator.js
/**
* Class used to calculator CRC64 checksum
*/
var StorageCRC64Calculator = class StorageCRC64Calculator {
	nativeCrc64Hash;
	static nativeInstance;
	constructor() {
		this.nativeCrc64Hash = new StorageCRC64Calculator.nativeInstance.Crc64Hash();
	}
	static initPromise;
	/**
	* Initialize environment for CRC64 checksum calculator
	*/
	static async init() {
		if (!this.initPromise) this.initPromise = NativeCRC64().then((instance) => {
			this.nativeInstance = instance;
		});
		return this.initPromise;
	}
	/**
	* Append data for CRC64 checksum calculator
	* @param body - content to be append
	* @param length - length of the content
	*/
	append(body, length) {
		const ptr = StorageCRC64Calculator.nativeInstance._malloc(length);
		StorageCRC64Calculator.nativeInstance.HEAPU8.set(body, ptr);
		this.nativeCrc64Hash.OnAppend(ptr, length);
		StorageCRC64Calculator.nativeInstance._free(ptr);
	}
	/**
	* Complete CRC64 checksum calculating and get the final result.
	* @param body -
	* @param length -
	* @returns
	*/
	final(body, length) {
		const ptr = StorageCRC64Calculator.nativeInstance._malloc(length);
		StorageCRC64Calculator.nativeInstance.HEAPU8.set(body, ptr);
		const result = StorageCRC64Calculator.nativeInstance._malloc(8);
		this.nativeCrc64Hash.OnFinal(ptr, length, result);
		StorageCRC64Calculator.nativeInstance._free(ptr);
		const resultArray = /* @__PURE__ */ new Uint8Array(8);
		resultArray.set(StorageCRC64Calculator.nativeInstance.HEAPU8.subarray(result, result + 8));
		StorageCRC64Calculator.nativeInstance._free(result);
		return resultArray;
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/streamHelpers.js
/**
* Signals the end of a stream by pushing null.
* In Node.js, this is required to signal the end of a Readable stream.
* @internal
*/
function signalStreamEnd(pushData) {
	pushData(null);
}
var MAX_SEGMENT_CONTENT_LENGTH = 4194304;
var SMRegion$1;
(function(SMRegion) {
	SMRegion[SMRegion["StreamHeader"] = 0] = "StreamHeader";
	SMRegion[SMRegion["StreamFooter"] = 1] = "StreamFooter";
	SMRegion[SMRegion["SegmentHeader"] = 2] = "SegmentHeader";
	SMRegion[SMRegion["SegmentFooter"] = 3] = "SegmentFooter";
	SMRegion[SMRegion["SegmentContent"] = 4] = "SegmentContent";
	SMRegion[SMRegion["Completed"] = 5] = "Completed";
})(SMRegion$1 || (SMRegion$1 = {}));
var StructuredMessageEncoding = class {
	pushData;
	contentLength;
	messageLength;
	constructor(pushData, contentLength) {
		this.pushData = pushData;
		this.contentLength = contentLength;
		this.contentOffset = 0;
		this.currentDataOffset = 0;
		this.segmentsCount = Math.ceil(this.contentLength / MAX_SEGMENT_CONTENT_LENGTH);
		this.messageLength = this.contentLength + 13 + 18 * this.segmentsCount + 8;
		this.messageHeaderBuffer = /* @__PURE__ */ new Uint8Array(13);
		this.segmentNumber = 0;
		this.segmentContentLength = 0;
		this.segmentContentOffset = 0;
		this.state = SMRegion$1.StreamHeader;
		this.segmentCrc64 = new StorageCRC64Calculator();
		this.messageCrc64 = new StorageCRC64Calculator();
	}
	currentDataOffset;
	contentOffset;
	segmentsCount;
	messageHeaderBuffer;
	segmentNumber;
	segmentContentLength;
	segmentContentOffset;
	segmentCrc64;
	messageCrc64;
	state;
	sourceDataHandler = (data) => {
		this.currentDataOffset = 0;
		if (this.state === SMRegion$1.StreamHeader) this.handlingMessageHeader();
		while (this.segmentNumber < this.segmentsCount) {
			this.segmentContentLength = Math.min(MAX_SEGMENT_CONTENT_LENGTH, this.contentLength - this.contentOffset);
			if (this.state === SMRegion$1.SegmentHeader) this.handlingSegmentHeader();
			if (this.state === SMRegion$1.SegmentContent) this.handlingSegmentContent(data);
			if (this.state === SMRegion$1.SegmentFooter) {
				this.handlingSegmentFooter();
				this.contentOffset += this.segmentContentLength;
			}
			if (this.currentDataOffset === data.length) break;
		}
		if (this.state === SMRegion$1.StreamFooter) this.handlingMessageFooter();
	};
	handlingMessageHeader() {
		this.messageHeaderBuffer[0] = 1;
		this.fillInt64(this.messageHeaderBuffer, 1, this.messageLength);
		this.fillInt16(this.messageHeaderBuffer, 9, 1);
		this.fillInt16(this.messageHeaderBuffer, 11, this.segmentsCount);
		this.pushData(this.messageHeaderBuffer);
		this.state = SMRegion$1.SegmentHeader;
	}
	handlingSegmentHeader() {
		const segmentHeaderBuffer = /* @__PURE__ */ new Uint8Array(10);
		this.fillInt16(segmentHeaderBuffer, 0, this.segmentNumber + 1);
		this.fillInt64(segmentHeaderBuffer, 2, this.segmentContentLength);
		this.segmentContentOffset = 0;
		this.pushData(segmentHeaderBuffer);
		this.state = SMRegion$1.SegmentContent;
	}
	handlingSegmentContent(data) {
		const length = Math.min(this.segmentContentLength - this.segmentContentOffset, data.length - this.currentDataOffset);
		if (length !== 0) {
			const current_content = Uint8Array.prototype.slice.call(data, this.currentDataOffset, this.currentDataOffset + length);
			this.messageCrc64.append(current_content, length);
			this.segmentCrc64.append(current_content, length);
			this.pushData(current_content);
		}
		this.segmentContentOffset += length;
		this.currentDataOffset += length;
		if (this.segmentContentOffset === this.segmentContentLength) this.state = SMRegion$1.SegmentFooter;
	}
	handlingSegmentFooter() {
		const crc64Result = this.segmentCrc64.final(new Uint8Array([]), 0);
		this.pushData(crc64Result);
		this.segmentCrc64 = new StorageCRC64Calculator();
		++this.segmentNumber;
		if (this.segmentNumber === this.segmentsCount) this.state = SMRegion$1.StreamFooter;
		else this.state = SMRegion$1.SegmentHeader;
	}
	handlingMessageFooter() {
		const crc64Result = this.messageCrc64.final(new Uint8Array([]), 0);
		this.pushData(crc64Result);
		signalStreamEnd(this.pushData);
		this.state = SMRegion$1.Completed;
	}
	fillInt64(buffer, offset, input) {
		if (buffer.length < offset + 8) throw new Error("Uint8Array length is not expected.");
		new DataView(buffer.buffer, buffer.byteOffset + offset, 8).setBigUint64(0, BigInt(input), true);
	}
	fillInt16(buffer, offset, input) {
		if (buffer.length < offset + 2) throw new Error("Uint8Array length is not expected.");
		new DataView(buffer.buffer, buffer.byteOffset + offset, 2).setUint16(0, input, true);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/StructuredMessageEncodingStream.js
function isNodeReadableStream(source) {
	return source !== null && source instanceof Stream && typeof source._read === "function" && typeof source._readableState === "object" && typeof source.pipe === "function";
}
/**
*
* To encode structured body for CRC64 content validtion in storage uploading.
* @param source -
* @param contentLength -
* @returns
*/
async function structuredMessageEncoding(source, contentLength) {
	if (source === null) return {
		body: source,
		encodedContentLength: contentLength
	};
	if (isNodeReadableStream(source)) {
		const encodingMessage = new StructuredMessageEncodingStream(source, contentLength, {});
		return {
			body: encodingMessage,
			encodedContentLength: encodingMessage.messageLength()
		};
	}
	if (typeof source === "function") {
		const encodingMessage = new StructuredMessageEncodingStream(source(), contentLength, {});
		return {
			body: encodingMessage,
			encodedContentLength: encodingMessage.messageLength()
		};
	}
	if (source instanceof Blob) {
		const encoding = await BrowserStream(source, contentLength);
		return {
			body: encoding.content,
			encodedContentLength: encoding.encodedContentLength
		};
	}
	if (typeof source === "string") {
		const s = new Readable();
		s._read = () => {};
		s.push(source);
		s.push(null);
		const encodingMessage = await new StructuredMessageEncodingStream(s, Buffer.byteLength(source), {});
		return {
			body: encodingMessage,
			encodedContentLength: encodingMessage.messageLength()
		};
	}
	if (source instanceof ArrayBuffer) {
		const encodingMessage = await new StructuredMessageEncodingStream(Readable.from(Buffer.from(source)), contentLength, {});
		return {
			body: encodingMessage,
			encodedContentLength: encodingMessage.messageLength()
		};
	}
	if (source instanceof Buffer) {
		const encodingMessage = await new StructuredMessageEncodingStream(Readable.from(source), contentLength, {});
		return {
			body: encodingMessage,
			encodedContentLength: encodingMessage.messageLength()
		};
	}
	if (ArrayBuffer.isView(source)) {
		const encodingMessage = await new StructuredMessageEncodingStream(Readable.from(Buffer.from(source.buffer, source.byteOffset, source.byteLength)), contentLength, {});
		return {
			body: encodingMessage,
			encodedContentLength: encodingMessage.messageLength()
		};
	}
	throw new Error("The specified request body type is not supported for CRC64 checksum");
}
async function pump(reader, controller, encodingStream) {
	const { done, value } = await reader.read();
	if (done) {
		controller.close();
		return;
	}
	encodingStream.sourceDataHandler(Buffer.from(value));
}
async function BrowserStream(source, contentLength) {
	const reader = (source instanceof Blob ? source.stream() : source).getReader();
	let encodingStream = void 0;
	const stream = new ReadableStream({
		start(controller) {
			encodingStream = new StructuredMessageEncoding((data) => {
				controller.enqueue(data);
			}, contentLength);
		},
		pull(controller) {
			pump(reader, controller, encodingStream).then(() => {}).catch(function(error) {
				controller.error(error);
			});
		}
	});
	return {
		content: await new Response(stream).blob(),
		encodedContentLength: encodingStream.messageLength
	};
}
var StructuredMessageEncodingStream = class extends Readable {
	source;
	encodingMethods;
	constructor(source, contentLength, options) {
		super({ highWaterMark: options.highWaterMark });
		this.source = source;
		this.encodingMethods = new StructuredMessageEncoding((dataToHandle) => {
			if (!this.push(dataToHandle)) source.pause();
		}, contentLength);
		this.setSourceEventHandlers();
	}
	messageLength() {
		return this.encodingMethods.messageLength;
	}
	setSourceEventHandlers() {
		this.source.on("data", this.sourceDataHandler);
		this.source.on("end", this.sourceErrorOrEndHandler);
		this.source.on("error", this.sourceErrorOrEndHandler);
		this.source.on("aborted", this.sourceAbortedHandler);
	}
	removeSourceEventHandlers() {
		this.source.removeListener("data", this.sourceDataHandler);
		this.source.removeListener("end", this.sourceErrorOrEndHandler);
		this.source.removeListener("error", this.sourceErrorOrEndHandler);
		this.source.removeListener("aborted", this.sourceAbortedHandler);
	}
	sourceDataHandler = (data) => {
		this.encodingMethods.sourceDataHandler(data);
	};
	sourceAbortedHandler = () => {
		const abortError = new AbortError("The operation was aborted.");
		this.destroy(abortError);
	};
	sourceErrorOrEndHandler = (err) => {
		if (err && err.name === "AbortError") {
			this.destroy(err);
			return;
		}
		this.removeSourceEventHandlers();
	};
	_read() {
		this.source.resume();
	}
	_destroy(error, callback) {
		this.removeSourceEventHandlers();
		this.source.destroy();
		callback(error === null ? void 0 : error);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/StructuredMessageDecoding.js
var MESSAGE_VERSION = 1;
var MESSAGE_HEADER_LENGTH = 13;
var SEGMENT_HEADER_LENGTH = 10;
var FOOTER_LENGTH = 8;
var SMRegion;
(function(SMRegion) {
	SMRegion[SMRegion["StreamHeader"] = 0] = "StreamHeader";
	SMRegion[SMRegion["StreamFooter"] = 1] = "StreamFooter";
	SMRegion[SMRegion["SegmentHeader"] = 2] = "SegmentHeader";
	SMRegion[SMRegion["SegmentFooter"] = 3] = "SegmentFooter";
	SMRegion[SMRegion["SegmentContent"] = 4] = "SegmentContent";
})(SMRegion || (SMRegion = {}));
var StructuredMessageDecoding = class {
	pushData;
	segmentsCount;
	currentOffset;
	currentDataOffset;
	messageHeaderBuffer;
	messageHeaderOffset;
	segmentNumber;
	segmentHeaderOffset;
	segmentHeaderBuffer;
	segmentContentOffset;
	segmentContentLength;
	segmentFooterOffset;
	segmentFooterBuffer;
	messageFooterOffset;
	messageFooterBuffer;
	segmentCrc64;
	messageCrc64;
	state;
	constructor(pushData) {
		this.pushData = pushData;
		this.currentOffset = 0;
		this.segmentsCount = 0;
		this.messageHeaderOffset = 0;
		this.messageHeaderBuffer = new Uint8Array(MESSAGE_HEADER_LENGTH);
		this.currentDataOffset = 0;
		this.segmentNumber = 0;
		this.segmentHeaderOffset = 0;
		this.segmentHeaderBuffer = new Uint8Array(SEGMENT_HEADER_LENGTH);
		this.segmentContentOffset = 0;
		this.segmentContentLength = 0;
		this.state = SMRegion.StreamHeader;
		this.segmentFooterOffset = 0;
		this.segmentFooterBuffer = new Uint8Array(FOOTER_LENGTH);
		this.messageFooterOffset = 0;
		this.messageFooterBuffer = new Uint8Array(FOOTER_LENGTH);
		this.segmentCrc64 = new StorageCRC64Calculator();
		this.messageCrc64 = new StorageCRC64Calculator();
	}
	sourceDataHandler = (data) => {
		this.currentDataOffset = 0;
		if (this.state === SMRegion.StreamHeader) this.parseMessageHeader(data);
		while (this.segmentNumber < this.segmentsCount && this.currentDataOffset < data.length) {
			if (this.state === SMRegion.SegmentHeader) this.parseSegmentHeader(data);
			if (this.state === SMRegion.SegmentContent) this.parseSegmentContent(data);
			if (this.state === SMRegion.SegmentFooter) this.parseSegmentFooter(data);
		}
		if (this.state === SMRegion.StreamFooter) this.parseMessageFooter(data);
	};
	parseMessageHeader(data) {
		const length = Math.min(MESSAGE_HEADER_LENGTH - this.messageHeaderOffset, data.length - this.currentDataOffset);
		this.messageHeaderBuffer.set(Uint8Array.prototype.slice.call(data, this.currentDataOffset, this.currentDataOffset + length), this.messageHeaderOffset);
		this.currentDataOffset += length;
		this.messageHeaderOffset += length;
		this.currentOffset += length;
		if (this.messageHeaderOffset === MESSAGE_HEADER_LENGTH) {
			if (this.messageHeaderBuffer[0] !== MESSAGE_VERSION) throw new Error("Unexpected message version");
			this.segmentsCount = this.toInt16(Uint8Array.prototype.slice.call(this.messageHeaderBuffer, 11, 13));
			this.state = SMRegion.SegmentHeader;
		}
	}
	parseSegmentHeader(data) {
		const length = Math.min(SEGMENT_HEADER_LENGTH - this.segmentHeaderOffset, data.length - this.currentDataOffset);
		this.segmentHeaderBuffer.set(Uint8Array.prototype.slice.call(data, this.currentDataOffset, this.currentDataOffset + length), this.segmentHeaderOffset);
		this.currentDataOffset += length;
		this.segmentHeaderOffset += length;
		this.currentOffset += length;
		if (this.segmentHeaderOffset === SEGMENT_HEADER_LENGTH) {
			if (this.toInt16(Uint8Array.prototype.slice.call(this.segmentHeaderBuffer, 0, 2)) !== this.segmentNumber + 1) throw new Error("Segment number is unexpected.");
			this.segmentContentLength = this.toInt64(this.segmentHeaderBuffer, 2);
			this.segmentContentOffset = 0;
			this.state = SMRegion.SegmentContent;
		}
	}
	parseSegmentContent(data) {
		const length = Math.min(this.segmentContentLength - this.segmentContentOffset, data.length - this.currentDataOffset);
		const dataToHandle = Uint8Array.prototype.slice.call(data, this.currentDataOffset, this.currentDataOffset + length);
		this.segmentCrc64.append(dataToHandle, length);
		this.messageCrc64.append(dataToHandle, length);
		this.pushData(dataToHandle);
		this.currentDataOffset += length;
		this.segmentContentOffset += length;
		this.currentOffset += length;
		if (this.segmentContentOffset === this.segmentContentLength) this.state = SMRegion.SegmentFooter;
	}
	parseSegmentFooter(data) {
		const length = Math.min(FOOTER_LENGTH - this.segmentFooterOffset, data.length - this.currentDataOffset);
		this.segmentFooterBuffer.set(Uint8Array.prototype.slice.call(data, this.currentDataOffset, this.currentDataOffset + length), this.segmentFooterOffset);
		this.currentDataOffset += length;
		this.segmentFooterOffset += length;
		this.currentOffset += length;
		if (this.segmentFooterOffset === FOOTER_LENGTH) {
			const crc64Result = this.segmentCrc64.final(new Uint8Array([]), 0);
			if (!this.checkCrc64CheckSum(crc64Result, this.segmentFooterBuffer)) throw new Error(`Segment check sum mismatch, segmentNumber: ${this.segmentNumber}`);
			++this.segmentNumber;
			if (this.segmentNumber === this.segmentsCount) this.state = SMRegion.StreamFooter;
			else {
				this.segmentHeaderOffset = 0;
				this.segmentFooterOffset = 0;
				this.segmentCrc64 = new StorageCRC64Calculator();
				this.state = SMRegion.SegmentHeader;
			}
		}
	}
	parseMessageFooter(data) {
		const length = Math.min(FOOTER_LENGTH - this.messageFooterOffset, data.length - this.currentDataOffset);
		this.messageFooterBuffer.set(Uint8Array.prototype.slice.call(data, this.currentDataOffset, this.currentDataOffset + length), this.messageFooterOffset);
		this.currentDataOffset += length;
		this.messageFooterOffset += length;
		this.currentOffset += length;
		if (this.messageFooterOffset === FOOTER_LENGTH) {
			const crc64Result = this.messageCrc64.final(new Uint8Array([]), 0);
			if (!this.checkCrc64CheckSum(crc64Result, this.messageFooterBuffer)) throw new Error("Check sum mismatch");
			this.pushData(null);
		}
	}
	toInt64(input, offset) {
		if (input.length < offset + 8) throw new Error("CRC64 buffer error, something wrong with crc64 calculator");
		const view = new DataView(input.buffer, input.byteOffset + offset, 8);
		return Number(view.getBigUint64(0, true));
	}
	toInt16(input) {
		if (input.length !== 2) throw new Error("CRC64 buffer error, something wrong with crc64 calculator");
		return input[0] + input[1] * 256;
	}
	checkCrc64CheckSum(first, second) {
		if (first.length !== 8 || second.length !== 8) throw new Error("CRC64 buffer error, something wrong with crc64 calculator");
		for (let index = 0; index < 8; ++index) if (first[index] !== second[index]) return false;
		return true;
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/StructuredMessageDecodingStream.js
/**
* To decode structured body for CRC64 content validtion in storage downloading.
* @param source -
*/
async function structuredMessageDecodingBrowser(source) {
	throw new Error("structuredMessageDecodingBrowser is only for Browser");
}
/**
* To decode structured body for CRC64 content validtion in storage downloading.
* @param source -
* @param options -
* @returns
*/
function structuredMessageDecodingStream(source, options) {
	return new StructuredMessageDecodingStream(source, options);
}
var StructuredMessageDecodingStream = class extends Readable {
	source;
	decodingMethods;
	constructor(source, options) {
		super({ highWaterMark: options.highWaterMark });
		this.source = source;
		this.decodingMethods = new StructuredMessageDecoding((dataToHandle) => {
			if (!this.push(dataToHandle)) source.pause();
		});
		this.setSourceEventHandlers();
	}
	_read() {
		this.source.resume();
	}
	setSourceEventHandlers() {
		this.source.on("data", this.sourceDataHandler);
		this.source.on("end", this.sourceErrorOrEndHandler);
		this.source.on("error", this.sourceErrorOrEndHandler);
		this.source.on("aborted", this.sourceAbortedHandler);
	}
	removeSourceEventHandlers() {
		this.source.removeListener("data", this.sourceDataHandler);
		this.source.removeListener("end", this.sourceErrorOrEndHandler);
		this.source.removeListener("error", this.sourceErrorOrEndHandler);
		this.source.removeListener("aborted", this.sourceAbortedHandler);
	}
	sourceDataHandler = (data) => {
		try {
			this.decodingMethods.sourceDataHandler(data);
		} catch (err) {
			this.destroy(err);
		}
	};
	sourceAbortedHandler = () => {
		const abortError = new AbortError("The operation was aborted.");
		this.destroy(abortError);
	};
	sourceErrorOrEndHandler = (err) => {
		if (err) {
			this.destroy(err);
			return;
		}
		this.removeSourceEventHandlers();
	};
	_destroy(error, callback) {
		this.removeSourceEventHandlers();
		this.source.destroy();
		callback(error === null ? void 0 : error);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/cache.js
var _defaultHttpClient;
function getCachedDefaultHttpClient() {
	if (!_defaultHttpClient) _defaultHttpClient = createDefaultHttpClient();
	return _defaultHttpClient;
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/RequestPolicy.js
/**
* The base class from which all request policies derive.
*/
var BaseRequestPolicy = class {
	_nextPolicy;
	_options;
	/**
	* The main method to implement that manipulates a request/response.
	*/
	constructor(_nextPolicy, _options) {
		this._nextPolicy = _nextPolicy;
		this._options = _options;
	}
	/**
	* Get whether or not a log with the provided log level should be logged.
	* @param logLevel - The log level of the log that will be logged.
	* @returns Whether or not a log with the provided log level should be logged.
	*/
	shouldLog(logLevel) {
		return this._options.shouldLog(logLevel);
	}
	/**
	* Attempt to log the provided message to the provided logger. If no logger was provided or if
	* the log level does not meat the logger's threshold, then nothing will be logged.
	* @param logLevel - The log level of this log.
	* @param message - The message of this log.
	*/
	log(logLevel, message) {
		this._options.log(logLevel, message);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/StorageBrowserPolicy.js
/**
* StorageBrowserPolicy will handle differences between Node.js and browser runtime, including:
*
* 1. Browsers cache GET/HEAD requests by adding conditional headers such as 'IF_MODIFIED_SINCE'.
* StorageBrowserPolicy is a policy used to add a timestamp query to GET/HEAD request URL
* thus avoid the browser cache.
*
* 2. Remove cookie header for security
*
* 3. Remove content-length header to avoid browsers warning
*
* In Node.js, this policy is a no-op pass-through.
*/
var StorageBrowserPolicy = class extends BaseRequestPolicy {
	/**
	* Creates an instance of StorageBrowserPolicy.
	* @param nextPolicy -
	* @param options -
	*/
	constructor(nextPolicy, options) {
		super(nextPolicy, options);
	}
	/**
	* Sends out request.
	*
	* @param request -
	*/
	async sendRequest(request) {
		return this._nextPolicy.sendRequest(request);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/StorageBrowserPolicyFactory.js
/**
* StorageBrowserPolicyFactory is a factory class helping generating StorageBrowserPolicy objects.
*/
var StorageBrowserPolicyFactory = class {
	/**
	* Creates a StorageBrowserPolicyFactory object.
	*
	* @param nextPolicy -
	* @param options -
	*/
	create(nextPolicy, options) {
		return new StorageBrowserPolicy(nextPolicy, options);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/CredentialPolicy.js
/**
* Credential policy used to sign HTTP(S) requests before sending. This is an
* abstract class.
*/
var CredentialPolicy = class extends BaseRequestPolicy {
	/**
	* Sends out request.
	*
	* @param request -
	*/
	sendRequest(request) {
		return this._nextPolicy.sendRequest(this.signRequest(request));
	}
	/**
	* Child classes must implement this method with request signing. This method
	* will be executed in {@link sendRequest}.
	*
	* @param request -
	*/
	signRequest(request) {
		return request;
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/AnonymousCredentialPolicy.js
/**
* AnonymousCredentialPolicy is used with HTTP(S) requests that read public resources
* or for use with Shared Access Signatures (SAS).
*/
var AnonymousCredentialPolicy = class extends CredentialPolicy {
	/**
	* Creates an instance of AnonymousCredentialPolicy.
	* @param nextPolicy -
	* @param options -
	*/
	constructor(nextPolicy, options) {
		super(nextPolicy, options);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/credentials/Credential.js
/**
* Credential is an abstract class for Azure Storage HTTP requests signing. This
* class will host an credentialPolicyCreator factory which generates CredentialPolicy.
*/
var Credential = class {
	/**
	* Creates a RequestPolicy object.
	*
	* @param _nextPolicy -
	* @param _options -
	*/
	create(_nextPolicy, _options) {
		throw new Error("Method should be implemented in children classes.");
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/credentials/AnonymousCredential.js
/**
* AnonymousCredential provides a credentialPolicyCreator member used to create
* AnonymousCredentialPolicy objects. AnonymousCredentialPolicy is used with
* HTTP(S) requests that read public resources or for use with Shared Access
* Signatures (SAS).
*/
var AnonymousCredential = class extends Credential {
	/**
	* Creates an {@link AnonymousCredentialPolicy} object.
	*
	* @param nextPolicy -
	* @param options -
	*/
	create(nextPolicy, options) {
		return new AnonymousCredentialPolicy(nextPolicy, options);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/utils/constants.js
var URLConstants$1 = { Parameters: {
	FORCE_BROWSER_NO_CACHE: "_",
	SIGNATURE: "sig",
	SNAPSHOT: "snapshot",
	VERSIONID: "versionid",
	TIMEOUT: "timeout"
} };
var HeaderConstants = {
	AUTHORIZATION: "Authorization",
	AUTHORIZATION_SCHEME: "Bearer",
	CONTENT_ENCODING: "Content-Encoding",
	CONTENT_ID: "Content-ID",
	CONTENT_LANGUAGE: "Content-Language",
	CONTENT_LENGTH: "Content-Length",
	CONTENT_MD5: "Content-Md5",
	CONTENT_TRANSFER_ENCODING: "Content-Transfer-Encoding",
	CONTENT_TYPE: "Content-Type",
	COOKIE: "Cookie",
	DATE: "date",
	IF_MATCH: "if-match",
	IF_MODIFIED_SINCE: "if-modified-since",
	IF_NONE_MATCH: "if-none-match",
	IF_UNMODIFIED_SINCE: "if-unmodified-since",
	PREFIX_FOR_STORAGE: "x-ms-",
	RANGE: "Range",
	USER_AGENT: "User-Agent",
	X_MS_CLIENT_REQUEST_ID: "x-ms-client-request-id",
	X_MS_COPY_SOURCE: "x-ms-copy-source",
	X_MS_DATE: "x-ms-date",
	X_MS_ERROR_CODE: "x-ms-error-code",
	X_MS_VERSION: "x-ms-version",
	X_MS_CopySourceErrorCode: "x-ms-copy-source-error-code"
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/utils/utils.common.js
/**
* Set URL parameter name and value. If name exists in URL parameters, old value
* will be replaced by name key. If not provide value, the parameter will be deleted.
*
* @param url - Source URL string
* @param name - Parameter name
* @param value - Parameter value
* @returns An updated URL string
*/
function setURLParameter$1(url, name, value) {
	const urlParsed = new URL(url);
	const encodedName = encodeURIComponent(name);
	const encodedValue = value ? encodeURIComponent(value) : void 0;
	const searchString = urlParsed.search === "" ? "?" : urlParsed.search;
	const searchPieces = [];
	for (const pair of searchString.slice(1).split("&")) if (pair) {
		const [key] = pair.split("=", 2);
		if (key !== encodedName) searchPieces.push(pair);
	}
	if (encodedValue) searchPieces.push(`${encodedName}=${encodedValue}`);
	urlParsed.search = searchPieces.length ? `?${searchPieces.join("&")}` : "";
	return urlParsed.toString();
}
__name(setURLParameter$1, "setURLParameter");
/**
* Set URL host.
*
* @param url - Source URL string
* @param host - New host string
* @returns An updated URL string
*/
function setURLHost(url, host) {
	const urlParsed = new URL(url);
	urlParsed.hostname = host;
	return urlParsed.toString();
}
/**
* Get URL path from an URL string.
*
* @param url - Source URL string
*/
function getURLPath(url) {
	try {
		return new URL(url).pathname;
	} catch (e) {
		return;
	}
}
/**
* Get URL query key value pairs from an URL string.
*
* @param url -
*/
function getURLQueries(url) {
	let queryString = new URL(url).search;
	if (!queryString) return {};
	queryString = queryString.trim();
	queryString = queryString.startsWith("?") ? queryString.substring(1) : queryString;
	let querySubStrings = queryString.split("&");
	querySubStrings = querySubStrings.filter((value) => {
		const indexOfEqual = value.indexOf("=");
		const lastIndexOfEqual = value.lastIndexOf("=");
		return indexOfEqual > 0 && indexOfEqual === lastIndexOfEqual && lastIndexOfEqual < value.length - 1;
	});
	const queries = {};
	for (const querySubString of querySubStrings) {
		const splitResults = querySubString.split("=");
		const key = splitResults[0];
		queries[key] = splitResults[1];
	}
	return queries;
}
/**
* Delay specified time interval.
*
* @param timeInMs -
* @param aborter -
* @param abortError -
*/
async function delay(timeInMs, aborter, abortError) {
	return new Promise((resolve, reject) => {
		let timeout;
		const abortHandler = () => {
			if (timeout !== void 0) clearTimeout(timeout);
			reject(abortError);
		};
		const resolveHandler = () => {
			if (aborter !== void 0) aborter.removeEventListener("abort", abortHandler);
			resolve();
		};
		timeout = setTimeout(resolveHandler, timeInMs);
		if (aborter !== void 0) aborter.addEventListener("abort", abortHandler);
	});
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/utils/SharedKeyComparator.js
var table_lv0 = new Uint32Array([
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	1820,
	0,
	1823,
	1825,
	1827,
	1829,
	0,
	0,
	0,
	1837,
	2051,
	0,
	0,
	1843,
	0,
	3331,
	3354,
	3356,
	3358,
	3360,
	3362,
	3364,
	3366,
	3368,
	3370,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	3586,
	3593,
	3594,
	3610,
	3617,
	3619,
	3621,
	3628,
	3634,
	3637,
	3638,
	3656,
	3665,
	3696,
	3708,
	3710,
	3721,
	3722,
	3729,
	3737,
	3743,
	3746,
	3748,
	3750,
	3751,
	3753,
	0,
	0,
	0,
	1859,
	1860,
	1864,
	3586,
	3593,
	3594,
	3610,
	3617,
	3619,
	3621,
	3628,
	3634,
	3637,
	3638,
	3656,
	3665,
	3696,
	3708,
	3710,
	3721,
	3722,
	3729,
	3737,
	3743,
	3746,
	3748,
	3750,
	3751,
	3753,
	0,
	1868,
	0,
	1872,
	0
]);
var table_lv2 = new Uint32Array([
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	18,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0
]);
var table_lv4 = new Uint32Array([
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	32786,
	0,
	0,
	0,
	0,
	0,
	33298,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0
]);
function compareHeader(lhs, rhs) {
	if (isLessThan(lhs, rhs)) return -1;
	return 1;
}
function isLessThan(lhs, rhs) {
	const tables = [
		table_lv0,
		table_lv2,
		table_lv4
	];
	let curr_level = 0;
	let i = 0;
	let j = 0;
	while (curr_level < tables.length) {
		if (curr_level === tables.length - 1 && i !== j) return i > j;
		const weight1 = i < lhs.length ? tables[curr_level][lhs[i].charCodeAt(0)] : 1;
		const weight2 = j < rhs.length ? tables[curr_level][rhs[j].charCodeAt(0)] : 1;
		if (weight1 === 1 && weight2 === 1) {
			i = 0;
			j = 0;
			++curr_level;
		} else if (weight1 === weight2) {
			++i;
			++j;
		} else if (weight1 === 0) ++i;
		else if (weight2 === 0) ++j;
		else return weight1 < weight2;
	}
	return false;
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/StorageSharedKeyCredentialPolicy.js
/**
* StorageSharedKeyCredentialPolicy is a policy used to sign HTTP request with a shared key.
*/
var StorageSharedKeyCredentialPolicy = class extends CredentialPolicy {
	/**
	* Reference to StorageSharedKeyCredential which generates StorageSharedKeyCredentialPolicy
	*/
	factory;
	/**
	* Creates an instance of StorageSharedKeyCredentialPolicy.
	* @param nextPolicy -
	* @param options -
	* @param factory -
	*/
	constructor(nextPolicy, options, factory) {
		super(nextPolicy, options);
		this.factory = factory;
	}
	/**
	* Signs request.
	*
	* @param request -
	*/
	signRequest(request) {
		request.headers.set(HeaderConstants.X_MS_DATE, (/* @__PURE__ */ new Date()).toUTCString());
		if (request.body && (typeof request.body === "string" || request.body !== void 0) && request.body.length > 0) request.headers.set(HeaderConstants.CONTENT_LENGTH, Buffer.byteLength(request.body));
		const stringToSign = [
			request.method.toUpperCase(),
			this.getHeaderValueToSign(request, HeaderConstants.CONTENT_LANGUAGE),
			this.getHeaderValueToSign(request, HeaderConstants.CONTENT_ENCODING),
			this.getHeaderValueToSign(request, HeaderConstants.CONTENT_LENGTH),
			this.getHeaderValueToSign(request, HeaderConstants.CONTENT_MD5),
			this.getHeaderValueToSign(request, HeaderConstants.CONTENT_TYPE),
			this.getHeaderValueToSign(request, HeaderConstants.DATE),
			this.getHeaderValueToSign(request, HeaderConstants.IF_MODIFIED_SINCE),
			this.getHeaderValueToSign(request, HeaderConstants.IF_MATCH),
			this.getHeaderValueToSign(request, HeaderConstants.IF_NONE_MATCH),
			this.getHeaderValueToSign(request, HeaderConstants.IF_UNMODIFIED_SINCE),
			this.getHeaderValueToSign(request, HeaderConstants.RANGE)
		].join("\n") + "\n" + this.getCanonicalizedHeadersString(request) + this.getCanonicalizedResourceString(request);
		const signature = this.factory.computeHMACSHA256(stringToSign);
		request.headers.set(HeaderConstants.AUTHORIZATION, `SharedKey ${this.factory.accountName}:${signature}`);
		return request;
	}
	/**
	* Retrieve header value according to shared key sign rules.
	* @see https://learn.microsoft.com/rest/api/storageservices/authenticate-with-shared-key
	*
	* @param request -
	* @param headerName -
	*/
	getHeaderValueToSign(request, headerName) {
		const value = request.headers.get(headerName);
		if (!value) return "";
		if (headerName === HeaderConstants.CONTENT_LENGTH && value === "0") return "";
		return value;
	}
	/**
	* To construct the CanonicalizedHeaders portion of the signature string, follow these steps:
	* 1. Retrieve all headers for the resource that begin with x-ms-, including the x-ms-date header.
	* 2. Convert each HTTP header name to lowercase.
	* 3. Sort the headers lexicographically by header name, in ascending order.
	*    Each header may appear only once in the string.
	* 4. Replace any linear whitespace in the header value with a single space.
	* 5. Trim any whitespace around the colon in the header.
	* 6. Finally, append a new-line character to each canonicalized header in the resulting list.
	*    Construct the CanonicalizedHeaders string by concatenating all headers in this list into a single string.
	*
	* @param request -
	*/
	getCanonicalizedHeadersString(request) {
		let headersArray = request.headers.headersArray().filter((value) => {
			return value.name.toLowerCase().startsWith(HeaderConstants.PREFIX_FOR_STORAGE);
		});
		headersArray.sort((a, b) => {
			return compareHeader(a.name.toLowerCase(), b.name.toLowerCase());
		});
		headersArray = headersArray.filter((value, index, array) => {
			if (index > 0 && value.name.toLowerCase() === array[index - 1].name.toLowerCase()) return false;
			return true;
		});
		let canonicalizedHeadersStringToSign = "";
		headersArray.forEach((header) => {
			canonicalizedHeadersStringToSign += `${header.name.toLowerCase().trimRight()}:${header.value.trimLeft()}\n`;
		});
		return canonicalizedHeadersStringToSign;
	}
	/**
	* Retrieves the webResource canonicalized resource string.
	*
	* @param request -
	*/
	getCanonicalizedResourceString(request) {
		const path = getURLPath(request.url) || "/";
		let canonicalizedResourceString = "";
		canonicalizedResourceString += `/${this.factory.accountName}${path}`;
		const queries = getURLQueries(request.url);
		const lowercaseQueries = {};
		if (queries) {
			const queryKeys = [];
			for (const key in queries) if (Object.prototype.hasOwnProperty.call(queries, key)) {
				const lowercaseKey = key.toLowerCase();
				lowercaseQueries[lowercaseKey] = queries[key];
				queryKeys.push(lowercaseKey);
			}
			queryKeys.sort();
			for (const key of queryKeys) canonicalizedResourceString += `\n${key}:${decodeURIComponent(lowercaseQueries[key])}`;
		}
		return canonicalizedResourceString;
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/credentials/StorageSharedKeyCredential.js
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
*
* StorageSharedKeyCredential for account key authorization of Azure Storage service.
*/
var StorageSharedKeyCredential = class extends Credential {
	/**
	* Azure Storage account name; readonly.
	*/
	accountName;
	/**
	* Azure Storage account key; readonly.
	*/
	accountKey;
	/**
	* Creates an instance of StorageSharedKeyCredential.
	* @param accountName -
	* @param accountKey -
	*/
	constructor(accountName, accountKey) {
		super();
		this.accountName = accountName;
		this.accountKey = Buffer.from(accountKey, "base64");
	}
	/**
	* Creates a StorageSharedKeyCredentialPolicy object.
	*
	* @param nextPolicy -
	* @param options -
	*/
	create(nextPolicy, options) {
		return new StorageSharedKeyCredentialPolicy(nextPolicy, options, this);
	}
	/**
	* Generates a hash signature for an HTTP request or for a SAS.
	*
	* @param stringToSign -
	*/
	computeHMACSHA256(stringToSign) {
		return createHmac("sha256", this.accountKey).update(stringToSign, "utf8").digest("base64");
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/log.js
/**
* The `@azure/logger` configuration for this package.
*/
var logger = createClientLogger("storage-common");
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/StorageRetryPolicyType.js
/**
* RetryPolicy types.
*/
var StorageRetryPolicyType;
(function(StorageRetryPolicyType) {
	/**
	* Exponential retry. Retry time delay grows exponentially.
	*/
	StorageRetryPolicyType[StorageRetryPolicyType["EXPONENTIAL"] = 0] = "EXPONENTIAL";
	/**
	* Linear retry. Retry time delay grows linearly.
	*/
	StorageRetryPolicyType[StorageRetryPolicyType["FIXED"] = 1] = "FIXED";
})(StorageRetryPolicyType || (StorageRetryPolicyType = {}));
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/StorageRetryPolicy.js
var DEFAULT_RETRY_OPTIONS$1 = {
	maxRetryDelayInMs: 12e4,
	maxTries: 4,
	retryDelayInMs: 4e3,
	retryPolicyType: StorageRetryPolicyType.EXPONENTIAL,
	secondaryHost: "",
	tryTimeoutInMs: void 0
};
var RETRY_ABORT_ERROR$1 = new AbortError("The operation was aborted.");
/**
* Retry policy with exponential retry and linear retry implemented.
*/
var StorageRetryPolicy = class extends BaseRequestPolicy {
	/**
	* RetryOptions.
	*/
	retryOptions;
	/**
	* Creates an instance of RetryPolicy.
	*
	* @param nextPolicy -
	* @param options -
	* @param retryOptions -
	*/
	constructor(nextPolicy, options, retryOptions = DEFAULT_RETRY_OPTIONS$1) {
		super(nextPolicy, options);
		this.retryOptions = {
			retryPolicyType: retryOptions.retryPolicyType ? retryOptions.retryPolicyType : DEFAULT_RETRY_OPTIONS$1.retryPolicyType,
			maxTries: retryOptions.maxTries && retryOptions.maxTries >= 1 ? Math.floor(retryOptions.maxTries) : DEFAULT_RETRY_OPTIONS$1.maxTries,
			tryTimeoutInMs: retryOptions.tryTimeoutInMs && retryOptions.tryTimeoutInMs >= 0 ? retryOptions.tryTimeoutInMs : DEFAULT_RETRY_OPTIONS$1.tryTimeoutInMs,
			retryDelayInMs: retryOptions.retryDelayInMs && retryOptions.retryDelayInMs >= 0 ? Math.min(retryOptions.retryDelayInMs, retryOptions.maxRetryDelayInMs ? retryOptions.maxRetryDelayInMs : DEFAULT_RETRY_OPTIONS$1.maxRetryDelayInMs) : DEFAULT_RETRY_OPTIONS$1.retryDelayInMs,
			maxRetryDelayInMs: retryOptions.maxRetryDelayInMs && retryOptions.maxRetryDelayInMs >= 0 ? retryOptions.maxRetryDelayInMs : DEFAULT_RETRY_OPTIONS$1.maxRetryDelayInMs,
			secondaryHost: retryOptions.secondaryHost ? retryOptions.secondaryHost : DEFAULT_RETRY_OPTIONS$1.secondaryHost
		};
	}
	/**
	* Sends request.
	*
	* @param request -
	*/
	async sendRequest(request) {
		return this.attemptSendRequest(request, false, 1);
	}
	/**
	* Decide and perform next retry. Won't mutate request parameter.
	*
	* @param request -
	* @param secondaryHas404 -  If attempt was against the secondary & it returned a StatusNotFound (404), then
	*                                   the resource was not found. This may be due to replication delay. So, in this
	*                                   case, we'll never try the secondary again for this operation.
	* @param attempt -           How many retries has been attempted to performed, starting from 1, which includes
	*                                   the attempt will be performed by this method call.
	*/
	async attemptSendRequest(request, secondaryHas404, attempt) {
		const newRequest = request.clone();
		const isPrimaryRetry = secondaryHas404 || !this.retryOptions.secondaryHost || !(request.method === "GET" || request.method === "HEAD" || request.method === "OPTIONS") || attempt % 2 === 1;
		if (!isPrimaryRetry) newRequest.url = setURLHost(newRequest.url, this.retryOptions.secondaryHost);
		if (this.retryOptions.tryTimeoutInMs) newRequest.url = setURLParameter$1(newRequest.url, URLConstants$1.Parameters.TIMEOUT, Math.floor(this.retryOptions.tryTimeoutInMs / 1e3).toString());
		let response;
		try {
			logger.info(`RetryPolicy: =====> Try=${attempt} ${isPrimaryRetry ? "Primary" : "Secondary"}`);
			response = await this._nextPolicy.sendRequest(newRequest);
			if (!this.shouldRetry(isPrimaryRetry, attempt, response)) return response;
			secondaryHas404 = secondaryHas404 || !isPrimaryRetry && response.status === 404;
		} catch (err) {
			logger.error(`RetryPolicy: Caught error, message: ${err.message}, code: ${err.code}`);
			if (!this.shouldRetry(isPrimaryRetry, attempt, response, err)) throw err;
		}
		await this.delay(isPrimaryRetry, attempt, request.abortSignal);
		return this.attemptSendRequest(request, secondaryHas404, ++attempt);
	}
	/**
	* Decide whether to retry according to last HTTP response and retry counters.
	*
	* @param isPrimaryRetry -
	* @param attempt -
	* @param response -
	* @param err -
	*/
	shouldRetry(isPrimaryRetry, attempt, response, err) {
		if (attempt >= this.retryOptions.maxTries) {
			logger.info(`RetryPolicy: Attempt(s) ${attempt} >= maxTries ${this.retryOptions.maxTries}, no further try.`);
			return false;
		}
		const retriableErrors = [
			"ETIMEDOUT",
			"ESOCKETTIMEDOUT",
			"ECONNREFUSED",
			"ECONNRESET",
			"ENOENT",
			"ENOTFOUND",
			"TIMEOUT",
			"EPIPE",
			"REQUEST_SEND_ERROR"
		];
		if (err) {
			for (const retriableError of retriableErrors) if (err.name.toUpperCase().includes(retriableError) || err.message.toUpperCase().includes(retriableError) || err.code && err.code.toString().toUpperCase() === retriableError) {
				logger.info(`RetryPolicy: Network error ${retriableError} found, will retry.`);
				return true;
			}
		}
		if (response || err) {
			const statusCode = response ? response.status : err ? err.statusCode : 0;
			if (!isPrimaryRetry && statusCode === 404) {
				logger.info(`RetryPolicy: Secondary access with 404, will retry.`);
				return true;
			}
			if (statusCode === 503 || statusCode === 500) {
				logger.info(`RetryPolicy: Will retry for status code ${statusCode}.`);
				return true;
			}
		}
		if (response) {
			if (response?.status >= 400) {
				const copySourceError = response.headers.get(HeaderConstants.X_MS_CopySourceErrorCode);
				if (copySourceError !== void 0) switch (copySourceError) {
					case "InternalError":
					case "OperationTimedOut":
					case "ServerBusy": return true;
				}
			}
		}
		if (err?.code === "PARSE_ERROR" && err?.message.startsWith(`Error "Error: Unclosed root tag`)) {
			logger.info("RetryPolicy: Incomplete XML response likely due to service timeout, will retry.");
			return true;
		}
		return false;
	}
	/**
	* Delay a calculated time between retries.
	*
	* @param isPrimaryRetry -
	* @param attempt -
	* @param abortSignal -
	*/
	async delay(isPrimaryRetry, attempt, abortSignal) {
		let delayTimeInMs = 0;
		if (isPrimaryRetry) switch (this.retryOptions.retryPolicyType) {
			case StorageRetryPolicyType.EXPONENTIAL:
				delayTimeInMs = Math.min((Math.pow(2, attempt - 1) - 1) * this.retryOptions.retryDelayInMs, this.retryOptions.maxRetryDelayInMs);
				break;
			case StorageRetryPolicyType.FIXED: delayTimeInMs = this.retryOptions.retryDelayInMs;
		}
		else delayTimeInMs = Math.random() * 1e3;
		logger.info(`RetryPolicy: Delay for ${delayTimeInMs}ms`);
		return delay(delayTimeInMs, abortSignal, RETRY_ABORT_ERROR$1);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/StorageRetryPolicyFactory.js
/**
* StorageRetryPolicyFactory is a factory class helping generating {@link StorageRetryPolicy} objects.
*/
var StorageRetryPolicyFactory = class {
	retryOptions;
	/**
	* Creates an instance of StorageRetryPolicyFactory.
	* @param retryOptions -
	*/
	constructor(retryOptions) {
		this.retryOptions = retryOptions;
	}
	/**
	* Creates a StorageRetryPolicy object.
	*
	* @param nextPolicy -
	* @param options -
	*/
	create(nextPolicy, options) {
		return new StorageRetryPolicy(nextPolicy, options, this.retryOptions);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/StorageBrowserPolicyV2.js
/**
* The programmatic identifier of the StorageBrowserPolicy.
*/
var storageBrowserPolicyName = "storageBrowserPolicy";
/**
* storageBrowserPolicy is a policy used to prevent browsers from caching requests
* and to remove cookies and explicit content-length headers.
*
* In Node.js, this policy is a no-op pass-through.
*/
function storageBrowserPolicy() {
	return {
		name: storageBrowserPolicyName,
		async sendRequest(request, next) {
			return next(request);
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/StorageCorrectContentLengthPolicy.js
/**
* The programmatic identifier of the storageCorrectContentLengthPolicy.
*/
var storageCorrectContentLengthPolicyName = "StorageCorrectContentLengthPolicy";
/**
* storageCorrectContentLengthPolicy to correctly set Content-Length header with request body length.
*/
function storageCorrectContentLengthPolicy() {
	function correctContentLength(request) {
		if (request.body && (typeof request.body === "string" || Buffer.isBuffer(request.body)) && request.body.length > 0) request.headers.set(HeaderConstants.CONTENT_LENGTH, Buffer.byteLength(request.body));
	}
	return {
		name: storageCorrectContentLengthPolicyName,
		async sendRequest(request, next) {
			correctContentLength(request);
			return next(request);
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/StorageRetryPolicyV2.js
/**
* Name of the {@link storageRetryPolicy}
*/
var storageRetryPolicyName = "storageRetryPolicy";
var DEFAULT_RETRY_OPTIONS = {
	maxRetryDelayInMs: 12e4,
	maxTries: 4,
	retryDelayInMs: 4e3,
	retryPolicyType: StorageRetryPolicyType.EXPONENTIAL,
	secondaryHost: "",
	tryTimeoutInMs: void 0
};
var retriableErrors = [
	"ETIMEDOUT",
	"ESOCKETTIMEDOUT",
	"ECONNREFUSED",
	"ECONNRESET",
	"ENOENT",
	"ENOTFOUND",
	"TIMEOUT",
	"EPIPE",
	"REQUEST_SEND_ERROR"
];
var RETRY_ABORT_ERROR = new AbortError("The operation was aborted.");
/**
* Retry policy with exponential retry and linear retry implemented.
*/
function storageRetryPolicy(options = {}) {
	const retryPolicyType = options.retryPolicyType ?? DEFAULT_RETRY_OPTIONS.retryPolicyType;
	const maxTries = options.maxTries ?? DEFAULT_RETRY_OPTIONS.maxTries;
	const retryDelayInMs = options.retryDelayInMs ?? DEFAULT_RETRY_OPTIONS.retryDelayInMs;
	const maxRetryDelayInMs = options.maxRetryDelayInMs ?? DEFAULT_RETRY_OPTIONS.maxRetryDelayInMs;
	const secondaryHost = options.secondaryHost ?? DEFAULT_RETRY_OPTIONS.secondaryHost;
	const tryTimeoutInMs = options.tryTimeoutInMs ?? DEFAULT_RETRY_OPTIONS.tryTimeoutInMs;
	function shouldRetry({ isPrimaryRetry, attempt, response, error }) {
		if (attempt >= maxTries) {
			logger.info(`RetryPolicy: Attempt(s) ${attempt} >= maxTries ${maxTries}, no further try.`);
			return false;
		}
		if (error) {
			for (const retriableError of retriableErrors) if (error.name.toUpperCase().includes(retriableError) || error.message.toUpperCase().includes(retriableError) || error.code && error.code.toString().toUpperCase() === retriableError) {
				logger.info(`RetryPolicy: Network error ${retriableError} found, will retry.`);
				return true;
			}
			if (error?.code === "PARSE_ERROR" && error?.message.startsWith(`Error "Error: Unclosed root tag`)) {
				logger.info("RetryPolicy: Incomplete XML response likely due to service timeout, will retry.");
				return true;
			}
		}
		if (response || error) {
			const statusCode = response?.status ?? error?.statusCode ?? 0;
			if (!isPrimaryRetry && statusCode === 404) {
				logger.info(`RetryPolicy: Secondary access with 404, will retry.`);
				return true;
			}
			if (statusCode === 503 || statusCode === 500) {
				logger.info(`RetryPolicy: Will retry for status code ${statusCode}.`);
				return true;
			}
		}
		if (response) {
			if (response?.status >= 400) {
				const copySourceError = response.headers.get(HeaderConstants.X_MS_CopySourceErrorCode);
				if (copySourceError !== void 0) switch (copySourceError) {
					case "InternalError":
					case "OperationTimedOut":
					case "ServerBusy": return true;
				}
			}
		}
		return false;
	}
	function calculateDelay(isPrimaryRetry, attempt) {
		let delayTimeInMs = 0;
		if (isPrimaryRetry) switch (retryPolicyType) {
			case StorageRetryPolicyType.EXPONENTIAL:
				delayTimeInMs = Math.min((Math.pow(2, attempt - 1) - 1) * retryDelayInMs, maxRetryDelayInMs);
				break;
			case StorageRetryPolicyType.FIXED: delayTimeInMs = retryDelayInMs;
		}
		else delayTimeInMs = Math.random() * 1e3;
		logger.info(`RetryPolicy: Delay for ${delayTimeInMs}ms`);
		return delayTimeInMs;
	}
	return {
		name: storageRetryPolicyName,
		async sendRequest(request, next) {
			if (tryTimeoutInMs) request.url = setURLParameter$1(request.url, URLConstants$1.Parameters.TIMEOUT, String(Math.floor(tryTimeoutInMs / 1e3)));
			const primaryUrl = request.url;
			const secondaryUrl = secondaryHost ? setURLHost(request.url, secondaryHost) : void 0;
			let secondaryHas404 = false;
			let attempt = 1;
			let retryAgain = true;
			let response;
			let error;
			while (retryAgain) {
				const isPrimaryRetry = secondaryHas404 || !secondaryUrl || ![
					"GET",
					"HEAD",
					"OPTIONS"
				].includes(request.method) || attempt % 2 === 1;
				request.url = isPrimaryRetry ? primaryUrl : secondaryUrl;
				response = void 0;
				error = void 0;
				try {
					logger.info(`RetryPolicy: =====> Try=${attempt} ${isPrimaryRetry ? "Primary" : "Secondary"}`);
					response = await next(request);
					secondaryHas404 = secondaryHas404 || !isPrimaryRetry && response.status === 404;
				} catch (e) {
					if (isRestError(e)) {
						logger.error(`RetryPolicy: Caught error, message: ${e.message}, code: ${e.code}`);
						error = e;
					} else {
						logger.error(`RetryPolicy: Caught error, message: ${getErrorMessage(e)}`);
						throw e;
					}
				}
				retryAgain = shouldRetry({
					isPrimaryRetry,
					attempt,
					response,
					error
				});
				if (retryAgain) await delay(calculateDelay(isPrimaryRetry, attempt), request.abortSignal, RETRY_ABORT_ERROR);
				attempt++;
			}
			if (response) return response;
			throw error ?? new RestError("RetryPolicy failed without known error.");
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/StorageSharedKeyCredentialPolicyV2.js
/**
* The programmatic identifier of the storageSharedKeyCredentialPolicy.
*/
var storageSharedKeyCredentialPolicyName = "storageSharedKeyCredentialPolicy";
/**
* storageSharedKeyCredentialPolicy handles signing requests using storage account keys.
*/
function storageSharedKeyCredentialPolicy(options) {
	function signRequest(request) {
		request.headers.set(HeaderConstants.X_MS_DATE, (/* @__PURE__ */ new Date()).toUTCString());
		if (request.body && (typeof request.body === "string" || Buffer.isBuffer(request.body)) && request.body.length > 0) request.headers.set(HeaderConstants.CONTENT_LENGTH, Buffer.byteLength(request.body));
		const stringToSign = [
			request.method.toUpperCase(),
			getHeaderValueToSign(request, HeaderConstants.CONTENT_LANGUAGE),
			getHeaderValueToSign(request, HeaderConstants.CONTENT_ENCODING),
			getHeaderValueToSign(request, HeaderConstants.CONTENT_LENGTH),
			getHeaderValueToSign(request, HeaderConstants.CONTENT_MD5),
			getHeaderValueToSign(request, HeaderConstants.CONTENT_TYPE),
			getHeaderValueToSign(request, HeaderConstants.DATE),
			getHeaderValueToSign(request, HeaderConstants.IF_MODIFIED_SINCE),
			getHeaderValueToSign(request, HeaderConstants.IF_MATCH),
			getHeaderValueToSign(request, HeaderConstants.IF_NONE_MATCH),
			getHeaderValueToSign(request, HeaderConstants.IF_UNMODIFIED_SINCE),
			getHeaderValueToSign(request, HeaderConstants.RANGE)
		].join("\n") + "\n" + getCanonicalizedHeadersString(request) + getCanonicalizedResourceString(request);
		const signature = createHmac("sha256", options.accountKey).update(stringToSign, "utf8").digest("base64");
		request.headers.set(HeaderConstants.AUTHORIZATION, `SharedKey ${options.accountName}:${signature}`);
	}
	/**
	* Retrieve header value according to shared key sign rules.
	* @see https://learn.microsoft.com/rest/api/storageservices/authenticate-with-shared-key
	*/
	function getHeaderValueToSign(request, headerName) {
		const value = request.headers.get(headerName);
		if (!value) return "";
		if (headerName === HeaderConstants.CONTENT_LENGTH && value === "0") return "";
		return value;
	}
	/**
	* To construct the CanonicalizedHeaders portion of the signature string, follow these steps:
	* 1. Retrieve all headers for the resource that begin with x-ms-, including the x-ms-date header.
	* 2. Convert each HTTP header name to lowercase.
	* 3. Sort the headers lexicographically by header name, in ascending order.
	*    Each header may appear only once in the string.
	* 4. Replace any linear whitespace in the header value with a single space.
	* 5. Trim any whitespace around the colon in the header.
	* 6. Finally, append a new-line character to each canonicalized header in the resulting list.
	*    Construct the CanonicalizedHeaders string by concatenating all headers in this list into a single string.
	*
	*/
	function getCanonicalizedHeadersString(request) {
		let headersArray = [];
		for (const [name, value] of request.headers) if (name.toLowerCase().startsWith(HeaderConstants.PREFIX_FOR_STORAGE)) headersArray.push({
			name,
			value
		});
		headersArray.sort((a, b) => {
			return compareHeader(a.name.toLowerCase(), b.name.toLowerCase());
		});
		headersArray = headersArray.filter((value, index, array) => {
			if (index > 0 && value.name.toLowerCase() === array[index - 1].name.toLowerCase()) return false;
			return true;
		});
		let canonicalizedHeadersStringToSign = "";
		headersArray.forEach((header) => {
			canonicalizedHeadersStringToSign += `${header.name.toLowerCase().trimRight()}:${header.value.trimLeft()}\n`;
		});
		return canonicalizedHeadersStringToSign;
	}
	function getCanonicalizedResourceString(request) {
		const path = getURLPath(request.url) || "/";
		let canonicalizedResourceString = "";
		canonicalizedResourceString += `/${options.accountName}${path}`;
		const queries = getURLQueries(request.url);
		const lowercaseQueries = {};
		if (queries) {
			const queryKeys = [];
			for (const key in queries) if (Object.prototype.hasOwnProperty.call(queries, key)) {
				const lowercaseKey = key.toLowerCase();
				lowercaseQueries[lowercaseKey] = queries[key];
				queryKeys.push(lowercaseKey);
			}
			queryKeys.sort();
			for (const key of queryKeys) canonicalizedResourceString += `\n${key}:${decodeURIComponent(lowercaseQueries[key])}`;
		}
		return canonicalizedResourceString;
	}
	return {
		name: storageSharedKeyCredentialPolicyName,
		async sendRequest(request, next) {
			signRequest(request);
			return next(request);
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/policies/StorageRequestFailureDetailsParserPolicy.js
/**
* The programmatic identifier of the StorageRequestFailureDetailsParserPolicy.
*/
var storageRequestFailureDetailsParserPolicyName = "storageRequestFailureDetailsParserPolicy";
/**
* StorageRequestFailureDetailsParserPolicy
*/
function storageRequestFailureDetailsParserPolicy() {
	return {
		name: storageRequestFailureDetailsParserPolicyName,
		async sendRequest(request, next) {
			try {
				const response = await next(request);
				if (response.status === 400 && response.bodyAsText?.includes("<Error><Code>InvalidHeaderValue</Code>") && response.bodyAsText.includes("<HeaderName>x-ms-version</HeaderName>")) response.bodyAsText = response.bodyAsText.replace(/<Message>.*<\/Message>/s, "<Message>The provided service version is not enabled on this storage account. Please see https://learn.microsoft.com/rest/api/storageservices/versioning-for-the-azure-storage-services for additional information.</Message>");
				return response;
			} catch (err) {
				if (typeof err === "object" && err !== null && err.response && err.response.parsedBody) {
					if (err.response.parsedBody.code === "InvalidHeaderValue" && err.response.parsedBody.HeaderName === "x-ms-version") err.message = "The provided service version is not enabled on this storage account. Please see https://learn.microsoft.com/rest/api/storageservices/versioning-for-the-azure-storage-services for additional information.\n";
				}
				throw err;
			}
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-common@12.5.0_@azure+core-client@1.11.0_supports-color@7.2.0__supports-color@7.2.0/node_modules/@azure/storage-common/dist/esm/credentials/UserDelegationKeyCredential.js
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
*
* UserDelegationKeyCredential is only used for generation of user delegation SAS.
* @see https://learn.microsoft.com/rest/api/storageservices/create-user-delegation-sas
*/
var UserDelegationKeyCredential = class {
	/**
	* Azure Storage account name; readonly.
	*/
	accountName;
	/**
	* Azure Storage user delegation key; readonly.
	*/
	userDelegationKey;
	/**
	* Key value in Buffer type.
	*/
	key;
	/**
	* Creates an instance of UserDelegationKeyCredential.
	* @param accountName -
	* @param userDelegationKey -
	*/
	constructor(accountName, userDelegationKey) {
		this.accountName = accountName;
		this.userDelegationKey = userDelegationKey;
		this.key = Buffer.from(userDelegationKey.value, "base64");
	}
	/**
	* Generates a hash signature for an HTTP request or for a SAS.
	*
	* @param stringToSign -
	*/
	computeHMACSHA256(stringToSign) {
		return createHmac("sha256", this.key).update(stringToSign, "utf8").digest("base64");
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/utils/constants.js
var SDK_VERSION = "12.33.0";
var SERVICE_VERSION = "2026-06-06";
var BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES = 268435456;
var BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES = 4194304e3;
var BLOCK_BLOB_MAX_BLOCKS = 5e4;
var DEFAULT_BLOCK_BUFFER_SIZE_BYTES = 8388608;
var DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES = 4194304;
var REQUEST_TIMEOUT = 1e5;
var URLConstants = { Parameters: {
	FORCE_BROWSER_NO_CACHE: "_",
	SIGNATURE: "sig",
	SNAPSHOT: "snapshot",
	VERSIONID: "versionid",
	TIMEOUT: "timeout"
} };
var EncryptionAlgorithmAES25 = "AES256";
var DevelopmentConnectionString = `DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://127.0.0.1:10000/devstoreaccount1;`;
var StorageBlobLoggingAllowedHeaderNames = [
	"Access-Control-Allow-Origin",
	"Cache-Control",
	"Content-Length",
	"Content-Type",
	"Date",
	"Request-Id",
	"traceparent",
	"Transfer-Encoding",
	"User-Agent",
	"x-ms-client-request-id",
	"x-ms-date",
	"x-ms-error-code",
	"x-ms-request-id",
	"x-ms-return-client-request-id",
	"x-ms-version",
	"Accept-Ranges",
	"Content-Disposition",
	"Content-Encoding",
	"Content-Language",
	"Content-MD5",
	"Content-Range",
	"ETag",
	"Last-Modified",
	"Server",
	"Vary",
	"x-ms-content-crc64",
	"x-ms-copy-action",
	"x-ms-copy-completion-time",
	"x-ms-copy-id",
	"x-ms-copy-progress",
	"x-ms-copy-status",
	"x-ms-has-immutability-policy",
	"x-ms-has-legal-hold",
	"x-ms-lease-state",
	"x-ms-lease-status",
	"x-ms-range",
	"x-ms-request-server-encrypted",
	"x-ms-server-encrypted",
	"x-ms-snapshot",
	"x-ms-source-range",
	"If-Match",
	"If-Modified-Since",
	"If-None-Match",
	"If-Unmodified-Since",
	"x-ms-access-tier",
	"x-ms-access-tier-change-time",
	"x-ms-access-tier-inferred",
	"x-ms-account-kind",
	"x-ms-archive-status",
	"x-ms-blob-append-offset",
	"x-ms-blob-cache-control",
	"x-ms-blob-committed-block-count",
	"x-ms-blob-condition-appendpos",
	"x-ms-blob-condition-maxsize",
	"x-ms-blob-content-disposition",
	"x-ms-blob-content-encoding",
	"x-ms-blob-content-language",
	"x-ms-blob-content-length",
	"x-ms-blob-content-md5",
	"x-ms-blob-content-type",
	"x-ms-blob-public-access",
	"x-ms-blob-sequence-number",
	"x-ms-blob-type",
	"x-ms-copy-destination-snapshot",
	"x-ms-creation-time",
	"x-ms-default-encryption-scope",
	"x-ms-delete-snapshots",
	"x-ms-delete-type-permanent",
	"x-ms-deny-encryption-scope-override",
	"x-ms-encryption-algorithm",
	"x-ms-if-sequence-number-eq",
	"x-ms-if-sequence-number-le",
	"x-ms-if-sequence-number-lt",
	"x-ms-incremental-copy",
	"x-ms-lease-action",
	"x-ms-lease-break-period",
	"x-ms-lease-duration",
	"x-ms-lease-id",
	"x-ms-lease-time",
	"x-ms-page-write",
	"x-ms-proposed-lease-id",
	"x-ms-range-get-content-md5",
	"x-ms-rehydrate-priority",
	"x-ms-sequence-number-action",
	"x-ms-sku-name",
	"x-ms-source-content-md5",
	"x-ms-source-if-match",
	"x-ms-source-if-modified-since",
	"x-ms-source-if-none-match",
	"x-ms-source-if-unmodified-since",
	"x-ms-tag-count",
	"x-ms-encryption-key-sha256",
	"x-ms-copy-source-error-code",
	"x-ms-copy-source-status-code",
	"x-ms-if-tags",
	"x-ms-source-if-tags"
];
var StorageBlobLoggingAllowedQueryParameters = [
	"comp",
	"maxresults",
	"rscc",
	"rscd",
	"rsce",
	"rscl",
	"rsct",
	"se",
	"si",
	"sip",
	"sp",
	"spr",
	"sr",
	"srt",
	"ss",
	"st",
	"sv",
	"include",
	"marker",
	"prefix",
	"copyid",
	"restype",
	"blockid",
	"blocklisttype",
	"delimiter",
	"prevsnapshot",
	"ske",
	"skoid",
	"sks",
	"skt",
	"sktid",
	"skv",
	"snapshot"
];
var PathStylePorts = [
	"10000",
	"10001",
	"10002",
	"10003",
	"10004",
	"10100",
	"10101",
	"10102",
	"10103",
	"10104",
	"11000",
	"11001",
	"11002",
	"11003",
	"11004",
	"11100",
	"11101",
	"11102",
	"11103",
	"11104"
];
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/Pipeline.js
/**
* A helper to decide if a given argument satisfies the Pipeline contract
* @param pipeline - An argument that may be a Pipeline
* @returns true when the argument satisfies the Pipeline contract
*/
function isPipelineLike(pipeline) {
	if (!pipeline || typeof pipeline !== "object") return false;
	const castPipeline = pipeline;
	return Array.isArray(castPipeline.factories) && typeof castPipeline.options === "object" && typeof castPipeline.toServiceClientOptions === "function";
}
/**
* A Pipeline class containing HTTP request policies.
* You can create a default Pipeline by calling {@link newPipeline}.
* Or you can create a Pipeline with your own policies by the constructor of Pipeline.
*
* Refer to {@link newPipeline} and provided policies before implementing your
* customized Pipeline.
*/
var Pipeline = class {
	/**
	* A list of chained request policy factories.
	*/
	factories;
	/**
	* Configures pipeline logger and HTTP client.
	*/
	options;
	/**
	* Creates an instance of Pipeline. Customize HTTPClient by implementing IHttpClient interface.
	*
	* @param factories -
	* @param options -
	*/
	constructor(factories, options = {}) {
		this.factories = factories;
		this.options = options;
	}
	/**
	* Transfer Pipeline object to ServiceClientOptions object which is required by
	* ServiceClient constructor.
	*
	* @returns The ServiceClientOptions object from this Pipeline.
	*/
	toServiceClientOptions() {
		return {
			httpClient: this.options.httpClient,
			requestPolicyFactories: this.factories
		};
	}
};
/**
* Creates a new Pipeline object with Credential provided.
*
* @param credential -  Such as AnonymousCredential, StorageSharedKeyCredential or any credential from the `@azure/identity` package to authenticate requests to the service. You can also provide an object that implements the TokenCredential interface. If not specified, AnonymousCredential is used.
* @param pipelineOptions - Optional. Options.
* @returns A new Pipeline object.
*/
function newPipeline(credential, pipelineOptions = {}) {
	if (!credential) credential = new AnonymousCredential();
	const pipeline = new Pipeline([], pipelineOptions);
	pipeline._credential = credential;
	return pipeline;
}
function processDownlevelPipeline(pipeline) {
	const knownFactoryFunctions = [
		isAnonymousCredential,
		isStorageSharedKeyCredential,
		isCoreHttpBearerTokenFactory,
		isStorageBrowserPolicyFactory,
		isStorageRetryPolicyFactory,
		isStorageTelemetryPolicyFactory,
		isCoreHttpPolicyFactory
	];
	if (pipeline.factories.length) {
		const novelFactories = pipeline.factories.filter((factory) => {
			return !knownFactoryFunctions.some((knownFactory) => knownFactory(factory));
		});
		if (novelFactories.length) {
			const hasInjector = novelFactories.some((factory) => isInjectorPolicyFactory(factory));
			return {
				wrappedPolicies: createRequestPolicyFactoryPolicy(novelFactories),
				afterRetry: hasInjector
			};
		}
	}
}
function getCoreClientOptions(pipeline) {
	const { httpClient: v1Client, ...restOptions } = pipeline.options;
	let httpClient = pipeline._coreHttpClient;
	if (!httpClient) {
		httpClient = v1Client ? convertHttpClient(v1Client) : getCachedDefaultHttpClient();
		pipeline._coreHttpClient = httpClient;
	}
	let corePipeline = pipeline._corePipeline;
	if (!corePipeline) {
		const packageDetails = `azsdk-js-azure-storage-blob/${SDK_VERSION}`;
		const userAgentPrefix = restOptions.userAgentOptions && restOptions.userAgentOptions.userAgentPrefix ? `${restOptions.userAgentOptions.userAgentPrefix} ${packageDetails}` : `${packageDetails}`;
		corePipeline = createClientPipeline({
			...restOptions,
			loggingOptions: {
				additionalAllowedHeaderNames: StorageBlobLoggingAllowedHeaderNames,
				additionalAllowedQueryParameters: StorageBlobLoggingAllowedQueryParameters,
				logger: logger$1.info
			},
			userAgentOptions: { userAgentPrefix },
			serializationOptions: {
				stringifyXML,
				serializerOptions: { xml: { xmlCharKey: "#" } }
			},
			deserializationOptions: {
				parseXML,
				serializerOptions: { xml: { xmlCharKey: "#" } }
			}
		});
		corePipeline.removePolicy({ phase: "Retry" });
		corePipeline.removePolicy({ name: decompressResponsePolicyName });
		corePipeline.addPolicy(storageCorrectContentLengthPolicy());
		corePipeline.addPolicy(storageRetryPolicy(restOptions.retryOptions), { phase: "Retry" });
		corePipeline.addPolicy(storageRequestFailureDetailsParserPolicy());
		corePipeline.addPolicy(storageBrowserPolicy());
		const downlevelResults = processDownlevelPipeline(pipeline);
		if (downlevelResults) corePipeline.addPolicy(downlevelResults.wrappedPolicies, downlevelResults.afterRetry ? { afterPhase: "Retry" } : void 0);
		const credential = getCredentialFromPipeline(pipeline);
		if (isTokenCredential(credential)) corePipeline.addPolicy(bearerTokenAuthenticationPolicy({
			credential,
			scopes: restOptions.audience ?? "https://storage.azure.com/.default",
			challengeCallbacks: { authorizeRequestOnChallenge: authorizeRequestOnTenantChallenge }
		}), { phase: "Sign" });
		else if (credential instanceof StorageSharedKeyCredential) corePipeline.addPolicy(storageSharedKeyCredentialPolicy({
			accountName: credential.accountName,
			accountKey: credential.accountKey
		}), { phase: "Sign" });
		pipeline._corePipeline = corePipeline;
	}
	return {
		...restOptions,
		allowInsecureConnection: true,
		httpClient,
		pipeline: corePipeline
	};
}
function getCredentialFromPipeline(pipeline) {
	if (pipeline._credential) return pipeline._credential;
	let credential = new AnonymousCredential();
	for (const factory of pipeline.factories) if (isTokenCredential(factory.credential)) credential = factory.credential;
	else if (isStorageSharedKeyCredential(factory)) return factory;
	return credential;
}
function isStorageSharedKeyCredential(factory) {
	if (factory instanceof StorageSharedKeyCredential) return true;
	return factory.constructor.name === "StorageSharedKeyCredential";
}
function isAnonymousCredential(factory) {
	if (factory instanceof AnonymousCredential) return true;
	return factory.constructor.name === "AnonymousCredential";
}
function isCoreHttpBearerTokenFactory(factory) {
	return isTokenCredential(factory.credential);
}
function isStorageBrowserPolicyFactory(factory) {
	if (factory instanceof StorageBrowserPolicyFactory) return true;
	return factory.constructor.name === "StorageBrowserPolicyFactory";
}
function isStorageRetryPolicyFactory(factory) {
	if (factory instanceof StorageRetryPolicyFactory) return true;
	return factory.constructor.name === "StorageRetryPolicyFactory";
}
function isStorageTelemetryPolicyFactory(factory) {
	return factory.constructor.name === "TelemetryPolicyFactory";
}
function isInjectorPolicyFactory(factory) {
	return factory.constructor.name === "InjectorPolicyFactory";
}
function isCoreHttpPolicyFactory(factory) {
	const knownPolicies = [
		"GenerateClientRequestIdPolicy",
		"TracingPolicy",
		"LogPolicy",
		"ProxyPolicy",
		"DisableResponseDecompressionPolicy",
		"KeepAlivePolicy",
		"DeserializationPolicy"
	];
	const policyName = factory.create({ sendRequest: async (request) => {
		return {
			request,
			headers: request.headers.clone(),
			status: 500
		};
	} }, {
		log(_logLevel, _message) {},
		shouldLog(_logLevel) {
			return false;
		}
	}).constructor.name;
	return knownPolicies.some((knownPolicyName) => {
		return policyName.startsWith(knownPolicyName);
	});
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/generated/src/models/mappers.js
var mappers_exports = /* @__PURE__ */ __exportAll({
	AccessPolicy: () => AccessPolicy,
	AppendBlobAppendBlockExceptionHeaders: () => AppendBlobAppendBlockExceptionHeaders,
	AppendBlobAppendBlockFromUrlExceptionHeaders: () => AppendBlobAppendBlockFromUrlExceptionHeaders,
	AppendBlobAppendBlockFromUrlHeaders: () => AppendBlobAppendBlockFromUrlHeaders,
	AppendBlobAppendBlockHeaders: () => AppendBlobAppendBlockHeaders,
	AppendBlobCreateExceptionHeaders: () => AppendBlobCreateExceptionHeaders,
	AppendBlobCreateHeaders: () => AppendBlobCreateHeaders,
	AppendBlobSealExceptionHeaders: () => AppendBlobSealExceptionHeaders,
	AppendBlobSealHeaders: () => AppendBlobSealHeaders,
	ArrowConfiguration: () => ArrowConfiguration,
	ArrowField: () => ArrowField,
	BlobAbortCopyFromURLExceptionHeaders: () => BlobAbortCopyFromURLExceptionHeaders,
	BlobAbortCopyFromURLHeaders: () => BlobAbortCopyFromURLHeaders,
	BlobAcquireLeaseExceptionHeaders: () => BlobAcquireLeaseExceptionHeaders,
	BlobAcquireLeaseHeaders: () => BlobAcquireLeaseHeaders,
	BlobBreakLeaseExceptionHeaders: () => BlobBreakLeaseExceptionHeaders,
	BlobBreakLeaseHeaders: () => BlobBreakLeaseHeaders,
	BlobChangeLeaseExceptionHeaders: () => BlobChangeLeaseExceptionHeaders,
	BlobChangeLeaseHeaders: () => BlobChangeLeaseHeaders,
	BlobCopyFromURLExceptionHeaders: () => BlobCopyFromURLExceptionHeaders,
	BlobCopyFromURLHeaders: () => BlobCopyFromURLHeaders,
	BlobCreateSnapshotExceptionHeaders: () => BlobCreateSnapshotExceptionHeaders,
	BlobCreateSnapshotHeaders: () => BlobCreateSnapshotHeaders,
	BlobDeleteExceptionHeaders: () => BlobDeleteExceptionHeaders,
	BlobDeleteHeaders: () => BlobDeleteHeaders,
	BlobDeleteImmutabilityPolicyExceptionHeaders: () => BlobDeleteImmutabilityPolicyExceptionHeaders,
	BlobDeleteImmutabilityPolicyHeaders: () => BlobDeleteImmutabilityPolicyHeaders,
	BlobDownloadExceptionHeaders: () => BlobDownloadExceptionHeaders,
	BlobDownloadHeaders: () => BlobDownloadHeaders,
	BlobFlatListSegment: () => BlobFlatListSegment,
	BlobGetAccountInfoExceptionHeaders: () => BlobGetAccountInfoExceptionHeaders,
	BlobGetAccountInfoHeaders: () => BlobGetAccountInfoHeaders,
	BlobGetPropertiesExceptionHeaders: () => BlobGetPropertiesExceptionHeaders,
	BlobGetPropertiesHeaders: () => BlobGetPropertiesHeaders,
	BlobGetTagsExceptionHeaders: () => BlobGetTagsExceptionHeaders,
	BlobGetTagsHeaders: () => BlobGetTagsHeaders,
	BlobHierarchyListSegment: () => BlobHierarchyListSegment,
	BlobItemInternal: () => BlobItemInternal,
	BlobName: () => BlobName,
	BlobPrefix: () => BlobPrefix,
	BlobPropertiesInternal: () => BlobPropertiesInternal,
	BlobQueryExceptionHeaders: () => BlobQueryExceptionHeaders,
	BlobQueryHeaders: () => BlobQueryHeaders,
	BlobReleaseLeaseExceptionHeaders: () => BlobReleaseLeaseExceptionHeaders,
	BlobReleaseLeaseHeaders: () => BlobReleaseLeaseHeaders,
	BlobRenewLeaseExceptionHeaders: () => BlobRenewLeaseExceptionHeaders,
	BlobRenewLeaseHeaders: () => BlobRenewLeaseHeaders,
	BlobServiceProperties: () => BlobServiceProperties,
	BlobServiceStatistics: () => BlobServiceStatistics,
	BlobSetExpiryExceptionHeaders: () => BlobSetExpiryExceptionHeaders,
	BlobSetExpiryHeaders: () => BlobSetExpiryHeaders,
	BlobSetHttpHeadersExceptionHeaders: () => BlobSetHttpHeadersExceptionHeaders,
	BlobSetHttpHeadersHeaders: () => BlobSetHttpHeadersHeaders,
	BlobSetImmutabilityPolicyExceptionHeaders: () => BlobSetImmutabilityPolicyExceptionHeaders,
	BlobSetImmutabilityPolicyHeaders: () => BlobSetImmutabilityPolicyHeaders,
	BlobSetLegalHoldExceptionHeaders: () => BlobSetLegalHoldExceptionHeaders,
	BlobSetLegalHoldHeaders: () => BlobSetLegalHoldHeaders,
	BlobSetMetadataExceptionHeaders: () => BlobSetMetadataExceptionHeaders,
	BlobSetMetadataHeaders: () => BlobSetMetadataHeaders,
	BlobSetTagsExceptionHeaders: () => BlobSetTagsExceptionHeaders,
	BlobSetTagsHeaders: () => BlobSetTagsHeaders,
	BlobSetTierExceptionHeaders: () => BlobSetTierExceptionHeaders,
	BlobSetTierHeaders: () => BlobSetTierHeaders,
	BlobStartCopyFromURLExceptionHeaders: () => BlobStartCopyFromURLExceptionHeaders,
	BlobStartCopyFromURLHeaders: () => BlobStartCopyFromURLHeaders,
	BlobTag: () => BlobTag,
	BlobTags: () => BlobTags,
	BlobUndeleteExceptionHeaders: () => BlobUndeleteExceptionHeaders,
	BlobUndeleteHeaders: () => BlobUndeleteHeaders,
	Block: () => Block,
	BlockBlobCommitBlockListExceptionHeaders: () => BlockBlobCommitBlockListExceptionHeaders,
	BlockBlobCommitBlockListHeaders: () => BlockBlobCommitBlockListHeaders,
	BlockBlobGetBlockListExceptionHeaders: () => BlockBlobGetBlockListExceptionHeaders,
	BlockBlobGetBlockListHeaders: () => BlockBlobGetBlockListHeaders,
	BlockBlobPutBlobFromUrlExceptionHeaders: () => BlockBlobPutBlobFromUrlExceptionHeaders,
	BlockBlobPutBlobFromUrlHeaders: () => BlockBlobPutBlobFromUrlHeaders,
	BlockBlobStageBlockExceptionHeaders: () => BlockBlobStageBlockExceptionHeaders,
	BlockBlobStageBlockFromURLExceptionHeaders: () => BlockBlobStageBlockFromURLExceptionHeaders,
	BlockBlobStageBlockFromURLHeaders: () => BlockBlobStageBlockFromURLHeaders,
	BlockBlobStageBlockHeaders: () => BlockBlobStageBlockHeaders,
	BlockBlobUploadExceptionHeaders: () => BlockBlobUploadExceptionHeaders,
	BlockBlobUploadHeaders: () => BlockBlobUploadHeaders,
	BlockList: () => BlockList,
	BlockLookupList: () => BlockLookupList,
	ClearRange: () => ClearRange,
	ContainerAcquireLeaseExceptionHeaders: () => ContainerAcquireLeaseExceptionHeaders,
	ContainerAcquireLeaseHeaders: () => ContainerAcquireLeaseHeaders,
	ContainerBreakLeaseExceptionHeaders: () => ContainerBreakLeaseExceptionHeaders,
	ContainerBreakLeaseHeaders: () => ContainerBreakLeaseHeaders,
	ContainerChangeLeaseExceptionHeaders: () => ContainerChangeLeaseExceptionHeaders,
	ContainerChangeLeaseHeaders: () => ContainerChangeLeaseHeaders,
	ContainerCreateExceptionHeaders: () => ContainerCreateExceptionHeaders,
	ContainerCreateHeaders: () => ContainerCreateHeaders,
	ContainerDeleteExceptionHeaders: () => ContainerDeleteExceptionHeaders,
	ContainerDeleteHeaders: () => ContainerDeleteHeaders,
	ContainerFilterBlobsExceptionHeaders: () => ContainerFilterBlobsExceptionHeaders,
	ContainerFilterBlobsHeaders: () => ContainerFilterBlobsHeaders,
	ContainerGetAccessPolicyExceptionHeaders: () => ContainerGetAccessPolicyExceptionHeaders,
	ContainerGetAccessPolicyHeaders: () => ContainerGetAccessPolicyHeaders,
	ContainerGetAccountInfoExceptionHeaders: () => ContainerGetAccountInfoExceptionHeaders,
	ContainerGetAccountInfoHeaders: () => ContainerGetAccountInfoHeaders,
	ContainerGetPropertiesExceptionHeaders: () => ContainerGetPropertiesExceptionHeaders,
	ContainerGetPropertiesHeaders: () => ContainerGetPropertiesHeaders,
	ContainerItem: () => ContainerItem,
	ContainerListBlobFlatSegmentExceptionHeaders: () => ContainerListBlobFlatSegmentExceptionHeaders,
	ContainerListBlobFlatSegmentHeaders: () => ContainerListBlobFlatSegmentHeaders,
	ContainerListBlobHierarchySegmentExceptionHeaders: () => ContainerListBlobHierarchySegmentExceptionHeaders,
	ContainerListBlobHierarchySegmentHeaders: () => ContainerListBlobHierarchySegmentHeaders,
	ContainerProperties: () => ContainerProperties,
	ContainerReleaseLeaseExceptionHeaders: () => ContainerReleaseLeaseExceptionHeaders,
	ContainerReleaseLeaseHeaders: () => ContainerReleaseLeaseHeaders,
	ContainerRenameExceptionHeaders: () => ContainerRenameExceptionHeaders,
	ContainerRenameHeaders: () => ContainerRenameHeaders,
	ContainerRenewLeaseExceptionHeaders: () => ContainerRenewLeaseExceptionHeaders,
	ContainerRenewLeaseHeaders: () => ContainerRenewLeaseHeaders,
	ContainerRestoreExceptionHeaders: () => ContainerRestoreExceptionHeaders,
	ContainerRestoreHeaders: () => ContainerRestoreHeaders,
	ContainerSetAccessPolicyExceptionHeaders: () => ContainerSetAccessPolicyExceptionHeaders,
	ContainerSetAccessPolicyHeaders: () => ContainerSetAccessPolicyHeaders,
	ContainerSetMetadataExceptionHeaders: () => ContainerSetMetadataExceptionHeaders,
	ContainerSetMetadataHeaders: () => ContainerSetMetadataHeaders,
	ContainerSubmitBatchExceptionHeaders: () => ContainerSubmitBatchExceptionHeaders,
	ContainerSubmitBatchHeaders: () => ContainerSubmitBatchHeaders,
	CorsRule: () => CorsRule,
	DelimitedTextConfiguration: () => DelimitedTextConfiguration,
	FilterBlobItem: () => FilterBlobItem,
	FilterBlobSegment: () => FilterBlobSegment,
	GeoReplication: () => GeoReplication,
	JsonTextConfiguration: () => JsonTextConfiguration,
	KeyInfo: () => KeyInfo,
	ListBlobsFlatSegmentResponse: () => ListBlobsFlatSegmentResponse,
	ListBlobsHierarchySegmentResponse: () => ListBlobsHierarchySegmentResponse,
	ListContainersSegmentResponse: () => ListContainersSegmentResponse,
	Logging: () => Logging,
	Metrics: () => Metrics,
	PageBlobClearPagesExceptionHeaders: () => PageBlobClearPagesExceptionHeaders,
	PageBlobClearPagesHeaders: () => PageBlobClearPagesHeaders,
	PageBlobCopyIncrementalExceptionHeaders: () => PageBlobCopyIncrementalExceptionHeaders,
	PageBlobCopyIncrementalHeaders: () => PageBlobCopyIncrementalHeaders,
	PageBlobCreateExceptionHeaders: () => PageBlobCreateExceptionHeaders,
	PageBlobCreateHeaders: () => PageBlobCreateHeaders,
	PageBlobGetPageRangesDiffExceptionHeaders: () => PageBlobGetPageRangesDiffExceptionHeaders,
	PageBlobGetPageRangesDiffHeaders: () => PageBlobGetPageRangesDiffHeaders,
	PageBlobGetPageRangesExceptionHeaders: () => PageBlobGetPageRangesExceptionHeaders,
	PageBlobGetPageRangesHeaders: () => PageBlobGetPageRangesHeaders,
	PageBlobResizeExceptionHeaders: () => PageBlobResizeExceptionHeaders,
	PageBlobResizeHeaders: () => PageBlobResizeHeaders,
	PageBlobUpdateSequenceNumberExceptionHeaders: () => PageBlobUpdateSequenceNumberExceptionHeaders,
	PageBlobUpdateSequenceNumberHeaders: () => PageBlobUpdateSequenceNumberHeaders,
	PageBlobUploadPagesExceptionHeaders: () => PageBlobUploadPagesExceptionHeaders,
	PageBlobUploadPagesFromURLExceptionHeaders: () => PageBlobUploadPagesFromURLExceptionHeaders,
	PageBlobUploadPagesFromURLHeaders: () => PageBlobUploadPagesFromURLHeaders,
	PageBlobUploadPagesHeaders: () => PageBlobUploadPagesHeaders,
	PageList: () => PageList,
	PageRange: () => PageRange,
	QueryFormat: () => QueryFormat,
	QueryRequest: () => QueryRequest,
	QuerySerialization: () => QuerySerialization,
	RetentionPolicy: () => RetentionPolicy,
	ServiceFilterBlobsExceptionHeaders: () => ServiceFilterBlobsExceptionHeaders,
	ServiceFilterBlobsHeaders: () => ServiceFilterBlobsHeaders,
	ServiceGetAccountInfoExceptionHeaders: () => ServiceGetAccountInfoExceptionHeaders,
	ServiceGetAccountInfoHeaders: () => ServiceGetAccountInfoHeaders,
	ServiceGetPropertiesExceptionHeaders: () => ServiceGetPropertiesExceptionHeaders,
	ServiceGetPropertiesHeaders: () => ServiceGetPropertiesHeaders,
	ServiceGetStatisticsExceptionHeaders: () => ServiceGetStatisticsExceptionHeaders,
	ServiceGetStatisticsHeaders: () => ServiceGetStatisticsHeaders,
	ServiceGetUserDelegationKeyExceptionHeaders: () => ServiceGetUserDelegationKeyExceptionHeaders,
	ServiceGetUserDelegationKeyHeaders: () => ServiceGetUserDelegationKeyHeaders,
	ServiceListContainersSegmentExceptionHeaders: () => ServiceListContainersSegmentExceptionHeaders,
	ServiceListContainersSegmentHeaders: () => ServiceListContainersSegmentHeaders,
	ServiceSetPropertiesExceptionHeaders: () => ServiceSetPropertiesExceptionHeaders,
	ServiceSetPropertiesHeaders: () => ServiceSetPropertiesHeaders,
	ServiceSubmitBatchExceptionHeaders: () => ServiceSubmitBatchExceptionHeaders,
	ServiceSubmitBatchHeaders: () => ServiceSubmitBatchHeaders,
	SignedIdentifier: () => SignedIdentifier,
	StaticWebsite: () => StaticWebsite,
	StorageError: () => StorageError,
	UserDelegationKey: () => UserDelegationKey
});
var BlobServiceProperties = {
	serializedName: "BlobServiceProperties",
	xmlName: "StorageServiceProperties",
	type: {
		name: "Composite",
		className: "BlobServiceProperties",
		modelProperties: {
			blobAnalyticsLogging: {
				serializedName: "Logging",
				xmlName: "Logging",
				type: {
					name: "Composite",
					className: "Logging"
				}
			},
			hourMetrics: {
				serializedName: "HourMetrics",
				xmlName: "HourMetrics",
				type: {
					name: "Composite",
					className: "Metrics"
				}
			},
			minuteMetrics: {
				serializedName: "MinuteMetrics",
				xmlName: "MinuteMetrics",
				type: {
					name: "Composite",
					className: "Metrics"
				}
			},
			cors: {
				serializedName: "Cors",
				xmlName: "Cors",
				xmlIsWrapped: true,
				xmlElementName: "CorsRule",
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "CorsRule"
					} }
				}
			},
			defaultServiceVersion: {
				serializedName: "DefaultServiceVersion",
				xmlName: "DefaultServiceVersion",
				type: { name: "String" }
			},
			deleteRetentionPolicy: {
				serializedName: "DeleteRetentionPolicy",
				xmlName: "DeleteRetentionPolicy",
				type: {
					name: "Composite",
					className: "RetentionPolicy"
				}
			},
			staticWebsite: {
				serializedName: "StaticWebsite",
				xmlName: "StaticWebsite",
				type: {
					name: "Composite",
					className: "StaticWebsite"
				}
			}
		}
	}
};
var Logging = {
	serializedName: "Logging",
	type: {
		name: "Composite",
		className: "Logging",
		modelProperties: {
			version: {
				serializedName: "Version",
				required: true,
				xmlName: "Version",
				type: { name: "String" }
			},
			deleteProperty: {
				serializedName: "Delete",
				required: true,
				xmlName: "Delete",
				type: { name: "Boolean" }
			},
			read: {
				serializedName: "Read",
				required: true,
				xmlName: "Read",
				type: { name: "Boolean" }
			},
			write: {
				serializedName: "Write",
				required: true,
				xmlName: "Write",
				type: { name: "Boolean" }
			},
			retentionPolicy: {
				serializedName: "RetentionPolicy",
				xmlName: "RetentionPolicy",
				type: {
					name: "Composite",
					className: "RetentionPolicy"
				}
			}
		}
	}
};
var RetentionPolicy = {
	serializedName: "RetentionPolicy",
	type: {
		name: "Composite",
		className: "RetentionPolicy",
		modelProperties: {
			enabled: {
				serializedName: "Enabled",
				required: true,
				xmlName: "Enabled",
				type: { name: "Boolean" }
			},
			days: {
				constraints: { InclusiveMinimum: 1 },
				serializedName: "Days",
				xmlName: "Days",
				type: { name: "Number" }
			}
		}
	}
};
var Metrics = {
	serializedName: "Metrics",
	type: {
		name: "Composite",
		className: "Metrics",
		modelProperties: {
			version: {
				serializedName: "Version",
				xmlName: "Version",
				type: { name: "String" }
			},
			enabled: {
				serializedName: "Enabled",
				required: true,
				xmlName: "Enabled",
				type: { name: "Boolean" }
			},
			includeAPIs: {
				serializedName: "IncludeAPIs",
				xmlName: "IncludeAPIs",
				type: { name: "Boolean" }
			},
			retentionPolicy: {
				serializedName: "RetentionPolicy",
				xmlName: "RetentionPolicy",
				type: {
					name: "Composite",
					className: "RetentionPolicy"
				}
			}
		}
	}
};
var CorsRule = {
	serializedName: "CorsRule",
	type: {
		name: "Composite",
		className: "CorsRule",
		modelProperties: {
			allowedOrigins: {
				serializedName: "AllowedOrigins",
				required: true,
				xmlName: "AllowedOrigins",
				type: { name: "String" }
			},
			allowedMethods: {
				serializedName: "AllowedMethods",
				required: true,
				xmlName: "AllowedMethods",
				type: { name: "String" }
			},
			allowedHeaders: {
				serializedName: "AllowedHeaders",
				required: true,
				xmlName: "AllowedHeaders",
				type: { name: "String" }
			},
			exposedHeaders: {
				serializedName: "ExposedHeaders",
				required: true,
				xmlName: "ExposedHeaders",
				type: { name: "String" }
			},
			maxAgeInSeconds: {
				constraints: { InclusiveMinimum: 0 },
				serializedName: "MaxAgeInSeconds",
				required: true,
				xmlName: "MaxAgeInSeconds",
				type: { name: "Number" }
			}
		}
	}
};
var StaticWebsite = {
	serializedName: "StaticWebsite",
	type: {
		name: "Composite",
		className: "StaticWebsite",
		modelProperties: {
			enabled: {
				serializedName: "Enabled",
				required: true,
				xmlName: "Enabled",
				type: { name: "Boolean" }
			},
			indexDocument: {
				serializedName: "IndexDocument",
				xmlName: "IndexDocument",
				type: { name: "String" }
			},
			errorDocument404Path: {
				serializedName: "ErrorDocument404Path",
				xmlName: "ErrorDocument404Path",
				type: { name: "String" }
			},
			defaultIndexDocumentPath: {
				serializedName: "DefaultIndexDocumentPath",
				xmlName: "DefaultIndexDocumentPath",
				type: { name: "String" }
			}
		}
	}
};
var StorageError = {
	serializedName: "StorageError",
	type: {
		name: "Composite",
		className: "StorageError",
		modelProperties: {
			message: {
				serializedName: "Message",
				xmlName: "Message",
				type: { name: "String" }
			},
			copySourceStatusCode: {
				serializedName: "CopySourceStatusCode",
				xmlName: "CopySourceStatusCode",
				type: { name: "Number" }
			},
			copySourceErrorCode: {
				serializedName: "CopySourceErrorCode",
				xmlName: "CopySourceErrorCode",
				type: { name: "String" }
			},
			copySourceErrorMessage: {
				serializedName: "CopySourceErrorMessage",
				xmlName: "CopySourceErrorMessage",
				type: { name: "String" }
			},
			code: {
				serializedName: "Code",
				xmlName: "Code",
				type: { name: "String" }
			},
			authenticationErrorDetail: {
				serializedName: "AuthenticationErrorDetail",
				xmlName: "AuthenticationErrorDetail",
				type: { name: "String" }
			}
		}
	}
};
var BlobServiceStatistics = {
	serializedName: "BlobServiceStatistics",
	xmlName: "StorageServiceStats",
	type: {
		name: "Composite",
		className: "BlobServiceStatistics",
		modelProperties: { geoReplication: {
			serializedName: "GeoReplication",
			xmlName: "GeoReplication",
			type: {
				name: "Composite",
				className: "GeoReplication"
			}
		} }
	}
};
var GeoReplication = {
	serializedName: "GeoReplication",
	type: {
		name: "Composite",
		className: "GeoReplication",
		modelProperties: {
			status: {
				serializedName: "Status",
				required: true,
				xmlName: "Status",
				type: {
					name: "Enum",
					allowedValues: [
						"live",
						"bootstrap",
						"unavailable"
					]
				}
			},
			lastSyncOn: {
				serializedName: "LastSyncTime",
				required: true,
				xmlName: "LastSyncTime",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var ListContainersSegmentResponse = {
	serializedName: "ListContainersSegmentResponse",
	xmlName: "EnumerationResults",
	type: {
		name: "Composite",
		className: "ListContainersSegmentResponse",
		modelProperties: {
			serviceEndpoint: {
				serializedName: "ServiceEndpoint",
				required: true,
				xmlName: "ServiceEndpoint",
				xmlIsAttribute: true,
				type: { name: "String" }
			},
			prefix: {
				serializedName: "Prefix",
				xmlName: "Prefix",
				type: { name: "String" }
			},
			marker: {
				serializedName: "Marker",
				xmlName: "Marker",
				type: { name: "String" }
			},
			maxPageSize: {
				serializedName: "MaxResults",
				xmlName: "MaxResults",
				type: { name: "Number" }
			},
			containerItems: {
				serializedName: "ContainerItems",
				required: true,
				xmlName: "Containers",
				xmlIsWrapped: true,
				xmlElementName: "Container",
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "ContainerItem"
					} }
				}
			},
			continuationToken: {
				serializedName: "NextMarker",
				xmlName: "NextMarker",
				type: { name: "String" }
			}
		}
	}
};
var ContainerItem = {
	serializedName: "ContainerItem",
	xmlName: "Container",
	type: {
		name: "Composite",
		className: "ContainerItem",
		modelProperties: {
			name: {
				serializedName: "Name",
				required: true,
				xmlName: "Name",
				type: { name: "String" }
			},
			deleted: {
				serializedName: "Deleted",
				xmlName: "Deleted",
				type: { name: "Boolean" }
			},
			version: {
				serializedName: "Version",
				xmlName: "Version",
				type: { name: "String" }
			},
			properties: {
				serializedName: "Properties",
				xmlName: "Properties",
				type: {
					name: "Composite",
					className: "ContainerProperties"
				}
			},
			metadata: {
				serializedName: "Metadata",
				xmlName: "Metadata",
				type: {
					name: "Dictionary",
					value: { type: { name: "String" } }
				}
			}
		}
	}
};
var ContainerProperties = {
	serializedName: "ContainerProperties",
	type: {
		name: "Composite",
		className: "ContainerProperties",
		modelProperties: {
			lastModified: {
				serializedName: "Last-Modified",
				required: true,
				xmlName: "Last-Modified",
				type: { name: "DateTimeRfc1123" }
			},
			etag: {
				serializedName: "Etag",
				required: true,
				xmlName: "Etag",
				type: { name: "String" }
			},
			leaseStatus: {
				serializedName: "LeaseStatus",
				xmlName: "LeaseStatus",
				type: {
					name: "Enum",
					allowedValues: ["locked", "unlocked"]
				}
			},
			leaseState: {
				serializedName: "LeaseState",
				xmlName: "LeaseState",
				type: {
					name: "Enum",
					allowedValues: [
						"available",
						"leased",
						"expired",
						"breaking",
						"broken"
					]
				}
			},
			leaseDuration: {
				serializedName: "LeaseDuration",
				xmlName: "LeaseDuration",
				type: {
					name: "Enum",
					allowedValues: ["infinite", "fixed"]
				}
			},
			publicAccess: {
				serializedName: "PublicAccess",
				xmlName: "PublicAccess",
				type: {
					name: "Enum",
					allowedValues: ["container", "blob"]
				}
			},
			hasImmutabilityPolicy: {
				serializedName: "HasImmutabilityPolicy",
				xmlName: "HasImmutabilityPolicy",
				type: { name: "Boolean" }
			},
			hasLegalHold: {
				serializedName: "HasLegalHold",
				xmlName: "HasLegalHold",
				type: { name: "Boolean" }
			},
			defaultEncryptionScope: {
				serializedName: "DefaultEncryptionScope",
				xmlName: "DefaultEncryptionScope",
				type: { name: "String" }
			},
			preventEncryptionScopeOverride: {
				serializedName: "DenyEncryptionScopeOverride",
				xmlName: "DenyEncryptionScopeOverride",
				type: { name: "Boolean" }
			},
			deletedOn: {
				serializedName: "DeletedTime",
				xmlName: "DeletedTime",
				type: { name: "DateTimeRfc1123" }
			},
			remainingRetentionDays: {
				serializedName: "RemainingRetentionDays",
				xmlName: "RemainingRetentionDays",
				type: { name: "Number" }
			},
			isImmutableStorageWithVersioningEnabled: {
				serializedName: "ImmutableStorageWithVersioningEnabled",
				xmlName: "ImmutableStorageWithVersioningEnabled",
				type: { name: "Boolean" }
			}
		}
	}
};
var KeyInfo = {
	serializedName: "KeyInfo",
	type: {
		name: "Composite",
		className: "KeyInfo",
		modelProperties: {
			startsOn: {
				serializedName: "Start",
				required: true,
				xmlName: "Start",
				type: { name: "String" }
			},
			expiresOn: {
				serializedName: "Expiry",
				required: true,
				xmlName: "Expiry",
				type: { name: "String" }
			},
			delegatedUserTid: {
				serializedName: "DelegatedUserTid",
				xmlName: "DelegatedUserTid",
				type: { name: "String" }
			}
		}
	}
};
var UserDelegationKey = {
	serializedName: "UserDelegationKey",
	type: {
		name: "Composite",
		className: "UserDelegationKey",
		modelProperties: {
			signedObjectId: {
				serializedName: "SignedOid",
				required: true,
				xmlName: "SignedOid",
				type: { name: "String" }
			},
			signedTenantId: {
				serializedName: "SignedTid",
				required: true,
				xmlName: "SignedTid",
				type: { name: "String" }
			},
			signedStartsOn: {
				serializedName: "SignedStart",
				required: true,
				xmlName: "SignedStart",
				type: { name: "String" }
			},
			signedExpiresOn: {
				serializedName: "SignedExpiry",
				required: true,
				xmlName: "SignedExpiry",
				type: { name: "String" }
			},
			signedService: {
				serializedName: "SignedService",
				required: true,
				xmlName: "SignedService",
				type: { name: "String" }
			},
			signedVersion: {
				serializedName: "SignedVersion",
				required: true,
				xmlName: "SignedVersion",
				type: { name: "String" }
			},
			signedDelegatedUserTenantId: {
				serializedName: "SignedDelegatedUserTid",
				xmlName: "SignedDelegatedUserTid",
				type: { name: "String" }
			},
			value: {
				serializedName: "Value",
				required: true,
				xmlName: "Value",
				type: { name: "String" }
			}
		}
	}
};
var FilterBlobSegment = {
	serializedName: "FilterBlobSegment",
	xmlName: "EnumerationResults",
	type: {
		name: "Composite",
		className: "FilterBlobSegment",
		modelProperties: {
			serviceEndpoint: {
				serializedName: "ServiceEndpoint",
				required: true,
				xmlName: "ServiceEndpoint",
				xmlIsAttribute: true,
				type: { name: "String" }
			},
			where: {
				serializedName: "Where",
				required: true,
				xmlName: "Where",
				type: { name: "String" }
			},
			blobs: {
				serializedName: "Blobs",
				required: true,
				xmlName: "Blobs",
				xmlIsWrapped: true,
				xmlElementName: "Blob",
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "FilterBlobItem"
					} }
				}
			},
			continuationToken: {
				serializedName: "NextMarker",
				xmlName: "NextMarker",
				type: { name: "String" }
			}
		}
	}
};
var FilterBlobItem = {
	serializedName: "FilterBlobItem",
	xmlName: "Blob",
	type: {
		name: "Composite",
		className: "FilterBlobItem",
		modelProperties: {
			name: {
				serializedName: "Name",
				required: true,
				xmlName: "Name",
				type: { name: "String" }
			},
			containerName: {
				serializedName: "ContainerName",
				required: true,
				xmlName: "ContainerName",
				type: { name: "String" }
			},
			tags: {
				serializedName: "Tags",
				xmlName: "Tags",
				type: {
					name: "Composite",
					className: "BlobTags"
				}
			}
		}
	}
};
var BlobTags = {
	serializedName: "BlobTags",
	xmlName: "Tags",
	type: {
		name: "Composite",
		className: "BlobTags",
		modelProperties: { blobTagSet: {
			serializedName: "BlobTagSet",
			required: true,
			xmlName: "TagSet",
			xmlIsWrapped: true,
			xmlElementName: "Tag",
			type: {
				name: "Sequence",
				element: { type: {
					name: "Composite",
					className: "BlobTag"
				} }
			}
		} }
	}
};
var BlobTag = {
	serializedName: "BlobTag",
	xmlName: "Tag",
	type: {
		name: "Composite",
		className: "BlobTag",
		modelProperties: {
			key: {
				serializedName: "Key",
				required: true,
				xmlName: "Key",
				type: { name: "String" }
			},
			value: {
				serializedName: "Value",
				required: true,
				xmlName: "Value",
				type: { name: "String" }
			}
		}
	}
};
var SignedIdentifier = {
	serializedName: "SignedIdentifier",
	xmlName: "SignedIdentifier",
	type: {
		name: "Composite",
		className: "SignedIdentifier",
		modelProperties: {
			id: {
				serializedName: "Id",
				required: true,
				xmlName: "Id",
				type: { name: "String" }
			},
			accessPolicy: {
				serializedName: "AccessPolicy",
				xmlName: "AccessPolicy",
				type: {
					name: "Composite",
					className: "AccessPolicy"
				}
			}
		}
	}
};
var AccessPolicy = {
	serializedName: "AccessPolicy",
	type: {
		name: "Composite",
		className: "AccessPolicy",
		modelProperties: {
			startsOn: {
				serializedName: "Start",
				xmlName: "Start",
				type: { name: "String" }
			},
			expiresOn: {
				serializedName: "Expiry",
				xmlName: "Expiry",
				type: { name: "String" }
			},
			permissions: {
				serializedName: "Permission",
				xmlName: "Permission",
				type: { name: "String" }
			}
		}
	}
};
var ListBlobsFlatSegmentResponse = {
	serializedName: "ListBlobsFlatSegmentResponse",
	xmlName: "EnumerationResults",
	type: {
		name: "Composite",
		className: "ListBlobsFlatSegmentResponse",
		modelProperties: {
			serviceEndpoint: {
				serializedName: "ServiceEndpoint",
				required: true,
				xmlName: "ServiceEndpoint",
				xmlIsAttribute: true,
				type: { name: "String" }
			},
			containerName: {
				serializedName: "ContainerName",
				required: true,
				xmlName: "ContainerName",
				xmlIsAttribute: true,
				type: { name: "String" }
			},
			prefix: {
				serializedName: "Prefix",
				xmlName: "Prefix",
				type: { name: "String" }
			},
			marker: {
				serializedName: "Marker",
				xmlName: "Marker",
				type: { name: "String" }
			},
			maxPageSize: {
				serializedName: "MaxResults",
				xmlName: "MaxResults",
				type: { name: "Number" }
			},
			segment: {
				serializedName: "Segment",
				xmlName: "Blobs",
				type: {
					name: "Composite",
					className: "BlobFlatListSegment"
				}
			},
			continuationToken: {
				serializedName: "NextMarker",
				xmlName: "NextMarker",
				type: { name: "String" }
			}
		}
	}
};
var BlobFlatListSegment = {
	serializedName: "BlobFlatListSegment",
	xmlName: "Blobs",
	type: {
		name: "Composite",
		className: "BlobFlatListSegment",
		modelProperties: { blobItems: {
			serializedName: "BlobItems",
			required: true,
			xmlName: "BlobItems",
			xmlElementName: "Blob",
			type: {
				name: "Sequence",
				element: { type: {
					name: "Composite",
					className: "BlobItemInternal"
				} }
			}
		} }
	}
};
var BlobItemInternal = {
	serializedName: "BlobItemInternal",
	xmlName: "Blob",
	type: {
		name: "Composite",
		className: "BlobItemInternal",
		modelProperties: {
			name: {
				serializedName: "Name",
				xmlName: "Name",
				type: {
					name: "Composite",
					className: "BlobName"
				}
			},
			deleted: {
				serializedName: "Deleted",
				required: true,
				xmlName: "Deleted",
				type: { name: "Boolean" }
			},
			snapshot: {
				serializedName: "Snapshot",
				required: true,
				xmlName: "Snapshot",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "VersionId",
				xmlName: "VersionId",
				type: { name: "String" }
			},
			isCurrentVersion: {
				serializedName: "IsCurrentVersion",
				xmlName: "IsCurrentVersion",
				type: { name: "Boolean" }
			},
			properties: {
				serializedName: "Properties",
				xmlName: "Properties",
				type: {
					name: "Composite",
					className: "BlobPropertiesInternal"
				}
			},
			metadata: {
				serializedName: "Metadata",
				xmlName: "Metadata",
				type: {
					name: "Dictionary",
					value: { type: { name: "String" } }
				}
			},
			blobTags: {
				serializedName: "BlobTags",
				xmlName: "Tags",
				type: {
					name: "Composite",
					className: "BlobTags"
				}
			},
			objectReplicationMetadata: {
				serializedName: "ObjectReplicationMetadata",
				xmlName: "OrMetadata",
				type: {
					name: "Dictionary",
					value: { type: { name: "String" } }
				}
			},
			hasVersionsOnly: {
				serializedName: "HasVersionsOnly",
				xmlName: "HasVersionsOnly",
				type: { name: "Boolean" }
			}
		}
	}
};
var BlobName = {
	serializedName: "BlobName",
	type: {
		name: "Composite",
		className: "BlobName",
		modelProperties: {
			encoded: {
				serializedName: "Encoded",
				xmlName: "Encoded",
				xmlIsAttribute: true,
				type: { name: "Boolean" }
			},
			content: {
				serializedName: "content",
				xmlName: "content",
				xmlIsMsText: true,
				type: { name: "String" }
			}
		}
	}
};
var BlobPropertiesInternal = {
	serializedName: "BlobPropertiesInternal",
	xmlName: "Properties",
	type: {
		name: "Composite",
		className: "BlobPropertiesInternal",
		modelProperties: {
			createdOn: {
				serializedName: "Creation-Time",
				xmlName: "Creation-Time",
				type: { name: "DateTimeRfc1123" }
			},
			lastModified: {
				serializedName: "Last-Modified",
				required: true,
				xmlName: "Last-Modified",
				type: { name: "DateTimeRfc1123" }
			},
			etag: {
				serializedName: "Etag",
				required: true,
				xmlName: "Etag",
				type: { name: "String" }
			},
			contentLength: {
				serializedName: "Content-Length",
				xmlName: "Content-Length",
				type: { name: "Number" }
			},
			contentType: {
				serializedName: "Content-Type",
				xmlName: "Content-Type",
				type: { name: "String" }
			},
			contentEncoding: {
				serializedName: "Content-Encoding",
				xmlName: "Content-Encoding",
				type: { name: "String" }
			},
			contentLanguage: {
				serializedName: "Content-Language",
				xmlName: "Content-Language",
				type: { name: "String" }
			},
			contentMD5: {
				serializedName: "Content-MD5",
				xmlName: "Content-MD5",
				type: { name: "ByteArray" }
			},
			contentDisposition: {
				serializedName: "Content-Disposition",
				xmlName: "Content-Disposition",
				type: { name: "String" }
			},
			cacheControl: {
				serializedName: "Cache-Control",
				xmlName: "Cache-Control",
				type: { name: "String" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			blobType: {
				serializedName: "BlobType",
				xmlName: "BlobType",
				type: {
					name: "Enum",
					allowedValues: [
						"BlockBlob",
						"PageBlob",
						"AppendBlob"
					]
				}
			},
			leaseStatus: {
				serializedName: "LeaseStatus",
				xmlName: "LeaseStatus",
				type: {
					name: "Enum",
					allowedValues: ["locked", "unlocked"]
				}
			},
			leaseState: {
				serializedName: "LeaseState",
				xmlName: "LeaseState",
				type: {
					name: "Enum",
					allowedValues: [
						"available",
						"leased",
						"expired",
						"breaking",
						"broken"
					]
				}
			},
			leaseDuration: {
				serializedName: "LeaseDuration",
				xmlName: "LeaseDuration",
				type: {
					name: "Enum",
					allowedValues: ["infinite", "fixed"]
				}
			},
			copyId: {
				serializedName: "CopyId",
				xmlName: "CopyId",
				type: { name: "String" }
			},
			copyStatus: {
				serializedName: "CopyStatus",
				xmlName: "CopyStatus",
				type: {
					name: "Enum",
					allowedValues: [
						"pending",
						"success",
						"aborted",
						"failed"
					]
				}
			},
			copySource: {
				serializedName: "CopySource",
				xmlName: "CopySource",
				type: { name: "String" }
			},
			copyProgress: {
				serializedName: "CopyProgress",
				xmlName: "CopyProgress",
				type: { name: "String" }
			},
			copyCompletedOn: {
				serializedName: "CopyCompletionTime",
				xmlName: "CopyCompletionTime",
				type: { name: "DateTimeRfc1123" }
			},
			copyStatusDescription: {
				serializedName: "CopyStatusDescription",
				xmlName: "CopyStatusDescription",
				type: { name: "String" }
			},
			serverEncrypted: {
				serializedName: "ServerEncrypted",
				xmlName: "ServerEncrypted",
				type: { name: "Boolean" }
			},
			incrementalCopy: {
				serializedName: "IncrementalCopy",
				xmlName: "IncrementalCopy",
				type: { name: "Boolean" }
			},
			destinationSnapshot: {
				serializedName: "DestinationSnapshot",
				xmlName: "DestinationSnapshot",
				type: { name: "String" }
			},
			deletedOn: {
				serializedName: "DeletedTime",
				xmlName: "DeletedTime",
				type: { name: "DateTimeRfc1123" }
			},
			remainingRetentionDays: {
				serializedName: "RemainingRetentionDays",
				xmlName: "RemainingRetentionDays",
				type: { name: "Number" }
			},
			accessTier: {
				serializedName: "AccessTier",
				xmlName: "AccessTier",
				type: {
					name: "Enum",
					allowedValues: [
						"P4",
						"P6",
						"P10",
						"P15",
						"P20",
						"P30",
						"P40",
						"P50",
						"P60",
						"P70",
						"P80",
						"Hot",
						"Cool",
						"Archive",
						"Cold",
						"Smart"
					]
				}
			},
			accessTierInferred: {
				serializedName: "AccessTierInferred",
				xmlName: "AccessTierInferred",
				type: { name: "Boolean" }
			},
			archiveStatus: {
				serializedName: "ArchiveStatus",
				xmlName: "ArchiveStatus",
				type: {
					name: "Enum",
					allowedValues: [
						"rehydrate-pending-to-hot",
						"rehydrate-pending-to-cool",
						"rehydrate-pending-to-cold",
						"rehydrate-pending-to-smart"
					]
				}
			},
			smartAccessTier: {
				serializedName: "SmartAccessTier",
				xmlName: "SmartAccessTier",
				type: {
					name: "Enum",
					allowedValues: [
						"P4",
						"P6",
						"P10",
						"P15",
						"P20",
						"P30",
						"P40",
						"P50",
						"P60",
						"P70",
						"P80",
						"Hot",
						"Cool",
						"Archive",
						"Cold",
						"Smart"
					]
				}
			},
			customerProvidedKeySha256: {
				serializedName: "CustomerProvidedKeySha256",
				xmlName: "CustomerProvidedKeySha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "EncryptionScope",
				xmlName: "EncryptionScope",
				type: { name: "String" }
			},
			accessTierChangedOn: {
				serializedName: "AccessTierChangeTime",
				xmlName: "AccessTierChangeTime",
				type: { name: "DateTimeRfc1123" }
			},
			tagCount: {
				serializedName: "TagCount",
				xmlName: "TagCount",
				type: { name: "Number" }
			},
			expiresOn: {
				serializedName: "Expiry-Time",
				xmlName: "Expiry-Time",
				type: { name: "DateTimeRfc1123" }
			},
			isSealed: {
				serializedName: "Sealed",
				xmlName: "Sealed",
				type: { name: "Boolean" }
			},
			rehydratePriority: {
				serializedName: "RehydratePriority",
				xmlName: "RehydratePriority",
				type: {
					name: "Enum",
					allowedValues: ["High", "Standard"]
				}
			},
			lastAccessedOn: {
				serializedName: "LastAccessTime",
				xmlName: "LastAccessTime",
				type: { name: "DateTimeRfc1123" }
			},
			immutabilityPolicyExpiresOn: {
				serializedName: "ImmutabilityPolicyUntilDate",
				xmlName: "ImmutabilityPolicyUntilDate",
				type: { name: "DateTimeRfc1123" }
			},
			immutabilityPolicyMode: {
				serializedName: "ImmutabilityPolicyMode",
				xmlName: "ImmutabilityPolicyMode",
				type: {
					name: "Enum",
					allowedValues: [
						"Mutable",
						"Unlocked",
						"Locked"
					]
				}
			},
			legalHold: {
				serializedName: "LegalHold",
				xmlName: "LegalHold",
				type: { name: "Boolean" }
			}
		}
	}
};
var ListBlobsHierarchySegmentResponse = {
	serializedName: "ListBlobsHierarchySegmentResponse",
	xmlName: "EnumerationResults",
	type: {
		name: "Composite",
		className: "ListBlobsHierarchySegmentResponse",
		modelProperties: {
			serviceEndpoint: {
				serializedName: "ServiceEndpoint",
				required: true,
				xmlName: "ServiceEndpoint",
				xmlIsAttribute: true,
				type: { name: "String" }
			},
			containerName: {
				serializedName: "ContainerName",
				required: true,
				xmlName: "ContainerName",
				xmlIsAttribute: true,
				type: { name: "String" }
			},
			prefix: {
				serializedName: "Prefix",
				xmlName: "Prefix",
				type: { name: "String" }
			},
			marker: {
				serializedName: "Marker",
				xmlName: "Marker",
				type: { name: "String" }
			},
			maxPageSize: {
				serializedName: "MaxResults",
				xmlName: "MaxResults",
				type: { name: "Number" }
			},
			delimiter: {
				serializedName: "Delimiter",
				xmlName: "Delimiter",
				type: { name: "String" }
			},
			segment: {
				serializedName: "Segment",
				xmlName: "Blobs",
				type: {
					name: "Composite",
					className: "BlobHierarchyListSegment"
				}
			},
			continuationToken: {
				serializedName: "NextMarker",
				xmlName: "NextMarker",
				type: { name: "String" }
			}
		}
	}
};
var BlobHierarchyListSegment = {
	serializedName: "BlobHierarchyListSegment",
	xmlName: "Blobs",
	type: {
		name: "Composite",
		className: "BlobHierarchyListSegment",
		modelProperties: {
			blobPrefixes: {
				serializedName: "BlobPrefixes",
				xmlName: "BlobPrefixes",
				xmlElementName: "BlobPrefix",
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "BlobPrefix"
					} }
				}
			},
			blobItems: {
				serializedName: "BlobItems",
				required: true,
				xmlName: "BlobItems",
				xmlElementName: "Blob",
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "BlobItemInternal"
					} }
				}
			}
		}
	}
};
var BlobPrefix = {
	serializedName: "BlobPrefix",
	type: {
		name: "Composite",
		className: "BlobPrefix",
		modelProperties: { name: {
			serializedName: "Name",
			xmlName: "Name",
			type: {
				name: "Composite",
				className: "BlobName"
			}
		} }
	}
};
var BlockLookupList = {
	serializedName: "BlockLookupList",
	xmlName: "BlockList",
	type: {
		name: "Composite",
		className: "BlockLookupList",
		modelProperties: {
			committed: {
				serializedName: "Committed",
				xmlName: "Committed",
				xmlElementName: "Committed",
				type: {
					name: "Sequence",
					element: { type: { name: "String" } }
				}
			},
			uncommitted: {
				serializedName: "Uncommitted",
				xmlName: "Uncommitted",
				xmlElementName: "Uncommitted",
				type: {
					name: "Sequence",
					element: { type: { name: "String" } }
				}
			},
			latest: {
				serializedName: "Latest",
				xmlName: "Latest",
				xmlElementName: "Latest",
				type: {
					name: "Sequence",
					element: { type: { name: "String" } }
				}
			}
		}
	}
};
var BlockList = {
	serializedName: "BlockList",
	type: {
		name: "Composite",
		className: "BlockList",
		modelProperties: {
			committedBlocks: {
				serializedName: "CommittedBlocks",
				xmlName: "CommittedBlocks",
				xmlIsWrapped: true,
				xmlElementName: "Block",
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "Block"
					} }
				}
			},
			uncommittedBlocks: {
				serializedName: "UncommittedBlocks",
				xmlName: "UncommittedBlocks",
				xmlIsWrapped: true,
				xmlElementName: "Block",
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "Block"
					} }
				}
			}
		}
	}
};
var Block = {
	serializedName: "Block",
	type: {
		name: "Composite",
		className: "Block",
		modelProperties: {
			name: {
				serializedName: "Name",
				required: true,
				xmlName: "Name",
				type: { name: "String" }
			},
			size: {
				serializedName: "Size",
				required: true,
				xmlName: "Size",
				type: { name: "Number" }
			}
		}
	}
};
var PageList = {
	serializedName: "PageList",
	type: {
		name: "Composite",
		className: "PageList",
		modelProperties: {
			pageRange: {
				serializedName: "PageRange",
				xmlName: "PageRange",
				xmlElementName: "PageRange",
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "PageRange"
					} }
				}
			},
			clearRange: {
				serializedName: "ClearRange",
				xmlName: "ClearRange",
				xmlElementName: "ClearRange",
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "ClearRange"
					} }
				}
			},
			continuationToken: {
				serializedName: "NextMarker",
				xmlName: "NextMarker",
				type: { name: "String" }
			}
		}
	}
};
var PageRange = {
	serializedName: "PageRange",
	xmlName: "PageRange",
	type: {
		name: "Composite",
		className: "PageRange",
		modelProperties: {
			start: {
				serializedName: "Start",
				required: true,
				xmlName: "Start",
				type: { name: "Number" }
			},
			end: {
				serializedName: "End",
				required: true,
				xmlName: "End",
				type: { name: "Number" }
			}
		}
	}
};
var ClearRange = {
	serializedName: "ClearRange",
	xmlName: "ClearRange",
	type: {
		name: "Composite",
		className: "ClearRange",
		modelProperties: {
			start: {
				serializedName: "Start",
				required: true,
				xmlName: "Start",
				type: { name: "Number" }
			},
			end: {
				serializedName: "End",
				required: true,
				xmlName: "End",
				type: { name: "Number" }
			}
		}
	}
};
var QueryRequest = {
	serializedName: "QueryRequest",
	xmlName: "QueryRequest",
	type: {
		name: "Composite",
		className: "QueryRequest",
		modelProperties: {
			queryType: {
				serializedName: "QueryType",
				required: true,
				xmlName: "QueryType",
				type: { name: "String" }
			},
			expression: {
				serializedName: "Expression",
				required: true,
				xmlName: "Expression",
				type: { name: "String" }
			},
			inputSerialization: {
				serializedName: "InputSerialization",
				xmlName: "InputSerialization",
				type: {
					name: "Composite",
					className: "QuerySerialization"
				}
			},
			outputSerialization: {
				serializedName: "OutputSerialization",
				xmlName: "OutputSerialization",
				type: {
					name: "Composite",
					className: "QuerySerialization"
				}
			}
		}
	}
};
var QuerySerialization = {
	serializedName: "QuerySerialization",
	type: {
		name: "Composite",
		className: "QuerySerialization",
		modelProperties: { format: {
			serializedName: "Format",
			xmlName: "Format",
			type: {
				name: "Composite",
				className: "QueryFormat"
			}
		} }
	}
};
var QueryFormat = {
	serializedName: "QueryFormat",
	type: {
		name: "Composite",
		className: "QueryFormat",
		modelProperties: {
			type: {
				serializedName: "Type",
				required: true,
				xmlName: "Type",
				type: {
					name: "Enum",
					allowedValues: [
						"delimited",
						"json",
						"arrow",
						"parquet"
					]
				}
			},
			delimitedTextConfiguration: {
				serializedName: "DelimitedTextConfiguration",
				xmlName: "DelimitedTextConfiguration",
				type: {
					name: "Composite",
					className: "DelimitedTextConfiguration"
				}
			},
			jsonTextConfiguration: {
				serializedName: "JsonTextConfiguration",
				xmlName: "JsonTextConfiguration",
				type: {
					name: "Composite",
					className: "JsonTextConfiguration"
				}
			},
			arrowConfiguration: {
				serializedName: "ArrowConfiguration",
				xmlName: "ArrowConfiguration",
				type: {
					name: "Composite",
					className: "ArrowConfiguration"
				}
			},
			parquetTextConfiguration: {
				serializedName: "ParquetTextConfiguration",
				xmlName: "ParquetTextConfiguration",
				type: {
					name: "Dictionary",
					value: { type: { name: "any" } }
				}
			}
		}
	}
};
var DelimitedTextConfiguration = {
	serializedName: "DelimitedTextConfiguration",
	xmlName: "DelimitedTextConfiguration",
	type: {
		name: "Composite",
		className: "DelimitedTextConfiguration",
		modelProperties: {
			columnSeparator: {
				serializedName: "ColumnSeparator",
				xmlName: "ColumnSeparator",
				type: { name: "String" }
			},
			fieldQuote: {
				serializedName: "FieldQuote",
				xmlName: "FieldQuote",
				type: { name: "String" }
			},
			recordSeparator: {
				serializedName: "RecordSeparator",
				xmlName: "RecordSeparator",
				type: { name: "String" }
			},
			escapeChar: {
				serializedName: "EscapeChar",
				xmlName: "EscapeChar",
				type: { name: "String" }
			},
			headersPresent: {
				serializedName: "HeadersPresent",
				xmlName: "HasHeaders",
				type: { name: "Boolean" }
			}
		}
	}
};
var JsonTextConfiguration = {
	serializedName: "JsonTextConfiguration",
	xmlName: "JsonTextConfiguration",
	type: {
		name: "Composite",
		className: "JsonTextConfiguration",
		modelProperties: { recordSeparator: {
			serializedName: "RecordSeparator",
			xmlName: "RecordSeparator",
			type: { name: "String" }
		} }
	}
};
var ArrowConfiguration = {
	serializedName: "ArrowConfiguration",
	xmlName: "ArrowConfiguration",
	type: {
		name: "Composite",
		className: "ArrowConfiguration",
		modelProperties: { schema: {
			serializedName: "Schema",
			required: true,
			xmlName: "Schema",
			xmlIsWrapped: true,
			xmlElementName: "Field",
			type: {
				name: "Sequence",
				element: { type: {
					name: "Composite",
					className: "ArrowField"
				} }
			}
		} }
	}
};
var ArrowField = {
	serializedName: "ArrowField",
	xmlName: "Field",
	type: {
		name: "Composite",
		className: "ArrowField",
		modelProperties: {
			type: {
				serializedName: "Type",
				required: true,
				xmlName: "Type",
				type: { name: "String" }
			},
			name: {
				serializedName: "Name",
				xmlName: "Name",
				type: { name: "String" }
			},
			precision: {
				serializedName: "Precision",
				xmlName: "Precision",
				type: { name: "Number" }
			},
			scale: {
				serializedName: "Scale",
				xmlName: "Scale",
				type: { name: "Number" }
			}
		}
	}
};
var ServiceSetPropertiesHeaders = {
	serializedName: "Service_setPropertiesHeaders",
	type: {
		name: "Composite",
		className: "ServiceSetPropertiesHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ServiceSetPropertiesExceptionHeaders = {
	serializedName: "Service_setPropertiesExceptionHeaders",
	type: {
		name: "Composite",
		className: "ServiceSetPropertiesExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ServiceGetPropertiesHeaders = {
	serializedName: "Service_getPropertiesHeaders",
	type: {
		name: "Composite",
		className: "ServiceGetPropertiesHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ServiceGetPropertiesExceptionHeaders = {
	serializedName: "Service_getPropertiesExceptionHeaders",
	type: {
		name: "Composite",
		className: "ServiceGetPropertiesExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ServiceGetStatisticsHeaders = {
	serializedName: "Service_getStatisticsHeaders",
	type: {
		name: "Composite",
		className: "ServiceGetStatisticsHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ServiceGetStatisticsExceptionHeaders = {
	serializedName: "Service_getStatisticsExceptionHeaders",
	type: {
		name: "Composite",
		className: "ServiceGetStatisticsExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ServiceListContainersSegmentHeaders = {
	serializedName: "Service_listContainersSegmentHeaders",
	type: {
		name: "Composite",
		className: "ServiceListContainersSegmentHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ServiceListContainersSegmentExceptionHeaders = {
	serializedName: "Service_listContainersSegmentExceptionHeaders",
	type: {
		name: "Composite",
		className: "ServiceListContainersSegmentExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ServiceGetUserDelegationKeyHeaders = {
	serializedName: "Service_getUserDelegationKeyHeaders",
	type: {
		name: "Composite",
		className: "ServiceGetUserDelegationKeyHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ServiceGetUserDelegationKeyExceptionHeaders = {
	serializedName: "Service_getUserDelegationKeyExceptionHeaders",
	type: {
		name: "Composite",
		className: "ServiceGetUserDelegationKeyExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ServiceGetAccountInfoHeaders = {
	serializedName: "Service_getAccountInfoHeaders",
	type: {
		name: "Composite",
		className: "ServiceGetAccountInfoHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			skuName: {
				serializedName: "x-ms-sku-name",
				xmlName: "x-ms-sku-name",
				type: {
					name: "Enum",
					allowedValues: [
						"Standard_LRS",
						"Standard_GRS",
						"Standard_RAGRS",
						"Standard_ZRS",
						"Premium_LRS",
						"Standard_GZRS",
						"Premium_ZRS",
						"Standard_RAGZRS"
					]
				}
			},
			accountKind: {
				serializedName: "x-ms-account-kind",
				xmlName: "x-ms-account-kind",
				type: {
					name: "Enum",
					allowedValues: [
						"Storage",
						"BlobStorage",
						"StorageV2",
						"FileStorage",
						"BlockBlobStorage"
					]
				}
			},
			isHierarchicalNamespaceEnabled: {
				serializedName: "x-ms-is-hns-enabled",
				xmlName: "x-ms-is-hns-enabled",
				type: { name: "Boolean" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ServiceGetAccountInfoExceptionHeaders = {
	serializedName: "Service_getAccountInfoExceptionHeaders",
	type: {
		name: "Composite",
		className: "ServiceGetAccountInfoExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ServiceSubmitBatchHeaders = {
	serializedName: "Service_submitBatchHeaders",
	type: {
		name: "Composite",
		className: "ServiceSubmitBatchHeaders",
		modelProperties: {
			contentType: {
				serializedName: "content-type",
				xmlName: "content-type",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ServiceSubmitBatchExceptionHeaders = {
	serializedName: "Service_submitBatchExceptionHeaders",
	type: {
		name: "Composite",
		className: "ServiceSubmitBatchExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ServiceFilterBlobsHeaders = {
	serializedName: "Service_filterBlobsHeaders",
	type: {
		name: "Composite",
		className: "ServiceFilterBlobsHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ServiceFilterBlobsExceptionHeaders = {
	serializedName: "Service_filterBlobsExceptionHeaders",
	type: {
		name: "Composite",
		className: "ServiceFilterBlobsExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerCreateHeaders = {
	serializedName: "Container_createHeaders",
	type: {
		name: "Composite",
		className: "ContainerCreateHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerCreateExceptionHeaders = {
	serializedName: "Container_createExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerCreateExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerGetPropertiesHeaders = {
	serializedName: "Container_getPropertiesHeaders",
	type: {
		name: "Composite",
		className: "ContainerGetPropertiesHeaders",
		modelProperties: {
			metadata: {
				serializedName: "x-ms-meta",
				headerCollectionPrefix: "x-ms-meta-",
				xmlName: "x-ms-meta",
				type: {
					name: "Dictionary",
					value: { type: { name: "String" } }
				}
			},
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			leaseDuration: {
				serializedName: "x-ms-lease-duration",
				xmlName: "x-ms-lease-duration",
				type: {
					name: "Enum",
					allowedValues: ["infinite", "fixed"]
				}
			},
			leaseState: {
				serializedName: "x-ms-lease-state",
				xmlName: "x-ms-lease-state",
				type: {
					name: "Enum",
					allowedValues: [
						"available",
						"leased",
						"expired",
						"breaking",
						"broken"
					]
				}
			},
			leaseStatus: {
				serializedName: "x-ms-lease-status",
				xmlName: "x-ms-lease-status",
				type: {
					name: "Enum",
					allowedValues: ["locked", "unlocked"]
				}
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			blobPublicAccess: {
				serializedName: "x-ms-blob-public-access",
				xmlName: "x-ms-blob-public-access",
				type: {
					name: "Enum",
					allowedValues: ["container", "blob"]
				}
			},
			hasImmutabilityPolicy: {
				serializedName: "x-ms-has-immutability-policy",
				xmlName: "x-ms-has-immutability-policy",
				type: { name: "Boolean" }
			},
			hasLegalHold: {
				serializedName: "x-ms-has-legal-hold",
				xmlName: "x-ms-has-legal-hold",
				type: { name: "Boolean" }
			},
			defaultEncryptionScope: {
				serializedName: "x-ms-default-encryption-scope",
				xmlName: "x-ms-default-encryption-scope",
				type: { name: "String" }
			},
			denyEncryptionScopeOverride: {
				serializedName: "x-ms-deny-encryption-scope-override",
				xmlName: "x-ms-deny-encryption-scope-override",
				type: { name: "Boolean" }
			},
			isImmutableStorageWithVersioningEnabled: {
				serializedName: "x-ms-immutable-storage-with-versioning-enabled",
				xmlName: "x-ms-immutable-storage-with-versioning-enabled",
				type: { name: "Boolean" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerGetPropertiesExceptionHeaders = {
	serializedName: "Container_getPropertiesExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerGetPropertiesExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerDeleteHeaders = {
	serializedName: "Container_deleteHeaders",
	type: {
		name: "Composite",
		className: "ContainerDeleteHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerDeleteExceptionHeaders = {
	serializedName: "Container_deleteExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerDeleteExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerSetMetadataHeaders = {
	serializedName: "Container_setMetadataHeaders",
	type: {
		name: "Composite",
		className: "ContainerSetMetadataHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerSetMetadataExceptionHeaders = {
	serializedName: "Container_setMetadataExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerSetMetadataExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerGetAccessPolicyHeaders = {
	serializedName: "Container_getAccessPolicyHeaders",
	type: {
		name: "Composite",
		className: "ContainerGetAccessPolicyHeaders",
		modelProperties: {
			blobPublicAccess: {
				serializedName: "x-ms-blob-public-access",
				xmlName: "x-ms-blob-public-access",
				type: {
					name: "Enum",
					allowedValues: ["container", "blob"]
				}
			},
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerGetAccessPolicyExceptionHeaders = {
	serializedName: "Container_getAccessPolicyExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerGetAccessPolicyExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerSetAccessPolicyHeaders = {
	serializedName: "Container_setAccessPolicyHeaders",
	type: {
		name: "Composite",
		className: "ContainerSetAccessPolicyHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerSetAccessPolicyExceptionHeaders = {
	serializedName: "Container_setAccessPolicyExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerSetAccessPolicyExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerRestoreHeaders = {
	serializedName: "Container_restoreHeaders",
	type: {
		name: "Composite",
		className: "ContainerRestoreHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerRestoreExceptionHeaders = {
	serializedName: "Container_restoreExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerRestoreExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerRenameHeaders = {
	serializedName: "Container_renameHeaders",
	type: {
		name: "Composite",
		className: "ContainerRenameHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerRenameExceptionHeaders = {
	serializedName: "Container_renameExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerRenameExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerSubmitBatchHeaders = {
	serializedName: "Container_submitBatchHeaders",
	type: {
		name: "Composite",
		className: "ContainerSubmitBatchHeaders",
		modelProperties: {
			contentType: {
				serializedName: "content-type",
				xmlName: "content-type",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			}
		}
	}
};
var ContainerSubmitBatchExceptionHeaders = {
	serializedName: "Container_submitBatchExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerSubmitBatchExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerFilterBlobsHeaders = {
	serializedName: "Container_filterBlobsHeaders",
	type: {
		name: "Composite",
		className: "ContainerFilterBlobsHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var ContainerFilterBlobsExceptionHeaders = {
	serializedName: "Container_filterBlobsExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerFilterBlobsExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerAcquireLeaseHeaders = {
	serializedName: "Container_acquireLeaseHeaders",
	type: {
		name: "Composite",
		className: "ContainerAcquireLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			leaseId: {
				serializedName: "x-ms-lease-id",
				xmlName: "x-ms-lease-id",
				type: { name: "String" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var ContainerAcquireLeaseExceptionHeaders = {
	serializedName: "Container_acquireLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerAcquireLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerReleaseLeaseHeaders = {
	serializedName: "Container_releaseLeaseHeaders",
	type: {
		name: "Composite",
		className: "ContainerReleaseLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var ContainerReleaseLeaseExceptionHeaders = {
	serializedName: "Container_releaseLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerReleaseLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerRenewLeaseHeaders = {
	serializedName: "Container_renewLeaseHeaders",
	type: {
		name: "Composite",
		className: "ContainerRenewLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			leaseId: {
				serializedName: "x-ms-lease-id",
				xmlName: "x-ms-lease-id",
				type: { name: "String" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var ContainerRenewLeaseExceptionHeaders = {
	serializedName: "Container_renewLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerRenewLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerBreakLeaseHeaders = {
	serializedName: "Container_breakLeaseHeaders",
	type: {
		name: "Composite",
		className: "ContainerBreakLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			leaseTime: {
				serializedName: "x-ms-lease-time",
				xmlName: "x-ms-lease-time",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var ContainerBreakLeaseExceptionHeaders = {
	serializedName: "Container_breakLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerBreakLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerChangeLeaseHeaders = {
	serializedName: "Container_changeLeaseHeaders",
	type: {
		name: "Composite",
		className: "ContainerChangeLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			leaseId: {
				serializedName: "x-ms-lease-id",
				xmlName: "x-ms-lease-id",
				type: { name: "String" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var ContainerChangeLeaseExceptionHeaders = {
	serializedName: "Container_changeLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerChangeLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerListBlobFlatSegmentHeaders = {
	serializedName: "Container_listBlobFlatSegmentHeaders",
	type: {
		name: "Composite",
		className: "ContainerListBlobFlatSegmentHeaders",
		modelProperties: {
			contentType: {
				serializedName: "content-type",
				xmlName: "content-type",
				type: { name: "String" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerListBlobFlatSegmentExceptionHeaders = {
	serializedName: "Container_listBlobFlatSegmentExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerListBlobFlatSegmentExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerListBlobHierarchySegmentHeaders = {
	serializedName: "Container_listBlobHierarchySegmentHeaders",
	type: {
		name: "Composite",
		className: "ContainerListBlobHierarchySegmentHeaders",
		modelProperties: {
			contentType: {
				serializedName: "content-type",
				xmlName: "content-type",
				type: { name: "String" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var ContainerListBlobHierarchySegmentExceptionHeaders = {
	serializedName: "Container_listBlobHierarchySegmentExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerListBlobHierarchySegmentExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var ContainerGetAccountInfoHeaders = {
	serializedName: "Container_getAccountInfoHeaders",
	type: {
		name: "Composite",
		className: "ContainerGetAccountInfoHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			skuName: {
				serializedName: "x-ms-sku-name",
				xmlName: "x-ms-sku-name",
				type: {
					name: "Enum",
					allowedValues: [
						"Standard_LRS",
						"Standard_GRS",
						"Standard_RAGRS",
						"Standard_ZRS",
						"Premium_LRS",
						"Standard_GZRS",
						"Premium_ZRS",
						"Standard_RAGZRS"
					]
				}
			},
			accountKind: {
				serializedName: "x-ms-account-kind",
				xmlName: "x-ms-account-kind",
				type: {
					name: "Enum",
					allowedValues: [
						"Storage",
						"BlobStorage",
						"StorageV2",
						"FileStorage",
						"BlockBlobStorage"
					]
				}
			},
			isHierarchicalNamespaceEnabled: {
				serializedName: "x-ms-is-hns-enabled",
				xmlName: "x-ms-is-hns-enabled",
				type: { name: "Boolean" }
			}
		}
	}
};
var ContainerGetAccountInfoExceptionHeaders = {
	serializedName: "Container_getAccountInfoExceptionHeaders",
	type: {
		name: "Composite",
		className: "ContainerGetAccountInfoExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobDownloadHeaders = {
	serializedName: "Blob_downloadHeaders",
	type: {
		name: "Composite",
		className: "BlobDownloadHeaders",
		modelProperties: {
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			createdOn: {
				serializedName: "x-ms-creation-time",
				xmlName: "x-ms-creation-time",
				type: { name: "DateTimeRfc1123" }
			},
			metadata: {
				serializedName: "x-ms-meta",
				headerCollectionPrefix: "x-ms-meta-",
				xmlName: "x-ms-meta",
				type: {
					name: "Dictionary",
					value: { type: { name: "String" } }
				}
			},
			objectReplicationPolicyId: {
				serializedName: "x-ms-or-policy-id",
				xmlName: "x-ms-or-policy-id",
				type: { name: "String" }
			},
			objectReplicationRules: {
				serializedName: "x-ms-or",
				headerCollectionPrefix: "x-ms-or-",
				xmlName: "x-ms-or",
				type: {
					name: "Dictionary",
					value: { type: { name: "String" } }
				}
			},
			contentLength: {
				serializedName: "content-length",
				xmlName: "content-length",
				type: { name: "Number" }
			},
			contentType: {
				serializedName: "content-type",
				xmlName: "content-type",
				type: { name: "String" }
			},
			contentRange: {
				serializedName: "content-range",
				xmlName: "content-range",
				type: { name: "String" }
			},
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			contentEncoding: {
				serializedName: "content-encoding",
				xmlName: "content-encoding",
				type: { name: "String" }
			},
			cacheControl: {
				serializedName: "cache-control",
				xmlName: "cache-control",
				type: { name: "String" }
			},
			contentDisposition: {
				serializedName: "content-disposition",
				xmlName: "content-disposition",
				type: { name: "String" }
			},
			contentLanguage: {
				serializedName: "content-language",
				xmlName: "content-language",
				type: { name: "String" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			blobType: {
				serializedName: "x-ms-blob-type",
				xmlName: "x-ms-blob-type",
				type: {
					name: "Enum",
					allowedValues: [
						"BlockBlob",
						"PageBlob",
						"AppendBlob"
					]
				}
			},
			copyCompletedOn: {
				serializedName: "x-ms-copy-completion-time",
				xmlName: "x-ms-copy-completion-time",
				type: { name: "DateTimeRfc1123" }
			},
			copyStatusDescription: {
				serializedName: "x-ms-copy-status-description",
				xmlName: "x-ms-copy-status-description",
				type: { name: "String" }
			},
			copyId: {
				serializedName: "x-ms-copy-id",
				xmlName: "x-ms-copy-id",
				type: { name: "String" }
			},
			copyProgress: {
				serializedName: "x-ms-copy-progress",
				xmlName: "x-ms-copy-progress",
				type: { name: "String" }
			},
			copySource: {
				serializedName: "x-ms-copy-source",
				xmlName: "x-ms-copy-source",
				type: { name: "String" }
			},
			copyStatus: {
				serializedName: "x-ms-copy-status",
				xmlName: "x-ms-copy-status",
				type: {
					name: "Enum",
					allowedValues: [
						"pending",
						"success",
						"aborted",
						"failed"
					]
				}
			},
			leaseDuration: {
				serializedName: "x-ms-lease-duration",
				xmlName: "x-ms-lease-duration",
				type: {
					name: "Enum",
					allowedValues: ["infinite", "fixed"]
				}
			},
			leaseState: {
				serializedName: "x-ms-lease-state",
				xmlName: "x-ms-lease-state",
				type: {
					name: "Enum",
					allowedValues: [
						"available",
						"leased",
						"expired",
						"breaking",
						"broken"
					]
				}
			},
			leaseStatus: {
				serializedName: "x-ms-lease-status",
				xmlName: "x-ms-lease-status",
				type: {
					name: "Enum",
					allowedValues: ["locked", "unlocked"]
				}
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			isCurrentVersion: {
				serializedName: "x-ms-is-current-version",
				xmlName: "x-ms-is-current-version",
				type: { name: "Boolean" }
			},
			acceptRanges: {
				serializedName: "accept-ranges",
				xmlName: "accept-ranges",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			blobCommittedBlockCount: {
				serializedName: "x-ms-blob-committed-block-count",
				xmlName: "x-ms-blob-committed-block-count",
				type: { name: "Number" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-server-encrypted",
				xmlName: "x-ms-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			blobContentMD5: {
				serializedName: "x-ms-blob-content-md5",
				xmlName: "x-ms-blob-content-md5",
				type: { name: "ByteArray" }
			},
			tagCount: {
				serializedName: "x-ms-tag-count",
				xmlName: "x-ms-tag-count",
				type: { name: "Number" }
			},
			isSealed: {
				serializedName: "x-ms-blob-sealed",
				xmlName: "x-ms-blob-sealed",
				type: { name: "Boolean" }
			},
			lastAccessed: {
				serializedName: "x-ms-last-access-time",
				xmlName: "x-ms-last-access-time",
				type: { name: "DateTimeRfc1123" }
			},
			immutabilityPolicyExpiresOn: {
				serializedName: "x-ms-immutability-policy-until-date",
				xmlName: "x-ms-immutability-policy-until-date",
				type: { name: "DateTimeRfc1123" }
			},
			immutabilityPolicyMode: {
				serializedName: "x-ms-immutability-policy-mode",
				xmlName: "x-ms-immutability-policy-mode",
				type: {
					name: "Enum",
					allowedValues: [
						"Mutable",
						"Unlocked",
						"Locked"
					]
				}
			},
			legalHold: {
				serializedName: "x-ms-legal-hold",
				xmlName: "x-ms-legal-hold",
				type: { name: "Boolean" }
			},
			structuredBodyType: {
				serializedName: "x-ms-structured-body",
				xmlName: "x-ms-structured-body",
				type: { name: "String" }
			},
			structuredContentLength: {
				serializedName: "x-ms-structured-content-length",
				xmlName: "x-ms-structured-content-length",
				type: { name: "Number" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			},
			contentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			}
		}
	}
};
var BlobDownloadExceptionHeaders = {
	serializedName: "Blob_downloadExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobDownloadExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobGetPropertiesHeaders = {
	serializedName: "Blob_getPropertiesHeaders",
	type: {
		name: "Composite",
		className: "BlobGetPropertiesHeaders",
		modelProperties: {
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			createdOn: {
				serializedName: "x-ms-creation-time",
				xmlName: "x-ms-creation-time",
				type: { name: "DateTimeRfc1123" }
			},
			metadata: {
				serializedName: "x-ms-meta",
				headerCollectionPrefix: "x-ms-meta-",
				xmlName: "x-ms-meta",
				type: {
					name: "Dictionary",
					value: { type: { name: "String" } }
				}
			},
			objectReplicationPolicyId: {
				serializedName: "x-ms-or-policy-id",
				xmlName: "x-ms-or-policy-id",
				type: { name: "String" }
			},
			objectReplicationRules: {
				serializedName: "x-ms-or",
				headerCollectionPrefix: "x-ms-or-",
				xmlName: "x-ms-or",
				type: {
					name: "Dictionary",
					value: { type: { name: "String" } }
				}
			},
			blobType: {
				serializedName: "x-ms-blob-type",
				xmlName: "x-ms-blob-type",
				type: {
					name: "Enum",
					allowedValues: [
						"BlockBlob",
						"PageBlob",
						"AppendBlob"
					]
				}
			},
			copyCompletedOn: {
				serializedName: "x-ms-copy-completion-time",
				xmlName: "x-ms-copy-completion-time",
				type: { name: "DateTimeRfc1123" }
			},
			copyStatusDescription: {
				serializedName: "x-ms-copy-status-description",
				xmlName: "x-ms-copy-status-description",
				type: { name: "String" }
			},
			copyId: {
				serializedName: "x-ms-copy-id",
				xmlName: "x-ms-copy-id",
				type: { name: "String" }
			},
			copyProgress: {
				serializedName: "x-ms-copy-progress",
				xmlName: "x-ms-copy-progress",
				type: { name: "String" }
			},
			copySource: {
				serializedName: "x-ms-copy-source",
				xmlName: "x-ms-copy-source",
				type: { name: "String" }
			},
			copyStatus: {
				serializedName: "x-ms-copy-status",
				xmlName: "x-ms-copy-status",
				type: {
					name: "Enum",
					allowedValues: [
						"pending",
						"success",
						"aborted",
						"failed"
					]
				}
			},
			isIncrementalCopy: {
				serializedName: "x-ms-incremental-copy",
				xmlName: "x-ms-incremental-copy",
				type: { name: "Boolean" }
			},
			destinationSnapshot: {
				serializedName: "x-ms-copy-destination-snapshot",
				xmlName: "x-ms-copy-destination-snapshot",
				type: { name: "String" }
			},
			leaseDuration: {
				serializedName: "x-ms-lease-duration",
				xmlName: "x-ms-lease-duration",
				type: {
					name: "Enum",
					allowedValues: ["infinite", "fixed"]
				}
			},
			leaseState: {
				serializedName: "x-ms-lease-state",
				xmlName: "x-ms-lease-state",
				type: {
					name: "Enum",
					allowedValues: [
						"available",
						"leased",
						"expired",
						"breaking",
						"broken"
					]
				}
			},
			leaseStatus: {
				serializedName: "x-ms-lease-status",
				xmlName: "x-ms-lease-status",
				type: {
					name: "Enum",
					allowedValues: ["locked", "unlocked"]
				}
			},
			contentLength: {
				serializedName: "content-length",
				xmlName: "content-length",
				type: { name: "Number" }
			},
			contentType: {
				serializedName: "content-type",
				xmlName: "content-type",
				type: { name: "String" }
			},
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			contentEncoding: {
				serializedName: "content-encoding",
				xmlName: "content-encoding",
				type: { name: "String" }
			},
			contentDisposition: {
				serializedName: "content-disposition",
				xmlName: "content-disposition",
				type: { name: "String" }
			},
			contentLanguage: {
				serializedName: "content-language",
				xmlName: "content-language",
				type: { name: "String" }
			},
			cacheControl: {
				serializedName: "cache-control",
				xmlName: "cache-control",
				type: { name: "String" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			acceptRanges: {
				serializedName: "accept-ranges",
				xmlName: "accept-ranges",
				type: { name: "String" }
			},
			blobCommittedBlockCount: {
				serializedName: "x-ms-blob-committed-block-count",
				xmlName: "x-ms-blob-committed-block-count",
				type: { name: "Number" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-server-encrypted",
				xmlName: "x-ms-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			accessTier: {
				serializedName: "x-ms-access-tier",
				xmlName: "x-ms-access-tier",
				type: { name: "String" }
			},
			accessTierInferred: {
				serializedName: "x-ms-access-tier-inferred",
				xmlName: "x-ms-access-tier-inferred",
				type: { name: "Boolean" }
			},
			archiveStatus: {
				serializedName: "x-ms-archive-status",
				xmlName: "x-ms-archive-status",
				type: { name: "String" }
			},
			accessTierChangedOn: {
				serializedName: "x-ms-access-tier-change-time",
				xmlName: "x-ms-access-tier-change-time",
				type: { name: "DateTimeRfc1123" }
			},
			smartAccessTier: {
				serializedName: "x-ms-smart-access-tier",
				xmlName: "x-ms-smart-access-tier",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			isCurrentVersion: {
				serializedName: "x-ms-is-current-version",
				xmlName: "x-ms-is-current-version",
				type: { name: "Boolean" }
			},
			tagCount: {
				serializedName: "x-ms-tag-count",
				xmlName: "x-ms-tag-count",
				type: { name: "Number" }
			},
			expiresOn: {
				serializedName: "x-ms-expiry-time",
				xmlName: "x-ms-expiry-time",
				type: { name: "DateTimeRfc1123" }
			},
			isSealed: {
				serializedName: "x-ms-blob-sealed",
				xmlName: "x-ms-blob-sealed",
				type: { name: "Boolean" }
			},
			rehydratePriority: {
				serializedName: "x-ms-rehydrate-priority",
				xmlName: "x-ms-rehydrate-priority",
				type: {
					name: "Enum",
					allowedValues: ["High", "Standard"]
				}
			},
			lastAccessed: {
				serializedName: "x-ms-last-access-time",
				xmlName: "x-ms-last-access-time",
				type: { name: "DateTimeRfc1123" }
			},
			immutabilityPolicyExpiresOn: {
				serializedName: "x-ms-immutability-policy-until-date",
				xmlName: "x-ms-immutability-policy-until-date",
				type: { name: "DateTimeRfc1123" }
			},
			immutabilityPolicyMode: {
				serializedName: "x-ms-immutability-policy-mode",
				xmlName: "x-ms-immutability-policy-mode",
				type: {
					name: "Enum",
					allowedValues: [
						"Mutable",
						"Unlocked",
						"Locked"
					]
				}
			},
			legalHold: {
				serializedName: "x-ms-legal-hold",
				xmlName: "x-ms-legal-hold",
				type: { name: "Boolean" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobGetPropertiesExceptionHeaders = {
	serializedName: "Blob_getPropertiesExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobGetPropertiesExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobDeleteHeaders = {
	serializedName: "Blob_deleteHeaders",
	type: {
		name: "Composite",
		className: "BlobDeleteHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobDeleteExceptionHeaders = {
	serializedName: "Blob_deleteExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobDeleteExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobUndeleteHeaders = {
	serializedName: "Blob_undeleteHeaders",
	type: {
		name: "Composite",
		className: "BlobUndeleteHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobUndeleteExceptionHeaders = {
	serializedName: "Blob_undeleteExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobUndeleteExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobSetExpiryHeaders = {
	serializedName: "Blob_setExpiryHeaders",
	type: {
		name: "Composite",
		className: "BlobSetExpiryHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var BlobSetExpiryExceptionHeaders = {
	serializedName: "Blob_setExpiryExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobSetExpiryExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobSetHttpHeadersHeaders = {
	serializedName: "Blob_setHttpHeadersHeaders",
	type: {
		name: "Composite",
		className: "BlobSetHttpHeadersHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobSetHttpHeadersExceptionHeaders = {
	serializedName: "Blob_setHttpHeadersExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobSetHttpHeadersExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobSetImmutabilityPolicyHeaders = {
	serializedName: "Blob_setImmutabilityPolicyHeaders",
	type: {
		name: "Composite",
		className: "BlobSetImmutabilityPolicyHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			immutabilityPolicyExpiry: {
				serializedName: "x-ms-immutability-policy-until-date",
				xmlName: "x-ms-immutability-policy-until-date",
				type: { name: "DateTimeRfc1123" }
			},
			immutabilityPolicyMode: {
				serializedName: "x-ms-immutability-policy-mode",
				xmlName: "x-ms-immutability-policy-mode",
				type: {
					name: "Enum",
					allowedValues: [
						"Mutable",
						"Unlocked",
						"Locked"
					]
				}
			}
		}
	}
};
var BlobSetImmutabilityPolicyExceptionHeaders = {
	serializedName: "Blob_setImmutabilityPolicyExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobSetImmutabilityPolicyExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobDeleteImmutabilityPolicyHeaders = {
	serializedName: "Blob_deleteImmutabilityPolicyHeaders",
	type: {
		name: "Composite",
		className: "BlobDeleteImmutabilityPolicyHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var BlobDeleteImmutabilityPolicyExceptionHeaders = {
	serializedName: "Blob_deleteImmutabilityPolicyExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobDeleteImmutabilityPolicyExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobSetLegalHoldHeaders = {
	serializedName: "Blob_setLegalHoldHeaders",
	type: {
		name: "Composite",
		className: "BlobSetLegalHoldHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			legalHold: {
				serializedName: "x-ms-legal-hold",
				xmlName: "x-ms-legal-hold",
				type: { name: "Boolean" }
			}
		}
	}
};
var BlobSetLegalHoldExceptionHeaders = {
	serializedName: "Blob_setLegalHoldExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobSetLegalHoldExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobSetMetadataHeaders = {
	serializedName: "Blob_setMetadataHeaders",
	type: {
		name: "Composite",
		className: "BlobSetMetadataHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobSetMetadataExceptionHeaders = {
	serializedName: "Blob_setMetadataExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobSetMetadataExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobAcquireLeaseHeaders = {
	serializedName: "Blob_acquireLeaseHeaders",
	type: {
		name: "Composite",
		className: "BlobAcquireLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			leaseId: {
				serializedName: "x-ms-lease-id",
				xmlName: "x-ms-lease-id",
				type: { name: "String" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var BlobAcquireLeaseExceptionHeaders = {
	serializedName: "Blob_acquireLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobAcquireLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobReleaseLeaseHeaders = {
	serializedName: "Blob_releaseLeaseHeaders",
	type: {
		name: "Composite",
		className: "BlobReleaseLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var BlobReleaseLeaseExceptionHeaders = {
	serializedName: "Blob_releaseLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobReleaseLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobRenewLeaseHeaders = {
	serializedName: "Blob_renewLeaseHeaders",
	type: {
		name: "Composite",
		className: "BlobRenewLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			leaseId: {
				serializedName: "x-ms-lease-id",
				xmlName: "x-ms-lease-id",
				type: { name: "String" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var BlobRenewLeaseExceptionHeaders = {
	serializedName: "Blob_renewLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobRenewLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobChangeLeaseHeaders = {
	serializedName: "Blob_changeLeaseHeaders",
	type: {
		name: "Composite",
		className: "BlobChangeLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			leaseId: {
				serializedName: "x-ms-lease-id",
				xmlName: "x-ms-lease-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var BlobChangeLeaseExceptionHeaders = {
	serializedName: "Blob_changeLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobChangeLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobBreakLeaseHeaders = {
	serializedName: "Blob_breakLeaseHeaders",
	type: {
		name: "Composite",
		className: "BlobBreakLeaseHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			leaseTime: {
				serializedName: "x-ms-lease-time",
				xmlName: "x-ms-lease-time",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			}
		}
	}
};
var BlobBreakLeaseExceptionHeaders = {
	serializedName: "Blob_breakLeaseExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobBreakLeaseExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobCreateSnapshotHeaders = {
	serializedName: "Blob_createSnapshotHeaders",
	type: {
		name: "Composite",
		className: "BlobCreateSnapshotHeaders",
		modelProperties: {
			snapshot: {
				serializedName: "x-ms-snapshot",
				xmlName: "x-ms-snapshot",
				type: { name: "String" }
			},
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobCreateSnapshotExceptionHeaders = {
	serializedName: "Blob_createSnapshotExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobCreateSnapshotExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobStartCopyFromURLHeaders = {
	serializedName: "Blob_startCopyFromURLHeaders",
	type: {
		name: "Composite",
		className: "BlobStartCopyFromURLHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			copyId: {
				serializedName: "x-ms-copy-id",
				xmlName: "x-ms-copy-id",
				type: { name: "String" }
			},
			copyStatus: {
				serializedName: "x-ms-copy-status",
				xmlName: "x-ms-copy-status",
				type: {
					name: "Enum",
					allowedValues: [
						"pending",
						"success",
						"aborted",
						"failed"
					]
				}
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobStartCopyFromURLExceptionHeaders = {
	serializedName: "Blob_startCopyFromURLExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobStartCopyFromURLExceptionHeaders",
		modelProperties: {
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			},
			copySourceErrorCode: {
				serializedName: "x-ms-copy-source-error-code",
				xmlName: "x-ms-copy-source-error-code",
				type: { name: "String" }
			},
			copySourceStatusCode: {
				serializedName: "x-ms-copy-source-status-code",
				xmlName: "x-ms-copy-source-status-code",
				type: { name: "Number" }
			}
		}
	}
};
var BlobCopyFromURLHeaders = {
	serializedName: "Blob_copyFromURLHeaders",
	type: {
		name: "Composite",
		className: "BlobCopyFromURLHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			copyId: {
				serializedName: "x-ms-copy-id",
				xmlName: "x-ms-copy-id",
				type: { name: "String" }
			},
			copyStatus: {
				defaultValue: "success",
				isConstant: true,
				serializedName: "x-ms-copy-status",
				type: { name: "String" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			xMsContentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobCopyFromURLExceptionHeaders = {
	serializedName: "Blob_copyFromURLExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobCopyFromURLExceptionHeaders",
		modelProperties: {
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			},
			copySourceErrorCode: {
				serializedName: "x-ms-copy-source-error-code",
				xmlName: "x-ms-copy-source-error-code",
				type: { name: "String" }
			},
			copySourceStatusCode: {
				serializedName: "x-ms-copy-source-status-code",
				xmlName: "x-ms-copy-source-status-code",
				type: { name: "Number" }
			}
		}
	}
};
var BlobAbortCopyFromURLHeaders = {
	serializedName: "Blob_abortCopyFromURLHeaders",
	type: {
		name: "Composite",
		className: "BlobAbortCopyFromURLHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobAbortCopyFromURLExceptionHeaders = {
	serializedName: "Blob_abortCopyFromURLExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobAbortCopyFromURLExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobSetTierHeaders = {
	serializedName: "Blob_setTierHeaders",
	type: {
		name: "Composite",
		className: "BlobSetTierHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobSetTierExceptionHeaders = {
	serializedName: "Blob_setTierExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobSetTierExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobGetAccountInfoHeaders = {
	serializedName: "Blob_getAccountInfoHeaders",
	type: {
		name: "Composite",
		className: "BlobGetAccountInfoHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			skuName: {
				serializedName: "x-ms-sku-name",
				xmlName: "x-ms-sku-name",
				type: {
					name: "Enum",
					allowedValues: [
						"Standard_LRS",
						"Standard_GRS",
						"Standard_RAGRS",
						"Standard_ZRS",
						"Premium_LRS",
						"Standard_GZRS",
						"Premium_ZRS",
						"Standard_RAGZRS"
					]
				}
			},
			accountKind: {
				serializedName: "x-ms-account-kind",
				xmlName: "x-ms-account-kind",
				type: {
					name: "Enum",
					allowedValues: [
						"Storage",
						"BlobStorage",
						"StorageV2",
						"FileStorage",
						"BlockBlobStorage"
					]
				}
			},
			isHierarchicalNamespaceEnabled: {
				serializedName: "x-ms-is-hns-enabled",
				xmlName: "x-ms-is-hns-enabled",
				type: { name: "Boolean" }
			}
		}
	}
};
var BlobGetAccountInfoExceptionHeaders = {
	serializedName: "Blob_getAccountInfoExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobGetAccountInfoExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobQueryHeaders = {
	serializedName: "Blob_queryHeaders",
	type: {
		name: "Composite",
		className: "BlobQueryHeaders",
		modelProperties: {
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			metadata: {
				serializedName: "x-ms-meta",
				headerCollectionPrefix: "x-ms-meta-",
				xmlName: "x-ms-meta",
				type: {
					name: "Dictionary",
					value: { type: { name: "String" } }
				}
			},
			contentLength: {
				serializedName: "content-length",
				xmlName: "content-length",
				type: { name: "Number" }
			},
			contentType: {
				serializedName: "content-type",
				xmlName: "content-type",
				type: { name: "String" }
			},
			contentRange: {
				serializedName: "content-range",
				xmlName: "content-range",
				type: { name: "String" }
			},
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			contentEncoding: {
				serializedName: "content-encoding",
				xmlName: "content-encoding",
				type: { name: "String" }
			},
			cacheControl: {
				serializedName: "cache-control",
				xmlName: "cache-control",
				type: { name: "String" }
			},
			contentDisposition: {
				serializedName: "content-disposition",
				xmlName: "content-disposition",
				type: { name: "String" }
			},
			contentLanguage: {
				serializedName: "content-language",
				xmlName: "content-language",
				type: { name: "String" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			blobType: {
				serializedName: "x-ms-blob-type",
				xmlName: "x-ms-blob-type",
				type: {
					name: "Enum",
					allowedValues: [
						"BlockBlob",
						"PageBlob",
						"AppendBlob"
					]
				}
			},
			copyCompletionTime: {
				serializedName: "x-ms-copy-completion-time",
				xmlName: "x-ms-copy-completion-time",
				type: { name: "DateTimeRfc1123" }
			},
			copyStatusDescription: {
				serializedName: "x-ms-copy-status-description",
				xmlName: "x-ms-copy-status-description",
				type: { name: "String" }
			},
			copyId: {
				serializedName: "x-ms-copy-id",
				xmlName: "x-ms-copy-id",
				type: { name: "String" }
			},
			copyProgress: {
				serializedName: "x-ms-copy-progress",
				xmlName: "x-ms-copy-progress",
				type: { name: "String" }
			},
			copySource: {
				serializedName: "x-ms-copy-source",
				xmlName: "x-ms-copy-source",
				type: { name: "String" }
			},
			copyStatus: {
				serializedName: "x-ms-copy-status",
				xmlName: "x-ms-copy-status",
				type: {
					name: "Enum",
					allowedValues: [
						"pending",
						"success",
						"aborted",
						"failed"
					]
				}
			},
			leaseDuration: {
				serializedName: "x-ms-lease-duration",
				xmlName: "x-ms-lease-duration",
				type: {
					name: "Enum",
					allowedValues: ["infinite", "fixed"]
				}
			},
			leaseState: {
				serializedName: "x-ms-lease-state",
				xmlName: "x-ms-lease-state",
				type: {
					name: "Enum",
					allowedValues: [
						"available",
						"leased",
						"expired",
						"breaking",
						"broken"
					]
				}
			},
			leaseStatus: {
				serializedName: "x-ms-lease-status",
				xmlName: "x-ms-lease-status",
				type: {
					name: "Enum",
					allowedValues: ["locked", "unlocked"]
				}
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			acceptRanges: {
				serializedName: "accept-ranges",
				xmlName: "accept-ranges",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			blobCommittedBlockCount: {
				serializedName: "x-ms-blob-committed-block-count",
				xmlName: "x-ms-blob-committed-block-count",
				type: { name: "Number" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-server-encrypted",
				xmlName: "x-ms-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			blobContentMD5: {
				serializedName: "x-ms-blob-content-md5",
				xmlName: "x-ms-blob-content-md5",
				type: { name: "ByteArray" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			},
			contentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			}
		}
	}
};
var BlobQueryExceptionHeaders = {
	serializedName: "Blob_queryExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobQueryExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobGetTagsHeaders = {
	serializedName: "Blob_getTagsHeaders",
	type: {
		name: "Composite",
		className: "BlobGetTagsHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobGetTagsExceptionHeaders = {
	serializedName: "Blob_getTagsExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobGetTagsExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlobSetTagsHeaders = {
	serializedName: "Blob_setTagsHeaders",
	type: {
		name: "Composite",
		className: "BlobSetTagsHeaders",
		modelProperties: {
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlobSetTagsExceptionHeaders = {
	serializedName: "Blob_setTagsExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlobSetTagsExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var PageBlobCreateHeaders = {
	serializedName: "PageBlob_createHeaders",
	type: {
		name: "Composite",
		className: "PageBlobCreateHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var PageBlobCreateExceptionHeaders = {
	serializedName: "PageBlob_createExceptionHeaders",
	type: {
		name: "Composite",
		className: "PageBlobCreateExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var PageBlobUploadPagesHeaders = {
	serializedName: "PageBlob_uploadPagesHeaders",
	type: {
		name: "Composite",
		className: "PageBlobUploadPagesHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			xMsContentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			structuredBodyType: {
				serializedName: "x-ms-structured-body",
				xmlName: "x-ms-structured-body",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var PageBlobUploadPagesExceptionHeaders = {
	serializedName: "PageBlob_uploadPagesExceptionHeaders",
	type: {
		name: "Composite",
		className: "PageBlobUploadPagesExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var PageBlobClearPagesHeaders = {
	serializedName: "PageBlob_clearPagesHeaders",
	type: {
		name: "Composite",
		className: "PageBlobClearPagesHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			xMsContentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var PageBlobClearPagesExceptionHeaders = {
	serializedName: "PageBlob_clearPagesExceptionHeaders",
	type: {
		name: "Composite",
		className: "PageBlobClearPagesExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var PageBlobUploadPagesFromURLHeaders = {
	serializedName: "PageBlob_uploadPagesFromURLHeaders",
	type: {
		name: "Composite",
		className: "PageBlobUploadPagesFromURLHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			xMsContentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var PageBlobUploadPagesFromURLExceptionHeaders = {
	serializedName: "PageBlob_uploadPagesFromURLExceptionHeaders",
	type: {
		name: "Composite",
		className: "PageBlobUploadPagesFromURLExceptionHeaders",
		modelProperties: {
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			},
			copySourceErrorCode: {
				serializedName: "x-ms-copy-source-error-code",
				xmlName: "x-ms-copy-source-error-code",
				type: { name: "String" }
			},
			copySourceStatusCode: {
				serializedName: "x-ms-copy-source-status-code",
				xmlName: "x-ms-copy-source-status-code",
				type: { name: "Number" }
			}
		}
	}
};
var PageBlobGetPageRangesHeaders = {
	serializedName: "PageBlob_getPageRangesHeaders",
	type: {
		name: "Composite",
		className: "PageBlobGetPageRangesHeaders",
		modelProperties: {
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			blobContentLength: {
				serializedName: "x-ms-blob-content-length",
				xmlName: "x-ms-blob-content-length",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var PageBlobGetPageRangesExceptionHeaders = {
	serializedName: "PageBlob_getPageRangesExceptionHeaders",
	type: {
		name: "Composite",
		className: "PageBlobGetPageRangesExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var PageBlobGetPageRangesDiffHeaders = {
	serializedName: "PageBlob_getPageRangesDiffHeaders",
	type: {
		name: "Composite",
		className: "PageBlobGetPageRangesDiffHeaders",
		modelProperties: {
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			blobContentLength: {
				serializedName: "x-ms-blob-content-length",
				xmlName: "x-ms-blob-content-length",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var PageBlobGetPageRangesDiffExceptionHeaders = {
	serializedName: "PageBlob_getPageRangesDiffExceptionHeaders",
	type: {
		name: "Composite",
		className: "PageBlobGetPageRangesDiffExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var PageBlobResizeHeaders = {
	serializedName: "PageBlob_resizeHeaders",
	type: {
		name: "Composite",
		className: "PageBlobResizeHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var PageBlobResizeExceptionHeaders = {
	serializedName: "PageBlob_resizeExceptionHeaders",
	type: {
		name: "Composite",
		className: "PageBlobResizeExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var PageBlobUpdateSequenceNumberHeaders = {
	serializedName: "PageBlob_updateSequenceNumberHeaders",
	type: {
		name: "Composite",
		className: "PageBlobUpdateSequenceNumberHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			blobSequenceNumber: {
				serializedName: "x-ms-blob-sequence-number",
				xmlName: "x-ms-blob-sequence-number",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var PageBlobUpdateSequenceNumberExceptionHeaders = {
	serializedName: "PageBlob_updateSequenceNumberExceptionHeaders",
	type: {
		name: "Composite",
		className: "PageBlobUpdateSequenceNumberExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var PageBlobCopyIncrementalHeaders = {
	serializedName: "PageBlob_copyIncrementalHeaders",
	type: {
		name: "Composite",
		className: "PageBlobCopyIncrementalHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			copyId: {
				serializedName: "x-ms-copy-id",
				xmlName: "x-ms-copy-id",
				type: { name: "String" }
			},
			copyStatus: {
				serializedName: "x-ms-copy-status",
				xmlName: "x-ms-copy-status",
				type: {
					name: "Enum",
					allowedValues: [
						"pending",
						"success",
						"aborted",
						"failed"
					]
				}
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var PageBlobCopyIncrementalExceptionHeaders = {
	serializedName: "PageBlob_copyIncrementalExceptionHeaders",
	type: {
		name: "Composite",
		className: "PageBlobCopyIncrementalExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var AppendBlobCreateHeaders = {
	serializedName: "AppendBlob_createHeaders",
	type: {
		name: "Composite",
		className: "AppendBlobCreateHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var AppendBlobCreateExceptionHeaders = {
	serializedName: "AppendBlob_createExceptionHeaders",
	type: {
		name: "Composite",
		className: "AppendBlobCreateExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var AppendBlobAppendBlockHeaders = {
	serializedName: "AppendBlob_appendBlockHeaders",
	type: {
		name: "Composite",
		className: "AppendBlobAppendBlockHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			xMsContentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			blobAppendOffset: {
				serializedName: "x-ms-blob-append-offset",
				xmlName: "x-ms-blob-append-offset",
				type: { name: "String" }
			},
			blobCommittedBlockCount: {
				serializedName: "x-ms-blob-committed-block-count",
				xmlName: "x-ms-blob-committed-block-count",
				type: { name: "Number" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			structuredBodyType: {
				serializedName: "x-ms-structured-body",
				xmlName: "x-ms-structured-body",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var AppendBlobAppendBlockExceptionHeaders = {
	serializedName: "AppendBlob_appendBlockExceptionHeaders",
	type: {
		name: "Composite",
		className: "AppendBlobAppendBlockExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var AppendBlobAppendBlockFromUrlHeaders = {
	serializedName: "AppendBlob_appendBlockFromUrlHeaders",
	type: {
		name: "Composite",
		className: "AppendBlobAppendBlockFromUrlHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			xMsContentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			blobAppendOffset: {
				serializedName: "x-ms-blob-append-offset",
				xmlName: "x-ms-blob-append-offset",
				type: { name: "String" }
			},
			blobCommittedBlockCount: {
				serializedName: "x-ms-blob-committed-block-count",
				xmlName: "x-ms-blob-committed-block-count",
				type: { name: "Number" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var AppendBlobAppendBlockFromUrlExceptionHeaders = {
	serializedName: "AppendBlob_appendBlockFromUrlExceptionHeaders",
	type: {
		name: "Composite",
		className: "AppendBlobAppendBlockFromUrlExceptionHeaders",
		modelProperties: {
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			},
			copySourceErrorCode: {
				serializedName: "x-ms-copy-source-error-code",
				xmlName: "x-ms-copy-source-error-code",
				type: { name: "String" }
			},
			copySourceStatusCode: {
				serializedName: "x-ms-copy-source-status-code",
				xmlName: "x-ms-copy-source-status-code",
				type: { name: "Number" }
			}
		}
	}
};
var AppendBlobSealHeaders = {
	serializedName: "AppendBlob_sealHeaders",
	type: {
		name: "Composite",
		className: "AppendBlobSealHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isSealed: {
				serializedName: "x-ms-blob-sealed",
				xmlName: "x-ms-blob-sealed",
				type: { name: "Boolean" }
			}
		}
	}
};
var AppendBlobSealExceptionHeaders = {
	serializedName: "AppendBlob_sealExceptionHeaders",
	type: {
		name: "Composite",
		className: "AppendBlobSealExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlockBlobUploadHeaders = {
	serializedName: "BlockBlob_uploadHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobUploadHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			structuredBodyType: {
				serializedName: "x-ms-structured-body",
				xmlName: "x-ms-structured-body",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlockBlobUploadExceptionHeaders = {
	serializedName: "BlockBlob_uploadExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobUploadExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlockBlobPutBlobFromUrlHeaders = {
	serializedName: "BlockBlob_putBlobFromUrlHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobPutBlobFromUrlHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlockBlobPutBlobFromUrlExceptionHeaders = {
	serializedName: "BlockBlob_putBlobFromUrlExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobPutBlobFromUrlExceptionHeaders",
		modelProperties: {
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			},
			copySourceErrorCode: {
				serializedName: "x-ms-copy-source-error-code",
				xmlName: "x-ms-copy-source-error-code",
				type: { name: "String" }
			},
			copySourceStatusCode: {
				serializedName: "x-ms-copy-source-status-code",
				xmlName: "x-ms-copy-source-status-code",
				type: { name: "Number" }
			}
		}
	}
};
var BlockBlobStageBlockHeaders = {
	serializedName: "BlockBlob_stageBlockHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobStageBlockHeaders",
		modelProperties: {
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			xMsContentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			structuredBodyType: {
				serializedName: "x-ms-structured-body",
				xmlName: "x-ms-structured-body",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlockBlobStageBlockExceptionHeaders = {
	serializedName: "BlockBlob_stageBlockExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobStageBlockExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlockBlobStageBlockFromURLHeaders = {
	serializedName: "BlockBlob_stageBlockFromURLHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobStageBlockFromURLHeaders",
		modelProperties: {
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			xMsContentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlockBlobStageBlockFromURLExceptionHeaders = {
	serializedName: "BlockBlob_stageBlockFromURLExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobStageBlockFromURLExceptionHeaders",
		modelProperties: {
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			},
			copySourceErrorCode: {
				serializedName: "x-ms-copy-source-error-code",
				xmlName: "x-ms-copy-source-error-code",
				type: { name: "String" }
			},
			copySourceStatusCode: {
				serializedName: "x-ms-copy-source-status-code",
				xmlName: "x-ms-copy-source-status-code",
				type: { name: "Number" }
			}
		}
	}
};
var BlockBlobCommitBlockListHeaders = {
	serializedName: "BlockBlob_commitBlockListHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobCommitBlockListHeaders",
		modelProperties: {
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			contentMD5: {
				serializedName: "content-md5",
				xmlName: "content-md5",
				type: { name: "ByteArray" }
			},
			xMsContentCrc64: {
				serializedName: "x-ms-content-crc64",
				xmlName: "x-ms-content-crc64",
				type: { name: "ByteArray" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			versionId: {
				serializedName: "x-ms-version-id",
				xmlName: "x-ms-version-id",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			isServerEncrypted: {
				serializedName: "x-ms-request-server-encrypted",
				xmlName: "x-ms-request-server-encrypted",
				type: { name: "Boolean" }
			},
			encryptionKeySha256: {
				serializedName: "x-ms-encryption-key-sha256",
				xmlName: "x-ms-encryption-key-sha256",
				type: { name: "String" }
			},
			encryptionScope: {
				serializedName: "x-ms-encryption-scope",
				xmlName: "x-ms-encryption-scope",
				type: { name: "String" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlockBlobCommitBlockListExceptionHeaders = {
	serializedName: "BlockBlob_commitBlockListExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobCommitBlockListExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
var BlockBlobGetBlockListHeaders = {
	serializedName: "BlockBlob_getBlockListHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobGetBlockListHeaders",
		modelProperties: {
			lastModified: {
				serializedName: "last-modified",
				xmlName: "last-modified",
				type: { name: "DateTimeRfc1123" }
			},
			etag: {
				serializedName: "etag",
				xmlName: "etag",
				type: { name: "String" }
			},
			contentType: {
				serializedName: "content-type",
				xmlName: "content-type",
				type: { name: "String" }
			},
			blobContentLength: {
				serializedName: "x-ms-blob-content-length",
				xmlName: "x-ms-blob-content-length",
				type: { name: "Number" }
			},
			clientRequestId: {
				serializedName: "x-ms-client-request-id",
				xmlName: "x-ms-client-request-id",
				type: { name: "String" }
			},
			requestId: {
				serializedName: "x-ms-request-id",
				xmlName: "x-ms-request-id",
				type: { name: "String" }
			},
			version: {
				serializedName: "x-ms-version",
				xmlName: "x-ms-version",
				type: { name: "String" }
			},
			date: {
				serializedName: "date",
				xmlName: "date",
				type: { name: "DateTimeRfc1123" }
			},
			errorCode: {
				serializedName: "x-ms-error-code",
				xmlName: "x-ms-error-code",
				type: { name: "String" }
			}
		}
	}
};
var BlockBlobGetBlockListExceptionHeaders = {
	serializedName: "BlockBlob_getBlockListExceptionHeaders",
	type: {
		name: "Composite",
		className: "BlockBlobGetBlockListExceptionHeaders",
		modelProperties: { errorCode: {
			serializedName: "x-ms-error-code",
			xmlName: "x-ms-error-code",
			type: { name: "String" }
		} }
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/generated/src/models/parameters.js
var contentType = {
	parameterPath: ["options", "contentType"],
	mapper: {
		defaultValue: "application/xml",
		isConstant: true,
		serializedName: "Content-Type",
		type: { name: "String" }
	}
};
var blobServiceProperties = {
	parameterPath: "blobServiceProperties",
	mapper: BlobServiceProperties
};
var accept = {
	parameterPath: "accept",
	mapper: {
		defaultValue: "application/xml",
		isConstant: true,
		serializedName: "Accept",
		type: { name: "String" }
	}
};
var url = {
	parameterPath: "url",
	mapper: {
		serializedName: "url",
		required: true,
		xmlName: "url",
		type: { name: "String" }
	},
	skipEncoding: true
};
var restype = {
	parameterPath: "restype",
	mapper: {
		defaultValue: "service",
		isConstant: true,
		serializedName: "restype",
		type: { name: "String" }
	}
};
var comp = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "properties",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var timeoutInSeconds = {
	parameterPath: ["options", "timeoutInSeconds"],
	mapper: {
		constraints: { InclusiveMinimum: 0 },
		serializedName: "timeout",
		xmlName: "timeout",
		type: { name: "Number" }
	}
};
var version$2 = {
	parameterPath: "version",
	mapper: {
		defaultValue: "2026-06-06",
		isConstant: true,
		serializedName: "x-ms-version",
		type: { name: "String" }
	}
};
var requestId = {
	parameterPath: ["options", "requestId"],
	mapper: {
		serializedName: "x-ms-client-request-id",
		xmlName: "x-ms-client-request-id",
		type: { name: "String" }
	}
};
var accept1 = {
	parameterPath: "accept",
	mapper: {
		defaultValue: "application/xml",
		isConstant: true,
		serializedName: "Accept",
		type: { name: "String" }
	}
};
var comp1 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "stats",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var comp2 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "list",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var prefix = {
	parameterPath: ["options", "prefix"],
	mapper: {
		serializedName: "prefix",
		xmlName: "prefix",
		type: { name: "String" }
	}
};
var marker = {
	parameterPath: ["options", "marker"],
	mapper: {
		serializedName: "marker",
		xmlName: "marker",
		type: { name: "String" }
	}
};
var maxPageSize = {
	parameterPath: ["options", "maxPageSize"],
	mapper: {
		constraints: { InclusiveMinimum: 1 },
		serializedName: "maxresults",
		xmlName: "maxresults",
		type: { name: "Number" }
	}
};
var include = {
	parameterPath: ["options", "include"],
	mapper: {
		serializedName: "include",
		xmlName: "include",
		xmlElementName: "ListContainersIncludeType",
		type: {
			name: "Sequence",
			element: { type: {
				name: "Enum",
				allowedValues: [
					"metadata",
					"deleted",
					"system"
				]
			} }
		}
	},
	collectionFormat: "CSV"
};
var keyInfo = {
	parameterPath: "keyInfo",
	mapper: KeyInfo
};
var comp3 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "userdelegationkey",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var restype1 = {
	parameterPath: "restype",
	mapper: {
		defaultValue: "account",
		isConstant: true,
		serializedName: "restype",
		type: { name: "String" }
	}
};
var body = {
	parameterPath: "body",
	mapper: {
		serializedName: "body",
		required: true,
		xmlName: "body",
		type: { name: "Stream" }
	}
};
var comp4 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "batch",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var contentLength = {
	parameterPath: "contentLength",
	mapper: {
		serializedName: "Content-Length",
		required: true,
		xmlName: "Content-Length",
		type: { name: "Number" }
	}
};
var multipartContentType = {
	parameterPath: "multipartContentType",
	mapper: {
		serializedName: "Content-Type",
		required: true,
		xmlName: "Content-Type",
		type: { name: "String" }
	}
};
var comp5 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "blobs",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var where = {
	parameterPath: ["options", "where"],
	mapper: {
		serializedName: "where",
		xmlName: "where",
		type: { name: "String" }
	}
};
var restype2 = {
	parameterPath: "restype",
	mapper: {
		defaultValue: "container",
		isConstant: true,
		serializedName: "restype",
		type: { name: "String" }
	}
};
var metadata = {
	parameterPath: ["options", "metadata"],
	mapper: {
		serializedName: "x-ms-meta",
		xmlName: "x-ms-meta",
		headerCollectionPrefix: "x-ms-meta-",
		type: {
			name: "Dictionary",
			value: { type: { name: "String" } }
		}
	}
};
var access = {
	parameterPath: ["options", "access"],
	mapper: {
		serializedName: "x-ms-blob-public-access",
		xmlName: "x-ms-blob-public-access",
		type: {
			name: "Enum",
			allowedValues: ["container", "blob"]
		}
	}
};
var defaultEncryptionScope = {
	parameterPath: [
		"options",
		"containerEncryptionScope",
		"defaultEncryptionScope"
	],
	mapper: {
		serializedName: "x-ms-default-encryption-scope",
		xmlName: "x-ms-default-encryption-scope",
		type: { name: "String" }
	}
};
var preventEncryptionScopeOverride = {
	parameterPath: [
		"options",
		"containerEncryptionScope",
		"preventEncryptionScopeOverride"
	],
	mapper: {
		serializedName: "x-ms-deny-encryption-scope-override",
		xmlName: "x-ms-deny-encryption-scope-override",
		type: { name: "Boolean" }
	}
};
var leaseId = {
	parameterPath: [
		"options",
		"leaseAccessConditions",
		"leaseId"
	],
	mapper: {
		serializedName: "x-ms-lease-id",
		xmlName: "x-ms-lease-id",
		type: { name: "String" }
	}
};
var ifModifiedSince = {
	parameterPath: [
		"options",
		"modifiedAccessConditions",
		"ifModifiedSince"
	],
	mapper: {
		serializedName: "If-Modified-Since",
		xmlName: "If-Modified-Since",
		type: { name: "DateTimeRfc1123" }
	}
};
var ifUnmodifiedSince = {
	parameterPath: [
		"options",
		"modifiedAccessConditions",
		"ifUnmodifiedSince"
	],
	mapper: {
		serializedName: "If-Unmodified-Since",
		xmlName: "If-Unmodified-Since",
		type: { name: "DateTimeRfc1123" }
	}
};
var comp6 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "metadata",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var comp7 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "acl",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var containerAcl = {
	parameterPath: ["options", "containerAcl"],
	mapper: {
		serializedName: "containerAcl",
		xmlName: "SignedIdentifiers",
		xmlIsWrapped: true,
		xmlElementName: "SignedIdentifier",
		type: {
			name: "Sequence",
			element: { type: {
				name: "Composite",
				className: "SignedIdentifier"
			} }
		}
	}
};
var comp8 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "undelete",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var deletedContainerName = {
	parameterPath: ["options", "deletedContainerName"],
	mapper: {
		serializedName: "x-ms-deleted-container-name",
		xmlName: "x-ms-deleted-container-name",
		type: { name: "String" }
	}
};
var deletedContainerVersion = {
	parameterPath: ["options", "deletedContainerVersion"],
	mapper: {
		serializedName: "x-ms-deleted-container-version",
		xmlName: "x-ms-deleted-container-version",
		type: { name: "String" }
	}
};
var comp9 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "rename",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var sourceContainerName = {
	parameterPath: "sourceContainerName",
	mapper: {
		serializedName: "x-ms-source-container-name",
		required: true,
		xmlName: "x-ms-source-container-name",
		type: { name: "String" }
	}
};
var sourceLeaseId = {
	parameterPath: ["options", "sourceLeaseId"],
	mapper: {
		serializedName: "x-ms-source-lease-id",
		xmlName: "x-ms-source-lease-id",
		type: { name: "String" }
	}
};
var comp10 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "lease",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var action = {
	parameterPath: "action",
	mapper: {
		defaultValue: "acquire",
		isConstant: true,
		serializedName: "x-ms-lease-action",
		type: { name: "String" }
	}
};
var duration = {
	parameterPath: ["options", "duration"],
	mapper: {
		serializedName: "x-ms-lease-duration",
		xmlName: "x-ms-lease-duration",
		type: { name: "Number" }
	}
};
var proposedLeaseId = {
	parameterPath: ["options", "proposedLeaseId"],
	mapper: {
		serializedName: "x-ms-proposed-lease-id",
		xmlName: "x-ms-proposed-lease-id",
		type: { name: "String" }
	}
};
var action1 = {
	parameterPath: "action",
	mapper: {
		defaultValue: "release",
		isConstant: true,
		serializedName: "x-ms-lease-action",
		type: { name: "String" }
	}
};
var leaseId1 = {
	parameterPath: "leaseId",
	mapper: {
		serializedName: "x-ms-lease-id",
		required: true,
		xmlName: "x-ms-lease-id",
		type: { name: "String" }
	}
};
var action2 = {
	parameterPath: "action",
	mapper: {
		defaultValue: "renew",
		isConstant: true,
		serializedName: "x-ms-lease-action",
		type: { name: "String" }
	}
};
var action3 = {
	parameterPath: "action",
	mapper: {
		defaultValue: "break",
		isConstant: true,
		serializedName: "x-ms-lease-action",
		type: { name: "String" }
	}
};
var breakPeriod = {
	parameterPath: ["options", "breakPeriod"],
	mapper: {
		serializedName: "x-ms-lease-break-period",
		xmlName: "x-ms-lease-break-period",
		type: { name: "Number" }
	}
};
var action4 = {
	parameterPath: "action",
	mapper: {
		defaultValue: "change",
		isConstant: true,
		serializedName: "x-ms-lease-action",
		type: { name: "String" }
	}
};
var proposedLeaseId1 = {
	parameterPath: "proposedLeaseId",
	mapper: {
		serializedName: "x-ms-proposed-lease-id",
		required: true,
		xmlName: "x-ms-proposed-lease-id",
		type: { name: "String" }
	}
};
var include1 = {
	parameterPath: ["options", "include"],
	mapper: {
		serializedName: "include",
		xmlName: "include",
		xmlElementName: "ListBlobsIncludeItem",
		type: {
			name: "Sequence",
			element: { type: {
				name: "Enum",
				allowedValues: [
					"copy",
					"deleted",
					"metadata",
					"snapshots",
					"uncommittedblobs",
					"versions",
					"tags",
					"immutabilitypolicy",
					"legalhold",
					"deletedwithversions"
				]
			} }
		}
	},
	collectionFormat: "CSV"
};
var startFrom = {
	parameterPath: ["options", "startFrom"],
	mapper: {
		serializedName: "startFrom",
		xmlName: "startFrom",
		type: { name: "String" }
	}
};
var delimiter = {
	parameterPath: "delimiter",
	mapper: {
		serializedName: "delimiter",
		required: true,
		xmlName: "delimiter",
		type: { name: "String" }
	}
};
var snapshot = {
	parameterPath: ["options", "snapshot"],
	mapper: {
		serializedName: "snapshot",
		xmlName: "snapshot",
		type: { name: "String" }
	}
};
var versionId = {
	parameterPath: ["options", "versionId"],
	mapper: {
		serializedName: "versionid",
		xmlName: "versionid",
		type: { name: "String" }
	}
};
var range = {
	parameterPath: ["options", "range"],
	mapper: {
		serializedName: "x-ms-range",
		xmlName: "x-ms-range",
		type: { name: "String" }
	}
};
var rangeGetContentMD5 = {
	parameterPath: ["options", "rangeGetContentMD5"],
	mapper: {
		serializedName: "x-ms-range-get-content-md5",
		xmlName: "x-ms-range-get-content-md5",
		type: { name: "Boolean" }
	}
};
var rangeGetContentCRC64 = {
	parameterPath: ["options", "rangeGetContentCRC64"],
	mapper: {
		serializedName: "x-ms-range-get-content-crc64",
		xmlName: "x-ms-range-get-content-crc64",
		type: { name: "Boolean" }
	}
};
var structuredBodyType = {
	parameterPath: ["options", "structuredBodyType"],
	mapper: {
		serializedName: "x-ms-structured-body",
		xmlName: "x-ms-structured-body",
		type: { name: "String" }
	}
};
var encryptionKey = {
	parameterPath: [
		"options",
		"cpkInfo",
		"encryptionKey"
	],
	mapper: {
		serializedName: "x-ms-encryption-key",
		xmlName: "x-ms-encryption-key",
		type: { name: "String" }
	}
};
var encryptionKeySha256 = {
	parameterPath: [
		"options",
		"cpkInfo",
		"encryptionKeySha256"
	],
	mapper: {
		serializedName: "x-ms-encryption-key-sha256",
		xmlName: "x-ms-encryption-key-sha256",
		type: { name: "String" }
	}
};
var encryptionAlgorithm = {
	parameterPath: [
		"options",
		"cpkInfo",
		"encryptionAlgorithm"
	],
	mapper: {
		serializedName: "x-ms-encryption-algorithm",
		xmlName: "x-ms-encryption-algorithm",
		type: { name: "String" }
	}
};
var ifMatch = {
	parameterPath: [
		"options",
		"modifiedAccessConditions",
		"ifMatch"
	],
	mapper: {
		serializedName: "If-Match",
		xmlName: "If-Match",
		type: { name: "String" }
	}
};
var ifNoneMatch = {
	parameterPath: [
		"options",
		"modifiedAccessConditions",
		"ifNoneMatch"
	],
	mapper: {
		serializedName: "If-None-Match",
		xmlName: "If-None-Match",
		type: { name: "String" }
	}
};
var ifTags = {
	parameterPath: [
		"options",
		"modifiedAccessConditions",
		"ifTags"
	],
	mapper: {
		serializedName: "x-ms-if-tags",
		xmlName: "x-ms-if-tags",
		type: { name: "String" }
	}
};
var deleteSnapshots = {
	parameterPath: ["options", "deleteSnapshots"],
	mapper: {
		serializedName: "x-ms-delete-snapshots",
		xmlName: "x-ms-delete-snapshots",
		type: {
			name: "Enum",
			allowedValues: ["include", "only"]
		}
	}
};
var blobDeleteType = {
	parameterPath: ["options", "blobDeleteType"],
	mapper: {
		serializedName: "deletetype",
		xmlName: "deletetype",
		type: { name: "String" }
	}
};
var accessTierIfModifiedSince = {
	parameterPath: ["options", "accessTierIfModifiedSince"],
	mapper: {
		serializedName: "x-ms-access-tier-if-modified-since",
		xmlName: "x-ms-access-tier-if-modified-since",
		type: { name: "DateTimeRfc1123" }
	}
};
var accessTierIfUnmodifiedSince = {
	parameterPath: ["options", "accessTierIfUnmodifiedSince"],
	mapper: {
		serializedName: "x-ms-access-tier-if-unmodified-since",
		xmlName: "x-ms-access-tier-if-unmodified-since",
		type: { name: "DateTimeRfc1123" }
	}
};
var comp11 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "expiry",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var expiryOptions = {
	parameterPath: "expiryOptions",
	mapper: {
		serializedName: "x-ms-expiry-option",
		required: true,
		xmlName: "x-ms-expiry-option",
		type: { name: "String" }
	}
};
var expiresOn = {
	parameterPath: ["options", "expiresOn"],
	mapper: {
		serializedName: "x-ms-expiry-time",
		xmlName: "x-ms-expiry-time",
		type: { name: "String" }
	}
};
var blobCacheControl = {
	parameterPath: [
		"options",
		"blobHttpHeaders",
		"blobCacheControl"
	],
	mapper: {
		serializedName: "x-ms-blob-cache-control",
		xmlName: "x-ms-blob-cache-control",
		type: { name: "String" }
	}
};
var blobContentType = {
	parameterPath: [
		"options",
		"blobHttpHeaders",
		"blobContentType"
	],
	mapper: {
		serializedName: "x-ms-blob-content-type",
		xmlName: "x-ms-blob-content-type",
		type: { name: "String" }
	}
};
var blobContentMD5 = {
	parameterPath: [
		"options",
		"blobHttpHeaders",
		"blobContentMD5"
	],
	mapper: {
		serializedName: "x-ms-blob-content-md5",
		xmlName: "x-ms-blob-content-md5",
		type: { name: "ByteArray" }
	}
};
var blobContentEncoding = {
	parameterPath: [
		"options",
		"blobHttpHeaders",
		"blobContentEncoding"
	],
	mapper: {
		serializedName: "x-ms-blob-content-encoding",
		xmlName: "x-ms-blob-content-encoding",
		type: { name: "String" }
	}
};
var blobContentLanguage = {
	parameterPath: [
		"options",
		"blobHttpHeaders",
		"blobContentLanguage"
	],
	mapper: {
		serializedName: "x-ms-blob-content-language",
		xmlName: "x-ms-blob-content-language",
		type: { name: "String" }
	}
};
var blobContentDisposition = {
	parameterPath: [
		"options",
		"blobHttpHeaders",
		"blobContentDisposition"
	],
	mapper: {
		serializedName: "x-ms-blob-content-disposition",
		xmlName: "x-ms-blob-content-disposition",
		type: { name: "String" }
	}
};
var comp12 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "immutabilityPolicies",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var immutabilityPolicyExpiry = {
	parameterPath: ["options", "immutabilityPolicyExpiry"],
	mapper: {
		serializedName: "x-ms-immutability-policy-until-date",
		xmlName: "x-ms-immutability-policy-until-date",
		type: { name: "DateTimeRfc1123" }
	}
};
var immutabilityPolicyMode = {
	parameterPath: ["options", "immutabilityPolicyMode"],
	mapper: {
		serializedName: "x-ms-immutability-policy-mode",
		xmlName: "x-ms-immutability-policy-mode",
		type: {
			name: "Enum",
			allowedValues: [
				"Mutable",
				"Unlocked",
				"Locked"
			]
		}
	}
};
var comp13 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "legalhold",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var legalHold = {
	parameterPath: "legalHold",
	mapper: {
		serializedName: "x-ms-legal-hold",
		required: true,
		xmlName: "x-ms-legal-hold",
		type: { name: "Boolean" }
	}
};
var encryptionScope = {
	parameterPath: ["options", "encryptionScope"],
	mapper: {
		serializedName: "x-ms-encryption-scope",
		xmlName: "x-ms-encryption-scope",
		type: { name: "String" }
	}
};
var comp14 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "snapshot",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var tier = {
	parameterPath: ["options", "tier"],
	mapper: {
		serializedName: "x-ms-access-tier",
		xmlName: "x-ms-access-tier",
		type: {
			name: "Enum",
			allowedValues: [
				"P4",
				"P6",
				"P10",
				"P15",
				"P20",
				"P30",
				"P40",
				"P50",
				"P60",
				"P70",
				"P80",
				"Hot",
				"Cool",
				"Archive",
				"Cold",
				"Smart"
			]
		}
	}
};
var rehydratePriority = {
	parameterPath: ["options", "rehydratePriority"],
	mapper: {
		serializedName: "x-ms-rehydrate-priority",
		xmlName: "x-ms-rehydrate-priority",
		type: {
			name: "Enum",
			allowedValues: ["High", "Standard"]
		}
	}
};
var sourceIfModifiedSince = {
	parameterPath: [
		"options",
		"sourceModifiedAccessConditions",
		"sourceIfModifiedSince"
	],
	mapper: {
		serializedName: "x-ms-source-if-modified-since",
		xmlName: "x-ms-source-if-modified-since",
		type: { name: "DateTimeRfc1123" }
	}
};
var sourceIfUnmodifiedSince = {
	parameterPath: [
		"options",
		"sourceModifiedAccessConditions",
		"sourceIfUnmodifiedSince"
	],
	mapper: {
		serializedName: "x-ms-source-if-unmodified-since",
		xmlName: "x-ms-source-if-unmodified-since",
		type: { name: "DateTimeRfc1123" }
	}
};
var sourceIfMatch = {
	parameterPath: [
		"options",
		"sourceModifiedAccessConditions",
		"sourceIfMatch"
	],
	mapper: {
		serializedName: "x-ms-source-if-match",
		xmlName: "x-ms-source-if-match",
		type: { name: "String" }
	}
};
var sourceIfNoneMatch = {
	parameterPath: [
		"options",
		"sourceModifiedAccessConditions",
		"sourceIfNoneMatch"
	],
	mapper: {
		serializedName: "x-ms-source-if-none-match",
		xmlName: "x-ms-source-if-none-match",
		type: { name: "String" }
	}
};
var sourceIfTags = {
	parameterPath: [
		"options",
		"sourceModifiedAccessConditions",
		"sourceIfTags"
	],
	mapper: {
		serializedName: "x-ms-source-if-tags",
		xmlName: "x-ms-source-if-tags",
		type: { name: "String" }
	}
};
var copySource = {
	parameterPath: "copySource",
	mapper: {
		serializedName: "x-ms-copy-source",
		required: true,
		xmlName: "x-ms-copy-source",
		type: { name: "String" }
	}
};
var blobTagsString = {
	parameterPath: ["options", "blobTagsString"],
	mapper: {
		serializedName: "x-ms-tags",
		xmlName: "x-ms-tags",
		type: { name: "String" }
	}
};
var sealBlob = {
	parameterPath: ["options", "sealBlob"],
	mapper: {
		serializedName: "x-ms-seal-blob",
		xmlName: "x-ms-seal-blob",
		type: { name: "Boolean" }
	}
};
var legalHold1 = {
	parameterPath: ["options", "legalHold"],
	mapper: {
		serializedName: "x-ms-legal-hold",
		xmlName: "x-ms-legal-hold",
		type: { name: "Boolean" }
	}
};
var xMsRequiresSync = {
	parameterPath: "xMsRequiresSync",
	mapper: {
		defaultValue: "true",
		isConstant: true,
		serializedName: "x-ms-requires-sync",
		type: { name: "String" }
	}
};
var sourceContentMD5 = {
	parameterPath: ["options", "sourceContentMD5"],
	mapper: {
		serializedName: "x-ms-source-content-md5",
		xmlName: "x-ms-source-content-md5",
		type: { name: "ByteArray" }
	}
};
var copySourceAuthorization = {
	parameterPath: ["options", "copySourceAuthorization"],
	mapper: {
		serializedName: "x-ms-copy-source-authorization",
		xmlName: "x-ms-copy-source-authorization",
		type: { name: "String" }
	}
};
var copySourceTags = {
	parameterPath: ["options", "copySourceTags"],
	mapper: {
		serializedName: "x-ms-copy-source-tag-option",
		xmlName: "x-ms-copy-source-tag-option",
		type: {
			name: "Enum",
			allowedValues: ["REPLACE", "COPY"]
		}
	}
};
var fileRequestIntent = {
	parameterPath: ["options", "fileRequestIntent"],
	mapper: {
		serializedName: "x-ms-file-request-intent",
		xmlName: "x-ms-file-request-intent",
		type: { name: "String" }
	}
};
var comp15 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "copy",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var copyActionAbortConstant = {
	parameterPath: "copyActionAbortConstant",
	mapper: {
		defaultValue: "abort",
		isConstant: true,
		serializedName: "x-ms-copy-action",
		type: { name: "String" }
	}
};
var copyId = {
	parameterPath: "copyId",
	mapper: {
		serializedName: "copyid",
		required: true,
		xmlName: "copyid",
		type: { name: "String" }
	}
};
var comp16 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "tier",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var tier1 = {
	parameterPath: "tier",
	mapper: {
		serializedName: "x-ms-access-tier",
		required: true,
		xmlName: "x-ms-access-tier",
		type: {
			name: "Enum",
			allowedValues: [
				"P4",
				"P6",
				"P10",
				"P15",
				"P20",
				"P30",
				"P40",
				"P50",
				"P60",
				"P70",
				"P80",
				"Hot",
				"Cool",
				"Archive",
				"Cold",
				"Smart"
			]
		}
	}
};
var queryRequest = {
	parameterPath: ["options", "queryRequest"],
	mapper: QueryRequest
};
var comp17 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "query",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var comp18 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "tags",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var ifModifiedSince1 = {
	parameterPath: [
		"options",
		"blobModifiedAccessConditions",
		"ifModifiedSince"
	],
	mapper: {
		serializedName: "x-ms-blob-if-modified-since",
		xmlName: "x-ms-blob-if-modified-since",
		type: { name: "DateTimeRfc1123" }
	}
};
var ifUnmodifiedSince1 = {
	parameterPath: [
		"options",
		"blobModifiedAccessConditions",
		"ifUnmodifiedSince"
	],
	mapper: {
		serializedName: "x-ms-blob-if-unmodified-since",
		xmlName: "x-ms-blob-if-unmodified-since",
		type: { name: "DateTimeRfc1123" }
	}
};
var ifMatch1 = {
	parameterPath: [
		"options",
		"blobModifiedAccessConditions",
		"ifMatch"
	],
	mapper: {
		serializedName: "x-ms-blob-if-match",
		xmlName: "x-ms-blob-if-match",
		type: { name: "String" }
	}
};
var ifNoneMatch1 = {
	parameterPath: [
		"options",
		"blobModifiedAccessConditions",
		"ifNoneMatch"
	],
	mapper: {
		serializedName: "x-ms-blob-if-none-match",
		xmlName: "x-ms-blob-if-none-match",
		type: { name: "String" }
	}
};
var tags = {
	parameterPath: ["options", "tags"],
	mapper: BlobTags
};
var transactionalContentMD5 = {
	parameterPath: ["options", "transactionalContentMD5"],
	mapper: {
		serializedName: "Content-MD5",
		xmlName: "Content-MD5",
		type: { name: "ByteArray" }
	}
};
var transactionalContentCrc64 = {
	parameterPath: ["options", "transactionalContentCrc64"],
	mapper: {
		serializedName: "x-ms-content-crc64",
		xmlName: "x-ms-content-crc64",
		type: { name: "ByteArray" }
	}
};
var blobType = {
	parameterPath: "blobType",
	mapper: {
		defaultValue: "PageBlob",
		isConstant: true,
		serializedName: "x-ms-blob-type",
		type: { name: "String" }
	}
};
var blobContentLength = {
	parameterPath: "blobContentLength",
	mapper: {
		serializedName: "x-ms-blob-content-length",
		required: true,
		xmlName: "x-ms-blob-content-length",
		type: { name: "Number" }
	}
};
var blobSequenceNumber = {
	parameterPath: ["options", "blobSequenceNumber"],
	mapper: {
		defaultValue: 0,
		serializedName: "x-ms-blob-sequence-number",
		xmlName: "x-ms-blob-sequence-number",
		type: { name: "Number" }
	}
};
var contentType1 = {
	parameterPath: ["options", "contentType"],
	mapper: {
		defaultValue: "application/octet-stream",
		isConstant: true,
		serializedName: "Content-Type",
		type: { name: "String" }
	}
};
var body1 = {
	parameterPath: "body",
	mapper: {
		serializedName: "body",
		required: true,
		xmlName: "body",
		type: { name: "Stream" }
	}
};
var accept2 = {
	parameterPath: "accept",
	mapper: {
		defaultValue: "application/xml",
		isConstant: true,
		serializedName: "Accept",
		type: { name: "String" }
	}
};
var comp19 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "page",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var pageWrite = {
	parameterPath: "pageWrite",
	mapper: {
		defaultValue: "update",
		isConstant: true,
		serializedName: "x-ms-page-write",
		type: { name: "String" }
	}
};
var ifSequenceNumberLessThanOrEqualTo = {
	parameterPath: [
		"options",
		"sequenceNumberAccessConditions",
		"ifSequenceNumberLessThanOrEqualTo"
	],
	mapper: {
		serializedName: "x-ms-if-sequence-number-le",
		xmlName: "x-ms-if-sequence-number-le",
		type: { name: "Number" }
	}
};
var ifSequenceNumberLessThan = {
	parameterPath: [
		"options",
		"sequenceNumberAccessConditions",
		"ifSequenceNumberLessThan"
	],
	mapper: {
		serializedName: "x-ms-if-sequence-number-lt",
		xmlName: "x-ms-if-sequence-number-lt",
		type: { name: "Number" }
	}
};
var ifSequenceNumberEqualTo = {
	parameterPath: [
		"options",
		"sequenceNumberAccessConditions",
		"ifSequenceNumberEqualTo"
	],
	mapper: {
		serializedName: "x-ms-if-sequence-number-eq",
		xmlName: "x-ms-if-sequence-number-eq",
		type: { name: "Number" }
	}
};
var structuredContentLength = {
	parameterPath: ["options", "structuredContentLength"],
	mapper: {
		serializedName: "x-ms-structured-content-length",
		xmlName: "x-ms-structured-content-length",
		type: { name: "Number" }
	}
};
var pageWrite1 = {
	parameterPath: "pageWrite",
	mapper: {
		defaultValue: "clear",
		isConstant: true,
		serializedName: "x-ms-page-write",
		type: { name: "String" }
	}
};
var sourceUrl = {
	parameterPath: "sourceUrl",
	mapper: {
		serializedName: "x-ms-copy-source",
		required: true,
		xmlName: "x-ms-copy-source",
		type: { name: "String" }
	}
};
var sourceRange = {
	parameterPath: "sourceRange",
	mapper: {
		serializedName: "x-ms-source-range",
		required: true,
		xmlName: "x-ms-source-range",
		type: { name: "String" }
	}
};
var sourceContentCrc64 = {
	parameterPath: ["options", "sourceContentCrc64"],
	mapper: {
		serializedName: "x-ms-source-content-crc64",
		xmlName: "x-ms-source-content-crc64",
		type: { name: "ByteArray" }
	}
};
var range1 = {
	parameterPath: "range",
	mapper: {
		serializedName: "x-ms-range",
		required: true,
		xmlName: "x-ms-range",
		type: { name: "String" }
	}
};
var sourceEncryptionKey = {
	parameterPath: [
		"options",
		"sourceCpkInfo",
		"sourceEncryptionKey"
	],
	mapper: {
		serializedName: "x-ms-source-encryption-key",
		xmlName: "x-ms-source-encryption-key",
		type: { name: "String" }
	}
};
var sourceEncryptionKeySha256 = {
	parameterPath: [
		"options",
		"sourceCpkInfo",
		"sourceEncryptionKeySha256"
	],
	mapper: {
		serializedName: "x-ms-source-encryption-key-sha256",
		xmlName: "x-ms-source-encryption-key-sha256",
		type: { name: "String" }
	}
};
var sourceEncryptionAlgorithm = {
	parameterPath: [
		"options",
		"sourceCpkInfo",
		"sourceEncryptionAlgorithm"
	],
	mapper: {
		serializedName: "x-ms-source-encryption-algorithm",
		xmlName: "x-ms-source-encryption-algorithm",
		type: { name: "String" }
	}
};
var comp20 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "pagelist",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var prevsnapshot = {
	parameterPath: ["options", "prevsnapshot"],
	mapper: {
		serializedName: "prevsnapshot",
		xmlName: "prevsnapshot",
		type: { name: "String" }
	}
};
var prevSnapshotUrl = {
	parameterPath: ["options", "prevSnapshotUrl"],
	mapper: {
		serializedName: "x-ms-previous-snapshot-url",
		xmlName: "x-ms-previous-snapshot-url",
		type: { name: "String" }
	}
};
var sequenceNumberAction = {
	parameterPath: "sequenceNumberAction",
	mapper: {
		serializedName: "x-ms-sequence-number-action",
		required: true,
		xmlName: "x-ms-sequence-number-action",
		type: {
			name: "Enum",
			allowedValues: [
				"max",
				"update",
				"increment"
			]
		}
	}
};
var comp21 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "incrementalcopy",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var blobType1 = {
	parameterPath: "blobType",
	mapper: {
		defaultValue: "AppendBlob",
		isConstant: true,
		serializedName: "x-ms-blob-type",
		type: { name: "String" }
	}
};
var comp22 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "appendblock",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var maxSize = {
	parameterPath: [
		"options",
		"appendPositionAccessConditions",
		"maxSize"
	],
	mapper: {
		serializedName: "x-ms-blob-condition-maxsize",
		xmlName: "x-ms-blob-condition-maxsize",
		type: { name: "Number" }
	}
};
var appendPosition = {
	parameterPath: [
		"options",
		"appendPositionAccessConditions",
		"appendPosition"
	],
	mapper: {
		serializedName: "x-ms-blob-condition-appendpos",
		xmlName: "x-ms-blob-condition-appendpos",
		type: { name: "Number" }
	}
};
var sourceRange1 = {
	parameterPath: ["options", "sourceRange"],
	mapper: {
		serializedName: "x-ms-source-range",
		xmlName: "x-ms-source-range",
		type: { name: "String" }
	}
};
var comp23 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "seal",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var blobType2 = {
	parameterPath: "blobType",
	mapper: {
		defaultValue: "BlockBlob",
		isConstant: true,
		serializedName: "x-ms-blob-type",
		type: { name: "String" }
	}
};
var copySourceBlobProperties = {
	parameterPath: ["options", "copySourceBlobProperties"],
	mapper: {
		serializedName: "x-ms-copy-source-blob-properties",
		xmlName: "x-ms-copy-source-blob-properties",
		type: { name: "Boolean" }
	}
};
var comp24 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "block",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var blockId = {
	parameterPath: "blockId",
	mapper: {
		serializedName: "blockid",
		required: true,
		xmlName: "blockid",
		type: { name: "String" }
	}
};
var blocks = {
	parameterPath: "blocks",
	mapper: BlockLookupList
};
var comp25 = {
	parameterPath: "comp",
	mapper: {
		defaultValue: "blocklist",
		isConstant: true,
		serializedName: "comp",
		type: { name: "String" }
	}
};
var listType = {
	parameterPath: "listType",
	mapper: {
		defaultValue: "committed",
		serializedName: "blocklisttype",
		required: true,
		xmlName: "blocklisttype",
		type: {
			name: "Enum",
			allowedValues: [
				"committed",
				"uncommitted",
				"all"
			]
		}
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/generated/src/operations/service.js
/** Class containing Service operations. */
var ServiceImpl = class {
	client;
	/**
	* Initialize a new instance of the class Service class.
	* @param client Reference to the service client
	*/
	constructor(client) {
		this.client = client;
	}
	/**
	* Sets properties for a storage account's Blob service endpoint, including properties for Storage
	* Analytics and CORS (Cross-Origin Resource Sharing) rules
	* @param blobServiceProperties The StorageService properties.
	* @param options The options parameters.
	*/
	setProperties(blobServiceProperties, options) {
		return this.client.sendOperationRequest({
			blobServiceProperties,
			options
		}, setPropertiesOperationSpec);
	}
	/**
	* gets the properties of a storage account's Blob service, including properties for Storage Analytics
	* and CORS (Cross-Origin Resource Sharing) rules.
	* @param options The options parameters.
	*/
	getProperties(options) {
		return this.client.sendOperationRequest({ options }, getPropertiesOperationSpec$2);
	}
	/**
	* Retrieves statistics related to replication for the Blob service. It is only available on the
	* secondary location endpoint when read-access geo-redundant replication is enabled for the storage
	* account.
	* @param options The options parameters.
	*/
	getStatistics(options) {
		return this.client.sendOperationRequest({ options }, getStatisticsOperationSpec);
	}
	/**
	* The List Containers Segment operation returns a list of the containers under the specified account
	* @param options The options parameters.
	*/
	listContainersSegment(options) {
		return this.client.sendOperationRequest({ options }, listContainersSegmentOperationSpec);
	}
	/**
	* Retrieves a user delegation key for the Blob service. This is only a valid operation when using
	* bearer token authentication.
	* @param keyInfo Key information
	* @param options The options parameters.
	*/
	getUserDelegationKey(keyInfo, options) {
		return this.client.sendOperationRequest({
			keyInfo,
			options
		}, getUserDelegationKeyOperationSpec);
	}
	/**
	* Returns the sku name and account kind
	* @param options The options parameters.
	*/
	getAccountInfo(options) {
		return this.client.sendOperationRequest({ options }, getAccountInfoOperationSpec$2);
	}
	/**
	* The Batch operation allows multiple API calls to be embedded into a single HTTP request.
	* @param contentLength The length of the request.
	* @param multipartContentType Required. The value of this header must be multipart/mixed with a batch
	*                             boundary. Example header value: multipart/mixed; boundary=batch_<GUID>
	* @param body Initial data
	* @param options The options parameters.
	*/
	submitBatch(contentLength, multipartContentType, body, options) {
		return this.client.sendOperationRequest({
			contentLength,
			multipartContentType,
			body,
			options
		}, submitBatchOperationSpec$1);
	}
	/**
	* The Filter Blobs operation enables callers to list blobs across all containers whose tags match a
	* given search expression.  Filter blobs searches across all containers within a storage account but
	* can be scoped within the expression to a single container.
	* @param options The options parameters.
	*/
	filterBlobs(options) {
		return this.client.sendOperationRequest({ options }, filterBlobsOperationSpec$1);
	}
};
var xmlSerializer$5 = createSerializer(mappers_exports, true);
var setPropertiesOperationSpec = {
	path: "/",
	httpMethod: "PUT",
	responses: {
		202: { headersMapper: ServiceSetPropertiesHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ServiceSetPropertiesExceptionHeaders
		}
	},
	requestBody: blobServiceProperties,
	queryParameters: [
		restype,
		comp,
		timeoutInSeconds
	],
	urlParameters: [url],
	headerParameters: [
		contentType,
		accept,
		version$2,
		requestId
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "xml",
	serializer: xmlSerializer$5
};
var getPropertiesOperationSpec$2 = {
	path: "/",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: BlobServiceProperties,
			headersMapper: ServiceGetPropertiesHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ServiceGetPropertiesExceptionHeaders
		}
	},
	queryParameters: [
		restype,
		comp,
		timeoutInSeconds
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$5
};
var getStatisticsOperationSpec = {
	path: "/",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: BlobServiceStatistics,
			headersMapper: ServiceGetStatisticsHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ServiceGetStatisticsExceptionHeaders
		}
	},
	queryParameters: [
		restype,
		timeoutInSeconds,
		comp1
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$5
};
var listContainersSegmentOperationSpec = {
	path: "/",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: ListContainersSegmentResponse,
			headersMapper: ServiceListContainersSegmentHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ServiceListContainersSegmentExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		comp2,
		prefix,
		marker,
		maxPageSize,
		include
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$5
};
var getUserDelegationKeyOperationSpec = {
	path: "/",
	httpMethod: "POST",
	responses: {
		200: {
			bodyMapper: UserDelegationKey,
			headersMapper: ServiceGetUserDelegationKeyHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ServiceGetUserDelegationKeyExceptionHeaders
		}
	},
	requestBody: keyInfo,
	queryParameters: [
		restype,
		timeoutInSeconds,
		comp3
	],
	urlParameters: [url],
	headerParameters: [
		contentType,
		accept,
		version$2,
		requestId
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "xml",
	serializer: xmlSerializer$5
};
var getAccountInfoOperationSpec$2 = {
	path: "/",
	httpMethod: "GET",
	responses: {
		200: { headersMapper: ServiceGetAccountInfoHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ServiceGetAccountInfoExceptionHeaders
		}
	},
	queryParameters: [
		comp,
		timeoutInSeconds,
		restype1
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$5
};
var submitBatchOperationSpec$1 = {
	path: "/",
	httpMethod: "POST",
	responses: {
		202: {
			bodyMapper: {
				type: { name: "Stream" },
				serializedName: "parsedResponse"
			},
			headersMapper: ServiceSubmitBatchHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ServiceSubmitBatchExceptionHeaders
		}
	},
	requestBody: body,
	queryParameters: [timeoutInSeconds, comp4],
	urlParameters: [url],
	headerParameters: [
		accept,
		version$2,
		requestId,
		contentLength,
		multipartContentType
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "xml",
	serializer: xmlSerializer$5
};
var filterBlobsOperationSpec$1 = {
	path: "/",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: FilterBlobSegment,
			headersMapper: ServiceFilterBlobsHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ServiceFilterBlobsExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		marker,
		maxPageSize,
		comp5,
		where
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$5
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/generated/src/operations/container.js
/** Class containing Container operations. */
var ContainerImpl = class {
	client;
	/**
	* Initialize a new instance of the class Container class.
	* @param client Reference to the service client
	*/
	constructor(client) {
		this.client = client;
	}
	/**
	* creates a new container under the specified account. If the container with the same name already
	* exists, the operation fails
	* @param options The options parameters.
	*/
	create(options) {
		return this.client.sendOperationRequest({ options }, createOperationSpec$2);
	}
	/**
	* returns all user-defined metadata and system properties for the specified container. The data
	* returned does not include the container's list of blobs
	* @param options The options parameters.
	*/
	getProperties(options) {
		return this.client.sendOperationRequest({ options }, getPropertiesOperationSpec$1);
	}
	/**
	* operation marks the specified container for deletion. The container and any blobs contained within
	* it are later deleted during garbage collection
	* @param options The options parameters.
	*/
	delete(options) {
		return this.client.sendOperationRequest({ options }, deleteOperationSpec$1);
	}
	/**
	* operation sets one or more user-defined name-value pairs for the specified container.
	* @param options The options parameters.
	*/
	setMetadata(options) {
		return this.client.sendOperationRequest({ options }, setMetadataOperationSpec$1);
	}
	/**
	* gets the permissions for the specified container. The permissions indicate whether container data
	* may be accessed publicly.
	* @param options The options parameters.
	*/
	getAccessPolicy(options) {
		return this.client.sendOperationRequest({ options }, getAccessPolicyOperationSpec);
	}
	/**
	* sets the permissions for the specified container. The permissions indicate whether blobs in a
	* container may be accessed publicly.
	* @param options The options parameters.
	*/
	setAccessPolicy(options) {
		return this.client.sendOperationRequest({ options }, setAccessPolicyOperationSpec);
	}
	/**
	* Restores a previously-deleted container.
	* @param options The options parameters.
	*/
	restore(options) {
		return this.client.sendOperationRequest({ options }, restoreOperationSpec);
	}
	/**
	* Renames an existing container.
	* @param sourceContainerName Required.  Specifies the name of the container to rename.
	* @param options The options parameters.
	*/
	rename(sourceContainerName, options) {
		return this.client.sendOperationRequest({
			sourceContainerName,
			options
		}, renameOperationSpec);
	}
	/**
	* The Batch operation allows multiple API calls to be embedded into a single HTTP request.
	* @param contentLength The length of the request.
	* @param multipartContentType Required. The value of this header must be multipart/mixed with a batch
	*                             boundary. Example header value: multipart/mixed; boundary=batch_<GUID>
	* @param body Initial data
	* @param options The options parameters.
	*/
	submitBatch(contentLength, multipartContentType, body, options) {
		return this.client.sendOperationRequest({
			contentLength,
			multipartContentType,
			body,
			options
		}, submitBatchOperationSpec);
	}
	/**
	* The Filter Blobs operation enables callers to list blobs in a container whose tags match a given
	* search expression.  Filter blobs searches within the given container.
	* @param options The options parameters.
	*/
	filterBlobs(options) {
		return this.client.sendOperationRequest({ options }, filterBlobsOperationSpec);
	}
	/**
	* [Update] establishes and manages a lock on a container for delete operations. The lock duration can
	* be 15 to 60 seconds, or can be infinite
	* @param options The options parameters.
	*/
	acquireLease(options) {
		return this.client.sendOperationRequest({ options }, acquireLeaseOperationSpec$1);
	}
	/**
	* [Update] establishes and manages a lock on a container for delete operations. The lock duration can
	* be 15 to 60 seconds, or can be infinite
	* @param leaseId Specifies the current lease ID on the resource.
	* @param options The options parameters.
	*/
	releaseLease(leaseId, options) {
		return this.client.sendOperationRequest({
			leaseId,
			options
		}, releaseLeaseOperationSpec$1);
	}
	/**
	* [Update] establishes and manages a lock on a container for delete operations. The lock duration can
	* be 15 to 60 seconds, or can be infinite
	* @param leaseId Specifies the current lease ID on the resource.
	* @param options The options parameters.
	*/
	renewLease(leaseId, options) {
		return this.client.sendOperationRequest({
			leaseId,
			options
		}, renewLeaseOperationSpec$1);
	}
	/**
	* [Update] establishes and manages a lock on a container for delete operations. The lock duration can
	* be 15 to 60 seconds, or can be infinite
	* @param options The options parameters.
	*/
	breakLease(options) {
		return this.client.sendOperationRequest({ options }, breakLeaseOperationSpec$1);
	}
	/**
	* [Update] establishes and manages a lock on a container for delete operations. The lock duration can
	* be 15 to 60 seconds, or can be infinite
	* @param leaseId Specifies the current lease ID on the resource.
	* @param proposedLeaseId Proposed lease ID, in a GUID string format. The Blob service returns 400
	*                        (Invalid request) if the proposed lease ID is not in the correct format. See Guid Constructor
	*                        (String) for a list of valid GUID string formats.
	* @param options The options parameters.
	*/
	changeLease(leaseId, proposedLeaseId, options) {
		return this.client.sendOperationRequest({
			leaseId,
			proposedLeaseId,
			options
		}, changeLeaseOperationSpec$1);
	}
	/**
	* [Update] The List Blobs operation returns a list of the blobs under the specified container
	* @param options The options parameters.
	*/
	listBlobFlatSegment(options) {
		return this.client.sendOperationRequest({ options }, listBlobFlatSegmentOperationSpec);
	}
	/**
	* [Update] The List Blobs operation returns a list of the blobs under the specified container
	* @param delimiter When the request includes this parameter, the operation returns a BlobPrefix
	*                  element in the response body that acts as a placeholder for all blobs whose names begin with the
	*                  same substring up to the appearance of the delimiter character. The delimiter may be a single
	*                  character or a string.
	* @param options The options parameters.
	*/
	listBlobHierarchySegment(delimiter, options) {
		return this.client.sendOperationRequest({
			delimiter,
			options
		}, listBlobHierarchySegmentOperationSpec);
	}
	/**
	* Returns the sku name and account kind
	* @param options The options parameters.
	*/
	getAccountInfo(options) {
		return this.client.sendOperationRequest({ options }, getAccountInfoOperationSpec$1);
	}
};
var xmlSerializer$4 = createSerializer(mappers_exports, true);
var createOperationSpec$2 = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: ContainerCreateHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerCreateExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, restype2],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		metadata,
		access,
		defaultEncryptionScope,
		preventEncryptionScopeOverride
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var getPropertiesOperationSpec$1 = {
	path: "/{containerName}",
	httpMethod: "GET",
	responses: {
		200: { headersMapper: ContainerGetPropertiesHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerGetPropertiesExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, restype2],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var deleteOperationSpec$1 = {
	path: "/{containerName}",
	httpMethod: "DELETE",
	responses: {
		202: { headersMapper: ContainerDeleteHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerDeleteExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, restype2],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var setMetadataOperationSpec$1 = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: ContainerSetMetadataHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerSetMetadataExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp6
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		metadata,
		leaseId,
		ifModifiedSince
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var getAccessPolicyOperationSpec = {
	path: "/{containerName}",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: {
				type: {
					name: "Sequence",
					element: { type: {
						name: "Composite",
						className: "SignedIdentifier"
					} }
				},
				serializedName: "SignedIdentifiers",
				xmlName: "SignedIdentifiers",
				xmlIsWrapped: true,
				xmlElementName: "SignedIdentifier"
			},
			headersMapper: ContainerGetAccessPolicyHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerGetAccessPolicyExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp7
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var setAccessPolicyOperationSpec = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: ContainerSetAccessPolicyHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerSetAccessPolicyExceptionHeaders
		}
	},
	requestBody: containerAcl,
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp7
	],
	urlParameters: [url],
	headerParameters: [
		contentType,
		accept,
		version$2,
		requestId,
		access,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "xml",
	serializer: xmlSerializer$4
};
var restoreOperationSpec = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: ContainerRestoreHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerRestoreExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp8
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		deletedContainerName,
		deletedContainerVersion
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var renameOperationSpec = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: ContainerRenameHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerRenameExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp9
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		sourceContainerName,
		sourceLeaseId
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var submitBatchOperationSpec = {
	path: "/{containerName}",
	httpMethod: "POST",
	responses: {
		202: {
			bodyMapper: {
				type: { name: "Stream" },
				serializedName: "parsedResponse"
			},
			headersMapper: ContainerSubmitBatchHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerSubmitBatchExceptionHeaders
		}
	},
	requestBody: body,
	queryParameters: [
		timeoutInSeconds,
		comp4,
		restype2
	],
	urlParameters: [url],
	headerParameters: [
		accept,
		version$2,
		requestId,
		contentLength,
		multipartContentType
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "xml",
	serializer: xmlSerializer$4
};
var filterBlobsOperationSpec = {
	path: "/{containerName}",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: FilterBlobSegment,
			headersMapper: ContainerFilterBlobsHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerFilterBlobsExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		marker,
		maxPageSize,
		comp5,
		where,
		restype2
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var acquireLeaseOperationSpec$1 = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: ContainerAcquireLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerAcquireLeaseExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp10
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		action,
		duration,
		proposedLeaseId
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var releaseLeaseOperationSpec$1 = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: ContainerReleaseLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerReleaseLeaseExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp10
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		action1,
		leaseId1
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var renewLeaseOperationSpec$1 = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: ContainerRenewLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerRenewLeaseExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp10
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		leaseId1,
		action2
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var breakLeaseOperationSpec$1 = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		202: { headersMapper: ContainerBreakLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerBreakLeaseExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp10
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		action3,
		breakPeriod
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var changeLeaseOperationSpec$1 = {
	path: "/{containerName}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: ContainerChangeLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerChangeLeaseExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		restype2,
		comp10
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		leaseId1,
		action4,
		proposedLeaseId1
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var listBlobFlatSegmentOperationSpec = {
	path: "/{containerName}",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: ListBlobsFlatSegmentResponse,
			headersMapper: ContainerListBlobFlatSegmentHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerListBlobFlatSegmentExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		comp2,
		prefix,
		marker,
		maxPageSize,
		restype2,
		include1,
		startFrom
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var listBlobHierarchySegmentOperationSpec = {
	path: "/{containerName}",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: ListBlobsHierarchySegmentResponse,
			headersMapper: ContainerListBlobHierarchySegmentHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerListBlobHierarchySegmentExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		comp2,
		prefix,
		marker,
		maxPageSize,
		restype2,
		include1,
		startFrom,
		delimiter
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$4
};
var getAccountInfoOperationSpec$1 = {
	path: "/{containerName}",
	httpMethod: "GET",
	responses: {
		200: { headersMapper: ContainerGetAccountInfoHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: ContainerGetAccountInfoExceptionHeaders
		}
	},
	queryParameters: [
		comp,
		timeoutInSeconds,
		restype1
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$4
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/generated/src/operations/blob.js
/** Class containing Blob operations. */
var BlobImpl = class {
	client;
	/**
	* Initialize a new instance of the class Blob class.
	* @param client Reference to the service client
	*/
	constructor(client) {
		this.client = client;
	}
	/**
	* The Download operation reads or downloads a blob from the system, including its metadata and
	* properties. You can also call Download to read a snapshot.
	* @param options The options parameters.
	*/
	download(options) {
		return this.client.sendOperationRequest({ options }, downloadOperationSpec);
	}
	/**
	* The Get Properties operation returns all user-defined metadata, standard HTTP properties, and system
	* properties for the blob. It does not return the content of the blob.
	* @param options The options parameters.
	*/
	getProperties(options) {
		return this.client.sendOperationRequest({ options }, getPropertiesOperationSpec);
	}
	/**
	* If the storage account's soft delete feature is disabled then, when a blob is deleted, it is
	* permanently removed from the storage account. If the storage account's soft delete feature is
	* enabled, then, when a blob is deleted, it is marked for deletion and becomes inaccessible
	* immediately. However, the blob service retains the blob or snapshot for the number of days specified
	* by the DeleteRetentionPolicy section of [Storage service properties]
	* (Set-Blob-Service-Properties.md). After the specified number of days has passed, the blob's data is
	* permanently removed from the storage account. Note that you continue to be charged for the
	* soft-deleted blob's storage until it is permanently removed. Use the List Blobs API and specify the
	* "include=deleted" query parameter to discover which blobs and snapshots have been soft deleted. You
	* can then use the Undelete Blob API to restore a soft-deleted blob. All other operations on a
	* soft-deleted blob or snapshot causes the service to return an HTTP status code of 404
	* (ResourceNotFound).
	* @param options The options parameters.
	*/
	delete(options) {
		return this.client.sendOperationRequest({ options }, deleteOperationSpec);
	}
	/**
	* Undelete a blob that was previously soft deleted
	* @param options The options parameters.
	*/
	undelete(options) {
		return this.client.sendOperationRequest({ options }, undeleteOperationSpec);
	}
	/**
	* Sets the time a blob will expire and be deleted.
	* @param expiryOptions Required. Indicates mode of the expiry time
	* @param options The options parameters.
	*/
	setExpiry(expiryOptions, options) {
		return this.client.sendOperationRequest({
			expiryOptions,
			options
		}, setExpiryOperationSpec);
	}
	/**
	* The Set HTTP Headers operation sets system properties on the blob
	* @param options The options parameters.
	*/
	setHttpHeaders(options) {
		return this.client.sendOperationRequest({ options }, setHttpHeadersOperationSpec);
	}
	/**
	* The Set Immutability Policy operation sets the immutability policy on the blob
	* @param options The options parameters.
	*/
	setImmutabilityPolicy(options) {
		return this.client.sendOperationRequest({ options }, setImmutabilityPolicyOperationSpec);
	}
	/**
	* The Delete Immutability Policy operation deletes the immutability policy on the blob
	* @param options The options parameters.
	*/
	deleteImmutabilityPolicy(options) {
		return this.client.sendOperationRequest({ options }, deleteImmutabilityPolicyOperationSpec);
	}
	/**
	* The Set Legal Hold operation sets a legal hold on the blob.
	* @param legalHold Specified if a legal hold should be set on the blob.
	* @param options The options parameters.
	*/
	setLegalHold(legalHold, options) {
		return this.client.sendOperationRequest({
			legalHold,
			options
		}, setLegalHoldOperationSpec);
	}
	/**
	* The Set Blob Metadata operation sets user-defined metadata for the specified blob as one or more
	* name-value pairs
	* @param options The options parameters.
	*/
	setMetadata(options) {
		return this.client.sendOperationRequest({ options }, setMetadataOperationSpec);
	}
	/**
	* [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
	* operations
	* @param options The options parameters.
	*/
	acquireLease(options) {
		return this.client.sendOperationRequest({ options }, acquireLeaseOperationSpec);
	}
	/**
	* [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
	* operations
	* @param leaseId Specifies the current lease ID on the resource.
	* @param options The options parameters.
	*/
	releaseLease(leaseId, options) {
		return this.client.sendOperationRequest({
			leaseId,
			options
		}, releaseLeaseOperationSpec);
	}
	/**
	* [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
	* operations
	* @param leaseId Specifies the current lease ID on the resource.
	* @param options The options parameters.
	*/
	renewLease(leaseId, options) {
		return this.client.sendOperationRequest({
			leaseId,
			options
		}, renewLeaseOperationSpec);
	}
	/**
	* [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
	* operations
	* @param leaseId Specifies the current lease ID on the resource.
	* @param proposedLeaseId Proposed lease ID, in a GUID string format. The Blob service returns 400
	*                        (Invalid request) if the proposed lease ID is not in the correct format. See Guid Constructor
	*                        (String) for a list of valid GUID string formats.
	* @param options The options parameters.
	*/
	changeLease(leaseId, proposedLeaseId, options) {
		return this.client.sendOperationRequest({
			leaseId,
			proposedLeaseId,
			options
		}, changeLeaseOperationSpec);
	}
	/**
	* [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
	* operations
	* @param options The options parameters.
	*/
	breakLease(options) {
		return this.client.sendOperationRequest({ options }, breakLeaseOperationSpec);
	}
	/**
	* The Create Snapshot operation creates a read-only snapshot of a blob
	* @param options The options parameters.
	*/
	createSnapshot(options) {
		return this.client.sendOperationRequest({ options }, createSnapshotOperationSpec);
	}
	/**
	* The Start Copy From URL operation copies a blob or an internet resource to a new blob.
	* @param copySource Specifies the name of the source page blob snapshot. This value is a URL of up to
	*                   2 KB in length that specifies a page blob snapshot. The value should be URL-encoded as it would
	*                   appear in a request URI. The source blob must either be public or must be authenticated via a shared
	*                   access signature.
	* @param options The options parameters.
	*/
	startCopyFromURL(copySource, options) {
		return this.client.sendOperationRequest({
			copySource,
			options
		}, startCopyFromURLOperationSpec);
	}
	/**
	* The Copy From URL operation copies a blob or an internet resource to a new blob. It will not return
	* a response until the copy is complete.
	* @param copySource Specifies the name of the source page blob snapshot. This value is a URL of up to
	*                   2 KB in length that specifies a page blob snapshot. The value should be URL-encoded as it would
	*                   appear in a request URI. The source blob must either be public or must be authenticated via a shared
	*                   access signature.
	* @param options The options parameters.
	*/
	copyFromURL(copySource, options) {
		return this.client.sendOperationRequest({
			copySource,
			options
		}, copyFromURLOperationSpec);
	}
	/**
	* The Abort Copy From URL operation aborts a pending Copy From URL operation, and leaves a destination
	* blob with zero length and full metadata.
	* @param copyId The copy identifier provided in the x-ms-copy-id header of the original Copy Blob
	*               operation.
	* @param options The options parameters.
	*/
	abortCopyFromURL(copyId, options) {
		return this.client.sendOperationRequest({
			copyId,
			options
		}, abortCopyFromURLOperationSpec);
	}
	/**
	* The Set Tier operation sets the tier on a blob. The operation is allowed on a page blob in a premium
	* storage account and on a block blob in a blob storage account (locally redundant storage only). A
	* premium page blob's tier determines the allowed size, IOPS, and bandwidth of the blob. A block
	* blob's tier determines Hot/Cool/Archive storage type. This operation does not update the blob's
	* ETag.
	* @param tier Indicates the tier to be set on the blob.
	* @param options The options parameters.
	*/
	setTier(tier, options) {
		return this.client.sendOperationRequest({
			tier,
			options
		}, setTierOperationSpec);
	}
	/**
	* Returns the sku name and account kind
	* @param options The options parameters.
	*/
	getAccountInfo(options) {
		return this.client.sendOperationRequest({ options }, getAccountInfoOperationSpec);
	}
	/**
	* The Query operation enables users to select/project on blob data by providing simple query
	* expressions.
	* @param options The options parameters.
	*/
	query(options) {
		return this.client.sendOperationRequest({ options }, queryOperationSpec);
	}
	/**
	* The Get Tags operation enables users to get the tags associated with a blob.
	* @param options The options parameters.
	*/
	getTags(options) {
		return this.client.sendOperationRequest({ options }, getTagsOperationSpec);
	}
	/**
	* The Set Tags operation enables users to set tags on a blob.
	* @param options The options parameters.
	*/
	setTags(options) {
		return this.client.sendOperationRequest({ options }, setTagsOperationSpec);
	}
};
var xmlSerializer$3 = createSerializer(mappers_exports, true);
var downloadOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: {
				type: { name: "Stream" },
				serializedName: "parsedResponse"
			},
			headersMapper: BlobDownloadHeaders
		},
		206: {
			bodyMapper: {
				type: { name: "Stream" },
				serializedName: "parsedResponse"
			},
			headersMapper: BlobDownloadHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobDownloadExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		versionId
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		range,
		rangeGetContentMD5,
		rangeGetContentCRC64,
		structuredBodyType,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var getPropertiesOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "HEAD",
	responses: {
		200: { headersMapper: BlobGetPropertiesHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobGetPropertiesExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		versionId
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var deleteOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "DELETE",
	responses: {
		202: { headersMapper: BlobDeleteHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobDeleteExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		versionId,
		blobDeleteType
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		ifMatch,
		ifNoneMatch,
		ifTags,
		deleteSnapshots,
		accessTierIfModifiedSince,
		accessTierIfUnmodifiedSince
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var undeleteOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobUndeleteHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobUndeleteExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp8],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var setExpiryOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobSetExpiryHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobSetExpiryExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp11],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		expiryOptions,
		expiresOn
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var setHttpHeadersOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobSetHttpHeadersHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobSetHttpHeadersExceptionHeaders
		}
	},
	queryParameters: [comp, timeoutInSeconds],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		ifMatch,
		ifNoneMatch,
		ifTags,
		blobCacheControl,
		blobContentType,
		blobContentMD5,
		blobContentEncoding,
		blobContentLanguage,
		blobContentDisposition
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var setImmutabilityPolicyOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobSetImmutabilityPolicyHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobSetImmutabilityPolicyExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		versionId,
		comp12
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifUnmodifiedSince,
		immutabilityPolicyExpiry,
		immutabilityPolicyMode
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var deleteImmutabilityPolicyOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "DELETE",
	responses: {
		200: { headersMapper: BlobDeleteImmutabilityPolicyHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobDeleteImmutabilityPolicyExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		versionId,
		comp12
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var setLegalHoldOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobSetLegalHoldHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobSetLegalHoldExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		versionId,
		comp13
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		legalHold
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var setMetadataOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobSetMetadataHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobSetMetadataExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp6],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		metadata,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		encryptionScope
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var acquireLeaseOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: BlobAcquireLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobAcquireLeaseExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp10],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		action,
		duration,
		proposedLeaseId,
		ifMatch,
		ifNoneMatch,
		ifTags
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var releaseLeaseOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobReleaseLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobReleaseLeaseExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp10],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		action1,
		leaseId1,
		ifMatch,
		ifNoneMatch,
		ifTags
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var renewLeaseOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobRenewLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobRenewLeaseExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp10],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		leaseId1,
		action2,
		ifMatch,
		ifNoneMatch,
		ifTags
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var changeLeaseOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobChangeLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobChangeLeaseExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp10],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		leaseId1,
		action4,
		proposedLeaseId1,
		ifMatch,
		ifNoneMatch,
		ifTags
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var breakLeaseOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		202: { headersMapper: BlobBreakLeaseHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobBreakLeaseExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp10],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		action3,
		breakPeriod,
		ifMatch,
		ifNoneMatch,
		ifTags
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var createSnapshotOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: BlobCreateSnapshotHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobCreateSnapshotExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp14],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		metadata,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		encryptionScope
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var startCopyFromURLOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		202: { headersMapper: BlobStartCopyFromURLHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobStartCopyFromURLExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		metadata,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		ifMatch,
		ifNoneMatch,
		ifTags,
		immutabilityPolicyExpiry,
		immutabilityPolicyMode,
		tier,
		rehydratePriority,
		sourceIfModifiedSince,
		sourceIfUnmodifiedSince,
		sourceIfMatch,
		sourceIfNoneMatch,
		sourceIfTags,
		copySource,
		blobTagsString,
		sealBlob,
		legalHold1
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var copyFromURLOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		202: { headersMapper: BlobCopyFromURLHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobCopyFromURLExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		metadata,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		ifMatch,
		ifNoneMatch,
		ifTags,
		immutabilityPolicyExpiry,
		immutabilityPolicyMode,
		encryptionScope,
		tier,
		sourceIfModifiedSince,
		sourceIfUnmodifiedSince,
		sourceIfMatch,
		sourceIfNoneMatch,
		copySource,
		blobTagsString,
		legalHold1,
		xMsRequiresSync,
		sourceContentMD5,
		copySourceAuthorization,
		copySourceTags,
		fileRequestIntent
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var abortCopyFromURLOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		204: { headersMapper: BlobAbortCopyFromURLHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobAbortCopyFromURLExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		comp15,
		copyId
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		copyActionAbortConstant
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var setTierOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: BlobSetTierHeaders },
		202: { headersMapper: BlobSetTierHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobSetTierExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		versionId,
		comp16
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifTags,
		rehydratePriority,
		tier1
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var getAccountInfoOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "GET",
	responses: {
		200: { headersMapper: BlobGetAccountInfoHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobGetAccountInfoExceptionHeaders
		}
	},
	queryParameters: [
		comp,
		timeoutInSeconds,
		restype1
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var queryOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "POST",
	responses: {
		200: {
			bodyMapper: {
				type: { name: "Stream" },
				serializedName: "parsedResponse"
			},
			headersMapper: BlobQueryHeaders
		},
		206: {
			bodyMapper: {
				type: { name: "Stream" },
				serializedName: "parsedResponse"
			},
			headersMapper: BlobQueryHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobQueryExceptionHeaders
		}
	},
	requestBody: queryRequest,
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		comp17
	],
	urlParameters: [url],
	headerParameters: [
		contentType,
		accept,
		version$2,
		requestId,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "xml",
	serializer: xmlSerializer$3
};
var getTagsOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: BlobTags,
			headersMapper: BlobGetTagsHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobGetTagsExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		versionId,
		comp18
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifTags,
		ifModifiedSince1,
		ifUnmodifiedSince1,
		ifMatch1,
		ifNoneMatch1
	],
	isXML: true,
	serializer: xmlSerializer$3
};
var setTagsOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		204: { headersMapper: BlobSetTagsHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlobSetTagsExceptionHeaders
		}
	},
	requestBody: tags,
	queryParameters: [
		timeoutInSeconds,
		versionId,
		comp18
	],
	urlParameters: [url],
	headerParameters: [
		contentType,
		accept,
		version$2,
		requestId,
		leaseId,
		ifTags,
		ifModifiedSince1,
		ifUnmodifiedSince1,
		ifMatch1,
		ifNoneMatch1,
		transactionalContentMD5,
		transactionalContentCrc64
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "xml",
	serializer: xmlSerializer$3
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/generated/src/operations/pageBlob.js
/** Class containing PageBlob operations. */
var PageBlobImpl = class {
	client;
	/**
	* Initialize a new instance of the class PageBlob class.
	* @param client Reference to the service client
	*/
	constructor(client) {
		this.client = client;
	}
	/**
	* The Create operation creates a new page blob.
	* @param contentLength The length of the request.
	* @param blobContentLength This header specifies the maximum size for the page blob, up to 1 TB. The
	*                          page blob size must be aligned to a 512-byte boundary.
	* @param options The options parameters.
	*/
	create(contentLength, blobContentLength, options) {
		return this.client.sendOperationRequest({
			contentLength,
			blobContentLength,
			options
		}, createOperationSpec$1);
	}
	/**
	* The Upload Pages operation writes a range of pages to a page blob
	* @param contentLength The length of the request.
	* @param body Initial data
	* @param options The options parameters.
	*/
	uploadPages(contentLength, body, options) {
		return this.client.sendOperationRequest({
			contentLength,
			body,
			options
		}, uploadPagesOperationSpec);
	}
	/**
	* The Clear Pages operation clears a set of pages from a page blob
	* @param contentLength The length of the request.
	* @param options The options parameters.
	*/
	clearPages(contentLength, options) {
		return this.client.sendOperationRequest({
			contentLength,
			options
		}, clearPagesOperationSpec);
	}
	/**
	* The Upload Pages operation writes a range of pages to a page blob where the contents are read from a
	* URL
	* @param sourceUrl Specify a URL to the copy source.
	* @param sourceRange Bytes of source data in the specified range. The length of this range should
	*                    match the ContentLength header and x-ms-range/Range destination range header.
	* @param contentLength The length of the request.
	* @param range The range of bytes to which the source range would be written. The range should be 512
	*              aligned and range-end is required.
	* @param options The options parameters.
	*/
	uploadPagesFromURL(sourceUrl, sourceRange, contentLength, range, options) {
		return this.client.sendOperationRequest({
			sourceUrl,
			sourceRange,
			contentLength,
			range,
			options
		}, uploadPagesFromURLOperationSpec);
	}
	/**
	* The Get Page Ranges operation returns the list of valid page ranges for a page blob or snapshot of a
	* page blob
	* @param options The options parameters.
	*/
	getPageRanges(options) {
		return this.client.sendOperationRequest({ options }, getPageRangesOperationSpec);
	}
	/**
	* The Get Page Ranges Diff operation returns the list of valid page ranges for a page blob that were
	* changed between target blob and previous snapshot.
	* @param options The options parameters.
	*/
	getPageRangesDiff(options) {
		return this.client.sendOperationRequest({ options }, getPageRangesDiffOperationSpec);
	}
	/**
	* Resize the Blob
	* @param blobContentLength This header specifies the maximum size for the page blob, up to 1 TB. The
	*                          page blob size must be aligned to a 512-byte boundary.
	* @param options The options parameters.
	*/
	resize(blobContentLength, options) {
		return this.client.sendOperationRequest({
			blobContentLength,
			options
		}, resizeOperationSpec);
	}
	/**
	* Update the sequence number of the blob
	* @param sequenceNumberAction Required if the x-ms-blob-sequence-number header is set for the request.
	*                             This property applies to page blobs only. This property indicates how the service should modify the
	*                             blob's sequence number
	* @param options The options parameters.
	*/
	updateSequenceNumber(sequenceNumberAction, options) {
		return this.client.sendOperationRequest({
			sequenceNumberAction,
			options
		}, updateSequenceNumberOperationSpec);
	}
	/**
	* The Copy Incremental operation copies a snapshot of the source page blob to a destination page blob.
	* The snapshot is copied such that only the differential changes between the previously copied
	* snapshot are transferred to the destination. The copied snapshots are complete copies of the
	* original snapshot and can be read or copied from as usual. This API is supported since REST version
	* 2016-05-31.
	* @param copySource Specifies the name of the source page blob snapshot. This value is a URL of up to
	*                   2 KB in length that specifies a page blob snapshot. The value should be URL-encoded as it would
	*                   appear in a request URI. The source blob must either be public or must be authenticated via a shared
	*                   access signature.
	* @param options The options parameters.
	*/
	copyIncremental(copySource, options) {
		return this.client.sendOperationRequest({
			copySource,
			options
		}, copyIncrementalOperationSpec);
	}
};
var xmlSerializer$2 = createSerializer(mappers_exports, true);
var createOperationSpec$1 = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: PageBlobCreateHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: PageBlobCreateExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		contentLength,
		metadata,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		blobCacheControl,
		blobContentType,
		blobContentMD5,
		blobContentEncoding,
		blobContentLanguage,
		blobContentDisposition,
		immutabilityPolicyExpiry,
		immutabilityPolicyMode,
		encryptionScope,
		tier,
		blobTagsString,
		legalHold1,
		blobType,
		blobContentLength,
		blobSequenceNumber
	],
	isXML: true,
	serializer: xmlSerializer$2
};
var uploadPagesOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: PageBlobUploadPagesHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: PageBlobUploadPagesExceptionHeaders
		}
	},
	requestBody: body1,
	queryParameters: [timeoutInSeconds, comp19],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		contentLength,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		range,
		structuredBodyType,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		encryptionScope,
		transactionalContentMD5,
		transactionalContentCrc64,
		contentType1,
		accept2,
		pageWrite,
		ifSequenceNumberLessThanOrEqualTo,
		ifSequenceNumberLessThan,
		ifSequenceNumberEqualTo,
		structuredContentLength
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "binary",
	serializer: xmlSerializer$2
};
var clearPagesOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: PageBlobClearPagesHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: PageBlobClearPagesExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp19],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		contentLength,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		range,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		encryptionScope,
		ifSequenceNumberLessThanOrEqualTo,
		ifSequenceNumberLessThan,
		ifSequenceNumberEqualTo,
		pageWrite1
	],
	isXML: true,
	serializer: xmlSerializer$2
};
var uploadPagesFromURLOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: PageBlobUploadPagesFromURLHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: PageBlobUploadPagesFromURLExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp19],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		contentLength,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		encryptionScope,
		sourceIfModifiedSince,
		sourceIfUnmodifiedSince,
		sourceIfMatch,
		sourceIfNoneMatch,
		sourceContentMD5,
		copySourceAuthorization,
		fileRequestIntent,
		pageWrite,
		ifSequenceNumberLessThanOrEqualTo,
		ifSequenceNumberLessThan,
		ifSequenceNumberEqualTo,
		sourceUrl,
		sourceRange,
		sourceContentCrc64,
		range1,
		sourceEncryptionKey,
		sourceEncryptionKeySha256,
		sourceEncryptionAlgorithm
	],
	isXML: true,
	serializer: xmlSerializer$2
};
var getPageRangesOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: PageList,
			headersMapper: PageBlobGetPageRangesHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: PageBlobGetPageRangesExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		marker,
		maxPageSize,
		snapshot,
		comp20
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		range,
		ifMatch,
		ifNoneMatch,
		ifTags
	],
	isXML: true,
	serializer: xmlSerializer$2
};
var getPageRangesDiffOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: PageList,
			headersMapper: PageBlobGetPageRangesDiffHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: PageBlobGetPageRangesDiffExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		marker,
		maxPageSize,
		snapshot,
		comp20,
		prevsnapshot
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		range,
		ifMatch,
		ifNoneMatch,
		ifTags,
		prevSnapshotUrl
	],
	isXML: true,
	serializer: xmlSerializer$2
};
var resizeOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: PageBlobResizeHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: PageBlobResizeExceptionHeaders
		}
	},
	queryParameters: [comp, timeoutInSeconds],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		encryptionScope,
		blobContentLength
	],
	isXML: true,
	serializer: xmlSerializer$2
};
var updateSequenceNumberOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: PageBlobUpdateSequenceNumberHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: PageBlobUpdateSequenceNumberExceptionHeaders
		}
	},
	queryParameters: [comp, timeoutInSeconds],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		ifMatch,
		ifNoneMatch,
		ifTags,
		blobSequenceNumber,
		sequenceNumberAction
	],
	isXML: true,
	serializer: xmlSerializer$2
};
var copyIncrementalOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		202: { headersMapper: PageBlobCopyIncrementalHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: PageBlobCopyIncrementalExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp21],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		ifModifiedSince,
		ifUnmodifiedSince,
		ifMatch,
		ifNoneMatch,
		ifTags,
		copySource
	],
	isXML: true,
	serializer: xmlSerializer$2
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/generated/src/operations/appendBlob.js
/** Class containing AppendBlob operations. */
var AppendBlobImpl = class {
	client;
	/**
	* Initialize a new instance of the class AppendBlob class.
	* @param client Reference to the service client
	*/
	constructor(client) {
		this.client = client;
	}
	/**
	* The Create Append Blob operation creates a new append blob.
	* @param contentLength The length of the request.
	* @param options The options parameters.
	*/
	create(contentLength, options) {
		return this.client.sendOperationRequest({
			contentLength,
			options
		}, createOperationSpec);
	}
	/**
	* The Append Block operation commits a new block of data to the end of an existing append blob. The
	* Append Block operation is permitted only if the blob was created with x-ms-blob-type set to
	* AppendBlob. Append Block is supported only on version 2015-02-21 version or later.
	* @param contentLength The length of the request.
	* @param body Initial data
	* @param options The options parameters.
	*/
	appendBlock(contentLength, body, options) {
		return this.client.sendOperationRequest({
			contentLength,
			body,
			options
		}, appendBlockOperationSpec);
	}
	/**
	* The Append Block operation commits a new block of data to the end of an existing append blob where
	* the contents are read from a source url. The Append Block operation is permitted only if the blob
	* was created with x-ms-blob-type set to AppendBlob. Append Block is supported only on version
	* 2015-02-21 version or later.
	* @param sourceUrl Specify a URL to the copy source.
	* @param contentLength The length of the request.
	* @param options The options parameters.
	*/
	appendBlockFromUrl(sourceUrl, contentLength, options) {
		return this.client.sendOperationRequest({
			sourceUrl,
			contentLength,
			options
		}, appendBlockFromUrlOperationSpec);
	}
	/**
	* The Seal operation seals the Append Blob to make it read-only. Seal is supported only on version
	* 2019-12-12 version or later.
	* @param options The options parameters.
	*/
	seal(options) {
		return this.client.sendOperationRequest({ options }, sealOperationSpec);
	}
};
var xmlSerializer$1 = createSerializer(mappers_exports, true);
var createOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: AppendBlobCreateHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: AppendBlobCreateExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		contentLength,
		metadata,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		blobCacheControl,
		blobContentType,
		blobContentMD5,
		blobContentEncoding,
		blobContentLanguage,
		blobContentDisposition,
		immutabilityPolicyExpiry,
		immutabilityPolicyMode,
		encryptionScope,
		blobTagsString,
		legalHold1,
		blobType1
	],
	isXML: true,
	serializer: xmlSerializer$1
};
var appendBlockOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: AppendBlobAppendBlockHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: AppendBlobAppendBlockExceptionHeaders
		}
	},
	requestBody: body1,
	queryParameters: [timeoutInSeconds, comp22],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		contentLength,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		structuredBodyType,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		encryptionScope,
		transactionalContentMD5,
		transactionalContentCrc64,
		contentType1,
		accept2,
		structuredContentLength,
		maxSize,
		appendPosition
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "binary",
	serializer: xmlSerializer$1
};
var appendBlockFromUrlOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: AppendBlobAppendBlockFromUrlHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: AppendBlobAppendBlockFromUrlExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp22],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		contentLength,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		encryptionScope,
		sourceIfModifiedSince,
		sourceIfUnmodifiedSince,
		sourceIfMatch,
		sourceIfNoneMatch,
		sourceContentMD5,
		copySourceAuthorization,
		fileRequestIntent,
		transactionalContentMD5,
		sourceUrl,
		sourceContentCrc64,
		sourceEncryptionKey,
		sourceEncryptionKeySha256,
		sourceEncryptionAlgorithm,
		maxSize,
		appendPosition,
		sourceRange1
	],
	isXML: true,
	serializer: xmlSerializer$1
};
var sealOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		200: { headersMapper: AppendBlobSealHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: AppendBlobSealExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds, comp23],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		ifMatch,
		ifNoneMatch,
		appendPosition
	],
	isXML: true,
	serializer: xmlSerializer$1
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/generated/src/operations/blockBlob.js
/** Class containing BlockBlob operations. */
var BlockBlobImpl = class {
	client;
	/**
	* Initialize a new instance of the class BlockBlob class.
	* @param client Reference to the service client
	*/
	constructor(client) {
		this.client = client;
	}
	/**
	* The Upload Block Blob operation updates the content of an existing block blob. Updating an existing
	* block blob overwrites any existing metadata on the blob. Partial updates are not supported with Put
	* Blob; the content of the existing blob is overwritten with the content of the new blob. To perform a
	* partial update of the content of a block blob, use the Put Block List operation.
	* @param contentLength The length of the request.
	* @param body Initial data
	* @param options The options parameters.
	*/
	upload(contentLength, body, options) {
		return this.client.sendOperationRequest({
			contentLength,
			body,
			options
		}, uploadOperationSpec);
	}
	/**
	* The Put Blob from URL operation creates a new Block Blob where the contents of the blob are read
	* from a given URL.  This API is supported beginning with the 2020-04-08 version. Partial updates are
	* not supported with Put Blob from URL; the content of an existing blob is overwritten with the
	* content of the new blob.  To perform partial updates to a block blob’s contents using a source URL,
	* use the Put Block from URL API in conjunction with Put Block List.
	* @param contentLength The length of the request.
	* @param copySource Specifies the name of the source page blob snapshot. This value is a URL of up to
	*                   2 KB in length that specifies a page blob snapshot. The value should be URL-encoded as it would
	*                   appear in a request URI. The source blob must either be public or must be authenticated via a shared
	*                   access signature.
	* @param options The options parameters.
	*/
	putBlobFromUrl(contentLength, copySource, options) {
		return this.client.sendOperationRequest({
			contentLength,
			copySource,
			options
		}, putBlobFromUrlOperationSpec);
	}
	/**
	* The Stage Block operation creates a new block to be committed as part of a blob
	* @param blockId A valid Base64 string value that identifies the block. Prior to encoding, the string
	*                must be less than or equal to 64 bytes in size. For a given blob, the length of the value specified
	*                for the blockid parameter must be the same size for each block.
	* @param contentLength The length of the request.
	* @param body Initial data
	* @param options The options parameters.
	*/
	stageBlock(blockId, contentLength, body, options) {
		return this.client.sendOperationRequest({
			blockId,
			contentLength,
			body,
			options
		}, stageBlockOperationSpec);
	}
	/**
	* The Stage Block operation creates a new block to be committed as part of a blob where the contents
	* are read from a URL.
	* @param blockId A valid Base64 string value that identifies the block. Prior to encoding, the string
	*                must be less than or equal to 64 bytes in size. For a given blob, the length of the value specified
	*                for the blockid parameter must be the same size for each block.
	* @param contentLength The length of the request.
	* @param sourceUrl Specify a URL to the copy source.
	* @param options The options parameters.
	*/
	stageBlockFromURL(blockId, contentLength, sourceUrl, options) {
		return this.client.sendOperationRequest({
			blockId,
			contentLength,
			sourceUrl,
			options
		}, stageBlockFromURLOperationSpec);
	}
	/**
	* The Commit Block List operation writes a blob by specifying the list of block IDs that make up the
	* blob. In order to be written as part of a blob, a block must have been successfully written to the
	* server in a prior Put Block operation. You can call Put Block List to update a blob by uploading
	* only those blocks that have changed, then committing the new and existing blocks together. You can
	* do this by specifying whether to commit a block from the committed block list or from the
	* uncommitted block list, or to commit the most recently uploaded version of the block, whichever list
	* it may belong to.
	* @param blocks Blob Blocks.
	* @param options The options parameters.
	*/
	commitBlockList(blocks, options) {
		return this.client.sendOperationRequest({
			blocks,
			options
		}, commitBlockListOperationSpec);
	}
	/**
	* The Get Block List operation retrieves the list of blocks that have been uploaded as part of a block
	* blob
	* @param listType Specifies whether to return the list of committed blocks, the list of uncommitted
	*                 blocks, or both lists together.
	* @param options The options parameters.
	*/
	getBlockList(listType, options) {
		return this.client.sendOperationRequest({
			listType,
			options
		}, getBlockListOperationSpec);
	}
};
var xmlSerializer = createSerializer(mappers_exports, true);
var uploadOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: BlockBlobUploadHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlockBlobUploadExceptionHeaders
		}
	},
	requestBody: body1,
	queryParameters: [timeoutInSeconds],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		contentLength,
		metadata,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		structuredBodyType,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		blobCacheControl,
		blobContentType,
		blobContentMD5,
		blobContentEncoding,
		blobContentLanguage,
		blobContentDisposition,
		immutabilityPolicyExpiry,
		immutabilityPolicyMode,
		encryptionScope,
		tier,
		blobTagsString,
		legalHold1,
		transactionalContentMD5,
		transactionalContentCrc64,
		contentType1,
		accept2,
		structuredContentLength,
		blobType2
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "binary",
	serializer: xmlSerializer
};
var putBlobFromUrlOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: BlockBlobPutBlobFromUrlHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlockBlobPutBlobFromUrlExceptionHeaders
		}
	},
	queryParameters: [timeoutInSeconds],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		contentLength,
		metadata,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		blobCacheControl,
		blobContentType,
		blobContentMD5,
		blobContentEncoding,
		blobContentLanguage,
		blobContentDisposition,
		encryptionScope,
		tier,
		sourceIfModifiedSince,
		sourceIfUnmodifiedSince,
		sourceIfMatch,
		sourceIfNoneMatch,
		sourceIfTags,
		copySource,
		blobTagsString,
		sourceContentMD5,
		copySourceAuthorization,
		copySourceTags,
		fileRequestIntent,
		transactionalContentMD5,
		sourceEncryptionKey,
		sourceEncryptionKeySha256,
		sourceEncryptionAlgorithm,
		blobType2,
		copySourceBlobProperties
	],
	isXML: true,
	serializer: xmlSerializer
};
var stageBlockOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: BlockBlobStageBlockHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlockBlobStageBlockExceptionHeaders
		}
	},
	requestBody: body1,
	queryParameters: [
		timeoutInSeconds,
		comp24,
		blockId
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		contentLength,
		leaseId,
		structuredBodyType,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		encryptionScope,
		transactionalContentMD5,
		transactionalContentCrc64,
		contentType1,
		accept2,
		structuredContentLength
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "binary",
	serializer: xmlSerializer
};
var stageBlockFromURLOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: BlockBlobStageBlockFromURLHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlockBlobStageBlockFromURLExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		comp24,
		blockId
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		contentLength,
		leaseId,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		encryptionScope,
		sourceIfModifiedSince,
		sourceIfUnmodifiedSince,
		sourceIfMatch,
		sourceIfNoneMatch,
		sourceContentMD5,
		copySourceAuthorization,
		fileRequestIntent,
		sourceUrl,
		sourceContentCrc64,
		sourceEncryptionKey,
		sourceEncryptionKeySha256,
		sourceEncryptionAlgorithm,
		sourceRange1
	],
	isXML: true,
	serializer: xmlSerializer
};
var commitBlockListOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "PUT",
	responses: {
		201: { headersMapper: BlockBlobCommitBlockListHeaders },
		default: {
			bodyMapper: StorageError,
			headersMapper: BlockBlobCommitBlockListExceptionHeaders
		}
	},
	requestBody: blocks,
	queryParameters: [timeoutInSeconds, comp25],
	urlParameters: [url],
	headerParameters: [
		contentType,
		accept,
		version$2,
		requestId,
		metadata,
		leaseId,
		ifModifiedSince,
		ifUnmodifiedSince,
		encryptionKey,
		encryptionKeySha256,
		encryptionAlgorithm,
		ifMatch,
		ifNoneMatch,
		ifTags,
		blobCacheControl,
		blobContentType,
		blobContentMD5,
		blobContentEncoding,
		blobContentLanguage,
		blobContentDisposition,
		immutabilityPolicyExpiry,
		immutabilityPolicyMode,
		encryptionScope,
		tier,
		blobTagsString,
		legalHold1,
		transactionalContentMD5,
		transactionalContentCrc64
	],
	isXML: true,
	contentType: "application/xml; charset=utf-8",
	mediaType: "xml",
	serializer: xmlSerializer
};
var getBlockListOperationSpec = {
	path: "/{containerName}/{blob}",
	httpMethod: "GET",
	responses: {
		200: {
			bodyMapper: BlockList,
			headersMapper: BlockBlobGetBlockListHeaders
		},
		default: {
			bodyMapper: StorageError,
			headersMapper: BlockBlobGetBlockListExceptionHeaders
		}
	},
	queryParameters: [
		timeoutInSeconds,
		snapshot,
		comp25,
		listType
	],
	urlParameters: [url],
	headerParameters: [
		version$2,
		requestId,
		accept1,
		leaseId,
		ifTags
	],
	isXML: true,
	serializer: xmlSerializer
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/generated/src/storageClient.js
var StorageClient$1 = class extends ExtendedServiceClient {
	static {
		__name(this, "StorageClient");
	}
	url;
	version;
	/**
	* Initializes a new instance of the StorageClient class.
	* @param url The URL of the service account, container, or blob that is the target of the desired
	*            operation.
	* @param options The parameter options
	*/
	constructor(url, options) {
		if (url === void 0) throw new Error("'url' cannot be null");
		if (!options) options = {};
		const defaults = { requestContentType: "application/json; charset=utf-8" };
		const packageDetails = `azsdk-js-azure-storage-blob/12.33.0`;
		const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}` : `${packageDetails}`;
		const optionsWithDefaults = {
			...defaults,
			...options,
			userAgentOptions: { userAgentPrefix },
			endpoint: options.endpoint ?? options.baseUri ?? "{url}"
		};
		super(optionsWithDefaults);
		this.url = url;
		this.version = options.version || "2026-06-06";
		this.service = new ServiceImpl(this);
		this.container = new ContainerImpl(this);
		this.blob = new BlobImpl(this);
		this.pageBlob = new PageBlobImpl(this);
		this.appendBlob = new AppendBlobImpl(this);
		this.blockBlob = new BlockBlobImpl(this);
	}
	service;
	container;
	blob;
	pageBlob;
	appendBlob;
	blockBlob;
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/StorageContextClient.js
/**
* @internal
*/
var StorageContextClient = class extends StorageClient$1 {
	async sendOperationRequest(operationArguments, operationSpec) {
		const operationSpecToSend = { ...operationSpec };
		if (operationSpecToSend.path === "/{containerName}" || operationSpecToSend.path === "/{containerName}/{blob}") operationSpecToSend.path = "";
		return super.sendOperationRequest(operationArguments, operationSpecToSend);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/utils/utils.common.js
var accountNameSuffixes = [
	"-secondary-ipv6",
	"-secondary-dualstack",
	"-ipv6",
	"-dualstack",
	"-secondary"
];
/**
* Reserved URL characters must be properly escaped for Storage services like Blob or File.
*
* ## URL encode and escape strategy for JS SDKs
*
* When customers pass a URL string into XxxClient classes constructor, the URL string may already be URL encoded or not.
* But before sending to Azure Storage server, the URL must be encoded. However, it's hard for a SDK to guess whether the URL
* string has been encoded or not. We have 2 potential strategies, and chose strategy two for the XxxClient constructors.
*
* ### Strategy One: Assume the customer URL string is not encoded, and always encode URL string in SDK.
*
* This is what legacy V2 SDK does, simple and works for most of the cases.
* - When customer URL string is "http://account.blob.core.windows.net/con/b:",
*   SDK will encode it to "http://account.blob.core.windows.net/con/b%3A" and send to server. A blob named "b:" will be created.
* - When customer URL string is "http://account.blob.core.windows.net/con/b%3A",
*   SDK will encode it to "http://account.blob.core.windows.net/con/b%253A" and send to server. A blob named "b%3A" will be created.
*
* But this strategy will make it not possible to create a blob with "?" in it's name. Because when customer URL string is
* "http://account.blob.core.windows.net/con/blob?name", the "?name" will be treated as URL paramter instead of blob name.
* If customer URL string is "http://account.blob.core.windows.net/con/blob%3Fname", a blob named "blob%3Fname" will be created.
* V2 SDK doesn't have this issue because it doesn't allow customer pass in a full URL, it accepts a separate blob name and encodeURIComponent for it.
* We cannot accept a SDK cannot create a blob name with "?". So we implement strategy two:
*
* ### Strategy Two: SDK doesn't assume the URL has been encoded or not. It will just escape the special characters.
*
* This is what V10 Blob Go SDK does. It accepts a URL type in Go, and call url.EscapedPath() to escape the special chars unescaped.
* - When customer URL string is "http://account.blob.core.windows.net/con/b:",
*   SDK will escape ":" like "http://account.blob.core.windows.net/con/b%3A" and send to server. A blob named "b:" will be created.
* - When customer URL string is "http://account.blob.core.windows.net/con/b%3A",
*   There is no special characters, so send "http://account.blob.core.windows.net/con/b%3A" to server. A blob named "b:" will be created.
* - When customer URL string is "http://account.blob.core.windows.net/con/b%253A",
*   There is no special characters, so send "http://account.blob.core.windows.net/con/b%253A" to server. A blob named "b%3A" will be created.
*
* This strategy gives us flexibility to create with any special characters. But "%" will be treated as a special characters, if the URL string
* is not encoded, there shouldn't a "%" in the URL string, otherwise the URL is not a valid URL.
* If customer needs to create a blob with "%" in it's blob name, use "%25" instead of "%". Just like above 3rd sample.
* And following URL strings are invalid:
* - "http://account.blob.core.windows.net/con/b%"
* - "http://account.blob.core.windows.net/con/b%2"
* - "http://account.blob.core.windows.net/con/b%G"
*
* Another special character is "?", use "%2F" to represent a blob name with "?" in a URL string.
*
* ### Strategy for containerName, blobName or other specific XXXName parameters in methods such as `containerClient.getBlobClient(blobName)`
*
* We will apply strategy one, and call encodeURIComponent for these parameters like blobName. Because what customers passes in is a plain name instead of a URL.
*
* @see https://learn.microsoft.com/rest/api/storageservices/naming-and-referencing-containers--blobs--and-metadata
* @see https://learn.microsoft.com/rest/api/storageservices/naming-and-referencing-shares--directories--files--and-metadata
*
* @param url -
*/
function escapeURLPath(url) {
	const urlParsed = new URL(url);
	let path = urlParsed.pathname;
	path = path || "/";
	path = escape(path);
	urlParsed.pathname = path;
	return urlParsed.toString();
}
function getProxyUriFromDevConnString(connectionString) {
	let proxyUri = "";
	if (connectionString.search("DevelopmentStorageProxyUri=") !== -1) {
		const matchCredentials = connectionString.split(";");
		for (const element of matchCredentials) if (element.trim().startsWith("DevelopmentStorageProxyUri=")) proxyUri = element.trim().match("DevelopmentStorageProxyUri=(.*)")[1];
	}
	return proxyUri;
}
function getValueInConnString(connectionString, argument) {
	const elements = connectionString.split(";");
	for (const element of elements) if (element.trim().startsWith(argument)) return element.trim().match(argument + "=(.*)")[1];
	return "";
}
/**
* Extracts the parts of an Azure Storage account connection string.
*
* @param connectionString - Connection string.
* @returns String key value pairs of the storage account's url and credentials.
*/
function extractConnectionStringParts(connectionString) {
	let proxyUri = "";
	if (connectionString.startsWith("UseDevelopmentStorage=true")) {
		proxyUri = getProxyUriFromDevConnString(connectionString);
		connectionString = DevelopmentConnectionString;
	}
	let blobEndpoint = getValueInConnString(connectionString, "BlobEndpoint");
	blobEndpoint = blobEndpoint.endsWith("/") ? blobEndpoint.slice(0, -1) : blobEndpoint;
	if (connectionString.search("DefaultEndpointsProtocol=") !== -1 && connectionString.search("AccountKey=") !== -1) {
		let defaultEndpointsProtocol = "";
		let accountName = "";
		let accountKey = Buffer.from("accountKey", "base64");
		let endpointSuffix = "";
		accountName = getValueInConnString(connectionString, "AccountName");
		accountKey = Buffer.from(getValueInConnString(connectionString, "AccountKey"), "base64");
		if (!blobEndpoint) {
			defaultEndpointsProtocol = getValueInConnString(connectionString, "DefaultEndpointsProtocol");
			const protocol = defaultEndpointsProtocol.toLowerCase();
			if (protocol !== "https" && protocol !== "http") throw new Error("Invalid DefaultEndpointsProtocol in the provided Connection String. Expecting 'https' or 'http'");
			endpointSuffix = getValueInConnString(connectionString, "EndpointSuffix");
			if (!endpointSuffix) throw new Error("Invalid EndpointSuffix in the provided Connection String");
			blobEndpoint = `${defaultEndpointsProtocol}://${accountName}.blob.${endpointSuffix}`;
		}
		if (!accountName) throw new Error("Invalid AccountName in the provided Connection String");
		else if (accountKey.length === 0) throw new Error("Invalid AccountKey in the provided Connection String");
		return {
			kind: "AccountConnString",
			url: blobEndpoint,
			accountName,
			accountKey,
			proxyUri
		};
	} else {
		let accountSas = getValueInConnString(connectionString, "SharedAccessSignature");
		let accountName = getValueInConnString(connectionString, "AccountName");
		if (!accountName) accountName = getAccountNameFromUrl(blobEndpoint);
		if (!blobEndpoint) throw new Error("Invalid BlobEndpoint in the provided SAS Connection String");
		else if (!accountSas) throw new Error("Invalid SharedAccessSignature in the provided SAS Connection String");
		if (accountSas.startsWith("?")) accountSas = accountSas.substring(1);
		return {
			kind: "SASConnString",
			url: blobEndpoint,
			accountName,
			accountSas
		};
	}
}
/**
* Internal escape method implemented Strategy Two mentioned in escapeURL() description.
*
* @param text -
*/
function escape(text) {
	return encodeURIComponent(text).replace(/%2F/g, "/").replace(/'/g, "%27").replace(/\+/g, "%20").replace(/%25/g, "%");
}
/**
* Append a string to URL path. Will remove duplicated "/" in front of the string
* when URL path ends with a "/".
*
* @param url - Source URL string
* @param name - String to be appended to URL
* @returns An updated URL string
*/
function appendToURLPath(url, name) {
	const urlParsed = new URL(url);
	let path = urlParsed.pathname;
	path = path ? path.endsWith("/") ? `${path}${name}` : `${path}/${name}` : name;
	urlParsed.pathname = path;
	return urlParsed.toString();
}
/**
* Set URL parameter name and value. If name exists in URL parameters, old value
* will be replaced by name key. If not provide value, the parameter will be deleted.
*
* @param url - Source URL string
* @param name - Parameter name
* @param value - Parameter value
* @returns An updated URL string
*/
function setURLParameter(url, name, value) {
	const urlParsed = new URL(url);
	const encodedName = encodeURIComponent(name);
	const encodedValue = value ? encodeURIComponent(value) : void 0;
	const searchString = urlParsed.search === "" ? "?" : urlParsed.search;
	const searchPieces = [];
	for (const pair of searchString.slice(1).split("&")) if (pair) {
		const [key] = pair.split("=", 2);
		if (key !== encodedName) searchPieces.push(pair);
	}
	if (encodedValue) searchPieces.push(`${encodedName}=${encodedValue}`);
	urlParsed.search = searchPieces.length ? `?${searchPieces.join("&")}` : "";
	return urlParsed.toString();
}
/**
* Get URL parameter by name.
*
* @param url -
* @param name -
*/
function getURLParameter(url, name) {
	return new URL(url).searchParams.get(name) ?? void 0;
}
/**
* Get URL scheme from an URL string.
*
* @param url - Source URL string
*/
function getURLScheme(url) {
	try {
		const urlParsed = new URL(url);
		return urlParsed.protocol.endsWith(":") ? urlParsed.protocol.slice(0, -1) : urlParsed.protocol;
	} catch (e) {
		return;
	}
}
/**
* Append a string to URL query.
*
* @param url - Source URL string.
* @param queryParts - String to be appended to the URL query.
* @returns An updated URL string.
*/
function appendToURLQuery(url, queryParts) {
	const urlParsed = new URL(url);
	let query = urlParsed.search;
	if (query) query += "&" + queryParts;
	else query = queryParts;
	urlParsed.search = query;
	return urlParsed.toString();
}
/**
* Rounds a date off to seconds.
*
* @param date -
* @param withMilliseconds - If true, YYYY-MM-DDThh:mm:ss.fffffffZ will be returned;
*                                          If false, YYYY-MM-DDThh:mm:ssZ will be returned.
* @returns Date string in ISO8061 format, with or without 7 milliseconds component
*/
function truncatedISO8061Date(date, withMilliseconds = true) {
	const dateString = date.toISOString();
	return withMilliseconds ? dateString.substring(0, dateString.length - 1) + "0000Z" : dateString.substring(0, dateString.length - 5) + "Z";
}
/**
* Base64 encode.
*
* @param content -
*/
function base64encode$1(content) {
	return !isNodeLike ? btoa(content) : Buffer.from(content).toString("base64");
}
__name(base64encode$1, "base64encode");
/**
* Generate a 64 bytes base64 block ID string.
*
* @param blockIndex -
*/
function generateBlockID(blockIDPrefix, blockIndex) {
	const maxSourceStringLength = 48;
	const maxAllowedBlockIDPrefixLength = 42;
	if (blockIDPrefix.length > maxAllowedBlockIDPrefixLength) blockIDPrefix = blockIDPrefix.slice(0, maxAllowedBlockIDPrefixLength);
	return base64encode$1(blockIDPrefix + padStart(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0"));
}
/**
* String.prototype.padStart()
*
* @param currentString -
* @param targetLength -
* @param padString -
*/
function padStart(currentString, targetLength, padString = " ") {
	if (String.prototype.padStart) return currentString.padStart(targetLength, padString);
	padString = padString || " ";
	if (currentString.length > targetLength) return currentString;
	else {
		targetLength = targetLength - currentString.length;
		if (targetLength > padString.length) padString += padString.repeat(targetLength / padString.length);
		return padString.slice(0, targetLength) + currentString;
	}
}
/**
* If two strings are equal when compared case insensitive.
*
* @param str1 -
* @param str2 -
*/
function iEqual(str1, str2) {
	return str1.toLocaleLowerCase() === str2.toLocaleLowerCase();
}
/**
* Extracts account name from the url
* @param url - url to extract the account name from
* @returns with the account name
*/
function getAccountNameFromUrl(url) {
	const parsedUrl = new URL(url);
	let accountName;
	try {
		if (parsedUrl.hostname.split(".")[1] === "blob") {
			accountName = parsedUrl.hostname.split(".")[0];
			for (let i = 0; i < accountNameSuffixes.length; ++i) {
				const suffix = accountNameSuffixes[i];
				if (accountName.endsWith(suffix)) {
					accountName = accountName.substring(0, accountName.length - suffix.length);
					break;
				}
			}
		} else if (isIpEndpointStyle(parsedUrl)) accountName = parsedUrl.pathname.split("/")[1];
		else accountName = "";
		return accountName;
	} catch (error) {
		throw new Error("Unable to extract accountName with provided information.");
	}
}
function isIpEndpointStyle(parsedUrl) {
	const host = parsedUrl.host;
	return /^.*:.*:.*$|^(localhost|host.docker.internal)(:[0-9]+)?$|^(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])(\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])){3}(:[0-9]+)?$/.test(host) || Boolean(parsedUrl.port) && PathStylePorts.includes(parsedUrl.port);
}
/**
* Convert Tags to encoded string.
*
* @param tags -
*/
function toBlobTagsString(tags) {
	if (tags === void 0) return;
	const tagPairs = [];
	for (const key in tags) if (Object.prototype.hasOwnProperty.call(tags, key)) {
		const value = tags[key];
		tagPairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
	}
	return tagPairs.join("&");
}
/**
* Convert Tags type to BlobTags.
*
* @param tags -
*/
function toBlobTags(tags) {
	if (tags === void 0) return;
	const res = { blobTagSet: [] };
	for (const key in tags) if (Object.prototype.hasOwnProperty.call(tags, key)) {
		const value = tags[key];
		res.blobTagSet.push({
			key,
			value
		});
	}
	return res;
}
/**
* Covert BlobTags to Tags type.
*
* @param tags -
*/
function toTags(tags) {
	if (tags === void 0) return;
	const res = {};
	for (const blobTag of tags.blobTagSet) res[blobTag.key] = blobTag.value;
	return res;
}
/**
* Convert BlobQueryTextConfiguration to QuerySerialization type.
*
* @param textConfiguration -
*/
function toQuerySerialization(textConfiguration) {
	if (textConfiguration === void 0) return;
	switch (textConfiguration.kind) {
		case "csv": return { format: {
			type: "delimited",
			delimitedTextConfiguration: {
				columnSeparator: textConfiguration.columnSeparator || ",",
				fieldQuote: textConfiguration.fieldQuote || "",
				recordSeparator: textConfiguration.recordSeparator,
				escapeChar: textConfiguration.escapeCharacter || "",
				headersPresent: textConfiguration.hasHeaders || false
			}
		} };
		case "json": return { format: {
			type: "json",
			jsonTextConfiguration: { recordSeparator: textConfiguration.recordSeparator }
		} };
		case "arrow": return { format: {
			type: "arrow",
			arrowConfiguration: { schema: textConfiguration.schema }
		} };
		case "parquet": return { format: { type: "parquet" } };
		default: throw Error("Invalid BlobQueryTextConfiguration.");
	}
}
function parseObjectReplicationRecord(objectReplicationRecord) {
	if (!objectReplicationRecord) return;
	if ("policy-id" in objectReplicationRecord) return;
	const orProperties = [];
	for (const key in objectReplicationRecord) {
		const ids = key.split("_");
		if (ids[0].startsWith("or-")) ids[0] = ids[0].substring(3);
		const rule = {
			ruleId: ids[1],
			replicationStatus: objectReplicationRecord[key]
		};
		const policyIndex = orProperties.findIndex((policy) => policy.policyId === ids[0]);
		if (policyIndex > -1) orProperties[policyIndex].rules.push(rule);
		else orProperties.push({
			policyId: ids[0],
			rules: [rule]
		});
	}
	return orProperties;
}
function httpAuthorizationToString(httpAuthorization) {
	return httpAuthorization ? httpAuthorization.scheme + " " + httpAuthorization.value : void 0;
}
function* ExtractPageRangeInfoItems(getPageRangesSegment) {
	let pageRange = [];
	let clearRange = [];
	if (getPageRangesSegment.pageRange) pageRange = getPageRangesSegment.pageRange;
	if (getPageRangesSegment.clearRange) clearRange = getPageRangesSegment.clearRange;
	let pageRangeIndex = 0;
	let clearRangeIndex = 0;
	while (pageRangeIndex < pageRange.length && clearRangeIndex < clearRange.length) if (pageRange[pageRangeIndex].start < clearRange[clearRangeIndex].start) {
		yield {
			start: pageRange[pageRangeIndex].start,
			end: pageRange[pageRangeIndex].end,
			isClear: false
		};
		++pageRangeIndex;
	} else {
		yield {
			start: clearRange[clearRangeIndex].start,
			end: clearRange[clearRangeIndex].end,
			isClear: true
		};
		++clearRangeIndex;
	}
	for (; pageRangeIndex < pageRange.length; ++pageRangeIndex) yield {
		start: pageRange[pageRangeIndex].start,
		end: pageRange[pageRangeIndex].end,
		isClear: false
	};
	for (; clearRangeIndex < clearRange.length; ++clearRangeIndex) yield {
		start: clearRange[clearRangeIndex].start,
		end: clearRange[clearRangeIndex].end,
		isClear: true
	};
}
/**
* A typesafe helper for ensuring that a given response object has
* the original _response attached.
* @param response - A response object from calling a client operation
* @returns The same object, but with known _response property
*/
function assertResponse(response) {
	if (`_response` in response) return response;
	throw new TypeError(`Unexpected response object ${response}`);
}
async function setUploadChecksumParameters(body, contentLength, parameters, uploadOptions, configContentChecksumAlgorithm) {
	let contentChecksumAlgorithm = uploadOptions.contentChecksumAlgorithm ?? configContentChecksumAlgorithm;
	if (contentChecksumAlgorithm === void 0) contentChecksumAlgorithm = "Customized";
	if (contentChecksumAlgorithm === "Auto") contentChecksumAlgorithm = "StorageCrc64";
	let bodyInfo = void 0;
	if (contentChecksumAlgorithm === "Customized") {
		parameters.transactionalContentMD5 = uploadOptions.transactionalContentMD5;
		parameters.transactionalContentCrc64 = uploadOptions.transactionalContentCrc64;
	} else if (contentChecksumAlgorithm === "StorageCrc64") {
		await StorageCRC64Calculator.init();
		bodyInfo = await structuredMessageEncoding(body, contentLength);
		parameters.structuredBodyType = "XSM/1.0; properties=crc64";
		parameters.structuredContentLength = contentLength;
	}
	return {
		body: contentChecksumAlgorithm === "StorageCrc64" ? bodyInfo.body : body,
		contentLength: contentChecksumAlgorithm === "StorageCrc64" ? bodyInfo.encodedContentLength : contentLength,
		contentChecksumAlgorithm
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/StorageClient.js
/**
* A StorageClient represents a based URL class for {@link BlobServiceClient}, {@link ContainerClient}
* and etc.
*/
var StorageClient = class {
	/**
	* Encoded URL string value.
	*/
	url;
	accountName;
	/**
	* Request policy pipeline.
	*
	* @internal
	*/
	pipeline;
	/**
	* Such as AnonymousCredential, StorageSharedKeyCredential or any credential from the `@azure/identity` package to authenticate requests to the service. You can also provide an object that implements the TokenCredential interface. If not specified, AnonymousCredential is used.
	*/
	credential;
	/**
	* StorageClient is a reference to protocol layer operations entry, which is
	* generated by AutoRest generator.
	*/
	storageClientContext;
	/**
	*/
	isHttps;
	/**
	* Creates an instance of StorageClient.
	* @param url - url to resource
	* @param pipeline - request policy pipeline.
	*/
	constructor(url, pipeline) {
		this.url = escapeURLPath(url);
		this.accountName = getAccountNameFromUrl(url);
		this.pipeline = pipeline;
		this.storageClientContext = new StorageContextClient(this.url, getCoreClientOptions(pipeline));
		this.isHttps = iEqual(getURLScheme(this.url) || "", "https");
		this.credential = getCredentialFromPipeline(pipeline);
		const storageClientContext = this.storageClientContext;
		storageClientContext.requestContentType = void 0;
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/utils/tracing.js
/**
* Creates a span using the global tracer.
* @internal
*/
var tracingClient = createTracingClient({
	packageName: "@azure/storage-blob",
	packageVersion: SDK_VERSION,
	namespace: "Microsoft.Storage"
});
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/sas/BlobSASPermissions.js
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
*
* This is a helper class to construct a string representing the permissions granted by a ServiceSAS to a blob. Setting
* a value to true means that any SAS which uses these permissions will grant permissions for that operation. Once all
* the values are set, this should be serialized with toString and set as the permissions field on a
* {@link BlobSASSignatureValues} object. It is possible to construct the permissions string without this class, but
* the order of the permissions is particular and this class guarantees correctness.
*/
var BlobSASPermissions = class BlobSASPermissions {
	/**
	* Creates a {@link BlobSASPermissions} from the specified permissions string. This method will throw an
	* Error if it encounters a character that does not correspond to a valid permission.
	*
	* @param permissions -
	*/
	static parse(permissions) {
		const blobSASPermissions = new BlobSASPermissions();
		for (const char of permissions) switch (char) {
			case "r":
				blobSASPermissions.read = true;
				break;
			case "a":
				blobSASPermissions.add = true;
				break;
			case "c":
				blobSASPermissions.create = true;
				break;
			case "w":
				blobSASPermissions.write = true;
				break;
			case "d":
				blobSASPermissions.delete = true;
				break;
			case "x":
				blobSASPermissions.deleteVersion = true;
				break;
			case "t":
				blobSASPermissions.tag = true;
				break;
			case "m":
				blobSASPermissions.move = true;
				break;
			case "e":
				blobSASPermissions.execute = true;
				break;
			case "i":
				blobSASPermissions.setImmutabilityPolicy = true;
				break;
			case "y":
				blobSASPermissions.permanentDelete = true;
				break;
			default: throw new RangeError(`Invalid permission: ${char}`);
		}
		return blobSASPermissions;
	}
	/**
	* Creates a {@link BlobSASPermissions} from a raw object which contains same keys as it
	* and boolean values for them.
	*
	* @param permissionLike -
	*/
	static from(permissionLike) {
		const blobSASPermissions = new BlobSASPermissions();
		if (permissionLike.read) blobSASPermissions.read = true;
		if (permissionLike.add) blobSASPermissions.add = true;
		if (permissionLike.create) blobSASPermissions.create = true;
		if (permissionLike.write) blobSASPermissions.write = true;
		if (permissionLike.delete) blobSASPermissions.delete = true;
		if (permissionLike.deleteVersion) blobSASPermissions.deleteVersion = true;
		if (permissionLike.tag) blobSASPermissions.tag = true;
		if (permissionLike.move) blobSASPermissions.move = true;
		if (permissionLike.execute) blobSASPermissions.execute = true;
		if (permissionLike.setImmutabilityPolicy) blobSASPermissions.setImmutabilityPolicy = true;
		if (permissionLike.permanentDelete) blobSASPermissions.permanentDelete = true;
		return blobSASPermissions;
	}
	/**
	* Specifies Read access granted.
	*/
	read = false;
	/**
	* Specifies Add access granted.
	*/
	add = false;
	/**
	* Specifies Create access granted.
	*/
	create = false;
	/**
	* Specifies Write access granted.
	*/
	write = false;
	/**
	* Specifies Delete access granted.
	*/
	delete = false;
	/**
	* Specifies Delete version access granted.
	*/
	deleteVersion = false;
	/**
	* Specfies Tag access granted.
	*/
	tag = false;
	/**
	* Specifies Move access granted.
	*/
	move = false;
	/**
	* Specifies Execute access granted.
	*/
	execute = false;
	/**
	* Specifies SetImmutabilityPolicy access granted.
	*/
	setImmutabilityPolicy = false;
	/**
	* Specifies that Permanent Delete is permitted.
	*/
	permanentDelete = false;
	/**
	* Converts the given permissions to a string. Using this method will guarantee the permissions are in an
	* order accepted by the service.
	*
	* @returns A string which represents the BlobSASPermissions
	*/
	toString() {
		const permissions = [];
		if (this.read) permissions.push("r");
		if (this.add) permissions.push("a");
		if (this.create) permissions.push("c");
		if (this.write) permissions.push("w");
		if (this.delete) permissions.push("d");
		if (this.deleteVersion) permissions.push("x");
		if (this.tag) permissions.push("t");
		if (this.move) permissions.push("m");
		if (this.execute) permissions.push("e");
		if (this.setImmutabilityPolicy) permissions.push("i");
		if (this.permanentDelete) permissions.push("y");
		return permissions.join("");
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/sas/ContainerSASPermissions.js
/**
* This is a helper class to construct a string representing the permissions granted by a ServiceSAS to a container.
* Setting a value to true means that any SAS which uses these permissions will grant permissions for that operation.
* Once all the values are set, this should be serialized with toString and set as the permissions field on a
* {@link BlobSASSignatureValues} object. It is possible to construct the permissions string without this class, but
* the order of the permissions is particular and this class guarantees correctness.
*/
var ContainerSASPermissions = class ContainerSASPermissions {
	/**
	* Creates an {@link ContainerSASPermissions} from the specified permissions string. This method will throw an
	* Error if it encounters a character that does not correspond to a valid permission.
	*
	* @param permissions -
	*/
	static parse(permissions) {
		const containerSASPermissions = new ContainerSASPermissions();
		for (const char of permissions) switch (char) {
			case "r":
				containerSASPermissions.read = true;
				break;
			case "a":
				containerSASPermissions.add = true;
				break;
			case "c":
				containerSASPermissions.create = true;
				break;
			case "w":
				containerSASPermissions.write = true;
				break;
			case "d":
				containerSASPermissions.delete = true;
				break;
			case "l":
				containerSASPermissions.list = true;
				break;
			case "t":
				containerSASPermissions.tag = true;
				break;
			case "x":
				containerSASPermissions.deleteVersion = true;
				break;
			case "m":
				containerSASPermissions.move = true;
				break;
			case "e":
				containerSASPermissions.execute = true;
				break;
			case "i":
				containerSASPermissions.setImmutabilityPolicy = true;
				break;
			case "y":
				containerSASPermissions.permanentDelete = true;
				break;
			case "f":
				containerSASPermissions.filterByTags = true;
				break;
			default: throw new RangeError(`Invalid permission ${char}`);
		}
		return containerSASPermissions;
	}
	/**
	* Creates a {@link ContainerSASPermissions} from a raw object which contains same keys as it
	* and boolean values for them.
	*
	* @param permissionLike -
	*/
	static from(permissionLike) {
		const containerSASPermissions = new ContainerSASPermissions();
		if (permissionLike.read) containerSASPermissions.read = true;
		if (permissionLike.add) containerSASPermissions.add = true;
		if (permissionLike.create) containerSASPermissions.create = true;
		if (permissionLike.write) containerSASPermissions.write = true;
		if (permissionLike.delete) containerSASPermissions.delete = true;
		if (permissionLike.list) containerSASPermissions.list = true;
		if (permissionLike.deleteVersion) containerSASPermissions.deleteVersion = true;
		if (permissionLike.tag) containerSASPermissions.tag = true;
		if (permissionLike.move) containerSASPermissions.move = true;
		if (permissionLike.execute) containerSASPermissions.execute = true;
		if (permissionLike.setImmutabilityPolicy) containerSASPermissions.setImmutabilityPolicy = true;
		if (permissionLike.permanentDelete) containerSASPermissions.permanentDelete = true;
		if (permissionLike.filterByTags) containerSASPermissions.filterByTags = true;
		return containerSASPermissions;
	}
	/**
	* Specifies Read access granted.
	*/
	read = false;
	/**
	* Specifies Add access granted.
	*/
	add = false;
	/**
	* Specifies Create access granted.
	*/
	create = false;
	/**
	* Specifies Write access granted.
	*/
	write = false;
	/**
	* Specifies Delete access granted.
	*/
	delete = false;
	/**
	* Specifies Delete version access granted.
	*/
	deleteVersion = false;
	/**
	* Specifies List access granted.
	*/
	list = false;
	/**
	* Specfies Tag access granted.
	*/
	tag = false;
	/**
	* Specifies Move access granted.
	*/
	move = false;
	/**
	* Specifies Execute access granted.
	*/
	execute = false;
	/**
	* Specifies SetImmutabilityPolicy access granted.
	*/
	setImmutabilityPolicy = false;
	/**
	* Specifies that Permanent Delete is permitted.
	*/
	permanentDelete = false;
	/**
	* Specifies that Filter Blobs by Tags is permitted.
	*/
	filterByTags = false;
	/**
	* Converts the given permissions to a string. Using this method will guarantee the permissions are in an
	* order accepted by the service.
	*
	* The order of the characters should be as specified here to ensure correctness.
	* @see https://learn.microsoft.com/rest/api/storageservices/constructing-a-service-sas
	*
	*/
	toString() {
		const permissions = [];
		if (this.read) permissions.push("r");
		if (this.add) permissions.push("a");
		if (this.create) permissions.push("c");
		if (this.write) permissions.push("w");
		if (this.delete) permissions.push("d");
		if (this.deleteVersion) permissions.push("x");
		if (this.list) permissions.push("l");
		if (this.tag) permissions.push("t");
		if (this.move) permissions.push("m");
		if (this.execute) permissions.push("e");
		if (this.setImmutabilityPolicy) permissions.push("i");
		if (this.permanentDelete) permissions.push("y");
		if (this.filterByTags) permissions.push("f");
		return permissions.join("");
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/sas/SasIPRange.js
/**
* Generate SasIPRange format string. For example:
*
* "8.8.8.8" or "1.1.1.1-255.255.255.255"
*
* @param ipRange -
*/
function ipRangeToString(ipRange) {
	return ipRange.end ? `${ipRange.start}-${ipRange.end}` : ipRange.start;
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/sas/SASQueryParameters.js
/**
* Protocols for generated SAS.
*/
var SASProtocol;
(function(SASProtocol) {
	/**
	* Protocol that allows HTTPS only
	*/
	SASProtocol["Https"] = "https";
	/**
	* Protocol that allows both HTTPS and HTTP
	*/
	SASProtocol["HttpsAndHttp"] = "https,http";
})(SASProtocol || (SASProtocol = {}));
/**
* Represents the components that make up an Azure Storage SAS' query parameters. This type is not constructed directly
* by the user; it is only generated by the {@link AccountSASSignatureValues} and {@link BlobSASSignatureValues}
* types. Once generated, it can be encoded into a {@link String} and appended to a URL directly (though caution should
* be taken here in case there are existing query parameters, which might affect the appropriate means of appending
* these query parameters).
*
* NOTE: Instances of this class are immutable.
*/
var SASQueryParameters = class {
	/**
	* The storage API version.
	*/
	version;
	/**
	* Optional. The allowed HTTP protocol(s).
	*/
	protocol;
	/**
	* Optional. The start time for this SAS token.
	*/
	startsOn;
	/**
	* Optional only when identifier is provided. The expiry time for this SAS token.
	*/
	expiresOn;
	/**
	* Optional only when identifier is provided.
	* Please refer to {@link AccountSASPermissions}, {@link BlobSASPermissions}, or {@link ContainerSASPermissions} for
	* more details.
	*/
	permissions;
	/**
	* Optional. The storage services being accessed (only for Account SAS). Please refer to {@link AccountSASServices}
	* for more details.
	*/
	services;
	/**
	* Optional. The storage resource types being accessed (only for Account SAS). Please refer to
	* {@link AccountSASResourceTypes} for more details.
	*/
	resourceTypes;
	/**
	* Optional. The signed identifier (only for {@link BlobSASSignatureValues}).
	*
	* @see https://learn.microsoft.com/rest/api/storageservices/establishing-a-stored-access-policy
	*/
	identifier;
	/**
	* Optional. Beginning in version 2025-07-05, this value specifies the Entra ID of the user would is authorized to
	* use the resulting SAS URL.  The resulting SAS URL must be used in conjunction with an Entra ID token that has been
	* issued to the user specified in this value.
	*/
	delegatedUserObjectId;
	/**
	* Optional. Encryption scope to use when sending requests authorized with this SAS URI.
	*/
	encryptionScope;
	/**
	* Optional. Specifies which resources are accessible via the SAS (only for {@link BlobSASSignatureValues}).
	* @see https://learn.microsoft.com/rest/api/storageservices/create-service-sas#specifying-the-signed-resource-blob-service-only
	*/
	resource;
	/**
	* The signature for the SAS token.
	*/
	signature;
	/**
	* Value for cache-control header in Blob/File Service SAS.
	*/
	cacheControl;
	/**
	* Value for content-disposition header in Blob/File Service SAS.
	*/
	contentDisposition;
	/**
	* Value for content-encoding header in Blob/File Service SAS.
	*/
	contentEncoding;
	/**
	* Value for content-length header in Blob/File Service SAS.
	*/
	contentLanguage;
	/**
	* Value for content-type header in Blob/File Service SAS.
	*/
	contentType;
	/**
	* Inner value of getter ipRange.
	*/
	ipRangeInner;
	/**
	* The Azure Active Directory object ID in GUID format.
	* Property of user delegation key.
	*/
	signedOid;
	/**
	* The Azure Active Directory tenant ID in GUID format.
	* Property of user delegation key.
	*/
	signedTenantId;
	/**
	* The date-time the key is active.
	* Property of user delegation key.
	*/
	signedStartsOn;
	/**
	* The date-time the key expires.
	* Property of user delegation key.
	*/
	signedExpiresOn;
	/**
	* Abbreviation of the Azure Storage service that accepts the user delegation key.
	* Property of user delegation key.
	*/
	signedService;
	/**
	* The service version that created the user delegation key.
	* Property of user delegation key.
	*/
	signedVersion;
	/**
	* The delegated user tenant id in Azure AD.
	* Property of user delegation key.
	*/
	signedDelegatedUserTid;
	/**
	* Authorized AAD Object ID in GUID format. The AAD Object ID of a user authorized by the owner of the User Delegation Key
	* to perform the action granted by the SAS. The Azure Storage service will ensure that the owner of the user delegation key
	* has the required permissions before granting access but no additional permission check for the user specified in
	* this value will be performed. This is only used for User Delegation SAS.
	*/
	preauthorizedAgentObjectId;
	/**
	* A GUID value that will be logged in the storage diagnostic logs and can be used to correlate SAS generation with storage resource access.
	* This is only used for User Delegation SAS.
	*/
	correlationId;
	/**
	* Keys for request headers required in the SAS token
	*/
	requestHeaderKeys;
	/**
	* Keys for request query parameters required in the SAS token
	*/
	requestQueryParameterKeys;
	/** To indicate the depth of the virtual blob directory specified
	* in the canonicalizedresource field of the string-to-sign.
	*/
	directoryDepth;
	/**
	* Optional. IP range allowed for this SAS.
	*
	* @readonly
	*/
	get ipRange() {
		if (this.ipRangeInner) return {
			end: this.ipRangeInner.end,
			start: this.ipRangeInner.start
		};
	}
	constructor(version, signature, permissionsOrOptions, services, resourceTypes, protocol, startsOn, expiresOn, ipRange, identifier, resource, cacheControl, contentDisposition, contentEncoding, contentLanguage, contentType, userDelegationKey, preauthorizedAgentObjectId, correlationId, encryptionScope, delegatedUserObjectId, requestHeaderKeys, requestQueryParameterKeys, directoryDepth) {
		this.version = version;
		this.signature = signature;
		if (permissionsOrOptions !== void 0 && typeof permissionsOrOptions !== "string") {
			this.permissions = permissionsOrOptions.permissions;
			this.services = permissionsOrOptions.services;
			this.resourceTypes = permissionsOrOptions.resourceTypes;
			this.protocol = permissionsOrOptions.protocol;
			this.startsOn = permissionsOrOptions.startsOn;
			this.expiresOn = permissionsOrOptions.expiresOn;
			this.ipRangeInner = permissionsOrOptions.ipRange;
			this.identifier = permissionsOrOptions.identifier;
			this.delegatedUserObjectId = permissionsOrOptions.delegatedUserObjectId;
			this.encryptionScope = permissionsOrOptions.encryptionScope;
			this.resource = permissionsOrOptions.resource;
			this.cacheControl = permissionsOrOptions.cacheControl;
			this.contentDisposition = permissionsOrOptions.contentDisposition;
			this.contentEncoding = permissionsOrOptions.contentEncoding;
			this.contentLanguage = permissionsOrOptions.contentLanguage;
			this.contentType = permissionsOrOptions.contentType;
			this.requestHeaderKeys = permissionsOrOptions.requestHeaderKeys;
			this.requestQueryParameterKeys = permissionsOrOptions.requestQueryParameterKeys;
			this.directoryDepth = permissionsOrOptions.directoryDepth;
			if (permissionsOrOptions.userDelegationKey) {
				this.signedOid = permissionsOrOptions.userDelegationKey.signedObjectId;
				this.signedTenantId = permissionsOrOptions.userDelegationKey.signedTenantId;
				this.signedStartsOn = permissionsOrOptions.userDelegationKey.signedStartsOn;
				this.signedExpiresOn = permissionsOrOptions.userDelegationKey.signedExpiresOn;
				this.signedService = permissionsOrOptions.userDelegationKey.signedService;
				this.signedVersion = permissionsOrOptions.userDelegationKey.signedVersion;
				this.signedDelegatedUserTid = permissionsOrOptions.userDelegationKey.signedDelegatedUserTenantId;
				this.preauthorizedAgentObjectId = permissionsOrOptions.preauthorizedAgentObjectId;
				this.correlationId = permissionsOrOptions.correlationId;
			}
		} else {
			this.services = services;
			this.resourceTypes = resourceTypes;
			this.expiresOn = expiresOn;
			this.permissions = permissionsOrOptions;
			this.protocol = protocol;
			this.startsOn = startsOn;
			this.ipRangeInner = ipRange;
			this.delegatedUserObjectId = delegatedUserObjectId;
			this.encryptionScope = encryptionScope;
			this.identifier = identifier;
			this.resource = resource;
			this.cacheControl = cacheControl;
			this.contentDisposition = contentDisposition;
			this.contentEncoding = contentEncoding;
			this.contentLanguage = contentLanguage;
			this.contentType = contentType;
			this.requestHeaderKeys = requestHeaderKeys;
			this.requestQueryParameterKeys = requestQueryParameterKeys;
			this.directoryDepth = directoryDepth;
			if (userDelegationKey) {
				this.signedOid = userDelegationKey.signedObjectId;
				this.signedTenantId = userDelegationKey.signedTenantId;
				this.signedStartsOn = userDelegationKey.signedStartsOn;
				this.signedExpiresOn = userDelegationKey.signedExpiresOn;
				this.signedService = userDelegationKey.signedService;
				this.signedVersion = userDelegationKey.signedVersion;
				this.signedDelegatedUserTid = userDelegationKey.signedDelegatedUserTenantId;
				this.preauthorizedAgentObjectId = preauthorizedAgentObjectId;
				this.correlationId = correlationId;
			}
		}
	}
	/**
	* Encodes all SAS query parameters into a string that can be appended to a URL.
	*
	*/
	toString() {
		const params = [
			"sv",
			"ss",
			"srt",
			"spr",
			"st",
			"se",
			"sip",
			"si",
			"ses",
			"skoid",
			"sktid",
			"skt",
			"ske",
			"sks",
			"skv",
			"sr",
			"sp",
			"rscc",
			"rscd",
			"rsce",
			"rscl",
			"rsct",
			"saoid",
			"scid",
			"sdd",
			"sduoid",
			"skdutid",
			"srh",
			"srq",
			"sig"
		];
		const queries = [];
		for (const param of params) switch (param) {
			case "sv":
				this.tryAppendQueryParameter(queries, param, this.version);
				break;
			case "ss":
				this.tryAppendQueryParameter(queries, param, this.services);
				break;
			case "srt":
				this.tryAppendQueryParameter(queries, param, this.resourceTypes);
				break;
			case "spr":
				this.tryAppendQueryParameter(queries, param, this.protocol);
				break;
			case "st":
				this.tryAppendQueryParameter(queries, param, this.startsOn ? truncatedISO8061Date(this.startsOn, false) : void 0);
				break;
			case "se":
				this.tryAppendQueryParameter(queries, param, this.expiresOn ? truncatedISO8061Date(this.expiresOn, false) : void 0);
				break;
			case "sip":
				this.tryAppendQueryParameter(queries, param, this.ipRange ? ipRangeToString(this.ipRange) : void 0);
				break;
			case "si":
				this.tryAppendQueryParameter(queries, param, this.identifier);
				break;
			case "ses":
				this.tryAppendQueryParameter(queries, param, this.encryptionScope);
				break;
			case "skoid":
				this.tryAppendQueryParameter(queries, param, this.signedOid);
				break;
			case "sktid":
				this.tryAppendQueryParameter(queries, param, this.signedTenantId);
				break;
			case "skt":
				this.tryAppendQueryParameter(queries, param, this.signedStartsOn ? truncatedISO8061Date(this.signedStartsOn, false) : void 0);
				break;
			case "ske":
				this.tryAppendQueryParameter(queries, param, this.signedExpiresOn ? truncatedISO8061Date(this.signedExpiresOn, false) : void 0);
				break;
			case "sks":
				this.tryAppendQueryParameter(queries, param, this.signedService);
				break;
			case "skv":
				this.tryAppendQueryParameter(queries, param, this.signedVersion);
				break;
			case "skdutid":
				this.tryAppendQueryParameter(queries, param, this.signedDelegatedUserTid);
				break;
			case "sr":
				this.tryAppendQueryParameter(queries, param, this.resource);
				break;
			case "sp":
				this.tryAppendQueryParameter(queries, param, this.permissions);
				break;
			case "sig":
				this.tryAppendQueryParameter(queries, param, this.signature);
				break;
			case "rscc":
				this.tryAppendQueryParameter(queries, param, this.cacheControl);
				break;
			case "rscd":
				this.tryAppendQueryParameter(queries, param, this.contentDisposition);
				break;
			case "rsce":
				this.tryAppendQueryParameter(queries, param, this.contentEncoding);
				break;
			case "rscl":
				this.tryAppendQueryParameter(queries, param, this.contentLanguage);
				break;
			case "rsct":
				this.tryAppendQueryParameter(queries, param, this.contentType);
				break;
			case "saoid":
				this.tryAppendQueryParameter(queries, param, this.preauthorizedAgentObjectId);
				break;
			case "scid":
				this.tryAppendQueryParameter(queries, param, this.correlationId);
				break;
			case "sduoid":
				this.tryAppendQueryParameter(queries, param, this.delegatedUserObjectId);
				break;
			case "srh":
				this.tryAppendQueryParameter(queries, param, this.requestHeaderKeys);
				break;
			case "srq":
				this.tryAppendQueryParameter(queries, param, this.requestQueryParameterKeys);
				break;
			case "sdd": this.tryAppendQueryParameter(queries, param, this.directoryDepth !== void 0 ? this.directoryDepth.toString() : "");
		}
		return queries.join("&");
	}
	/**
	* A private helper method used to filter and append query key/value pairs into an array.
	*
	* @param queries -
	* @param key -
	* @param value -
	*/
	tryAppendQueryParameter(queries, key, value) {
		if (!value) return;
		key = encodeURIComponent(key);
		value = encodeURIComponent(value);
		if (key.length > 0 && value.length > 0) queries.push(`${key}=${value}`);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/sas/BlobSASSignatureValues.js
function generateBlobSASQueryParameters(blobSASSignatureValues, sharedKeyCredentialOrUserDelegationKey, accountName) {
	return generateBlobSASQueryParametersInternal(blobSASSignatureValues, sharedKeyCredentialOrUserDelegationKey, accountName).sasQueryParameters;
}
function generateBlobSASQueryParametersInternal(blobSASSignatureValues, sharedKeyCredentialOrUserDelegationKey, accountName) {
	const version = blobSASSignatureValues.version ? blobSASSignatureValues.version : SERVICE_VERSION;
	const sharedKeyCredential = sharedKeyCredentialOrUserDelegationKey instanceof StorageSharedKeyCredential ? sharedKeyCredentialOrUserDelegationKey : void 0;
	let userDelegationKeyCredential;
	if (sharedKeyCredential === void 0 && accountName !== void 0) userDelegationKeyCredential = new UserDelegationKeyCredential(accountName, sharedKeyCredentialOrUserDelegationKey);
	if (sharedKeyCredential === void 0 && userDelegationKeyCredential === void 0) throw TypeError("Invalid sharedKeyCredential, userDelegationKey or accountName.");
	if (version >= "2020-12-06") {
		if (sharedKeyCredential !== void 0) return generateBlobSASQueryParameters20201206(blobSASSignatureValues, sharedKeyCredential);
		else if (version >= "2026-04-06") return generateBlobSASQueryParametersUDK20260406(blobSASSignatureValues, userDelegationKeyCredential);
		else if (version >= "2025-07-05") return generateBlobSASQueryParametersUDK20250705(blobSASSignatureValues, userDelegationKeyCredential);
		else return generateBlobSASQueryParametersUDK20201206(blobSASSignatureValues, userDelegationKeyCredential);
	}
	if (version >= "2018-11-09") {
		if (sharedKeyCredential !== void 0) {
			if (version >= "2020-02-10") return generateBlobSASQueryParameters20200210(blobSASSignatureValues, sharedKeyCredential);
			else return generateBlobSASQueryParameters20181109(blobSASSignatureValues, sharedKeyCredential);
		} else if (version >= "2020-02-10") return generateBlobSASQueryParametersUDK20200210(blobSASSignatureValues, userDelegationKeyCredential);
		else return generateBlobSASQueryParametersUDK20181109(blobSASSignatureValues, userDelegationKeyCredential);
	}
	if (version >= "2015-04-05") {
		if (sharedKeyCredential !== void 0) return generateBlobSASQueryParameters20150405(blobSASSignatureValues, sharedKeyCredential);
		else throw new RangeError("'version' must be >= '2018-11-09' when generating user delegation SAS using user delegation key.");
	}
	throw new RangeError("'version' must be >= '2015-04-05'.");
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
* IMPLEMENTATION FOR API VERSION FROM 2015-04-05 AND BEFORE 2018-11-09.
*
* Creates an instance of SASQueryParameters.
*
* Only accepts required settings needed to create a SAS. For optional settings please
* set corresponding properties directly, such as permissions, startsOn and identifier.
*
* WARNING: When identifier is not provided, permissions and expiresOn are required.
* You MUST assign value to identifier or expiresOn & permissions manually if you initial with
* this constructor.
*
* @param blobSASSignatureValues -
* @param sharedKeyCredential -
*/
function generateBlobSASQueryParameters20150405(blobSASSignatureValues, sharedKeyCredential) {
	blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
	if (!blobSASSignatureValues.identifier && !(blobSASSignatureValues.permissions && blobSASSignatureValues.expiresOn)) throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when 'identifier' is not provided.");
	let resource = "c";
	if (blobSASSignatureValues.blobName) resource = "b";
	let verifiedPermissions;
	if (blobSASSignatureValues.permissions) {
		if (blobSASSignatureValues.blobName) verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
		else verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
	}
	const stringToSign = [
		verifiedPermissions ? verifiedPermissions : "",
		blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
		blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
		getCanonicalName(sharedKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
		blobSASSignatureValues.identifier,
		blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
		blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
		blobSASSignatureValues.version,
		blobSASSignatureValues.cacheControl ? blobSASSignatureValues.cacheControl : "",
		blobSASSignatureValues.contentDisposition ? blobSASSignatureValues.contentDisposition : "",
		blobSASSignatureValues.contentEncoding ? blobSASSignatureValues.contentEncoding : "",
		blobSASSignatureValues.contentLanguage ? blobSASSignatureValues.contentLanguage : "",
		blobSASSignatureValues.contentType ? blobSASSignatureValues.contentType : ""
	].join("\n");
	const signature = sharedKeyCredential.computeHMACSHA256(stringToSign);
	return {
		sasQueryParameters: new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, void 0, void 0, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType),
		stringToSign
	};
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
* IMPLEMENTATION FOR API VERSION FROM 2018-11-09.
*
* Creates an instance of SASQueryParameters.
*
* Only accepts required settings needed to create a SAS. For optional settings please
* set corresponding properties directly, such as permissions, startsOn and identifier.
*
* WARNING: When identifier is not provided, permissions and expiresOn are required.
* You MUST assign value to identifier or expiresOn & permissions manually if you initial with
* this constructor.
*
* @param blobSASSignatureValues -
* @param sharedKeyCredential -
*/
function generateBlobSASQueryParameters20181109(blobSASSignatureValues, sharedKeyCredential) {
	blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
	if (!blobSASSignatureValues.identifier && !(blobSASSignatureValues.permissions && blobSASSignatureValues.expiresOn)) throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when 'identifier' is not provided.");
	let resource = "c";
	let timestamp = blobSASSignatureValues.snapshotTime;
	if (blobSASSignatureValues.blobName) {
		resource = "b";
		if (blobSASSignatureValues.snapshotTime) resource = "bs";
		else if (blobSASSignatureValues.versionId) {
			resource = "bv";
			timestamp = blobSASSignatureValues.versionId;
		}
	}
	let verifiedPermissions;
	if (blobSASSignatureValues.permissions) {
		if (blobSASSignatureValues.blobName) verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
		else verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
	}
	const stringToSign = [
		verifiedPermissions ? verifiedPermissions : "",
		blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
		blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
		getCanonicalName(sharedKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
		blobSASSignatureValues.identifier,
		blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
		blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
		blobSASSignatureValues.version,
		resource,
		timestamp,
		blobSASSignatureValues.cacheControl ? blobSASSignatureValues.cacheControl : "",
		blobSASSignatureValues.contentDisposition ? blobSASSignatureValues.contentDisposition : "",
		blobSASSignatureValues.contentEncoding ? blobSASSignatureValues.contentEncoding : "",
		blobSASSignatureValues.contentLanguage ? blobSASSignatureValues.contentLanguage : "",
		blobSASSignatureValues.contentType ? blobSASSignatureValues.contentType : ""
	].join("\n");
	const signature = sharedKeyCredential.computeHMACSHA256(stringToSign);
	return {
		sasQueryParameters: new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, void 0, void 0, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType),
		stringToSign
	};
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
* IMPLEMENTATION FOR API VERSION FROM 2020-02-10.
*
* Creates an instance of SASQueryParameters.
*
* Only accepts required settings needed to create a SAS. For optional settings please
* set corresponding properties directly, such as permissions, startsOn and identifier.
*
* WARNING: When identifier is not provided, permissions and expiresOn are required.
* You MUST assign value to identifier or expiresOn & permissions manually if you initial with
* this constructor.
*
* @param blobSASSignatureValues -
* @param sharedKeyCredential -
*/
function generateBlobSASQueryParameters20200210(blobSASSignatureValues, sharedKeyCredential) {
	blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
	if (!blobSASSignatureValues.identifier && !(blobSASSignatureValues.permissions && blobSASSignatureValues.expiresOn)) throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when 'identifier' is not provided.");
	let resource = "c";
	let timestamp = blobSASSignatureValues.snapshotTime;
	let directoryDepth = void 0;
	if (blobSASSignatureValues.blobName) {
		if (blobSASSignatureValues.isDirectory === true) {
			resource = "d";
			directoryDepth = trimBlobName(blobSASSignatureValues.blobName).split("/").length;
		} else {
			resource = "b";
			if (blobSASSignatureValues.snapshotTime) resource = "bs";
			else if (blobSASSignatureValues.versionId) {
				resource = "bv";
				timestamp = blobSASSignatureValues.versionId;
			}
		}
	}
	let verifiedPermissions;
	if (blobSASSignatureValues.permissions) {
		if (blobSASSignatureValues.blobName) verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
		else verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
	}
	const stringToSign = [
		verifiedPermissions ? verifiedPermissions : "",
		blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
		blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
		getCanonicalName(sharedKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
		blobSASSignatureValues.identifier,
		blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
		blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
		blobSASSignatureValues.version,
		resource,
		timestamp,
		blobSASSignatureValues.cacheControl ? blobSASSignatureValues.cacheControl : "",
		blobSASSignatureValues.contentDisposition ? blobSASSignatureValues.contentDisposition : "",
		blobSASSignatureValues.contentEncoding ? blobSASSignatureValues.contentEncoding : "",
		blobSASSignatureValues.contentLanguage ? blobSASSignatureValues.contentLanguage : "",
		blobSASSignatureValues.contentType ? blobSASSignatureValues.contentType : ""
	].join("\n");
	const signature = sharedKeyCredential.computeHMACSHA256(stringToSign);
	return {
		sasQueryParameters: new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, void 0, void 0, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, void 0, void 0, void 0, void 0, void 0, void 0, void 0, directoryDepth),
		stringToSign
	};
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
* IMPLEMENTATION FOR API VERSION FROM 2020-12-06.
*
* Creates an instance of SASQueryParameters.
*
* Only accepts required settings needed to create a SAS. For optional settings please
* set corresponding properties directly, such as permissions, startsOn and identifier.
*
* WARNING: When identifier is not provided, permissions and expiresOn are required.
* You MUST assign value to identifier or expiresOn & permissions manually if you initial with
* this constructor.
*
* @param blobSASSignatureValues -
* @param sharedKeyCredential -
*/
function generateBlobSASQueryParameters20201206(blobSASSignatureValues, sharedKeyCredential) {
	blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
	if (!blobSASSignatureValues.identifier && !(blobSASSignatureValues.permissions && blobSASSignatureValues.expiresOn)) throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when 'identifier' is not provided.");
	let resource = "c";
	let timestamp = blobSASSignatureValues.snapshotTime;
	let directoryDepth = void 0;
	if (blobSASSignatureValues.blobName) {
		if (blobSASSignatureValues.isDirectory === true) {
			resource = "d";
			directoryDepth = trimBlobName(blobSASSignatureValues.blobName).split("/").length;
		} else {
			resource = "b";
			if (blobSASSignatureValues.snapshotTime) resource = "bs";
			else if (blobSASSignatureValues.versionId) {
				resource = "bv";
				timestamp = blobSASSignatureValues.versionId;
			}
		}
	}
	let verifiedPermissions;
	if (blobSASSignatureValues.permissions) {
		if (blobSASSignatureValues.blobName) verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
		else verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
	}
	const stringToSign = [
		verifiedPermissions ? verifiedPermissions : "",
		blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
		blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
		getCanonicalName(sharedKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
		blobSASSignatureValues.identifier,
		blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
		blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
		blobSASSignatureValues.version,
		resource,
		timestamp,
		blobSASSignatureValues.encryptionScope,
		blobSASSignatureValues.cacheControl ? blobSASSignatureValues.cacheControl : "",
		blobSASSignatureValues.contentDisposition ? blobSASSignatureValues.contentDisposition : "",
		blobSASSignatureValues.contentEncoding ? blobSASSignatureValues.contentEncoding : "",
		blobSASSignatureValues.contentLanguage ? blobSASSignatureValues.contentLanguage : "",
		blobSASSignatureValues.contentType ? blobSASSignatureValues.contentType : ""
	].join("\n");
	const signature = sharedKeyCredential.computeHMACSHA256(stringToSign);
	return {
		sasQueryParameters: new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, void 0, void 0, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, void 0, void 0, void 0, blobSASSignatureValues.encryptionScope, void 0, void 0, void 0, directoryDepth),
		stringToSign
	};
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
* IMPLEMENTATION FOR API VERSION FROM 2018-11-09.
*
* Creates an instance of SASQueryParameters.
*
* Only accepts required settings needed to create a SAS. For optional settings please
* set corresponding properties directly, such as permissions, startsOn.
*
* WARNING: identifier will be ignored, permissions and expiresOn are required.
*
* @param blobSASSignatureValues -
* @param userDelegationKeyCredential -
*/
function generateBlobSASQueryParametersUDK20181109(blobSASSignatureValues, userDelegationKeyCredential) {
	blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
	if (!blobSASSignatureValues.permissions || !blobSASSignatureValues.expiresOn) throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
	let resource = "c";
	let timestamp = blobSASSignatureValues.snapshotTime;
	if (blobSASSignatureValues.blobName) {
		resource = "b";
		if (blobSASSignatureValues.snapshotTime) resource = "bs";
		else if (blobSASSignatureValues.versionId) {
			resource = "bv";
			timestamp = blobSASSignatureValues.versionId;
		}
	}
	let verifiedPermissions;
	if (blobSASSignatureValues.permissions) {
		if (blobSASSignatureValues.blobName) verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
		else verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
	}
	const stringToSign = [
		verifiedPermissions ? verifiedPermissions : "",
		blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
		blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
		getCanonicalName(userDelegationKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
		userDelegationKeyCredential.userDelegationKey.signedObjectId,
		userDelegationKeyCredential.userDelegationKey.signedTenantId,
		userDelegationKeyCredential.userDelegationKey.signedStartsOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedStartsOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedExpiresOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedExpiresOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedService,
		userDelegationKeyCredential.userDelegationKey.signedVersion,
		blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
		blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
		blobSASSignatureValues.version,
		resource,
		timestamp,
		blobSASSignatureValues.cacheControl,
		blobSASSignatureValues.contentDisposition,
		blobSASSignatureValues.contentEncoding,
		blobSASSignatureValues.contentLanguage,
		blobSASSignatureValues.contentType
	].join("\n");
	const signature = userDelegationKeyCredential.computeHMACSHA256(stringToSign);
	return {
		sasQueryParameters: new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, void 0, void 0, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, userDelegationKeyCredential.userDelegationKey),
		stringToSign
	};
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
* IMPLEMENTATION FOR API VERSION FROM 2020-02-10.
*
* Creates an instance of SASQueryParameters.
*
* Only accepts required settings needed to create a SAS. For optional settings please
* set corresponding properties directly, such as permissions, startsOn.
*
* WARNING: identifier will be ignored, permissions and expiresOn are required.
*
* @param blobSASSignatureValues -
* @param userDelegationKeyCredential -
*/
function generateBlobSASQueryParametersUDK20200210(blobSASSignatureValues, userDelegationKeyCredential) {
	blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
	if (!blobSASSignatureValues.permissions || !blobSASSignatureValues.expiresOn) throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
	let resource = "c";
	let timestamp = blobSASSignatureValues.snapshotTime;
	let directoryDepth = void 0;
	if (blobSASSignatureValues.blobName) {
		if (blobSASSignatureValues.isDirectory === true) {
			resource = "d";
			directoryDepth = trimBlobName(blobSASSignatureValues.blobName).split("/").length;
		} else {
			resource = "b";
			if (blobSASSignatureValues.snapshotTime) resource = "bs";
			else if (blobSASSignatureValues.versionId) {
				resource = "bv";
				timestamp = blobSASSignatureValues.versionId;
			}
		}
	}
	let verifiedPermissions;
	if (blobSASSignatureValues.permissions) {
		if (blobSASSignatureValues.blobName) verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
		else verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
	}
	const stringToSign = [
		verifiedPermissions ? verifiedPermissions : "",
		blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
		blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
		getCanonicalName(userDelegationKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
		userDelegationKeyCredential.userDelegationKey.signedObjectId,
		userDelegationKeyCredential.userDelegationKey.signedTenantId,
		userDelegationKeyCredential.userDelegationKey.signedStartsOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedStartsOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedExpiresOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedExpiresOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedService,
		userDelegationKeyCredential.userDelegationKey.signedVersion,
		blobSASSignatureValues.preauthorizedAgentObjectId,
		void 0,
		blobSASSignatureValues.correlationId,
		blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
		blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
		blobSASSignatureValues.version,
		resource,
		timestamp,
		blobSASSignatureValues.cacheControl,
		blobSASSignatureValues.contentDisposition,
		blobSASSignatureValues.contentEncoding,
		blobSASSignatureValues.contentLanguage,
		blobSASSignatureValues.contentType
	].join("\n");
	const signature = userDelegationKeyCredential.computeHMACSHA256(stringToSign);
	return {
		sasQueryParameters: new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, void 0, void 0, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, userDelegationKeyCredential.userDelegationKey, blobSASSignatureValues.preauthorizedAgentObjectId, blobSASSignatureValues.correlationId, void 0, void 0, void 0, void 0, directoryDepth),
		stringToSign
	};
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
* IMPLEMENTATION FOR API VERSION FROM 2020-12-06.
*
* Creates an instance of SASQueryParameters.
*
* Only accepts required settings needed to create a SAS. For optional settings please
* set corresponding properties directly, such as permissions, startsOn.
*
* WARNING: identifier will be ignored, permissions and expiresOn are required.
*
* @param blobSASSignatureValues -
* @param userDelegationKeyCredential -
*/
function generateBlobSASQueryParametersUDK20201206(blobSASSignatureValues, userDelegationKeyCredential) {
	blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
	if (!blobSASSignatureValues.permissions || !blobSASSignatureValues.expiresOn) throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
	let resource = "c";
	let timestamp = blobSASSignatureValues.snapshotTime;
	let directoryDepth = void 0;
	if (blobSASSignatureValues.blobName) {
		if (blobSASSignatureValues.isDirectory === true) {
			resource = "d";
			directoryDepth = trimBlobName(blobSASSignatureValues.blobName).split("/").length;
		} else {
			resource = "b";
			if (blobSASSignatureValues.snapshotTime) resource = "bs";
			else if (blobSASSignatureValues.versionId) {
				resource = "bv";
				timestamp = blobSASSignatureValues.versionId;
			}
		}
	}
	let verifiedPermissions;
	if (blobSASSignatureValues.permissions) {
		if (blobSASSignatureValues.blobName) verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
		else verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
	}
	const stringToSign = [
		verifiedPermissions ? verifiedPermissions : "",
		blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
		blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
		getCanonicalName(userDelegationKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
		userDelegationKeyCredential.userDelegationKey.signedObjectId,
		userDelegationKeyCredential.userDelegationKey.signedTenantId,
		userDelegationKeyCredential.userDelegationKey.signedStartsOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedStartsOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedExpiresOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedExpiresOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedService,
		userDelegationKeyCredential.userDelegationKey.signedVersion,
		blobSASSignatureValues.preauthorizedAgentObjectId,
		void 0,
		blobSASSignatureValues.correlationId,
		blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
		blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
		blobSASSignatureValues.version,
		resource,
		timestamp,
		blobSASSignatureValues.encryptionScope,
		blobSASSignatureValues.cacheControl,
		blobSASSignatureValues.contentDisposition,
		blobSASSignatureValues.contentEncoding,
		blobSASSignatureValues.contentLanguage,
		blobSASSignatureValues.contentType
	].join("\n");
	const signature = userDelegationKeyCredential.computeHMACSHA256(stringToSign);
	return {
		sasQueryParameters: new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, void 0, void 0, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, userDelegationKeyCredential.userDelegationKey, blobSASSignatureValues.preauthorizedAgentObjectId, blobSASSignatureValues.correlationId, blobSASSignatureValues.encryptionScope, void 0, void 0, void 0, directoryDepth),
		stringToSign
	};
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
* IMPLEMENTATION FOR API VERSION FROM 2020-12-06.
*
* Creates an instance of SASQueryParameters.
*
* Only accepts required settings needed to create a SAS. For optional settings please
* set corresponding properties directly, such as permissions, startsOn.
*
* WARNING: identifier will be ignored, permissions and expiresOn are required.
*
* @param blobSASSignatureValues -
* @param userDelegationKeyCredential -
*/
function generateBlobSASQueryParametersUDK20250705(blobSASSignatureValues, userDelegationKeyCredential) {
	blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
	if (!blobSASSignatureValues.permissions || !blobSASSignatureValues.expiresOn) throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
	let resource = "c";
	let timestamp = blobSASSignatureValues.snapshotTime;
	let directoryDepth = void 0;
	if (blobSASSignatureValues.blobName) {
		if (blobSASSignatureValues.isDirectory === true) {
			resource = "d";
			directoryDepth = trimBlobName(blobSASSignatureValues.blobName).split("/").length;
		} else {
			resource = "b";
			if (blobSASSignatureValues.snapshotTime) resource = "bs";
			else if (blobSASSignatureValues.versionId) {
				resource = "bv";
				timestamp = blobSASSignatureValues.versionId;
			}
		}
	}
	let verifiedPermissions;
	if (blobSASSignatureValues.permissions) {
		if (blobSASSignatureValues.blobName) verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
		else verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
	}
	const stringToSign = [
		verifiedPermissions ? verifiedPermissions : "",
		blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
		blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
		getCanonicalName(userDelegationKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
		userDelegationKeyCredential.userDelegationKey.signedObjectId,
		userDelegationKeyCredential.userDelegationKey.signedTenantId,
		userDelegationKeyCredential.userDelegationKey.signedStartsOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedStartsOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedExpiresOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedExpiresOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedService,
		userDelegationKeyCredential.userDelegationKey.signedVersion,
		blobSASSignatureValues.preauthorizedAgentObjectId,
		void 0,
		blobSASSignatureValues.correlationId,
		userDelegationKeyCredential.userDelegationKey.signedDelegatedUserTenantId,
		blobSASSignatureValues.delegatedUserObjectId,
		blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
		blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
		blobSASSignatureValues.version,
		resource,
		timestamp,
		blobSASSignatureValues.encryptionScope,
		blobSASSignatureValues.cacheControl,
		blobSASSignatureValues.contentDisposition,
		blobSASSignatureValues.contentEncoding,
		blobSASSignatureValues.contentLanguage,
		blobSASSignatureValues.contentType
	].join("\n");
	const signature = userDelegationKeyCredential.computeHMACSHA256(stringToSign);
	return {
		sasQueryParameters: new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, void 0, void 0, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, userDelegationKeyCredential.userDelegationKey, blobSASSignatureValues.preauthorizedAgentObjectId, blobSASSignatureValues.correlationId, blobSASSignatureValues.encryptionScope, blobSASSignatureValues.delegatedUserObjectId, void 0, void 0, directoryDepth),
		stringToSign
	};
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
* IMPLEMENTATION FOR API VERSION FROM 2020-12-06.
*
* Creates an instance of SASQueryParameters.
*
* Only accepts required settings needed to create a SAS. For optional settings please
* set corresponding properties directly, such as permissions, startsOn.
*
* WARNING: identifier will be ignored, permissions and expiresOn are required.
*
* @param blobSASSignatureValues -
* @param userDelegationKeyCredential -
*/
function generateBlobSASQueryParametersUDK20260406(blobSASSignatureValues, userDelegationKeyCredential) {
	blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
	if (!blobSASSignatureValues.permissions || !blobSASSignatureValues.expiresOn) throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
	let resource = "c";
	let timestamp = blobSASSignatureValues.snapshotTime;
	let directoryDepth = void 0;
	if (blobSASSignatureValues.blobName) {
		if (blobSASSignatureValues.isDirectory === true) {
			resource = "d";
			directoryDepth = trimBlobName(blobSASSignatureValues.blobName).split("/").length;
		} else {
			resource = "b";
			if (blobSASSignatureValues.snapshotTime) resource = "bs";
			else if (blobSASSignatureValues.versionId) {
				resource = "bv";
				timestamp = blobSASSignatureValues.versionId;
			}
		}
	}
	let verifiedPermissions;
	if (blobSASSignatureValues.permissions) {
		if (blobSASSignatureValues.blobName) verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
		else verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
	}
	const stringToSign = [
		verifiedPermissions ? verifiedPermissions : "",
		blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
		blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
		getCanonicalName(userDelegationKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
		userDelegationKeyCredential.userDelegationKey.signedObjectId,
		userDelegationKeyCredential.userDelegationKey.signedTenantId,
		userDelegationKeyCredential.userDelegationKey.signedStartsOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedStartsOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedExpiresOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedExpiresOn, false) : "",
		userDelegationKeyCredential.userDelegationKey.signedService,
		userDelegationKeyCredential.userDelegationKey.signedVersion,
		blobSASSignatureValues.preauthorizedAgentObjectId,
		void 0,
		blobSASSignatureValues.correlationId,
		userDelegationKeyCredential.userDelegationKey.signedDelegatedUserTenantId,
		blobSASSignatureValues.delegatedUserObjectId,
		blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
		blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
		blobSASSignatureValues.version,
		resource,
		timestamp,
		blobSASSignatureValues.encryptionScope,
		formatRequestHeadersForSasSigning(blobSASSignatureValues.requestHeaders),
		formatRequestQueryParametersForSasSigning(blobSASSignatureValues.requestQueryParameters),
		blobSASSignatureValues.cacheControl,
		blobSASSignatureValues.contentDisposition,
		blobSASSignatureValues.contentEncoding,
		blobSASSignatureValues.contentLanguage,
		blobSASSignatureValues.contentType
	].join("\n");
	const signature = userDelegationKeyCredential.computeHMACSHA256(stringToSign);
	return {
		sasQueryParameters: new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, void 0, void 0, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, userDelegationKeyCredential.userDelegationKey, blobSASSignatureValues.preauthorizedAgentObjectId, blobSASSignatureValues.correlationId, blobSASSignatureValues.encryptionScope, blobSASSignatureValues.delegatedUserObjectId, getKeysOfRequestHeaders(blobSASSignatureValues.requestHeaders), getKeysOfRequestHeaders(blobSASSignatureValues.requestQueryParameters), directoryDepth),
		stringToSign
	};
}
function formatRequestHeadersForSasSigning(requestHeaders) {
	if (requestHeaders === void 0) return;
	let canonicalValue = "";
	Object.keys(requestHeaders).forEach(function(key) {
		canonicalValue = canonicalValue + key + ":" + requestHeaders[key] + "\n";
	});
	return canonicalValue;
}
function formatRequestQueryParametersForSasSigning(queryParameters) {
	if (queryParameters === void 0) return;
	let canonicalValue = "";
	Object.keys(queryParameters).forEach(function(key) {
		canonicalValue = canonicalValue + "\n" + key + ":" + queryParameters[key];
	});
	return canonicalValue;
}
function getKeysOfRequestHeaders(requestHeaders) {
	if (requestHeaders === void 0) return;
	let requestKeys = "";
	let index = 0;
	Object.keys(requestHeaders).forEach(function(key) {
		if (index !== 0) requestKeys = requestKeys + ",";
		requestKeys = requestKeys + key;
		++index;
	});
	return requestKeys;
}
function getCanonicalName(accountName, containerName, blobName) {
	const elements = [`/blob/${accountName}/${containerName}`];
	if (blobName) elements.push(`/${blobName}`);
	return elements.join("");
}
function SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues) {
	const version = blobSASSignatureValues.version ? blobSASSignatureValues.version : SERVICE_VERSION;
	if (blobSASSignatureValues.snapshotTime && version < "2018-11-09") throw RangeError("'version' must be >= '2018-11-09' when providing 'snapshotTime'.");
	if (blobSASSignatureValues.blobName === void 0 && blobSASSignatureValues.snapshotTime) throw RangeError("Must provide 'blobName' when providing 'snapshotTime'.");
	if (blobSASSignatureValues.versionId && version < "2019-10-10") throw RangeError("'version' must be >= '2019-10-10' when providing 'versionId'.");
	if (blobSASSignatureValues.blobName === void 0 && blobSASSignatureValues.versionId) throw RangeError("Must provide 'blobName' when providing 'versionId'.");
	if (blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.setImmutabilityPolicy && version < "2020-08-04") throw RangeError("'version' must be >= '2020-08-04' when provided 'i' permission.");
	if (blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.deleteVersion && version < "2019-10-10") throw RangeError("'version' must be >= '2019-10-10' when providing 'x' permission.");
	if (blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.permanentDelete && version < "2019-10-10") throw RangeError("'version' must be >= '2019-10-10' when providing 'y' permission.");
	if (blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.tag && version < "2019-12-12") throw RangeError("'version' must be >= '2019-12-12' when providing 't' permission.");
	if (version < "2020-02-10" && blobSASSignatureValues.permissions && (blobSASSignatureValues.permissions.move || blobSASSignatureValues.permissions.execute)) throw RangeError("'version' must be >= '2020-02-10' when providing the 'm' or 'e' permission.");
	if (version < "2021-04-10" && blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.filterByTags) throw RangeError("'version' must be >= '2021-04-10' when providing the 'f' permission.");
	if (version < "2020-02-10" && (blobSASSignatureValues.preauthorizedAgentObjectId || blobSASSignatureValues.correlationId)) throw RangeError("'version' must be >= '2020-02-10' when providing 'preauthorizedAgentObjectId' or 'correlationId'.");
	if (blobSASSignatureValues.encryptionScope && version < "2020-12-06") throw RangeError("'version' must be >= '2020-12-06' when provided 'encryptionScope' in SAS.");
	blobSASSignatureValues.version = version;
	return blobSASSignatureValues;
}
function trimBlobName(blobName) {
	let internalName = blobName;
	while (internalName.startsWith("/")) internalName = internalName.substring(1);
	while (internalName.endsWith("/")) internalName = internalName.substring(0, internalName.length - 1);
	return internalName;
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/BlobLeaseClient.js
/**
* A client that manages leases for a {@link ContainerClient} or a {@link BlobClient}.
*/
var BlobLeaseClient = class {
	_leaseId;
	_url;
	_containerOrBlobOperation;
	_isContainer;
	/**
	* Gets the lease Id.
	*
	* @readonly
	*/
	get leaseId() {
		return this._leaseId;
	}
	/**
	* Gets the url.
	*
	* @readonly
	*/
	get url() {
		return this._url;
	}
	/**
	* Creates an instance of BlobLeaseClient.
	* @param client - The client to make the lease operation requests.
	* @param leaseId - Initial proposed lease id.
	*/
	constructor(client, leaseId) {
		const clientContext = client.storageClientContext;
		this._url = client.url;
		if (client.name === void 0) {
			this._isContainer = true;
			this._containerOrBlobOperation = clientContext.container;
		} else {
			this._isContainer = false;
			this._containerOrBlobOperation = clientContext.blob;
		}
		if (!leaseId) leaseId = randomUUID();
		this._leaseId = leaseId;
	}
	/**
	* Establishes and manages a lock on a container for delete operations, or on a blob
	* for write and delete operations.
	* The lock duration can be 15 to 60 seconds, or can be infinite.
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-container
	* and
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-blob
	*
	* @param duration - Must be between 15 to 60 seconds, or infinite (-1)
	* @param options - option to configure lease management operations.
	* @returns Response data for acquire lease operation.
	*/
	async acquireLease(duration, options = {}) {
		if (this._isContainer && (options.conditions?.ifMatch && options.conditions?.ifMatch !== "" || options.conditions?.ifNoneMatch && options.conditions?.ifNoneMatch !== "" || options.conditions?.tagConditions)) throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
		return tracingClient.withSpan("BlobLeaseClient-acquireLease", options, async (updatedOptions) => {
			return assertResponse(await this._containerOrBlobOperation.acquireLease({
				abortSignal: options.abortSignal,
				duration,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				proposedLeaseId: this._leaseId,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* To change the ID of the lease.
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-container
	* and
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-blob
	*
	* @param proposedLeaseId - the proposed new lease Id.
	* @param options - option to configure lease management operations.
	* @returns Response data for change lease operation.
	*/
	async changeLease(proposedLeaseId, options = {}) {
		if (this._isContainer && (options.conditions?.ifMatch && options.conditions?.ifMatch !== "" || options.conditions?.ifNoneMatch && options.conditions?.ifNoneMatch !== "" || options.conditions?.tagConditions)) throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
		return tracingClient.withSpan("BlobLeaseClient-changeLease", options, async (updatedOptions) => {
			const response = assertResponse(await this._containerOrBlobOperation.changeLease(this._leaseId, proposedLeaseId, {
				abortSignal: options.abortSignal,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions
			}));
			this._leaseId = proposedLeaseId;
			return response;
		});
	}
	/**
	* To free the lease if it is no longer needed so that another client may
	* immediately acquire a lease against the container or the blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-container
	* and
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-blob
	*
	* @param options - option to configure lease management operations.
	* @returns Response data for release lease operation.
	*/
	async releaseLease(options = {}) {
		if (this._isContainer && (options.conditions?.ifMatch && options.conditions?.ifMatch !== "" || options.conditions?.ifNoneMatch && options.conditions?.ifNoneMatch !== "" || options.conditions?.tagConditions)) throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
		return tracingClient.withSpan("BlobLeaseClient-releaseLease", options, async (updatedOptions) => {
			return assertResponse(await this._containerOrBlobOperation.releaseLease(this._leaseId, {
				abortSignal: options.abortSignal,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* To renew the lease.
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-container
	* and
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-blob
	*
	* @param options - Optional option to configure lease management operations.
	* @returns Response data for renew lease operation.
	*/
	async renewLease(options = {}) {
		if (this._isContainer && (options.conditions?.ifMatch && options.conditions?.ifMatch !== "" || options.conditions?.ifNoneMatch && options.conditions?.ifNoneMatch !== "" || options.conditions?.tagConditions)) throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
		return tracingClient.withSpan("BlobLeaseClient-renewLease", options, async (updatedOptions) => {
			return this._containerOrBlobOperation.renewLease(this._leaseId, {
				abortSignal: options.abortSignal,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions
			});
		});
	}
	/**
	* To end the lease but ensure that another client cannot acquire a new lease
	* until the current lease period has expired.
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-container
	* and
	* @see https://learn.microsoft.com/rest/api/storageservices/lease-blob
	*
	* @param breakPeriod - Break period
	* @param options - Optional options to configure lease management operations.
	* @returns Response data for break lease operation.
	*/
	async breakLease(breakPeriod, options = {}) {
		if (this._isContainer && (options.conditions?.ifMatch && options.conditions?.ifMatch !== "" || options.conditions?.ifNoneMatch && options.conditions?.ifNoneMatch !== "" || options.conditions?.tagConditions)) throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
		return tracingClient.withSpan("BlobLeaseClient-breakLease", options, async (updatedOptions) => {
			const operationOptions = {
				abortSignal: options.abortSignal,
				breakPeriod,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions
			};
			return assertResponse(await this._containerOrBlobOperation.breakLease(operationOptions));
		});
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/utils/RetriableReadableStream.js
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
*
* A Node.js ReadableStream will internally retry when internal ReadableStream unexpected ends.
*/
var RetriableReadableStream = class extends Readable {
	start;
	offset;
	end;
	getter;
	source;
	retries = 0;
	maxRetryRequests;
	onProgress;
	options;
	/**
	* Creates an instance of RetriableReadableStream.
	*
	* @param source - The current ReadableStream returned from getter
	* @param getter - A method calling downloading request returning
	*                                      a new ReadableStream from specified offset
	* @param offset - Offset position in original data source to read
	* @param count - How much data in original data source to read
	* @param options -
	*/
	constructor(source, getter, offset, count, options = {}) {
		super({ highWaterMark: options.highWaterMark });
		this.getter = getter;
		this.source = source;
		this.start = offset;
		this.offset = offset;
		this.end = offset + count - 1;
		this.maxRetryRequests = options.maxRetryRequests && options.maxRetryRequests >= 0 ? options.maxRetryRequests : 0;
		this.onProgress = options.onProgress;
		this.options = options;
		this.setSourceEventHandlers();
	}
	_read() {
		this.source.resume();
	}
	setSourceEventHandlers() {
		this.source.on("data", this.sourceDataHandler);
		this.source.on("end", this.sourceErrorOrEndHandler);
		this.source.on("error", this.sourceErrorOrEndHandler);
		this.source.on("aborted", this.sourceAbortedHandler);
	}
	removeSourceEventHandlers() {
		this.source.removeListener("data", this.sourceDataHandler);
		this.source.removeListener("end", this.sourceErrorOrEndHandler);
		this.source.removeListener("error", this.sourceErrorOrEndHandler);
		this.source.removeListener("aborted", this.sourceAbortedHandler);
	}
	sourceDataHandler = (data) => {
		if (this.options.doInjectErrorOnce) {
			this.options.doInjectErrorOnce = void 0;
			this.source.pause();
			this.sourceErrorOrEndHandler();
			this.source.destroy();
			return;
		}
		this.offset += data.length;
		if (this.onProgress) this.onProgress({ loadedBytes: this.offset - this.start });
		if (!this.push(data)) this.source.pause();
	};
	sourceAbortedHandler = () => {
		const abortError = new AbortError("The operation was aborted.");
		this.destroy(abortError);
	};
	sourceErrorOrEndHandler = (err) => {
		if (err && err.name === "AbortError") {
			this.destroy(err);
			return;
		}
		this.removeSourceEventHandlers();
		if (this.offset - 1 === this.end) this.push(null);
		else if (this.offset <= this.end) {
			if (this.retries < this.maxRetryRequests) {
				this.retries += 1;
				this.getter(this.offset).then((newSource) => {
					this.source = newSource;
					this.setSourceEventHandlers();
				}).catch((error) => {
					this.destroy(error);
				});
			} else this.destroy(/* @__PURE__ */ new Error(`Data corruption failure: received less data than required and reached maxRetires limitation. Received data offset: ${this.offset - 1}, data needed offset: ${this.end}, retries: ${this.retries}, max retries: ${this.maxRetryRequests}`));
		} else this.destroy(/* @__PURE__ */ new Error(`Data corruption failure: Received more data than original request, data needed offset is ${this.end}, received offset: ${this.offset - 1}`));
	};
	_destroy(error, callback) {
		this.removeSourceEventHandlers();
		this.source.destroy();
		callback(error === null ? void 0 : error);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/BlobDownloadResponse.js
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
*
* BlobDownloadResponse implements BlobDownloadResponseParsed interface, and in Node.js runtime it will
* automatically retry when internal read stream unexpected ends. (This kind of unexpected ends cannot
* trigger retries defined in pipeline retry policy.)
*
* The {@link readableStreamBody} stream will retry underlayer, you can just use it as a normal Node.js
* Readable stream.
*/
var BlobDownloadResponse = class {
	/**
	* Indicates that the service supports
	* requests for partial file content.
	*
	* @readonly
	*/
	get acceptRanges() {
		return this.originalResponse.acceptRanges;
	}
	/**
	* Returns if it was previously specified
	* for the file.
	*
	* @readonly
	*/
	get cacheControl() {
		return this.originalResponse.cacheControl;
	}
	/**
	* Returns the value that was specified
	* for the 'x-ms-content-disposition' header and specifies how to process the
	* response.
	*
	* @readonly
	*/
	get contentDisposition() {
		return this.originalResponse.contentDisposition;
	}
	/**
	* Returns the value that was specified
	* for the Content-Encoding request header.
	*
	* @readonly
	*/
	get contentEncoding() {
		return this.originalResponse.contentEncoding;
	}
	/**
	* Returns the value that was specified
	* for the Content-Language request header.
	*
	* @readonly
	*/
	get contentLanguage() {
		return this.originalResponse.contentLanguage;
	}
	/**
	* The current sequence number for a
	* page blob. This header is not returned for block blobs or append blobs.
	*
	* @readonly
	*/
	get blobSequenceNumber() {
		return this.originalResponse.blobSequenceNumber;
	}
	/**
	* The blob's type. Possible values include:
	* 'BlockBlob', 'PageBlob', 'AppendBlob'.
	*
	* @readonly
	*/
	get blobType() {
		return this.originalResponse.blobType;
	}
	/**
	* The number of bytes present in the
	* response body.
	*
	* @readonly
	*/
	get contentLength() {
		return this.originalResponse.contentLength;
	}
	/**
	* If the file has an MD5 hash and the
	* request is to read the full file, this response header is returned so that
	* the client can check for message content integrity. If the request is to
	* read a specified range and the 'x-ms-range-get-content-md5' is set to
	* true, then the request returns an MD5 hash for the range, as long as the
	* range size is less than or equal to 4 MB. If neither of these sets of
	* conditions is true, then no value is returned for the 'Content-MD5'
	* header.
	*
	* @readonly
	*/
	get contentMD5() {
		return this.originalResponse.contentMD5;
	}
	/**
	* Indicates the range of bytes returned if
	* the client requested a subset of the file by setting the Range request
	* header.
	*
	* @readonly
	*/
	get contentRange() {
		return this.originalResponse.contentRange;
	}
	/**
	* The content type specified for the file.
	* The default content type is 'application/octet-stream'
	*
	* @readonly
	*/
	get contentType() {
		return this.originalResponse.contentType;
	}
	/**
	* Conclusion time of the last attempted
	* Copy File operation where this file was the destination file. This value
	* can specify the time of a completed, aborted, or failed copy attempt.
	*
	* @readonly
	*/
	get copyCompletedOn() {
		return this.originalResponse.copyCompletedOn;
	}
	/**
	* String identifier for the last attempted Copy
	* File operation where this file was the destination file.
	*
	* @readonly
	*/
	get copyId() {
		return this.originalResponse.copyId;
	}
	/**
	* Contains the number of bytes copied and
	* the total bytes in the source in the last attempted Copy File operation
	* where this file was the destination file. Can show between 0 and
	* Content-Length bytes copied.
	*
	* @readonly
	*/
	get copyProgress() {
		return this.originalResponse.copyProgress;
	}
	/**
	* URL up to 2KB in length that specifies the
	* source file used in the last attempted Copy File operation where this file
	* was the destination file.
	*
	* @readonly
	*/
	get copySource() {
		return this.originalResponse.copySource;
	}
	/**
	* State of the copy operation
	* identified by 'x-ms-copy-id'. Possible values include: 'pending',
	* 'success', 'aborted', 'failed'
	*
	* @readonly
	*/
	get copyStatus() {
		return this.originalResponse.copyStatus;
	}
	/**
	* Only appears when
	* x-ms-copy-status is failed or pending. Describes cause of fatal or
	* non-fatal copy operation failure.
	*
	* @readonly
	*/
	get copyStatusDescription() {
		return this.originalResponse.copyStatusDescription;
	}
	/**
	* When a blob is leased,
	* specifies whether the lease is of infinite or fixed duration. Possible
	* values include: 'infinite', 'fixed'.
	*
	* @readonly
	*/
	get leaseDuration() {
		return this.originalResponse.leaseDuration;
	}
	/**
	* Lease state of the blob. Possible
	* values include: 'available', 'leased', 'expired', 'breaking', 'broken'.
	*
	* @readonly
	*/
	get leaseState() {
		return this.originalResponse.leaseState;
	}
	/**
	* The current lease status of the
	* blob. Possible values include: 'locked', 'unlocked'.
	*
	* @readonly
	*/
	get leaseStatus() {
		return this.originalResponse.leaseStatus;
	}
	/**
	* A UTC date/time value generated by the service that
	* indicates the time at which the response was initiated.
	*
	* @readonly
	*/
	get date() {
		return this.originalResponse.date;
	}
	/**
	* The number of committed blocks
	* present in the blob. This header is returned only for append blobs.
	*
	* @readonly
	*/
	get blobCommittedBlockCount() {
		return this.originalResponse.blobCommittedBlockCount;
	}
	/**
	* The ETag contains a value that you can use to
	* perform operations conditionally, in quotes.
	*
	* @readonly
	*/
	get etag() {
		return this.originalResponse.etag;
	}
	/**
	* The number of tags associated with the blob
	*
	* @readonly
	*/
	get tagCount() {
		return this.originalResponse.tagCount;
	}
	/**
	* The error code.
	*
	* @readonly
	*/
	get errorCode() {
		return this.originalResponse.errorCode;
	}
	/**
	* The value of this header is set to
	* true if the file data and application metadata are completely encrypted
	* using the specified algorithm. Otherwise, the value is set to false (when
	* the file is unencrypted, or if only parts of the file/application metadata
	* are encrypted).
	*
	* @readonly
	*/
	get isServerEncrypted() {
		return this.originalResponse.isServerEncrypted;
	}
	/**
	* If the blob has a MD5 hash, and if
	* request contains range header (Range or x-ms-range), this response header
	* is returned with the value of the whole blob's MD5 value. This value may
	* or may not be equal to the value returned in Content-MD5 header, with the
	* latter calculated from the requested range.
	*
	* @readonly
	*/
	get blobContentMD5() {
		return this.originalResponse.blobContentMD5;
	}
	/**
	* Returns the date and time the file was last
	* modified. Any operation that modifies the file or its properties updates
	* the last modified time.
	*
	* @readonly
	*/
	get lastModified() {
		return this.originalResponse.lastModified;
	}
	/**
	* Returns the UTC date and time generated by the service that indicates the time at which the blob was
	* last read or written to.
	*
	* @readonly
	*/
	get lastAccessed() {
		return this.originalResponse.lastAccessed;
	}
	/**
	* Returns the date and time the blob was created.
	*
	* @readonly
	*/
	get createdOn() {
		return this.originalResponse.createdOn;
	}
	/**
	* A name-value pair
	* to associate with a file storage object.
	*
	* @readonly
	*/
	get metadata() {
		return this.originalResponse.metadata;
	}
	/**
	* This header uniquely identifies the request
	* that was made and can be used for troubleshooting the request.
	*
	* @readonly
	*/
	get requestId() {
		return this.originalResponse.requestId;
	}
	/**
	* If a client request id header is sent in the request, this header will be present in the
	* response with the same value.
	*
	* @readonly
	*/
	get clientRequestId() {
		return this.originalResponse.clientRequestId;
	}
	/**
	* Indicates the version of the Blob service used
	* to execute the request.
	*
	* @readonly
	*/
	get version() {
		return this.originalResponse.version;
	}
	/**
	* Indicates the versionId of the downloaded blob version.
	*
	* @readonly
	*/
	get versionId() {
		return this.originalResponse.versionId;
	}
	/**
	* Indicates whether version of this blob is a current version.
	*
	* @readonly
	*/
	get isCurrentVersion() {
		return this.originalResponse.isCurrentVersion;
	}
	/**
	* The SHA-256 hash of the encryption key used to encrypt the blob. This value is only returned
	* when the blob was encrypted with a customer-provided key.
	*
	* @readonly
	*/
	get encryptionKeySha256() {
		return this.originalResponse.encryptionKeySha256;
	}
	/**
	* If the request is to read a specified range and the x-ms-range-get-content-crc64 is set to
	* true, then the request returns a crc64 for the range, as long as the range size is less than
	* or equal to 4 MB. If both x-ms-range-get-content-crc64 & x-ms-range-get-content-md5 is
	* specified in the same request, it will fail with 400(Bad Request)
	*/
	get contentCrc64() {
		return this.originalResponse.contentCrc64;
	}
	/**
	* Object Replication Policy Id of the destination blob.
	*
	* @readonly
	*/
	get objectReplicationDestinationPolicyId() {
		return this.originalResponse.objectReplicationDestinationPolicyId;
	}
	/**
	* Parsed Object Replication Policy Id, Rule Id(s) and status of the source blob.
	*
	* @readonly
	*/
	get objectReplicationSourceProperties() {
		return this.originalResponse.objectReplicationSourceProperties;
	}
	/**
	* If this blob has been sealed.
	*
	* @readonly
	*/
	get isSealed() {
		return this.originalResponse.isSealed;
	}
	/**
	* UTC date/time value generated by the service that indicates the time at which the blob immutability policy will expire.
	*
	* @readonly
	*/
	get immutabilityPolicyExpiresOn() {
		return this.originalResponse.immutabilityPolicyExpiresOn;
	}
	/**
	* Indicates immutability policy mode.
	*
	* @readonly
	*/
	get immutabilityPolicyMode() {
		return this.originalResponse.immutabilityPolicyMode;
	}
	/**
	* Indicates if a legal hold is present on the blob.
	*
	* @readonly
	*/
	get legalHold() {
		return this.originalResponse.legalHold;
	}
	get structuredBodyType() {
		return this.originalResponse.structuredBodyType;
	}
	/**
	* The response body as a browser Blob.
	* Always undefined in node.js.
	*
	* @readonly
	*/
	get contentAsBlob() {
		return this.originalResponse.blobBody;
	}
	/**
	* The response body as a node.js Readable stream.
	* Always undefined in the browser.
	*
	* It will automatically retry when internal read stream unexpected ends.
	*
	* @readonly
	*/
	get readableStreamBody() {
		return isNodeLike ? this.blobDownloadStream : void 0;
	}
	/**
	* The HTTP response.
	*/
	get _response() {
		return this.originalResponse._response;
	}
	originalResponse;
	blobDownloadStream;
	/**
	* Creates an instance of BlobDownloadResponse.
	*
	* @param originalResponse -
	* @param getter -
	* @param offset -
	* @param count -
	* @param options -
	*/
	constructor(originalResponse, getter, offset, count, options = {}) {
		this.originalResponse = originalResponse;
		const streamBody = this.originalResponse.structuredBodyType === void 0 ? this.originalResponse.readableStreamBody : structuredMessageDecodingStream(this.originalResponse.readableStreamBody, options);
		this.blobDownloadStream = new RetriableReadableStream(streamBody, getter, offset, count, options);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/internal-avro/AvroConstants.js
var AVRO_INIT_BYTES = new Uint8Array([
	79,
	98,
	106,
	1
]);
var AVRO_CODEC_KEY = "avro.codec";
var AVRO_SCHEMA_KEY = "avro.schema";
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/internal-avro/AvroParser.js
var AvroParser = class AvroParser {
	/**
	* Reads a fixed number of bytes from the stream.
	*
	* @param stream -
	* @param length -
	* @param options -
	*/
	static async readFixedBytes(stream, length, options = {}) {
		const bytes = await stream.read(length, { abortSignal: options.abortSignal });
		if (bytes.length !== length) throw new Error("Hit stream end.");
		return bytes;
	}
	/**
	* Reads a single byte from the stream.
	*
	* @param stream -
	* @param options -
	*/
	static async readByte(stream, options = {}) {
		return (await AvroParser.readFixedBytes(stream, 1, options))[0];
	}
	static async readZigZagLong(stream, options = {}) {
		let zigZagEncoded = 0;
		let significanceInBit = 0;
		let byte;
		let haveMoreByte;
		let significanceInFloat;
		do {
			byte = await AvroParser.readByte(stream, options);
			haveMoreByte = byte & 128;
			zigZagEncoded |= (byte & 127) << significanceInBit;
			significanceInBit += 7;
		} while (haveMoreByte && significanceInBit < 28);
		if (haveMoreByte) {
			zigZagEncoded = zigZagEncoded;
			significanceInFloat = 268435456;
			do {
				byte = await AvroParser.readByte(stream, options);
				zigZagEncoded += (byte & 127) * significanceInFloat;
				significanceInFloat *= 128;
			} while (byte & 128);
			const res = (zigZagEncoded % 2 ? -(zigZagEncoded + 1) : zigZagEncoded) / 2;
			if (res < Number.MIN_SAFE_INTEGER || res > Number.MAX_SAFE_INTEGER) throw new Error("Integer overflow.");
			return res;
		}
		return zigZagEncoded >> 1 ^ -(zigZagEncoded & 1);
	}
	static async readLong(stream, options = {}) {
		return AvroParser.readZigZagLong(stream, options);
	}
	static async readInt(stream, options = {}) {
		return AvroParser.readZigZagLong(stream, options);
	}
	static async readNull() {
		return null;
	}
	static async readBoolean(stream, options = {}) {
		const b = await AvroParser.readByte(stream, options);
		if (b === 1) return true;
		else if (b === 0) return false;
		else throw new Error("Byte was not a boolean.");
	}
	static async readFloat(stream, options = {}) {
		const u8arr = await AvroParser.readFixedBytes(stream, 4, options);
		return new DataView(u8arr.buffer, u8arr.byteOffset, u8arr.byteLength).getFloat32(0, true);
	}
	static async readDouble(stream, options = {}) {
		const u8arr = await AvroParser.readFixedBytes(stream, 8, options);
		return new DataView(u8arr.buffer, u8arr.byteOffset, u8arr.byteLength).getFloat64(0, true);
	}
	static async readBytes(stream, options = {}) {
		const size = await AvroParser.readLong(stream, options);
		if (size < 0) throw new Error("Bytes size was negative.");
		return stream.read(size, { abortSignal: options.abortSignal });
	}
	static async readString(stream, options = {}) {
		const u8arr = await AvroParser.readBytes(stream, options);
		return new TextDecoder().decode(u8arr);
	}
	static async readMapPair(stream, readItemMethod, options = {}) {
		return {
			key: await AvroParser.readString(stream, options),
			value: await readItemMethod(stream, options)
		};
	}
	static async readMap(stream, readItemMethod, options = {}) {
		const readPairMethod = (s, opts = {}) => {
			return AvroParser.readMapPair(s, readItemMethod, opts);
		};
		const pairs = await AvroParser.readArray(stream, readPairMethod, options);
		const dict = {};
		for (const pair of pairs) dict[pair.key] = pair.value;
		return dict;
	}
	static async readArray(stream, readItemMethod, options = {}) {
		const items = [];
		for (let count = await AvroParser.readLong(stream, options); count !== 0; count = await AvroParser.readLong(stream, options)) {
			if (count < 0) {
				await AvroParser.readLong(stream, options);
				count = -count;
			}
			while (count--) {
				const item = await readItemMethod(stream, options);
				items.push(item);
			}
		}
		return items;
	}
};
var AvroComplex;
(function(AvroComplex) {
	AvroComplex["RECORD"] = "record";
	AvroComplex["ENUM"] = "enum";
	AvroComplex["ARRAY"] = "array";
	AvroComplex["MAP"] = "map";
	AvroComplex["UNION"] = "union";
	AvroComplex["FIXED"] = "fixed";
})(AvroComplex || (AvroComplex = {}));
var AvroPrimitive;
(function(AvroPrimitive) {
	AvroPrimitive["NULL"] = "null";
	AvroPrimitive["BOOLEAN"] = "boolean";
	AvroPrimitive["INT"] = "int";
	AvroPrimitive["LONG"] = "long";
	AvroPrimitive["FLOAT"] = "float";
	AvroPrimitive["DOUBLE"] = "double";
	AvroPrimitive["BYTES"] = "bytes";
	AvroPrimitive["STRING"] = "string";
})(AvroPrimitive || (AvroPrimitive = {}));
var AvroType = class AvroType {
	/**
	* Determines the AvroType from the Avro Schema.
	*/
	static fromSchema(schema) {
		if (typeof schema === "string") return AvroType.fromStringSchema(schema);
		else if (Array.isArray(schema)) return AvroType.fromArraySchema(schema);
		else return AvroType.fromObjectSchema(schema);
	}
	static fromStringSchema(schema) {
		switch (schema) {
			case AvroPrimitive.NULL:
			case AvroPrimitive.BOOLEAN:
			case AvroPrimitive.INT:
			case AvroPrimitive.LONG:
			case AvroPrimitive.FLOAT:
			case AvroPrimitive.DOUBLE:
			case AvroPrimitive.BYTES:
			case AvroPrimitive.STRING: return new AvroPrimitiveType(schema);
			default: throw new Error(`Unexpected Avro type ${schema}`);
		}
	}
	static fromArraySchema(schema) {
		return new AvroUnionType(schema.map(AvroType.fromSchema));
	}
	static fromObjectSchema(schema) {
		const type = schema.type;
		try {
			return AvroType.fromStringSchema(type);
		} catch {}
		switch (type) {
			case AvroComplex.RECORD:
				if (schema.aliases) throw new Error(`aliases currently is not supported, schema: ${schema}`);
				if (!schema.name) throw new Error(`Required attribute 'name' doesn't exist on schema: ${schema}`);
				const fields = {};
				if (!schema.fields) throw new Error(`Required attribute 'fields' doesn't exist on schema: ${schema}`);
				for (const field of schema.fields) fields[field.name] = AvroType.fromSchema(field.type);
				return new AvroRecordType(fields, schema.name);
			case AvroComplex.ENUM:
				if (schema.aliases) throw new Error(`aliases currently is not supported, schema: ${schema}`);
				if (!schema.symbols) throw new Error(`Required attribute 'symbols' doesn't exist on schema: ${schema}`);
				return new AvroEnumType(schema.symbols);
			case AvroComplex.MAP:
				if (!schema.values) throw new Error(`Required attribute 'values' doesn't exist on schema: ${schema}`);
				return new AvroMapType(AvroType.fromSchema(schema.values));
			case AvroComplex.ARRAY:
			case AvroComplex.FIXED:
			default: throw new Error(`Unexpected Avro type ${type} in ${schema}`);
		}
	}
};
var AvroPrimitiveType = class extends AvroType {
	_primitive;
	constructor(primitive) {
		super();
		this._primitive = primitive;
	}
	read(stream, options = {}) {
		switch (this._primitive) {
			case AvroPrimitive.NULL: return AvroParser.readNull();
			case AvroPrimitive.BOOLEAN: return AvroParser.readBoolean(stream, options);
			case AvroPrimitive.INT: return AvroParser.readInt(stream, options);
			case AvroPrimitive.LONG: return AvroParser.readLong(stream, options);
			case AvroPrimitive.FLOAT: return AvroParser.readFloat(stream, options);
			case AvroPrimitive.DOUBLE: return AvroParser.readDouble(stream, options);
			case AvroPrimitive.BYTES: return AvroParser.readBytes(stream, options);
			case AvroPrimitive.STRING: return AvroParser.readString(stream, options);
			default: throw new Error("Unknown Avro Primitive");
		}
	}
};
var AvroEnumType = class extends AvroType {
	_symbols;
	constructor(symbols) {
		super();
		this._symbols = symbols;
	}
	async read(stream, options = {}) {
		const value = await AvroParser.readInt(stream, options);
		return this._symbols[value];
	}
};
var AvroUnionType = class extends AvroType {
	_types;
	constructor(types) {
		super();
		this._types = types;
	}
	async read(stream, options = {}) {
		const typeIndex = await AvroParser.readInt(stream, options);
		return this._types[typeIndex].read(stream, options);
	}
};
var AvroMapType = class extends AvroType {
	_itemType;
	constructor(itemType) {
		super();
		this._itemType = itemType;
	}
	read(stream, options = {}) {
		const readItemMethod = (s, opts) => {
			return this._itemType.read(s, opts);
		};
		return AvroParser.readMap(stream, readItemMethod, options);
	}
};
var AvroRecordType = class extends AvroType {
	_name;
	_fields;
	constructor(fields, name) {
		super();
		this._fields = fields;
		this._name = name;
	}
	async read(stream, options = {}) {
		const record = {};
		record["$schema"] = this._name;
		for (const key in this._fields) if (Object.prototype.hasOwnProperty.call(this._fields, key)) record[key] = await this._fields[key].read(stream, options);
		return record;
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/internal-avro/utils/utils.common.js
function arraysEqual(a, b) {
	if (a === b) return true;
	if (a == null || b == null) return false;
	if (a.length !== b.length) return false;
	for (let i = 0; i < a.length; ++i) if (a[i] !== b[i]) return false;
	return true;
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/internal-avro/AvroReader.js
var AvroReader = class {
	_dataStream;
	_headerStream;
	_syncMarker;
	_metadata;
	_itemType;
	_itemsRemainingInBlock;
	_initialBlockOffset;
	_blockOffset;
	get blockOffset() {
		return this._blockOffset;
	}
	_objectIndex;
	get objectIndex() {
		return this._objectIndex;
	}
	_initialized;
	constructor(dataStream, headerStream, currentBlockOffset, indexWithinCurrentBlock) {
		this._dataStream = dataStream;
		this._headerStream = headerStream || dataStream;
		this._initialized = false;
		this._blockOffset = currentBlockOffset || 0;
		this._objectIndex = indexWithinCurrentBlock || 0;
		this._initialBlockOffset = currentBlockOffset || 0;
	}
	async initialize(options = {}) {
		if (!arraysEqual(await AvroParser.readFixedBytes(this._headerStream, AVRO_INIT_BYTES.length, { abortSignal: options.abortSignal }), AVRO_INIT_BYTES)) throw new Error("Stream is not an Avro file.");
		this._metadata = await AvroParser.readMap(this._headerStream, AvroParser.readString, { abortSignal: options.abortSignal });
		const codec = this._metadata[AVRO_CODEC_KEY];
		if (!(codec === void 0 || codec === null || codec === "null")) throw new Error("Codecs are not supported");
		this._syncMarker = await AvroParser.readFixedBytes(this._headerStream, 16, { abortSignal: options.abortSignal });
		const schema = JSON.parse(this._metadata[AVRO_SCHEMA_KEY]);
		this._itemType = AvroType.fromSchema(schema);
		if (this._blockOffset === 0) this._blockOffset = this._initialBlockOffset + this._dataStream.position;
		this._itemsRemainingInBlock = await AvroParser.readLong(this._dataStream, { abortSignal: options.abortSignal });
		await AvroParser.readLong(this._dataStream, { abortSignal: options.abortSignal });
		this._initialized = true;
		if (this._objectIndex && this._objectIndex > 0) for (let i = 0; i < this._objectIndex; i++) {
			await this._itemType.read(this._dataStream, { abortSignal: options.abortSignal });
			this._itemsRemainingInBlock--;
		}
	}
	hasNext() {
		return !this._initialized || this._itemsRemainingInBlock > 0;
	}
	async *parseObjects(options = {}) {
		if (!this._initialized) await this.initialize(options);
		while (this.hasNext()) {
			const result = await this._itemType.read(this._dataStream, { abortSignal: options.abortSignal });
			this._itemsRemainingInBlock--;
			this._objectIndex++;
			if (this._itemsRemainingInBlock === 0) {
				const marker = await AvroParser.readFixedBytes(this._dataStream, 16, { abortSignal: options.abortSignal });
				this._blockOffset = this._initialBlockOffset + this._dataStream.position;
				this._objectIndex = 0;
				if (!arraysEqual(this._syncMarker, marker)) throw new Error("Stream is not a valid Avro file.");
				try {
					this._itemsRemainingInBlock = await AvroParser.readLong(this._dataStream, { abortSignal: options.abortSignal });
				} catch {
					this._itemsRemainingInBlock = 0;
				}
				if (this._itemsRemainingInBlock > 0) await AvroParser.readLong(this._dataStream, { abortSignal: options.abortSignal });
			}
			yield result;
		}
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/internal-avro/AvroReadable.js
var AvroReadable = class {};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/internal-avro/AvroReadableFromStream.js
var ABORT_ERROR = new AbortError("Reading from the avro stream was aborted.");
var AvroReadableFromStream = class extends AvroReadable {
	_position;
	_readable;
	toUint8Array(data) {
		if (typeof data === "string") return Buffer$1.from(data);
		return data;
	}
	constructor(readable) {
		super();
		this._readable = readable;
		this._position = 0;
	}
	get position() {
		return this._position;
	}
	async read(size, options = {}) {
		if (options.abortSignal?.aborted) throw ABORT_ERROR;
		if (size < 0) throw new Error(`size parameter should be positive: ${size}`);
		if (size === 0) return /* @__PURE__ */ new Uint8Array();
		if (!this._readable.readable) throw new Error("Stream no longer readable.");
		const chunk = this._readable.read(size);
		if (chunk) {
			this._position += chunk.length;
			return this.toUint8Array(chunk);
		} else return new Promise((resolve, reject) => {
			const cleanUp = () => {
				this._readable.removeListener("readable", readableCallback);
				this._readable.removeListener("error", rejectCallback);
				this._readable.removeListener("end", rejectCallback);
				this._readable.removeListener("close", rejectCallback);
				if (options.abortSignal) options.abortSignal.removeEventListener("abort", abortHandler);
			};
			const readableCallback = () => {
				const callbackChunk = this._readable.read(size);
				if (callbackChunk) {
					this._position += callbackChunk.length;
					cleanUp();
					resolve(this.toUint8Array(callbackChunk));
				}
			};
			const rejectCallback = () => {
				cleanUp();
				reject();
			};
			const abortHandler = () => {
				cleanUp();
				reject(ABORT_ERROR);
			};
			this._readable.on("readable", readableCallback);
			this._readable.once("error", rejectCallback);
			this._readable.once("end", rejectCallback);
			this._readable.once("close", rejectCallback);
			if (options.abortSignal) options.abortSignal.addEventListener("abort", abortHandler);
		});
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/utils/BlobQuickQueryStream.js
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
*
* A Node.js BlobQuickQueryStream will internally parse avro data stream for blob query.
*/
var BlobQuickQueryStream = class extends Readable {
	source;
	avroReader;
	avroIter;
	avroPaused = true;
	onProgress;
	onError;
	/**
	* Creates an instance of BlobQuickQueryStream.
	*
	* @param source - The current ReadableStream returned from getter
	* @param options -
	*/
	constructor(source, options = {}) {
		super();
		this.source = source;
		this.onProgress = options.onProgress;
		this.onError = options.onError;
		this.avroReader = new AvroReader(new AvroReadableFromStream(this.source));
		this.avroIter = this.avroReader.parseObjects({ abortSignal: options.abortSignal });
	}
	_read() {
		if (this.avroPaused) this.readInternal().catch((err) => {
			this.emit("error", err);
		});
	}
	async readInternal() {
		this.avroPaused = false;
		let avroNext;
		do {
			avroNext = await this.avroIter.next();
			if (avroNext.done) break;
			const obj = avroNext.value;
			const schema = obj.$schema;
			if (typeof schema !== "string") throw Error("Missing schema in avro record.");
			switch (schema) {
				case "com.microsoft.azure.storage.queryBlobContents.resultData":
					{
						const data = obj.data;
						if (data instanceof Uint8Array === false) throw Error("Invalid data in avro result record.");
						if (!this.push(Buffer.from(data))) this.avroPaused = true;
					}
					break;
				case "com.microsoft.azure.storage.queryBlobContents.progress":
					{
						const bytesScanned = obj.bytesScanned;
						if (typeof bytesScanned !== "number") throw Error("Invalid bytesScanned in avro progress record.");
						if (this.onProgress) this.onProgress({ loadedBytes: bytesScanned });
					}
					break;
				case "com.microsoft.azure.storage.queryBlobContents.end":
					if (this.onProgress) {
						const totalBytes = obj.totalBytes;
						if (typeof totalBytes !== "number") throw Error("Invalid totalBytes in avro end record.");
						this.onProgress({ loadedBytes: totalBytes });
					}
					this.push(null);
					break;
				case "com.microsoft.azure.storage.queryBlobContents.error":
					if (this.onError) {
						const fatal = obj.fatal;
						if (typeof fatal !== "boolean") throw Error("Invalid fatal in avro error record.");
						const name = obj.name;
						if (typeof name !== "string") throw Error("Invalid name in avro error record.");
						const description = obj.description;
						if (typeof description !== "string") throw Error("Invalid description in avro error record.");
						const position = obj.position;
						if (typeof position !== "number") throw Error("Invalid position in avro error record.");
						this.onError({
							position,
							name,
							isFatal: fatal,
							description
						});
					}
					break;
				default: throw Error(`Unknown schema ${schema} in avro progress record.`);
			}
		} while (!avroNext.done && !this.avroPaused);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/BlobQueryResponse.js
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
*
* BlobQueryResponse implements BlobDownloadResponseModel interface, and in Node.js runtime it will
* parse avro data returned by blob query.
*/
var BlobQueryResponse = class {
	/**
	* Indicates that the service supports
	* requests for partial file content.
	*
	* @readonly
	*/
	get acceptRanges() {
		return this.originalResponse.acceptRanges;
	}
	/**
	* Returns if it was previously specified
	* for the file.
	*
	* @readonly
	*/
	get cacheControl() {
		return this.originalResponse.cacheControl;
	}
	/**
	* Returns the value that was specified
	* for the 'x-ms-content-disposition' header and specifies how to process the
	* response.
	*
	* @readonly
	*/
	get contentDisposition() {
		return this.originalResponse.contentDisposition;
	}
	/**
	* Returns the value that was specified
	* for the Content-Encoding request header.
	*
	* @readonly
	*/
	get contentEncoding() {
		return this.originalResponse.contentEncoding;
	}
	/**
	* Returns the value that was specified
	* for the Content-Language request header.
	*
	* @readonly
	*/
	get contentLanguage() {
		return this.originalResponse.contentLanguage;
	}
	/**
	* The current sequence number for a
	* page blob. This header is not returned for block blobs or append blobs.
	*
	* @readonly
	*/
	get blobSequenceNumber() {
		return this.originalResponse.blobSequenceNumber;
	}
	/**
	* The blob's type. Possible values include:
	* 'BlockBlob', 'PageBlob', 'AppendBlob'.
	*
	* @readonly
	*/
	get blobType() {
		return this.originalResponse.blobType;
	}
	/**
	* The number of bytes present in the
	* response body.
	*
	* @readonly
	*/
	get contentLength() {
		return this.originalResponse.contentLength;
	}
	/**
	* If the file has an MD5 hash and the
	* request is to read the full file, this response header is returned so that
	* the client can check for message content integrity. If the request is to
	* read a specified range and the 'x-ms-range-get-content-md5' is set to
	* true, then the request returns an MD5 hash for the range, as long as the
	* range size is less than or equal to 4 MB. If neither of these sets of
	* conditions is true, then no value is returned for the 'Content-MD5'
	* header.
	*
	* @readonly
	*/
	get contentMD5() {
		return this.originalResponse.contentMD5;
	}
	/**
	* Indicates the range of bytes returned if
	* the client requested a subset of the file by setting the Range request
	* header.
	*
	* @readonly
	*/
	get contentRange() {
		return this.originalResponse.contentRange;
	}
	/**
	* The content type specified for the file.
	* The default content type is 'application/octet-stream'
	*
	* @readonly
	*/
	get contentType() {
		return this.originalResponse.contentType;
	}
	/**
	* Conclusion time of the last attempted
	* Copy File operation where this file was the destination file. This value
	* can specify the time of a completed, aborted, or failed copy attempt.
	*
	* @readonly
	*/
	get copyCompletedOn() {}
	/**
	* String identifier for the last attempted Copy
	* File operation where this file was the destination file.
	*
	* @readonly
	*/
	get copyId() {
		return this.originalResponse.copyId;
	}
	/**
	* Contains the number of bytes copied and
	* the total bytes in the source in the last attempted Copy File operation
	* where this file was the destination file. Can show between 0 and
	* Content-Length bytes copied.
	*
	* @readonly
	*/
	get copyProgress() {
		return this.originalResponse.copyProgress;
	}
	/**
	* URL up to 2KB in length that specifies the
	* source file used in the last attempted Copy File operation where this file
	* was the destination file.
	*
	* @readonly
	*/
	get copySource() {
		return this.originalResponse.copySource;
	}
	/**
	* State of the copy operation
	* identified by 'x-ms-copy-id'. Possible values include: 'pending',
	* 'success', 'aborted', 'failed'
	*
	* @readonly
	*/
	get copyStatus() {
		return this.originalResponse.copyStatus;
	}
	/**
	* Only appears when
	* x-ms-copy-status is failed or pending. Describes cause of fatal or
	* non-fatal copy operation failure.
	*
	* @readonly
	*/
	get copyStatusDescription() {
		return this.originalResponse.copyStatusDescription;
	}
	/**
	* When a blob is leased,
	* specifies whether the lease is of infinite or fixed duration. Possible
	* values include: 'infinite', 'fixed'.
	*
	* @readonly
	*/
	get leaseDuration() {
		return this.originalResponse.leaseDuration;
	}
	/**
	* Lease state of the blob. Possible
	* values include: 'available', 'leased', 'expired', 'breaking', 'broken'.
	*
	* @readonly
	*/
	get leaseState() {
		return this.originalResponse.leaseState;
	}
	/**
	* The current lease status of the
	* blob. Possible values include: 'locked', 'unlocked'.
	*
	* @readonly
	*/
	get leaseStatus() {
		return this.originalResponse.leaseStatus;
	}
	/**
	* A UTC date/time value generated by the service that
	* indicates the time at which the response was initiated.
	*
	* @readonly
	*/
	get date() {
		return this.originalResponse.date;
	}
	/**
	* The number of committed blocks
	* present in the blob. This header is returned only for append blobs.
	*
	* @readonly
	*/
	get blobCommittedBlockCount() {
		return this.originalResponse.blobCommittedBlockCount;
	}
	/**
	* The ETag contains a value that you can use to
	* perform operations conditionally, in quotes.
	*
	* @readonly
	*/
	get etag() {
		return this.originalResponse.etag;
	}
	/**
	* The error code.
	*
	* @readonly
	*/
	get errorCode() {
		return this.originalResponse.errorCode;
	}
	/**
	* The value of this header is set to
	* true if the file data and application metadata are completely encrypted
	* using the specified algorithm. Otherwise, the value is set to false (when
	* the file is unencrypted, or if only parts of the file/application metadata
	* are encrypted).
	*
	* @readonly
	*/
	get isServerEncrypted() {
		return this.originalResponse.isServerEncrypted;
	}
	/**
	* If the blob has a MD5 hash, and if
	* request contains range header (Range or x-ms-range), this response header
	* is returned with the value of the whole blob's MD5 value. This value may
	* or may not be equal to the value returned in Content-MD5 header, with the
	* latter calculated from the requested range.
	*
	* @readonly
	*/
	get blobContentMD5() {
		return this.originalResponse.blobContentMD5;
	}
	/**
	* Returns the date and time the file was last
	* modified. Any operation that modifies the file or its properties updates
	* the last modified time.
	*
	* @readonly
	*/
	get lastModified() {
		return this.originalResponse.lastModified;
	}
	/**
	* A name-value pair
	* to associate with a file storage object.
	*
	* @readonly
	*/
	get metadata() {
		return this.originalResponse.metadata;
	}
	/**
	* This header uniquely identifies the request
	* that was made and can be used for troubleshooting the request.
	*
	* @readonly
	*/
	get requestId() {
		return this.originalResponse.requestId;
	}
	/**
	* If a client request id header is sent in the request, this header will be present in the
	* response with the same value.
	*
	* @readonly
	*/
	get clientRequestId() {
		return this.originalResponse.clientRequestId;
	}
	/**
	* Indicates the version of the File service used
	* to execute the request.
	*
	* @readonly
	*/
	get version() {
		return this.originalResponse.version;
	}
	/**
	* The SHA-256 hash of the encryption key used to encrypt the blob. This value is only returned
	* when the blob was encrypted with a customer-provided key.
	*
	* @readonly
	*/
	get encryptionKeySha256() {
		return this.originalResponse.encryptionKeySha256;
	}
	/**
	* If the request is to read a specified range and the x-ms-range-get-content-crc64 is set to
	* true, then the request returns a crc64 for the range, as long as the range size is less than
	* or equal to 4 MB. If both x-ms-range-get-content-crc64 & x-ms-range-get-content-md5 is
	* specified in the same request, it will fail with 400(Bad Request)
	*/
	get contentCrc64() {
		return this.originalResponse.contentCrc64;
	}
	/**
	* The response body as a browser Blob.
	* Always undefined in node.js.
	*
	* @readonly
	*/
	get blobBody() {}
	/**
	* The response body as a node.js Readable stream.
	* Always undefined in the browser.
	*
	* It will parse avor data returned by blob query.
	*
	* @readonly
	*/
	get readableStreamBody() {
		return isNodeLike ? this.blobDownloadStream : void 0;
	}
	/**
	* The HTTP response.
	*/
	get _response() {
		return this.originalResponse._response;
	}
	originalResponse;
	blobDownloadStream;
	/**
	* Creates an instance of BlobQueryResponse.
	*
	* @param originalResponse -
	* @param options -
	*/
	constructor(originalResponse, options = {}) {
		this.originalResponse = originalResponse;
		this.blobDownloadStream = new BlobQuickQueryStream(this.originalResponse.readableStreamBody, options);
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/models.js
/**
* Represents the access tier on a blob.
* For detailed information about block blob level tiering see {@link https://learn.microsoft.com/azure/storage/blobs/storage-blob-storage-tiers|Hot, cool and archive storage tiers.}
*/
var BlockBlobTier;
(function(BlockBlobTier) {
	/**
	* Optimized for storing data that is accessed frequently.
	*/
	BlockBlobTier["Hot"] = "Hot";
	/**
	* Optimized for storing data that is infrequently accessed and stored for at least 30 days.
	*/
	BlockBlobTier["Cool"] = "Cool";
	/**
	* Optimized for storing data that is rarely accessed.
	*/
	BlockBlobTier["Cold"] = "Cold";
	/**
	* Optimized for storing data that is rarely accessed and stored for at least 180 days
	* with flexible latency requirements (on the order of hours).
	*/
	BlockBlobTier["Archive"] = "Archive";
})(BlockBlobTier || (BlockBlobTier = {}));
/**
* Specifies the page blob tier to set the blob to. This is only applicable to page blobs on premium storage accounts.
* Please see {@link https://learn.microsoft.com/azure/storage/storage-premium-storage#scalability-and-performance-targets|here}
* for detailed information on the corresponding IOPS and throughput per PageBlobTier.
*/
var PremiumPageBlobTier;
(function(PremiumPageBlobTier) {
	/**
	* P4 Tier.
	*/
	PremiumPageBlobTier["P4"] = "P4";
	/**
	* P6 Tier.
	*/
	PremiumPageBlobTier["P6"] = "P6";
	/**
	* P10 Tier.
	*/
	PremiumPageBlobTier["P10"] = "P10";
	/**
	* P15 Tier.
	*/
	PremiumPageBlobTier["P15"] = "P15";
	/**
	* P20 Tier.
	*/
	PremiumPageBlobTier["P20"] = "P20";
	/**
	* P30 Tier.
	*/
	PremiumPageBlobTier["P30"] = "P30";
	/**
	* P40 Tier.
	*/
	PremiumPageBlobTier["P40"] = "P40";
	/**
	* P50 Tier.
	*/
	PremiumPageBlobTier["P50"] = "P50";
	/**
	* P60 Tier.
	*/
	PremiumPageBlobTier["P60"] = "P60";
	/**
	* P70 Tier.
	*/
	PremiumPageBlobTier["P70"] = "P70";
	/**
	* P80 Tier.
	*/
	PremiumPageBlobTier["P80"] = "P80";
})(PremiumPageBlobTier || (PremiumPageBlobTier = {}));
function toAccessTier(tier) {
	if (tier === void 0) return;
	return tier;
}
function ensureCpkIfSpecified(cpk, isHttps) {
	if (cpk && !isHttps) throw new RangeError("Customer-provided encryption key must be used over HTTPS.");
	if (cpk && !cpk.encryptionAlgorithm) cpk.encryptionAlgorithm = EncryptionAlgorithmAES25;
}
/**
* Defines the known cloud audiences for Storage.
*/
var StorageBlobAudience;
(function(StorageBlobAudience) {
	/**
	* The OAuth scope to use to retrieve an AAD token for Azure Storage.
	*/
	StorageBlobAudience["StorageOAuthScopes"] = "https://storage.azure.com/.default";
	/**
	* The OAuth scope to use to retrieve an AAD token for Azure Disk.
	*/
	StorageBlobAudience["DiskComputeOAuthScopes"] = "https://disk.compute.azure.com/.default";
})(StorageBlobAudience || (StorageBlobAudience = {}));
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/PageBlobRangeResponse.js
/**
* Function that converts PageRange and ClearRange to a common Range object.
* PageRange and ClearRange have start and end while Range offset and count
* this function normalizes to Range.
* @param response - Model PageBlob Range response
*/
function rangeResponseFromModel(response) {
	const pageRange = (response._response.parsedBody.pageRange || []).map((x) => ({
		offset: x.start,
		count: x.end - x.start
	}));
	const clearRange = (response._response.parsedBody.clearRange || []).map((x) => ({
		offset: x.start,
		count: x.end - x.start
	}));
	return {
		...response,
		pageRange,
		clearRange,
		_response: {
			...response._response,
			parsedBody: {
				pageRange,
				clearRange
			}
		}
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+core-lro@2.7.2_supports-color@7.2.0/node_modules/@azure/core-lro/dist/esm/legacy/poller.js
/**
* When a poller is manually stopped through the `stopPolling` method,
* the poller will be rejected with an instance of the PollerStoppedError.
*/
var PollerStoppedError = class PollerStoppedError extends Error {
	constructor(message) {
		super(message);
		this.name = "PollerStoppedError";
		Object.setPrototypeOf(this, PollerStoppedError.prototype);
	}
};
/**
* When the operation is cancelled, the poller will be rejected with an instance
* of the PollerCancelledError.
*/
var PollerCancelledError = class PollerCancelledError extends Error {
	constructor(message) {
		super(message);
		this.name = "PollerCancelledError";
		Object.setPrototypeOf(this, PollerCancelledError.prototype);
	}
};
/**
* A class that represents the definition of a program that polls through consecutive requests
* until it reaches a state of completion.
*
* A poller can be executed manually, by polling request by request by calling to the `poll()` method repeatedly, until its operation is completed.
* It also provides a way to wait until the operation completes, by calling `pollUntilDone()` and waiting until the operation finishes.
* Pollers can also request the cancellation of the ongoing process to whom is providing the underlying long running operation.
*
* ```ts
* const poller = new MyPoller();
*
* // Polling just once:
* await poller.poll();
*
* // We can try to cancel the request here, by calling:
* //
* //     await poller.cancelOperation();
* //
*
* // Getting the final result:
* const result = await poller.pollUntilDone();
* ```
*
* The Poller is defined by two types, a type representing the state of the poller, which
* must include a basic set of properties from `PollOperationState<TResult>`,
* and a return type defined by `TResult`, which can be anything.
*
* The Poller class implements the `PollerLike` interface, which allows poller implementations to avoid having
* to export the Poller's class directly, and instead only export the already instantiated poller with the PollerLike type.
*
* ```ts
* class Client {
*   public async makePoller: PollerLike<MyOperationState, MyResult> {
*     const poller = new MyPoller({});
*     // It might be preferred to return the poller after the first request is made,
*     // so that some information can be obtained right away.
*     await poller.poll();
*     return poller;
*   }
* }
*
* const poller: PollerLike<MyOperationState, MyResult> = myClient.makePoller();
* ```
*
* A poller can be created through its constructor, then it can be polled until it's completed.
* At any point in time, the state of the poller can be obtained without delay through the getOperationState method.
* At any point in time, the intermediate forms of the result type can be requested without delay.
* Once the underlying operation is marked as completed, the poller will stop and the final value will be returned.
*
* ```ts
* const poller = myClient.makePoller();
* const state: MyOperationState = poller.getOperationState();
*
* // The intermediate result can be obtained at any time.
* const result: MyResult | undefined = poller.getResult();
*
* // The final result can only be obtained after the poller finishes.
* const result: MyResult = await poller.pollUntilDone();
* ```
*
*/
var Poller = class {
	/**
	* A poller needs to be initialized by passing in at least the basic properties of the `PollOperation<TState, TResult>`.
	*
	* When writing an implementation of a Poller, this implementation needs to deal with the initialization
	* of any custom state beyond the basic definition of the poller. The basic poller assumes that the poller's
	* operation has already been defined, at least its basic properties. The code below shows how to approach
	* the definition of the constructor of a new custom poller.
	*
	* ```ts
	* export class MyPoller extends Poller<MyOperationState, string> {
	*   constructor({
	*     // Anything you might need outside of the basics
	*   }) {
	*     let state: MyOperationState = {
	*       privateProperty: private,
	*       publicProperty: public,
	*     };
	*
	*     const operation = {
	*       state,
	*       update,
	*       cancel,
	*       toString
	*     }
	*
	*     // Sending the operation to the parent's constructor.
	*     super(operation);
	*
	*     // You can assign more local properties here.
	*   }
	* }
	* ```
	*
	* Inside of this constructor, a new promise is created. This will be used to
	* tell the user when the poller finishes (see `pollUntilDone()`). The promise's
	* resolve and reject methods are also used internally to control when to resolve
	* or reject anyone waiting for the poller to finish.
	*
	* The constructor of a custom implementation of a poller is where any serialized version of
	* a previous poller's operation should be deserialized into the operation sent to the
	* base constructor. For example:
	*
	* ```ts
	* export class MyPoller extends Poller<MyOperationState, string> {
	*   constructor(
	*     baseOperation: string | undefined
	*   ) {
	*     let state: MyOperationState = {};
	*     if (baseOperation) {
	*       state = {
	*         ...JSON.parse(baseOperation).state,
	*         ...state
	*       };
	*     }
	*     const operation = {
	*       state,
	*       // ...
	*     }
	*     super(operation);
	*   }
	* }
	* ```
	*
	* @param operation - Must contain the basic properties of `PollOperation<State, TResult>`.
	*/
	constructor(operation) {
		/** controls whether to throw an error if the operation failed or was canceled. */
		this.resolveOnUnsuccessful = false;
		this.stopped = true;
		this.pollProgressCallbacks = [];
		this.operation = operation;
		this.promise = new Promise((resolve, reject) => {
			this.resolve = resolve;
			this.reject = reject;
		});
		this.promise.catch(() => {});
	}
	/**
	* Starts a loop that will break only if the poller is done
	* or if the poller is stopped.
	*/
	async startPolling(pollOptions = {}) {
		if (this.stopped) this.stopped = false;
		while (!this.isStopped() && !this.isDone()) {
			await this.poll(pollOptions);
			await this.delay();
		}
	}
	/**
	* pollOnce does one polling, by calling to the update method of the underlying
	* poll operation to make any relevant change effective.
	*
	* It only optionally receives an object with an abortSignal property, from \@azure/abort-controller's AbortSignalLike.
	*
	* @param options - Optional properties passed to the operation's update method.
	*/
	async pollOnce(options = {}) {
		if (!this.isDone()) this.operation = await this.operation.update({
			abortSignal: options.abortSignal,
			fireProgress: this.fireProgress.bind(this)
		});
		this.processUpdatedState();
	}
	/**
	* fireProgress calls the functions passed in via onProgress the method of the poller.
	*
	* It loops over all of the callbacks received from onProgress, and executes them, sending them
	* the current operation state.
	*
	* @param state - The current operation state.
	*/
	fireProgress(state) {
		for (const callback of this.pollProgressCallbacks) callback(state);
	}
	/**
	* Invokes the underlying operation's cancel method.
	*/
	async cancelOnce(options = {}) {
		this.operation = await this.operation.cancel(options);
	}
	/**
	* Returns a promise that will resolve once a single polling request finishes.
	* It does this by calling the update method of the Poller's operation.
	*
	* It only optionally receives an object with an abortSignal property, from \@azure/abort-controller's AbortSignalLike.
	*
	* @param options - Optional properties passed to the operation's update method.
	*/
	poll(options = {}) {
		if (!this.pollOncePromise) {
			this.pollOncePromise = this.pollOnce(options);
			const clearPollOncePromise = () => {
				this.pollOncePromise = void 0;
			};
			this.pollOncePromise.then(clearPollOncePromise, clearPollOncePromise).catch(this.reject);
		}
		return this.pollOncePromise;
	}
	processUpdatedState() {
		if (this.operation.state.error) {
			this.stopped = true;
			if (!this.resolveOnUnsuccessful) {
				this.reject(this.operation.state.error);
				throw this.operation.state.error;
			}
		}
		if (this.operation.state.isCancelled) {
			this.stopped = true;
			if (!this.resolveOnUnsuccessful) {
				const error = new PollerCancelledError("Operation was canceled");
				this.reject(error);
				throw error;
			}
		}
		if (this.isDone() && this.resolve) this.resolve(this.getResult());
	}
	/**
	* Returns a promise that will resolve once the underlying operation is completed.
	*/
	async pollUntilDone(pollOptions = {}) {
		if (this.stopped) this.startPolling(pollOptions).catch(this.reject);
		this.processUpdatedState();
		return this.promise;
	}
	/**
	* Invokes the provided callback after each polling is completed,
	* sending the current state of the poller's operation.
	*
	* It returns a method that can be used to stop receiving updates on the given callback function.
	*/
	onProgress(callback) {
		this.pollProgressCallbacks.push(callback);
		return () => {
			this.pollProgressCallbacks = this.pollProgressCallbacks.filter((c) => c !== callback);
		};
	}
	/**
	* Returns true if the poller has finished polling.
	*/
	isDone() {
		const state = this.operation.state;
		return Boolean(state.isCompleted || state.isCancelled || state.error);
	}
	/**
	* Stops the poller from continuing to poll.
	*/
	stopPolling() {
		if (!this.stopped) {
			this.stopped = true;
			if (this.reject) this.reject(new PollerStoppedError("This poller is already stopped"));
		}
	}
	/**
	* Returns true if the poller is stopped.
	*/
	isStopped() {
		return this.stopped;
	}
	/**
	* Attempts to cancel the underlying operation.
	*
	* It only optionally receives an object with an abortSignal property, from \@azure/abort-controller's AbortSignalLike.
	*
	* If it's called again before it finishes, it will throw an error.
	*
	* @param options - Optional properties passed to the operation's update method.
	*/
	cancelOperation(options = {}) {
		if (!this.cancelPromise) this.cancelPromise = this.cancelOnce(options);
		else if (options.abortSignal) throw new Error("A cancel request is currently pending");
		return this.cancelPromise;
	}
	/**
	* Returns the state of the operation.
	*
	* Even though TState will be the same type inside any of the methods of any extension of the Poller class,
	* implementations of the pollers can customize what's shared with the public by writing their own
	* version of the `getOperationState` method, and by defining two types, one representing the internal state of the poller
	* and a public type representing a safe to share subset of the properties of the internal state.
	* Their definition of getOperationState can then return their public type.
	*
	* Example:
	*
	* ```ts
	* // Let's say we have our poller's operation state defined as:
	* interface MyOperationState extends PollOperationState<ResultType> {
	*   privateProperty?: string;
	*   publicProperty?: string;
	* }
	*
	* // To allow us to have a true separation of public and private state, we have to define another interface:
	* interface PublicState extends PollOperationState<ResultType> {
	*   publicProperty?: string;
	* }
	*
	* // Then, we define our Poller as follows:
	* export class MyPoller extends Poller<MyOperationState, ResultType> {
	*   // ... More content is needed here ...
	*
	*   public getOperationState(): PublicState {
	*     const state: PublicState = this.operation.state;
	*     return {
	*       // Properties from PollOperationState<TResult>
	*       isStarted: state.isStarted,
	*       isCompleted: state.isCompleted,
	*       isCancelled: state.isCancelled,
	*       error: state.error,
	*       result: state.result,
	*
	*       // The only other property needed by PublicState.
	*       publicProperty: state.publicProperty
	*     }
	*   }
	* }
	* ```
	*
	* You can see this in the tests of this repository, go to the file:
	* `../test/utils/testPoller.ts`
	* and look for the getOperationState implementation.
	*/
	getOperationState() {
		return this.operation.state;
	}
	/**
	* Returns the result value of the operation,
	* regardless of the state of the poller.
	* It can return undefined or an incomplete form of the final TResult value
	* depending on the implementation.
	*/
	getResult() {
		return this.operation.state.result;
	}
	/**
	* Returns a serialized version of the poller's operation
	* by invoking the operation's toString method.
	*/
	toString() {
		return this.operation.toString();
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/pollers/BlobStartCopyFromUrlPoller.js
/**
* This is the poller returned by {@link BlobClient.beginCopyFromURL}.
* This can not be instantiated directly outside of this package.
*
* @hidden
*/
var BlobBeginCopyFromUrlPoller = class extends Poller {
	intervalInMs;
	constructor(options) {
		const { blobClient, copySource, intervalInMs = 15e3, onProgress, resumeFrom, startCopyFromURLOptions } = options;
		let state;
		if (resumeFrom) state = JSON.parse(resumeFrom).state;
		const operation = makeBlobBeginCopyFromURLPollOperation({
			...state,
			blobClient,
			copySource,
			startCopyFromURLOptions
		});
		super(operation);
		if (typeof onProgress === "function") this.onProgress(onProgress);
		this.intervalInMs = intervalInMs;
	}
	delay() {
		return delay$1(this.intervalInMs);
	}
};
/**
* Note: Intentionally using function expression over arrow function expression
* so that the function can be invoked with a different context.
* This affects what `this` refers to.
* @hidden
*/
var cancel = async function cancel(options = {}) {
	const state = this.state;
	const { copyId } = state;
	if (state.isCompleted) return makeBlobBeginCopyFromURLPollOperation(state);
	if (!copyId) {
		state.isCancelled = true;
		return makeBlobBeginCopyFromURLPollOperation(state);
	}
	await state.blobClient.abortCopyFromURL(copyId, { abortSignal: options.abortSignal });
	state.isCancelled = true;
	return makeBlobBeginCopyFromURLPollOperation(state);
};
/**
* Note: Intentionally using function expression over arrow function expression
* so that the function can be invoked with a different context.
* This affects what `this` refers to.
* @hidden
*/
var update = async function update(options = {}) {
	const state = this.state;
	const { blobClient, copySource, startCopyFromURLOptions } = state;
	if (!state.isStarted) {
		state.isStarted = true;
		const result = await blobClient.startCopyFromURL(copySource, startCopyFromURLOptions);
		state.copyId = result.copyId;
		if (result.copyStatus === "success") {
			state.result = result;
			state.isCompleted = true;
		}
	} else if (!state.isCompleted) try {
		const result = await state.blobClient.getProperties({ abortSignal: options.abortSignal });
		const { copyStatus, copyProgress } = result;
		const prevCopyProgress = state.copyProgress;
		if (copyProgress) state.copyProgress = copyProgress;
		if (copyStatus === "pending" && copyProgress !== prevCopyProgress && typeof options.fireProgress === "function") options.fireProgress(state);
		else if (copyStatus === "success") {
			state.result = result;
			state.isCompleted = true;
		} else if (copyStatus === "failed") {
			state.error = /* @__PURE__ */ new Error(`Blob copy failed with reason: "${result.copyStatusDescription || "unknown"}"`);
			state.isCompleted = true;
		}
	} catch (err) {
		state.error = err;
		state.isCompleted = true;
	}
	return makeBlobBeginCopyFromURLPollOperation(state);
};
/**
* Note: Intentionally using function expression over arrow function expression
* so that the function can be invoked with a different context.
* This affects what `this` refers to.
* @hidden
*/
var toString = function toString() {
	return JSON.stringify({ state: this.state }, (key, value) => {
		if (key === "blobClient") return;
		return value;
	});
};
/**
* Creates a poll operation given the provided state.
* @hidden
*/
function makeBlobBeginCopyFromURLPollOperation(state) {
	return {
		state: { ...state },
		cancel,
		toString,
		update
	};
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/Range.js
/**
* Generate a range string. For example:
*
* "bytes=255-" or "bytes=0-511"
*
* @param iRange -
*/
function rangeToString(iRange) {
	if (iRange.offset < 0) throw new RangeError(`Range.offset cannot be smaller than 0.`);
	if (iRange.count && iRange.count <= 0) throw new RangeError(`Range.count must be larger than 0. Leave it undefined if you want a range from offset to the end.`);
	return iRange.count ? `bytes=${iRange.offset}-${iRange.offset + iRange.count - 1}` : `bytes=${iRange.offset}-`;
}
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/utils/Batch.js
/**
* States for Batch.
*/
var BatchStates;
(function(BatchStates) {
	BatchStates[BatchStates["Good"] = 0] = "Good";
	BatchStates[BatchStates["Error"] = 1] = "Error";
})(BatchStates || (BatchStates = {}));
/**
* Batch provides basic parallel execution with concurrency limits.
* Will stop execute left operations when one of the executed operation throws an error.
* But Batch cannot cancel ongoing operations, you need to cancel them by yourself.
*/
var Batch = class {
	/**
	* Concurrency. Must be lager than 0.
	*/
	concurrency;
	/**
	* Number of active operations under execution.
	*/
	actives = 0;
	/**
	* Number of completed operations under execution.
	*/
	completed = 0;
	/**
	* Offset of next operation to be executed.
	*/
	offset = 0;
	/**
	* Operation array to be executed.
	*/
	operations = [];
	/**
	* States of Batch. When an error happens, state will turn into error.
	* Batch will stop execute left operations.
	*/
	state = BatchStates.Good;
	/**
	* A private emitter used to pass events inside this class.
	*/
	emitter;
	/**
	* Creates an instance of Batch.
	* @param concurrency -
	*/
	constructor(concurrency = 5) {
		if (concurrency < 1) throw new RangeError("concurrency must be larger than 0");
		this.concurrency = concurrency;
		this.emitter = new EventEmitter();
	}
	/**
	* Add a operation into queue.
	*
	* @param operation -
	*/
	addOperation(operation) {
		this.operations.push(async () => {
			try {
				this.actives++;
				await operation();
				this.actives--;
				this.completed++;
				this.parallelExecute();
			} catch (error) {
				this.emitter.emit("error", error);
			}
		});
	}
	/**
	* Start execute operations in the queue.
	*
	*/
	async do() {
		if (this.operations.length === 0) return Promise.resolve();
		this.parallelExecute();
		return new Promise((resolve, reject) => {
			this.emitter.on("finish", resolve);
			this.emitter.on("error", (error) => {
				this.state = BatchStates.Error;
				reject(error);
			});
		});
	}
	/**
	* Get next operation to be executed. Return null when reaching ends.
	*
	*/
	nextOperation() {
		if (this.offset < this.operations.length) return this.operations[this.offset++];
		return null;
	}
	/**
	* Start execute operations. One one the most important difference between
	* this method with do() is that do() wraps as an sync method.
	*
	*/
	parallelExecute() {
		if (this.state === BatchStates.Error) return;
		if (this.completed >= this.operations.length) {
			this.emitter.emit("finish");
			return;
		}
		while (this.actives < this.concurrency) {
			const operation = this.nextOperation();
			if (operation) operation();
			else return;
		}
	}
};
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/utils/utils.js
/**
* Reads a readable stream into buffer. Fill the buffer from offset to end.
*
* @param stream - A Node.js Readable stream
* @param buffer - Buffer to be filled, length must greater than or equal to offset
* @param offset - From which position in the buffer to be filled, inclusive
* @param end - To which position in the buffer to be filled, exclusive
* @param encoding - Encoding of the Readable stream
*/
async function streamToBuffer(stream, buffer, offset, end, encoding) {
	let pos = 0;
	const count = end - offset;
	return new Promise((resolve, reject) => {
		const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`The operation cannot be completed in timeout.`)), REQUEST_TIMEOUT);
		stream.on("readable", () => {
			if (pos >= count) {
				clearTimeout(timeout);
				resolve();
				return;
			}
			let chunk;
			while ((chunk = stream.read()) !== null) {
				if (typeof chunk === "string") chunk = Buffer.from(chunk, encoding);
				const chunkLength = pos + chunk.length > count ? count - pos : chunk.length;
				buffer.fill(chunk.slice(0, chunkLength), offset + pos, offset + pos + chunkLength);
				pos += chunkLength;
				if (pos >= count) {
					clearTimeout(timeout);
					resolve();
					return;
				}
			}
		});
		stream.on("end", () => {
			clearTimeout(timeout);
			if (pos < count) reject(/* @__PURE__ */ new Error(`Stream drains before getting enough data needed. Data read: ${pos}, data need: ${count}`));
			resolve();
		});
		stream.on("error", (msg) => {
			clearTimeout(timeout);
			reject(msg);
		});
	});
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
*
* Writes the content of a readstream to a local file. Returns a Promise which is completed after the file handle is closed.
*
* @param rs - The read stream.
* @param file - Destination file path.
*/
async function readStreamToLocalFile(rs, file) {
	return new Promise((resolve, reject) => {
		const ws = fs.createWriteStream(file);
		rs.on("error", (err) => {
			reject(err);
		});
		ws.on("error", (err) => {
			reject(err);
		});
		ws.on("close", resolve);
		rs.pipe(ws);
	});
}
/**
* ONLY AVAILABLE IN NODE.JS RUNTIME.
*
* Promisified version of fs.stat().
*/
var fsStat = util.promisify(fs.stat);
var fsCreateReadStream = fs.createReadStream;
//#endregion
//#region node_modules/.pnpm/@azure+storage-blob@12.33.0_supports-color@7.2.0/node_modules/@azure/storage-blob/dist/esm/Clients.js
/**
* A BlobClient represents a URL to an Azure Storage blob; the blob may be a block blob,
* append blob, or page blob.
*/
var BlobClient = class BlobClient extends StorageClient {
	/**
	* blobContext provided by protocol layer.
	*/
	blobContext;
	_name;
	_containerName;
	_versionId;
	_snapshot;
	/**
	* Config used in creating blob client instances.
	*/
	blobClientConfig;
	/**
	* The name of the blob.
	*/
	get name() {
		return this._name;
	}
	/**
	* The name of the storage container the blob is associated with.
	*/
	get containerName() {
		return this._containerName;
	}
	constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, blobNameOrOptions, options) {
		options = options || {};
		let pipeline;
		let url;
		if (isPipelineLike(credentialOrPipelineOrContainerName)) {
			url = urlOrConnectionString;
			pipeline = credentialOrPipelineOrContainerName;
			options = blobNameOrOptions;
		} else if (isNodeLike && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential || credentialOrPipelineOrContainerName instanceof AnonymousCredential || isTokenCredential(credentialOrPipelineOrContainerName)) {
			url = urlOrConnectionString;
			options = blobNameOrOptions;
			pipeline = newPipeline(credentialOrPipelineOrContainerName, options);
		} else if (!credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName !== "string") {
			url = urlOrConnectionString;
			if (blobNameOrOptions && typeof blobNameOrOptions !== "string") options = blobNameOrOptions;
			pipeline = newPipeline(new AnonymousCredential(), options);
		} else if (credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName === "string" && blobNameOrOptions && typeof blobNameOrOptions === "string") {
			const containerName = credentialOrPipelineOrContainerName;
			const blobName = blobNameOrOptions;
			const extractedCreds = extractConnectionStringParts(urlOrConnectionString);
			if (extractedCreds.kind === "AccountConnString") {
				if (isNodeLike) {
					const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
					url = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName));
					if (!options.proxyOptions) options.proxyOptions = getDefaultProxySettings(extractedCreds.proxyUri);
					pipeline = newPipeline(sharedKeyCredential, options);
				} else throw new Error("Account connection string is only supported in Node.js environment");
			} else if (extractedCreds.kind === "SASConnString") {
				url = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName)) + "?" + extractedCreds.accountSas;
				pipeline = newPipeline(new AnonymousCredential(), options);
			} else throw new Error("Connection string must be either an Account connection string or a SAS connection string");
		} else throw new Error("Expecting non-empty strings for containerName and blobName parameters");
		super(url, pipeline);
		({blobName: this._name, containerName: this._containerName} = this.getBlobAndContainerNamesFromUrl());
		this.blobContext = this.storageClientContext.blob;
		this._snapshot = getURLParameter(this.url, URLConstants.Parameters.SNAPSHOT);
		this._versionId = getURLParameter(this.url, URLConstants.Parameters.VERSIONID);
		this.blobClientConfig = options;
	}
	/**
	* Creates a new BlobClient object identical to the source but with the specified snapshot timestamp.
	* Provide "" will remove the snapshot and return a Client to the base blob.
	*
	* @param snapshot - The snapshot timestamp.
	* @returns A new BlobClient object identical to the source but with the specified snapshot timestamp
	*/
	withSnapshot(snapshot) {
		return new BlobClient(setURLParameter(this.url, URLConstants.Parameters.SNAPSHOT, snapshot.length === 0 ? void 0 : snapshot), this.pipeline, this.blobClientConfig);
	}
	/**
	* Creates a new BlobClient object pointing to a version of this blob.
	* Provide "" will remove the versionId and return a Client to the base blob.
	*
	* @param versionId - The versionId.
	* @returns A new BlobClient object pointing to the version of this blob.
	*/
	withVersion(versionId) {
		return new BlobClient(setURLParameter(this.url, URLConstants.Parameters.VERSIONID, versionId.length === 0 ? void 0 : versionId), this.pipeline, this.blobClientConfig);
	}
	/**
	* Creates a AppendBlobClient object.
	*
	*/
	getAppendBlobClient() {
		return new AppendBlobClient(this.url, this.pipeline, this.blobClientConfig);
	}
	/**
	* Creates a BlockBlobClient object.
	*
	*/
	getBlockBlobClient() {
		return new BlockBlobClient(this.url, this.pipeline, this.blobClientConfig);
	}
	/**
	* Creates a PageBlobClient object.
	*
	*/
	getPageBlobClient() {
		return new PageBlobClient(this.url, this.pipeline, this.blobClientConfig);
	}
	/**
	* Reads or downloads a blob from the system, including its metadata and properties.
	* You can also call Get Blob to read a snapshot.
	*
	* * In Node.js, data returns in a Readable stream readableStreamBody
	* * In browsers, data returns in a promise blobBody
	*
	* @see https://learn.microsoft.com/rest/api/storageservices/get-blob
	*
	* @param offset - From which position of the blob to download, greater than or equal to 0
	* @param count - How much data to be downloaded, greater than 0. Will download to the end when undefined
	* @param options - Optional options to Blob Download operation.
	*
	*
	* Example usage (Node.js):
	*
	* ```ts snippet:ReadmeSampleDownloadBlob_Node
	* import { BlobServiceClient } from "@azure/storage-blob";
	* import { DefaultAzureCredential } from "@azure/identity";
	* import { buffer } from "node:stream/consumers";
	*
	* const account = "<account>";
	* const blobServiceClient = new BlobServiceClient(
	*   `https://${account}.blob.core.windows.net`,
	*   new DefaultAzureCredential(),
	* );
	*
	* const containerName = "<container name>";
	* const blobName = "<blob name>";
	* const containerClient = blobServiceClient.getContainerClient(containerName);
	* const blobClient = containerClient.getBlobClient(blobName);
	*
	* // Get blob content from position 0 to the end
	* // In Node.js, get downloaded data by accessing downloadBlockBlobResponse.readableStreamBody
	* const downloadBlockBlobResponse = await blobClient.download();
	* if (downloadBlockBlobResponse.readableStreamBody) {
	*   // Download the raw bytes of the blob. Use `text` from "node:stream/consumers"
	*   // instead if you want to read the content as a string directly.
	*   const downloaded = await buffer(downloadBlockBlobResponse.readableStreamBody);
	*   console.log(`Downloaded blob content: ${downloaded.toString()}`);
	* }
	* ```
	*
	* Example usage (browser):
	*
	* ```ts snippet:ReadmeSampleDownloadBlob_Browser
	* import { BlobServiceClient } from "@azure/storage-blob";
	* import { DefaultAzureCredential } from "@azure/identity";
	*
	* const account = "<account>";
	* const blobServiceClient = new BlobServiceClient(
	*   `https://${account}.blob.core.windows.net`,
	*   new DefaultAzureCredential(),
	* );
	*
	* const containerName = "<container name>";
	* const blobName = "<blob name>";
	* const containerClient = blobServiceClient.getContainerClient(containerName);
	* const blobClient = containerClient.getBlobClient(blobName);
	*
	* // Get blob content from position 0 to the end
	* // In browsers, get downloaded data by accessing downloadBlockBlobResponse.blobBody
	* const downloadBlockBlobResponse = await blobClient.download();
	* const blobBody = await downloadBlockBlobResponse.blobBody;
	* if (blobBody) {
	*   const downloaded = await blobBody.text();
	*   console.log(`Downloaded blob content: ${downloaded}`);
	* }
	* ```
	*/
	async download(offset = 0, count, options = {}) {
		options.conditions = options.conditions || {};
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlobClient-download", options, async (updatedOptions) => {
			let contentChecksumAlgorithm = options.contentChecksumAlgorithm ?? this.blobClientConfig?.downloadContentChecksumAlgorithm;
			if (contentChecksumAlgorithm === void 0) contentChecksumAlgorithm = "Customized";
			else if (contentChecksumAlgorithm === "Auto") contentChecksumAlgorithm = "StorageCrc64";
			if (contentChecksumAlgorithm === "StorageCrc64") await StorageCRC64Calculator.init();
			const res = assertResponse(await this.blobContext.download({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				requestOptions: { onDownloadProgress: isNodeLike ? void 0 : options.onProgress },
				range: offset === 0 && !count ? void 0 : rangeToString({
					offset,
					count
				}),
				rangeGetContentMD5: options.rangeGetContentMD5,
				rangeGetContentCRC64: options.rangeGetContentCrc64,
				snapshot: options.snapshot,
				cpkInfo: options.customerProvidedKey,
				tracingOptions: updatedOptions.tracingOptions,
				structuredBodyType: contentChecksumAlgorithm === "StorageCrc64" ? "XSM/1.0; properties=crc64" : void 0
			}));
			const wrappedRes = {
				...res,
				_response: res._response,
				objectReplicationDestinationPolicyId: res.objectReplicationPolicyId,
				objectReplicationSourceProperties: parseObjectReplicationRecord(res.objectReplicationRules)
			};
			if (!isNodeLike) {
				if (contentChecksumAlgorithm === "StorageCrc64") wrappedRes.blobBody = structuredMessageDecodingBrowser(await wrappedRes.blobBody);
				return wrappedRes;
			}
			if (options.maxRetryRequests === void 0 || options.maxRetryRequests < 0) options.maxRetryRequests = 5;
			if (res.contentLength === void 0) throw new RangeError(`File download response doesn't contain valid content length header`);
			if (contentChecksumAlgorithm === "StorageCrc64" && res.structuredContentLength === void 0) throw new RangeError(`Unexpected structured content length`);
			if (!res.etag) throw new RangeError(`File download response doesn't contain valid etag header`);
			const expectedContentLength = contentChecksumAlgorithm === "StorageCrc64" ? res.structuredContentLength : res.contentLength;
			return new BlobDownloadResponse(wrappedRes, async (start) => {
				const updatedDownloadOptions = {
					leaseAccessConditions: options.conditions,
					modifiedAccessConditions: {
						ifMatch: options.conditions.ifMatch || res.etag,
						ifModifiedSince: options.conditions.ifModifiedSince,
						ifNoneMatch: options.conditions.ifNoneMatch,
						ifUnmodifiedSince: options.conditions.ifUnmodifiedSince,
						ifTags: options.conditions?.tagConditions
					},
					range: rangeToString({
						count: offset + expectedContentLength - start,
						offset: start
					}),
					rangeGetContentMD5: options.rangeGetContentMD5,
					rangeGetContentCRC64: options.rangeGetContentCrc64,
					snapshot: options.snapshot,
					cpkInfo: options.customerProvidedKey,
					structuredBodyType: contentChecksumAlgorithm === "StorageCrc64" ? "XSM/1.0; properties=crc64" : void 0
				};
				const resBody = (await this.blobContext.download({
					abortSignal: options.abortSignal,
					...updatedDownloadOptions
				})).readableStreamBody;
				if (contentChecksumAlgorithm === "StorageCrc64") return structuredMessageDecodingStream(resBody, {});
				else return resBody;
			}, offset, expectedContentLength, {
				maxRetryRequests: options.maxRetryRequests,
				onProgress: options.onProgress
			});
		});
	}
	/**
	* Returns true if the Azure blob resource represented by this client exists; false otherwise.
	*
	* NOTE: use this function with care since an existing blob might be deleted by other clients or
	* applications. Vice versa new blobs might be added by other clients or applications after this
	* function completes.
	*
	* @param options - options to Exists operation.
	*/
	async exists(options = {}) {
		return tracingClient.withSpan("BlobClient-exists", options, async (updatedOptions) => {
			try {
				ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
				await this.getProperties({
					abortSignal: options.abortSignal,
					customerProvidedKey: options.customerProvidedKey,
					conditions: options.conditions,
					tracingOptions: updatedOptions.tracingOptions
				});
				return true;
			} catch (e) {
				if (e.statusCode === 404) return false;
				else if (e.statusCode === 409 && (e.details.errorCode === "BlobUsesCustomerSpecifiedEncryption" || e.details.errorCode === "BlobDoesNotUseCustomerSpecifiedEncryption")) return true;
				throw e;
			}
		});
	}
	/**
	* Returns all user-defined metadata, standard HTTP properties, and system properties
	* for the blob. It does not return the content of the blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-blob-properties
	*
	* WARNING: The `metadata` object returned in the response will have its keys in lowercase, even if
	* they originally contained uppercase characters. This differs from the metadata keys returned by
	* the methods of {@link ContainerClient} that list blobs using the `includeMetadata` option, which
	* will retain their original casing.
	*
	* @param options - Optional options to Get Properties operation.
	*/
	async getProperties(options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlobClient-getProperties", options, async (updatedOptions) => {
			const res = assertResponse(await this.blobContext.getProperties({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				cpkInfo: options.customerProvidedKey,
				tracingOptions: updatedOptions.tracingOptions
			}));
			return {
				...res,
				_response: res._response,
				objectReplicationDestinationPolicyId: res.objectReplicationPolicyId,
				objectReplicationSourceProperties: parseObjectReplicationRecord(res.objectReplicationRules)
			};
		});
	}
	/**
	* Marks the specified blob or snapshot for deletion. The blob is later deleted
	* during garbage collection. Note that in order to delete a blob, you must delete
	* all of its snapshots. You can delete both at the same time with the Delete
	* Blob operation.
	* @see https://learn.microsoft.com/rest/api/storageservices/delete-blob
	*
	* @param options - Optional options to Blob Delete operation.
	*/
	async delete(options = {}) {
		options.conditions = options.conditions || {};
		return tracingClient.withSpan("BlobClient-delete", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.delete({
				abortSignal: options.abortSignal,
				deleteSnapshots: options.deleteSnapshots,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions,
				accessTierIfModifiedSince: options.conditions?.accessTierIfModifiedSince,
				accessTierIfUnmodifiedSince: options.conditions?.accessTierIfUnmodifiedSince
			}));
		});
	}
	/**
	* Marks the specified blob or snapshot for deletion if it exists. The blob is later deleted
	* during garbage collection. Note that in order to delete a blob, you must delete
	* all of its snapshots. You can delete both at the same time with the Delete
	* Blob operation.
	* @see https://learn.microsoft.com/rest/api/storageservices/delete-blob
	*
	* @param options - Optional options to Blob Delete operation.
	*/
	async deleteIfExists(options = {}) {
		return tracingClient.withSpan("BlobClient-deleteIfExists", options, async (updatedOptions) => {
			try {
				const res = assertResponse(await this.delete(updatedOptions));
				return {
					succeeded: true,
					...res,
					_response: res._response
				};
			} catch (e) {
				if (e.details?.errorCode === "BlobNotFound") return {
					succeeded: false,
					...e.response?.parsedHeaders,
					_response: e.response
				};
				throw e;
			}
		});
	}
	/**
	* Restores the contents and metadata of soft deleted blob and any associated
	* soft deleted snapshots. Undelete Blob is supported only on version 2017-07-29
	* or later.
	* @see https://learn.microsoft.com/rest/api/storageservices/undelete-blob
	*
	* @param options - Optional options to Blob Undelete operation.
	*/
	async undelete(options = {}) {
		return tracingClient.withSpan("BlobClient-undelete", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.undelete({
				abortSignal: options.abortSignal,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Sets system properties on the blob.
	*
	* If no value provided, or no value provided for the specified blob HTTP headers,
	* these blob HTTP headers without a value will be cleared.
	* @see https://learn.microsoft.com/rest/api/storageservices/set-blob-properties
	*
	* @param blobHTTPHeaders - If no value provided, or no value provided for
	*                                                   the specified blob HTTP headers, these blob HTTP
	*                                                   headers without a value will be cleared.
	*                                                   A common header to set is `blobContentType`
	*                                                   enabling the browser to provide functionality
	*                                                   based on file type.
	* @param options - Optional options to Blob Set HTTP Headers operation.
	*/
	async setHTTPHeaders(blobHTTPHeaders, options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlobClient-setHTTPHeaders", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.setHttpHeaders({
				abortSignal: options.abortSignal,
				blobHttpHeaders: blobHTTPHeaders,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Sets user-defined metadata for the specified blob as one or more name-value pairs.
	*
	* If no option provided, or no metadata defined in the parameter, the blob
	* metadata will be removed.
	* @see https://learn.microsoft.com/rest/api/storageservices/set-blob-metadata
	*
	* @param metadata - Replace existing metadata with this value.
	*                               If no value provided the existing metadata will be removed.
	* @param options - Optional options to Set Metadata operation.
	*/
	async setMetadata(metadata, options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlobClient-setMetadata", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.setMetadata({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				metadata,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Sets tags on the underlying blob.
	* A blob can have up to 10 tags. Tag keys must be between 1 and 128 characters.  Tag values must be between 0 and 256 characters.
	* Valid tag key and value characters include lower and upper case letters, digits (0-9),
	* space (' '), plus ('+'), minus ('-'), period ('.'), foward slash ('/'), colon (':'), equals ('='), and underscore ('_').
	*
	* @param tags -
	* @param options -
	*/
	async setTags(tags, options = {}) {
		return tracingClient.withSpan("BlobClient-setTags", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.setTags({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				blobModifiedAccessConditions: options.conditions,
				tracingOptions: updatedOptions.tracingOptions,
				tags: toBlobTags(tags)
			}));
		});
	}
	/**
	* Gets the tags associated with the underlying blob.
	*
	* @param options -
	*/
	async getTags(options = {}) {
		return tracingClient.withSpan("BlobClient-getTags", options, async (updatedOptions) => {
			const response = assertResponse(await this.blobContext.getTags({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				blobModifiedAccessConditions: options.conditions,
				tracingOptions: updatedOptions.tracingOptions
			}));
			return {
				...response,
				_response: response._response,
				tags: toTags({ blobTagSet: response.blobTagSet }) || {}
			};
		});
	}
	/**
	* Get a {@link BlobLeaseClient} that manages leases on the blob.
	*
	* @param proposeLeaseId - Initial proposed lease Id.
	* @returns A new BlobLeaseClient object for managing leases on the blob.
	*/
	getBlobLeaseClient(proposeLeaseId) {
		return new BlobLeaseClient(this, proposeLeaseId);
	}
	/**
	* Creates a read-only snapshot of a blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/snapshot-blob
	*
	* @param options - Optional options to the Blob Create Snapshot operation.
	*/
	async createSnapshot(options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlobClient-createSnapshot", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.createSnapshot({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				metadata: options.metadata,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Asynchronously copies a blob to a destination within the storage account.
	* This method returns a long running operation poller that allows you to wait
	* indefinitely until the copy is completed.
	* You can also cancel a copy before it is completed by calling `cancelOperation` on the poller.
	* Note that the onProgress callback will not be invoked if the operation completes in the first
	* request, and attempting to cancel a completed copy will result in an error being thrown.
	*
	* In version 2012-02-12 and later, the source for a Copy Blob operation can be
	* a committed blob in any Azure storage account.
	* Beginning with version 2015-02-21, the source for a Copy Blob operation can be
	* an Azure file in any Azure storage account.
	* Only storage accounts created on or after June 7th, 2012 allow the Copy Blob
	* operation to copy from another storage account.
	* @see https://learn.microsoft.com/rest/api/storageservices/copy-blob
	*
	* ```ts snippet:ClientsBeginCopyFromURL
	* import { BlobServiceClient } from "@azure/storage-blob";
	* import { DefaultAzureCredential } from "@azure/identity";
	*
	* const account = "<account>";
	* const blobServiceClient = new BlobServiceClient(
	*   `https://${account}.blob.core.windows.net`,
	*   new DefaultAzureCredential(),
	* );
	*
	* const containerName = "<container name>";
	* const blobName = "<blob name>";
	* const containerClient = blobServiceClient.getContainerClient(containerName);
	* const blobClient = containerClient.getBlobClient(blobName);
	*
	* // Example using automatic polling
	* const automaticCopyPoller = await blobClient.beginCopyFromURL("url");
	* const automaticResult = await automaticCopyPoller.pollUntilDone();
	*
	* // Example using manual polling
	* const manualCopyPoller = await blobClient.beginCopyFromURL("url");
	* while (!manualCopyPoller.isDone()) {
	*   await manualCopyPoller.poll();
	* }
	* const manualResult = manualCopyPoller.getResult();
	*
	* // Example using progress updates
	* const progressUpdatesCopyPoller = await blobClient.beginCopyFromURL("url", {
	*   onProgress(state) {
	*     console.log(`Progress: ${state.copyProgress}`);
	*   },
	* });
	* const progressUpdatesResult = await progressUpdatesCopyPoller.pollUntilDone();
	*
	* // Example using a changing polling interval (default 15 seconds)
	* const pollingIntervalCopyPoller = await blobClient.beginCopyFromURL("url", {
	*   intervalInMs: 1000, // poll blob every 1 second for copy progress
	* });
	* const pollingIntervalResult = await pollingIntervalCopyPoller.pollUntilDone();
	*
	* // Example using copy cancellation:
	* const cancelCopyPoller = await blobClient.beginCopyFromURL("url");
	* // cancel operation after starting it.
	* try {
	*   await cancelCopyPoller.cancelOperation();
	*   // calls to get the result now throw PollerCancelledError
	*   cancelCopyPoller.getResult();
	* } catch (err: any) {
	*   if (err.name === "PollerCancelledError") {
	*     console.log("The copy was cancelled.");
	*   }
	* }
	* ```
	*
	* @param copySource - url to the source Azure Blob/File.
	* @param options - Optional options to the Blob Start Copy From URL operation.
	*/
	async beginCopyFromURL(copySource, options = {}) {
		const poller = new BlobBeginCopyFromUrlPoller({
			blobClient: {
				abortCopyFromURL: (...args) => this.abortCopyFromURL(...args),
				getProperties: (...args) => this.getProperties(...args),
				startCopyFromURL: (...args) => this.startCopyFromURL(...args)
			},
			copySource,
			intervalInMs: options.intervalInMs,
			onProgress: options.onProgress,
			resumeFrom: options.resumeFrom,
			startCopyFromURLOptions: options
		});
		await poller.poll();
		return poller;
	}
	/**
	* Aborts a pending asynchronous Copy Blob operation, and leaves a destination blob with zero
	* length and full metadata. Version 2012-02-12 and newer.
	* @see https://learn.microsoft.com/rest/api/storageservices/abort-copy-blob
	*
	* @param copyId - Id of the Copy From URL operation.
	* @param options - Optional options to the Blob Abort Copy From URL operation.
	*/
	async abortCopyFromURL(copyId, options = {}) {
		return tracingClient.withSpan("BlobClient-abortCopyFromURL", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.abortCopyFromURL(copyId, {
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* The synchronous Copy From URL operation copies a blob or an internet resource to a new blob. It will not
	* return a response until the copy is complete.
	* @see https://learn.microsoft.com/rest/api/storageservices/copy-blob-from-url
	*
	* @param copySource - The source URL to copy from, Shared Access Signature(SAS) maybe needed for authentication
	* @param options -
	*/
	async syncCopyFromURL(copySource, options = {}) {
		options.conditions = options.conditions || {};
		options.sourceConditions = options.sourceConditions || {};
		return tracingClient.withSpan("BlobClient-syncCopyFromURL", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.copyFromURL(copySource, {
				abortSignal: options.abortSignal,
				metadata: options.metadata,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				sourceModifiedAccessConditions: {
					sourceIfMatch: options.sourceConditions?.ifMatch,
					sourceIfModifiedSince: options.sourceConditions?.ifModifiedSince,
					sourceIfNoneMatch: options.sourceConditions?.ifNoneMatch,
					sourceIfUnmodifiedSince: options.sourceConditions?.ifUnmodifiedSince
				},
				sourceContentMD5: options.sourceContentMD5,
				copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization),
				tier: toAccessTier(options.tier),
				blobTagsString: toBlobTagsString(options.tags),
				immutabilityPolicyExpiry: options.immutabilityPolicy?.expiriesOn,
				immutabilityPolicyMode: options.immutabilityPolicy?.policyMode,
				legalHold: options.legalHold,
				encryptionScope: options.encryptionScope,
				copySourceTags: options.copySourceTags,
				fileRequestIntent: options.sourceShareTokenIntent,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Sets the tier on a blob. The operation is allowed on a page blob in a premium
	* storage account and on a block blob in a blob storage account (locally redundant
	* storage only). A premium page blob's tier determines the allowed size, IOPS,
	* and bandwidth of the blob. A block blob's tier determines Hot/Cool/Archive
	* storage type. This operation does not update the blob's ETag.
	* @see https://learn.microsoft.com/rest/api/storageservices/set-blob-tier
	*
	* @param tier - The tier to be set on the blob. Valid values are Hot, Cool, or Archive.
	* @param options - Optional options to the Blob Set Tier operation.
	*/
	async setAccessTier(tier, options = {}) {
		return tracingClient.withSpan("BlobClient-setAccessTier", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.setTier(toAccessTier(tier), {
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				rehydratePriority: options.rehydratePriority,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	async downloadToBuffer(param1, param2, param3, param4 = {}) {
		let buffer;
		let offset = 0;
		let count = 0;
		let options = param4;
		if (param1 instanceof Buffer) {
			buffer = param1;
			offset = param2 || 0;
			count = typeof param3 === "number" ? param3 : 0;
		} else {
			offset = typeof param1 === "number" ? param1 : 0;
			count = typeof param2 === "number" ? param2 : 0;
			options = param3 || {};
		}
		let blockSize = options.blockSize ?? 0;
		if (blockSize < 0) throw new RangeError("blockSize option must be >= 0");
		if (blockSize === 0) blockSize = DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES;
		if (offset < 0) throw new RangeError("offset option must be >= 0");
		if (count && count <= 0) throw new RangeError("count option must be greater than 0");
		if (!options.conditions) options.conditions = {};
		return tracingClient.withSpan("BlobClient-downloadToBuffer", options, async (updatedOptions) => {
			if (!count) {
				const response = await this.getProperties({
					...options,
					tracingOptions: updatedOptions.tracingOptions
				});
				count = response.contentLength - offset;
				if (count < 0) throw new RangeError(`offset ${offset} shouldn't be larger than blob size ${response.contentLength}`);
			}
			if (!buffer) try {
				buffer = Buffer.alloc(count);
			} catch (error) {
				throw new Error(`Unable to allocate the buffer of size: ${count}(in bytes). Please try passing your own buffer to the "downloadToBuffer" method or try using other methods like "download" or "downloadToFile".\t ${error.message}`);
			}
			if (buffer.length < count) throw new RangeError(`The buffer's size should be equal to or larger than the request count of bytes: ${count}`);
			let transferProgress = 0;
			const batch = new Batch(options.concurrency);
			for (let off = offset; off < offset + count; off = off + blockSize) batch.addOperation(async () => {
				let chunkEnd = offset + count;
				if (off + blockSize < chunkEnd) chunkEnd = off + blockSize;
				const stream = (await this.download(off, chunkEnd - off, {
					abortSignal: options.abortSignal,
					conditions: options.conditions,
					maxRetryRequests: options.maxRetryRequestsPerBlock,
					customerProvidedKey: options.customerProvidedKey,
					contentChecksumAlgorithm: options.contentChecksumAlgorithm,
					tracingOptions: updatedOptions.tracingOptions
				})).readableStreamBody;
				await streamToBuffer(stream, buffer, off - offset, chunkEnd - offset);
				transferProgress += chunkEnd - off;
				if (options.onProgress) options.onProgress({ loadedBytes: transferProgress });
			});
			await batch.do();
			return buffer;
		});
	}
	/**
	* ONLY AVAILABLE IN NODE.JS RUNTIME.
	*
	* Downloads an Azure Blob to a local file.
	* Fails if the the given file path already exits.
	* Offset and count are optional, pass 0 and undefined respectively to download the entire blob.
	*
	* @param filePath -
	* @param offset - From which position of the block blob to download.
	* @param count - How much data to be downloaded. Will download to the end when passing undefined.
	* @param options - Options to Blob download options.
	* @returns The response data for blob download operation,
	*                                                 but with readableStreamBody set to undefined since its
	*                                                 content is already read and written into a local file
	*                                                 at the specified path.
	*/
	async downloadToFile(filePath, offset = 0, count, options = {}) {
		return tracingClient.withSpan("BlobClient-downloadToFile", options, async (updatedOptions) => {
			const response = await this.download(offset, count, {
				...options,
				tracingOptions: updatedOptions.tracingOptions
			});
			if (response.readableStreamBody) await readStreamToLocalFile(response.readableStreamBody, filePath);
			response.blobDownloadStream = void 0;
			return response;
		});
	}
	getBlobAndContainerNamesFromUrl() {
		let containerName;
		let blobName;
		try {
			const parsedUrl = new URL(this.url);
			if (parsedUrl.host.split(".")[1] === "blob") {
				const pathComponents = parsedUrl.pathname.match("/([^/]*)(/(.*))?");
				containerName = pathComponents[1];
				blobName = pathComponents[3];
			} else if (isIpEndpointStyle(parsedUrl)) {
				const pathComponents = parsedUrl.pathname.match("/([^/]*)/([^/]*)(/(.*))?");
				containerName = pathComponents[2];
				blobName = pathComponents[4];
			} else {
				const pathComponents = parsedUrl.pathname.match("/([^/]*)(/(.*))?");
				containerName = pathComponents[1];
				blobName = pathComponents[3];
			}
			containerName = decodeURIComponent(containerName);
			blobName = decodeURIComponent(blobName);
			blobName = blobName.replace(/\\/g, "/");
			if (!containerName) throw new Error("Provided containerName is invalid.");
			return {
				blobName,
				containerName
			};
		} catch (error) {
			throw new Error("Unable to extract blobName and containerName with provided information.");
		}
	}
	/**
	* Asynchronously copies a blob to a destination within the storage account.
	* In version 2012-02-12 and later, the source for a Copy Blob operation can be
	* a committed blob in any Azure storage account.
	* Beginning with version 2015-02-21, the source for a Copy Blob operation can be
	* an Azure file in any Azure storage account.
	* Only storage accounts created on or after June 7th, 2012 allow the Copy Blob
	* operation to copy from another storage account.
	* @see https://learn.microsoft.com/rest/api/storageservices/copy-blob
	*
	* @param copySource - url to the source Azure Blob/File.
	* @param options - Optional options to the Blob Start Copy From URL operation.
	*/
	async startCopyFromURL(copySource, options = {}) {
		return tracingClient.withSpan("BlobClient-startCopyFromURL", options, async (updatedOptions) => {
			options.conditions = options.conditions || {};
			options.sourceConditions = options.sourceConditions || {};
			return assertResponse(await this.blobContext.startCopyFromURL(copySource, {
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				metadata: options.metadata,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				sourceModifiedAccessConditions: {
					sourceIfMatch: options.sourceConditions.ifMatch,
					sourceIfModifiedSince: options.sourceConditions.ifModifiedSince,
					sourceIfNoneMatch: options.sourceConditions.ifNoneMatch,
					sourceIfUnmodifiedSince: options.sourceConditions.ifUnmodifiedSince,
					sourceIfTags: options.sourceConditions.tagConditions
				},
				immutabilityPolicyExpiry: options.immutabilityPolicy?.expiriesOn,
				immutabilityPolicyMode: options.immutabilityPolicy?.policyMode,
				legalHold: options.legalHold,
				rehydratePriority: options.rehydratePriority,
				tier: toAccessTier(options.tier),
				blobTagsString: toBlobTagsString(options.tags),
				sealBlob: options.sealBlob,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Only available for BlobClient constructed with a shared key credential.
	*
	* Generates a Blob Service Shared Access Signature (SAS) URI based on the client properties
	* and parameters passed in. The SAS is signed by the shared key credential of the client.
	*
	* @see https://learn.microsoft.com/rest/api/storageservices/constructing-a-service-sas
	*
	* @param options - Optional parameters.
	* @returns The SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.
	*/
	generateSasUrl(options) {
		return new Promise((resolve) => {
			if (!(this.credential instanceof StorageSharedKeyCredential)) throw new RangeError("Can only generate the SAS when the client is initialized with a shared key credential");
			const sas = generateBlobSASQueryParameters({
				containerName: this._containerName,
				blobName: this._name,
				snapshotTime: this._snapshot,
				versionId: this._versionId,
				...options
			}, this.credential).toString();
			resolve(appendToURLQuery(this.url, sas));
		});
	}
	/**
	* Only available for BlobClient constructed with a shared key credential.
	*
	* Generates string to sign for a Blob Service Shared Access Signature (SAS) URI based on
	* the client properties and parameters passed in. The SAS is signed by the shared key credential of the client.
	*
	* @see https://learn.microsoft.com/rest/api/storageservices/constructing-a-service-sas
	*
	* @param options - Optional parameters.
	* @returns The SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.
	*/
	generateSasStringToSign(options) {
		if (!(this.credential instanceof StorageSharedKeyCredential)) throw new RangeError("Can only generate the SAS when the client is initialized with a shared key credential");
		return generateBlobSASQueryParametersInternal({
			containerName: this._containerName,
			blobName: this._name,
			snapshotTime: this._snapshot,
			versionId: this._versionId,
			...options
		}, this.credential).stringToSign;
	}
	/**
	*
	* Generates a Blob Service Shared Access Signature (SAS) URI based on
	* the client properties and parameters passed in. The SAS is signed by the input user delegation key.
	*
	* @see https://learn.microsoft.com/rest/api/storageservices/constructing-a-service-sas
	*
	* @param options - Optional parameters.
	* @param userDelegationKey -  Return value of `blobServiceClient.getUserDelegationKey()`
	* @returns The SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.
	*/
	generateUserDelegationSasUrl(options, userDelegationKey) {
		return new Promise((resolve) => {
			const sas = generateBlobSASQueryParameters({
				containerName: this._containerName,
				blobName: this._name,
				snapshotTime: this._snapshot,
				versionId: this._versionId,
				...options
			}, userDelegationKey, this.accountName).toString();
			resolve(appendToURLQuery(this.url, sas));
		});
	}
	/**
	* Only available for BlobClient constructed with a shared key credential.
	*
	* Generates string to sign for a Blob Service Shared Access Signature (SAS) URI based on
	* the client properties and parameters passed in. The SAS is signed by the input user delegation key.
	*
	* @see https://learn.microsoft.com/rest/api/storageservices/constructing-a-service-sas
	*
	* @param options - Optional parameters.
	* @param userDelegationKey -  Return value of `blobServiceClient.getUserDelegationKey()`
	* @returns The SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.
	*/
	generateUserDelegationSasStringToSign(options, userDelegationKey) {
		return generateBlobSASQueryParametersInternal({
			containerName: this._containerName,
			blobName: this._name,
			snapshotTime: this._snapshot,
			versionId: this._versionId,
			...options
		}, userDelegationKey, this.accountName).stringToSign;
	}
	/**
	* Delete the immutablility policy on the blob.
	*
	* @param options - Optional options to delete immutability policy on the blob.
	*/
	async deleteImmutabilityPolicy(options = {}) {
		return tracingClient.withSpan("BlobClient-deleteImmutabilityPolicy", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.deleteImmutabilityPolicy({ tracingOptions: updatedOptions.tracingOptions }));
		});
	}
	/**
	* Set immutability policy on the blob.
	*
	* @param options - Optional options to set immutability policy on the blob.
	*/
	async setImmutabilityPolicy(immutabilityPolicy, options = {}) {
		return tracingClient.withSpan("BlobClient-setImmutabilityPolicy", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.setImmutabilityPolicy({
				immutabilityPolicyExpiry: immutabilityPolicy.expiriesOn,
				immutabilityPolicyMode: immutabilityPolicy.policyMode,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Set legal hold on the blob.
	*
	* @param options - Optional options to set legal hold on the blob.
	*/
	async setLegalHold(legalHoldEnabled, options = {}) {
		return tracingClient.withSpan("BlobClient-setLegalHold", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.setLegalHold(legalHoldEnabled, { tracingOptions: updatedOptions.tracingOptions }));
		});
	}
	/**
	* The Get Account Information operation returns the sku name and account kind
	* for the specified account.
	* The Get Account Information operation is available on service versions beginning
	* with version 2018-03-28.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-account-information
	*
	* @param options - Options to the Service Get Account Info operation.
	* @returns Response data for the Service Get Account Info operation.
	*/
	async getAccountInfo(options = {}) {
		return tracingClient.withSpan("BlobClient-getAccountInfo", options, async (updatedOptions) => {
			return assertResponse(await this.blobContext.getAccountInfo({
				abortSignal: options.abortSignal,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
};
/**
* AppendBlobClient defines a set of operations applicable to append blobs.
*/
var AppendBlobClient = class AppendBlobClient extends BlobClient {
	/**
	* appendBlobsContext provided by protocol layer.
	*/
	appendBlobContext;
	constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, blobNameOrOptions, options) {
		let pipeline;
		let url;
		options = options || {};
		if (isPipelineLike(credentialOrPipelineOrContainerName)) {
			url = urlOrConnectionString;
			pipeline = credentialOrPipelineOrContainerName;
			options = blobNameOrOptions;
		} else if (isNodeLike && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential || credentialOrPipelineOrContainerName instanceof AnonymousCredential || isTokenCredential(credentialOrPipelineOrContainerName)) {
			url = urlOrConnectionString;
			options = blobNameOrOptions;
			pipeline = newPipeline(credentialOrPipelineOrContainerName, options);
		} else if (!credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName !== "string") {
			url = urlOrConnectionString;
			options = blobNameOrOptions;
			pipeline = newPipeline(new AnonymousCredential(), options);
		} else if (credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName === "string" && blobNameOrOptions && typeof blobNameOrOptions === "string") {
			const containerName = credentialOrPipelineOrContainerName;
			const blobName = blobNameOrOptions;
			const extractedCreds = extractConnectionStringParts(urlOrConnectionString);
			if (extractedCreds.kind === "AccountConnString") {
				if (isNodeLike) {
					const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
					url = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName));
					if (!options.proxyOptions) options.proxyOptions = getDefaultProxySettings(extractedCreds.proxyUri);
					pipeline = newPipeline(sharedKeyCredential, options);
				} else throw new Error("Account connection string is only supported in Node.js environment");
			} else if (extractedCreds.kind === "SASConnString") {
				url = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName)) + "?" + extractedCreds.accountSas;
				pipeline = newPipeline(new AnonymousCredential(), options);
			} else throw new Error("Connection string must be either an Account connection string or a SAS connection string");
		} else throw new Error("Expecting non-empty strings for containerName and blobName parameters");
		super(url, pipeline);
		this.appendBlobContext = this.storageClientContext.appendBlob;
		this.blobClientConfig = options;
	}
	/**
	* Creates a new AppendBlobClient object identical to the source but with the
	* specified snapshot timestamp.
	* Provide "" will remove the snapshot and return a Client to the base blob.
	*
	* @param snapshot - The snapshot timestamp.
	* @returns A new AppendBlobClient object identical to the source but with the specified snapshot timestamp.
	*/
	withSnapshot(snapshot) {
		return new AppendBlobClient(setURLParameter(this.url, URLConstants.Parameters.SNAPSHOT, snapshot.length === 0 ? void 0 : snapshot), this.pipeline, this.blobClientConfig);
	}
	/**
	* Creates a 0-length append blob. Call AppendBlock to append data to an append blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-blob
	*
	* @param options - Options to the Append Block Create operation.
	*
	*
	* Example usage:
	*
	* ```ts snippet:ClientsCreateAppendBlob
	* import { BlobServiceClient } from "@azure/storage-blob";
	* import { DefaultAzureCredential } from "@azure/identity";
	*
	* const account = "<account>";
	* const blobServiceClient = new BlobServiceClient(
	*   `https://${account}.blob.core.windows.net`,
	*   new DefaultAzureCredential(),
	* );
	*
	* const containerName = "<container name>";
	* const blobName = "<blob name>";
	* const containerClient = blobServiceClient.getContainerClient(containerName);
	*
	* const appendBlobClient = containerClient.getAppendBlobClient(blobName);
	* await appendBlobClient.create();
	* ```
	*/
	async create(options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("AppendBlobClient-create", options, async (updatedOptions) => {
			return assertResponse(await this.appendBlobContext.create(0, {
				abortSignal: options.abortSignal,
				blobHttpHeaders: options.blobHTTPHeaders,
				leaseAccessConditions: options.conditions,
				metadata: options.metadata,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				immutabilityPolicyExpiry: options.immutabilityPolicy?.expiriesOn,
				immutabilityPolicyMode: options.immutabilityPolicy?.policyMode,
				legalHold: options.legalHold,
				blobTagsString: toBlobTagsString(options.tags),
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Creates a 0-length append blob. Call AppendBlock to append data to an append blob.
	* If the blob with the same name already exists, the content of the existing blob will remain unchanged.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-blob
	*
	* @param options -
	*/
	async createIfNotExists(options = {}) {
		const conditions = { ifNoneMatch: "*" };
		return tracingClient.withSpan("AppendBlobClient-createIfNotExists", options, async (updatedOptions) => {
			try {
				const res = assertResponse(await this.create({
					...updatedOptions,
					conditions
				}));
				return {
					succeeded: true,
					...res,
					_response: res._response
				};
			} catch (e) {
				if (e.details?.errorCode === "BlobAlreadyExists") return {
					succeeded: false,
					...e.response?.parsedHeaders,
					_response: e.response
				};
				throw e;
			}
		});
	}
	/**
	* Seals the append blob, making it read only.
	*
	* @param options -
	*/
	async seal(options = {}) {
		options.conditions = options.conditions || {};
		return tracingClient.withSpan("AppendBlobClient-seal", options, async (updatedOptions) => {
			return assertResponse(await this.appendBlobContext.seal({
				abortSignal: options.abortSignal,
				appendPositionAccessConditions: options.conditions,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Commits a new block of data to the end of the existing append blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/append-block
	*
	* @param body - Data to be appended.
	* @param contentLength - Length of the body in bytes.
	* @param options - Options to the Append Block operation.
	*
	*
	* Example usage:
	*
	* ```ts snippet:ClientsAppendBlock
	* import { BlobServiceClient } from "@azure/storage-blob";
	* import { DefaultAzureCredential } from "@azure/identity";
	*
	* const account = "<account>";
	* const blobServiceClient = new BlobServiceClient(
	*   `https://${account}.blob.core.windows.net`,
	*   new DefaultAzureCredential(),
	* );
	*
	* const containerName = "<container name>";
	* const blobName = "<blob name>";
	* const containerClient = blobServiceClient.getContainerClient(containerName);
	*
	* const content = "Hello World!";
	*
	* // Create a new append blob and append data to the blob.
	* const newAppendBlobClient = containerClient.getAppendBlobClient(blobName);
	* await newAppendBlobClient.create();
	* await newAppendBlobClient.appendBlock(content, content.length);
	*
	* // Append data to an existing append blob.
	* const existingAppendBlobClient = containerClient.getAppendBlobClient(blobName);
	* await existingAppendBlobClient.appendBlock(content, content.length);
	* ```
	*/
	async appendBlock(body, contentLength, options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("AppendBlobClient-appendBlock", options, async (updatedOptions) => {
			const parameters = {
				abortSignal: options.abortSignal,
				appendPositionAccessConditions: options.conditions,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				requestOptions: { onUploadProgress: options.onProgress },
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				tracingOptions: updatedOptions.tracingOptions
			};
			const uploadBodyParameters = await setUploadChecksumParameters(body, contentLength, parameters, options, this.blobClientConfig?.uploadContentChecksumAlgorithm);
			return assertResponse(await this.appendBlobContext.appendBlock(uploadBodyParameters.contentLength, uploadBodyParameters.body, parameters));
		});
	}
	/**
	* The Append Block operation commits a new block of data to the end of an existing append blob
	* where the contents are read from a source url.
	* @see https://learn.microsoft.com/rest/api/storageservices/append-block-from-url
	*
	* @param sourceURL -
	*                 The url to the blob that will be the source of the copy. A source blob in the same storage account can
	*                 be authenticated via Shared Key. However, if the source is a blob in another account, the source blob
	*                 must either be public or must be authenticated via a shared access signature. If the source blob is
	*                 public, no authentication is required to perform the operation.
	* @param sourceOffset - Offset in source to be appended
	* @param count - Number of bytes to be appended as a block
	* @param options -
	*/
	async appendBlockFromURL(sourceURL, sourceOffset, count, options = {}) {
		options.conditions = options.conditions || {};
		options.sourceConditions = options.sourceConditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("AppendBlobClient-appendBlockFromURL", options, async (updatedOptions) => {
			return assertResponse(await this.appendBlobContext.appendBlockFromUrl(sourceURL, 0, {
				abortSignal: options.abortSignal,
				sourceRange: rangeToString({
					offset: sourceOffset,
					count
				}),
				sourceContentMD5: options.sourceContentMD5,
				sourceContentCrc64: options.sourceContentCrc64,
				leaseAccessConditions: options.conditions,
				appendPositionAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				sourceModifiedAccessConditions: {
					sourceIfMatch: options.sourceConditions?.ifMatch,
					sourceIfModifiedSince: options.sourceConditions?.ifModifiedSince,
					sourceIfNoneMatch: options.sourceConditions?.ifNoneMatch,
					sourceIfUnmodifiedSince: options.sourceConditions?.ifUnmodifiedSince
				},
				copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization),
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				fileRequestIntent: options.sourceShareTokenIntent,
				tracingOptions: updatedOptions.tracingOptions,
				sourceCpkInfo: {
					sourceEncryptionKey: options.sourceCustomerProvidedKey?.encryptionKey,
					sourceEncryptionAlgorithm: options.sourceCustomerProvidedKey?.encryptionAlgorithm,
					sourceEncryptionKeySha256: options.sourceCustomerProvidedKey?.encryptionKeySha256
				}
			}));
		});
	}
};
/**
* BlockBlobClient defines a set of operations applicable to block blobs.
*/
var BlockBlobClient = class BlockBlobClient extends BlobClient {
	/**
	* blobContext provided by protocol layer.
	*
	* Note. Ideally BlobClient should set BlobClient.blobContext to protected. However, API
	* extractor has issue blocking that. Here we redecelare _blobContext in BlockBlobClient.
	*/
	_blobContext;
	/**
	* blockBlobContext provided by protocol layer.
	*/
	blockBlobContext;
	constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, blobNameOrOptions, options) {
		let pipeline;
		let url;
		options = options || {};
		if (isPipelineLike(credentialOrPipelineOrContainerName)) {
			url = urlOrConnectionString;
			pipeline = credentialOrPipelineOrContainerName;
			options = blobNameOrOptions;
		} else if (isNodeLike && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential || credentialOrPipelineOrContainerName instanceof AnonymousCredential || isTokenCredential(credentialOrPipelineOrContainerName)) {
			url = urlOrConnectionString;
			options = blobNameOrOptions;
			pipeline = newPipeline(credentialOrPipelineOrContainerName, options);
		} else if (!credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName !== "string") {
			url = urlOrConnectionString;
			if (blobNameOrOptions && typeof blobNameOrOptions !== "string") options = blobNameOrOptions;
			pipeline = newPipeline(new AnonymousCredential(), options);
		} else if (credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName === "string" && blobNameOrOptions && typeof blobNameOrOptions === "string") {
			const containerName = credentialOrPipelineOrContainerName;
			const blobName = blobNameOrOptions;
			const extractedCreds = extractConnectionStringParts(urlOrConnectionString);
			if (extractedCreds.kind === "AccountConnString") {
				if (isNodeLike) {
					const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
					url = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName));
					if (!options.proxyOptions) options.proxyOptions = getDefaultProxySettings(extractedCreds.proxyUri);
					pipeline = newPipeline(sharedKeyCredential, options);
				} else throw new Error("Account connection string is only supported in Node.js environment");
			} else if (extractedCreds.kind === "SASConnString") {
				url = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName)) + "?" + extractedCreds.accountSas;
				pipeline = newPipeline(new AnonymousCredential(), options);
			} else throw new Error("Connection string must be either an Account connection string or a SAS connection string");
		} else throw new Error("Expecting non-empty strings for containerName and blobName parameters");
		super(url, pipeline);
		this.blockBlobContext = this.storageClientContext.blockBlob;
		this._blobContext = this.storageClientContext.blob;
		this.blobClientConfig = options;
	}
	/**
	* Creates a new BlockBlobClient object identical to the source but with the
	* specified snapshot timestamp.
	* Provide "" will remove the snapshot and return a URL to the base blob.
	*
	* @param snapshot - The snapshot timestamp.
	* @returns A new BlockBlobClient object identical to the source but with the specified snapshot timestamp.
	*/
	withSnapshot(snapshot) {
		return new BlockBlobClient(setURLParameter(this.url, URLConstants.Parameters.SNAPSHOT, snapshot.length === 0 ? void 0 : snapshot), this.pipeline, this.blobClientConfig);
	}
	/**
	* ONLY AVAILABLE IN NODE.JS RUNTIME.
	*
	* Quick query for a JSON or CSV formatted blob.
	*
	* Example usage (Node.js):
	*
	* ```ts snippet:ClientsQuery
	* import { BlobServiceClient } from "@azure/storage-blob";
	* import { DefaultAzureCredential } from "@azure/identity";
	* import { buffer } from "node:stream/consumers";
	*
	* const account = "<account>";
	* const blobServiceClient = new BlobServiceClient(
	*   `https://${account}.blob.core.windows.net`,
	*   new DefaultAzureCredential(),
	* );
	*
	* const containerName = "<container name>";
	* const blobName = "<blob name>";
	* const containerClient = blobServiceClient.getContainerClient(containerName);
	* const blockBlobClient = containerClient.getBlockBlobClient(blobName);
	*
	* // Query and convert a blob to a string
	* const queryBlockBlobResponse = await blockBlobClient.query("select from BlobStorage");
	* if (queryBlockBlobResponse.readableStreamBody) {
	*   // Read the response bytes. Use `text` from "node:stream/consumers" instead
	*   // if you want the response as a string directly.
	*   const downloadedBuffer = await buffer(queryBlockBlobResponse.readableStreamBody);
	*   console.log(`Query blob content: ${downloadedBuffer.toString()}`);
	* }
	* ```
	*
	* @param query -
	* @param options -
	*/
	async query(query, options = {}) {
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		if (!isNodeLike) throw new Error("This operation currently is only supported in Node.js.");
		return tracingClient.withSpan("BlockBlobClient-query", options, async (updatedOptions) => {
			return new BlobQueryResponse(assertResponse(await this._blobContext.query({
				abortSignal: options.abortSignal,
				queryRequest: {
					queryType: "SQL",
					expression: query,
					inputSerialization: toQuerySerialization(options.inputTextConfiguration),
					outputSerialization: toQuerySerialization(options.outputTextConfiguration)
				},
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				cpkInfo: options.customerProvidedKey,
				tracingOptions: updatedOptions.tracingOptions
			})), {
				abortSignal: options.abortSignal,
				onProgress: options.onProgress,
				onError: options.onError
			});
		});
	}
	/**
	* Creates a new block blob, or updates the content of an existing block blob.
	* Updating an existing block blob overwrites any existing metadata on the blob.
	* Partial updates are not supported; the content of the existing blob is
	* overwritten with the new content. To perform a partial update of a block blob's,
	* use {@link stageBlock} and {@link commitBlockList}.
	*
	* This is a non-parallel uploading method, please use {@link uploadFile},
	* {@link uploadStream} or {@link uploadBrowserData} for better performance
	* with concurrency uploading.
	*
	* @see https://learn.microsoft.com/rest/api/storageservices/put-blob
	*
	* @param body - Blob, string, ArrayBuffer, ArrayBufferView or a function
	*                               which returns a new Readable stream whose offset is from data source beginning.
	* @param contentLength - Length of body in bytes. Use Buffer.byteLength() to calculate body length for a
	*                               string including non non-Base64/Hex-encoded characters.
	* @param options - Options to the Block Blob Upload operation.
	* @returns Response data for the Block Blob Upload operation.
	*
	* Example usage:
	*
	* ```ts snippet:ClientsUpload
	* import { BlobServiceClient } from "@azure/storage-blob";
	* import { DefaultAzureCredential } from "@azure/identity";
	*
	* const account = "<account>";
	* const blobServiceClient = new BlobServiceClient(
	*   `https://${account}.blob.core.windows.net`,
	*   new DefaultAzureCredential(),
	* );
	*
	* const containerName = "<container name>";
	* const blobName = "<blob name>";
	* const containerClient = blobServiceClient.getContainerClient(containerName);
	* const blockBlobClient = containerClient.getBlockBlobClient(blobName);
	*
	* const content = "Hello world!";
	* const uploadBlobResponse = await blockBlobClient.upload(content, content.length);
	* ```
	*/
	async upload(body, contentLength, options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlockBlobClient-upload", options, async (updatedOptions) => {
			const parameters = {
				abortSignal: options.abortSignal,
				blobHttpHeaders: options.blobHTTPHeaders,
				leaseAccessConditions: options.conditions,
				metadata: options.metadata,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				requestOptions: { onUploadProgress: options.onProgress },
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				immutabilityPolicyExpiry: options.immutabilityPolicy?.expiriesOn,
				immutabilityPolicyMode: options.immutabilityPolicy?.policyMode,
				legalHold: options.legalHold,
				tier: toAccessTier(options.tier),
				blobTagsString: toBlobTagsString(options.tags),
				tracingOptions: updatedOptions.tracingOptions
			};
			const uploadBodyParameters = await setUploadChecksumParameters(body, contentLength, parameters, options, this.blobClientConfig?.uploadContentChecksumAlgorithm);
			return assertResponse(await this.blockBlobContext.upload(uploadBodyParameters.contentLength, uploadBodyParameters.body, parameters));
		});
	}
	/**
	* Creates a new Block Blob where the contents of the blob are read from a given URL.
	* This API is supported beginning with the 2020-04-08 version. Partial updates
	* are not supported with Put Blob from URL; the content of an existing blob is overwritten with
	* the content of the new blob.  To perform partial updates to a block blob’s contents using a
	* source URL, use {@link stageBlockFromURL} and {@link commitBlockList}.
	*
	* @param sourceURL - Specifies the URL of the blob. The value
	*                           may be a URL of up to 2 KB in length that specifies a blob.
	*                           The value should be URL-encoded as it would appear
	*                           in a request URI. The source blob must either be public
	*                           or must be authenticated via a shared access signature.
	*                           If the source blob is public, no authentication is required
	*                           to perform the operation. Here are some examples of source object URLs:
	*                           - https://myaccount.blob.core.windows.net/mycontainer/myblob
	*                           - https://myaccount.blob.core.windows.net/mycontainer/myblob?snapshot=<DateTime>
	* @param options - Optional parameters.
	*/
	async syncUploadFromURL(sourceURL, options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlockBlobClient-syncUploadFromURL", options, async (updatedOptions) => {
			return assertResponse(await this.blockBlobContext.putBlobFromUrl(0, sourceURL, {
				...options,
				blobHttpHeaders: options.blobHTTPHeaders,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				sourceModifiedAccessConditions: {
					sourceIfMatch: options.sourceConditions?.ifMatch,
					sourceIfModifiedSince: options.sourceConditions?.ifModifiedSince,
					sourceIfNoneMatch: options.sourceConditions?.ifNoneMatch,
					sourceIfUnmodifiedSince: options.sourceConditions?.ifUnmodifiedSince,
					sourceIfTags: options.sourceConditions?.tagConditions
				},
				cpkInfo: options.customerProvidedKey,
				copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization),
				tier: toAccessTier(options.tier),
				blobTagsString: toBlobTagsString(options.tags),
				copySourceTags: options.copySourceTags,
				fileRequestIntent: options.sourceShareTokenIntent,
				tracingOptions: updatedOptions.tracingOptions,
				sourceCpkInfo: {
					sourceEncryptionKey: options.sourceCustomerProvidedKey?.encryptionKey,
					sourceEncryptionAlgorithm: options.sourceCustomerProvidedKey?.encryptionAlgorithm,
					sourceEncryptionKeySha256: options.sourceCustomerProvidedKey?.encryptionKeySha256
				}
			}));
		});
	}
	/**
	* Uploads the specified block to the block blob's "staging area" to be later
	* committed by a call to commitBlockList.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-block
	*
	* @param blockId - A 64-byte value that is base64-encoded
	* @param body - Data to upload to the staging area.
	* @param contentLength - Number of bytes to upload.
	* @param options - Options to the Block Blob Stage Block operation.
	* @returns Response data for the Block Blob Stage Block operation.
	*/
	async stageBlock(blockId, body, contentLength, options = {}) {
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlockBlobClient-stageBlock", options, async (updatedOptions) => {
			const parameters = {
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				requestOptions: { onUploadProgress: options.onProgress },
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				tracingOptions: updatedOptions.tracingOptions
			};
			const uploadBodyParameters = await setUploadChecksumParameters(body, contentLength, parameters, options, this.blobClientConfig?.uploadContentChecksumAlgorithm);
			return assertResponse(await this.blockBlobContext.stageBlock(blockId, uploadBodyParameters.contentLength, uploadBodyParameters.body, parameters));
		});
	}
	/**
	* The Stage Block From URL operation creates a new block to be committed as part
	* of a blob where the contents are read from a URL.
	* This API is available starting in version 2018-03-28.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-block-from-url
	*
	* @param blockId - A 64-byte value that is base64-encoded
	* @param sourceURL - Specifies the URL of the blob. The value
	*                           may be a URL of up to 2 KB in length that specifies a blob.
	*                           The value should be URL-encoded as it would appear
	*                           in a request URI. The source blob must either be public
	*                           or must be authenticated via a shared access signature.
	*                           If the source blob is public, no authentication is required
	*                           to perform the operation. Here are some examples of source object URLs:
	*                           - https://myaccount.blob.core.windows.net/mycontainer/myblob
	*                           - https://myaccount.blob.core.windows.net/mycontainer/myblob?snapshot=<DateTime>
	* @param offset - From which position of the blob to download, greater than or equal to 0
	* @param count - How much data to be downloaded, greater than 0. Will download to the end when undefined
	* @param options - Options to the Block Blob Stage Block From URL operation.
	* @returns Response data for the Block Blob Stage Block From URL operation.
	*/
	async stageBlockFromURL(blockId, sourceURL, offset = 0, count, options = {}) {
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlockBlobClient-stageBlockFromURL", options, async (updatedOptions) => {
			return assertResponse(await this.blockBlobContext.stageBlockFromURL(blockId, 0, sourceURL, {
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				sourceContentMD5: options.sourceContentMD5,
				sourceContentCrc64: options.sourceContentCrc64,
				sourceRange: offset === 0 && !count ? void 0 : rangeToString({
					offset,
					count
				}),
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization),
				fileRequestIntent: options.sourceShareTokenIntent,
				tracingOptions: updatedOptions.tracingOptions,
				sourceCpkInfo: {
					sourceEncryptionKey: options.sourceCustomerProvidedKey?.encryptionKey,
					sourceEncryptionAlgorithm: options.sourceCustomerProvidedKey?.encryptionAlgorithm,
					sourceEncryptionKeySha256: options.sourceCustomerProvidedKey?.encryptionKeySha256
				}
			}));
		});
	}
	/**
	* Writes a blob by specifying the list of block IDs that make up the blob.
	* In order to be written as part of a blob, a block must have been successfully written
	* to the server in a prior {@link stageBlock} operation. You can call {@link commitBlockList} to
	* update a blob by uploading only those blocks that have changed, then committing the new and existing
	* blocks together. Any blocks not specified in the block list and permanently deleted.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-block-list
	*
	* @param blocks -  Array of 64-byte value that is base64-encoded
	* @param options - Options to the Block Blob Commit Block List operation.
	* @returns Response data for the Block Blob Commit Block List operation.
	*/
	async commitBlockList(blocks, options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("BlockBlobClient-commitBlockList", options, async (updatedOptions) => {
			return assertResponse(await this.blockBlobContext.commitBlockList({ latest: blocks }, {
				abortSignal: options.abortSignal,
				blobHttpHeaders: options.blobHTTPHeaders,
				leaseAccessConditions: options.conditions,
				metadata: options.metadata,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				immutabilityPolicyExpiry: options.immutabilityPolicy?.expiriesOn,
				immutabilityPolicyMode: options.immutabilityPolicy?.policyMode,
				legalHold: options.legalHold,
				tier: toAccessTier(options.tier),
				blobTagsString: toBlobTagsString(options.tags),
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Returns the list of blocks that have been uploaded as part of a block blob
	* using the specified block list filter.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-block-list
	*
	* @param listType - Specifies whether to return the list of committed blocks,
	*                                        the list of uncommitted blocks, or both lists together.
	* @param options - Options to the Block Blob Get Block List operation.
	* @returns Response data for the Block Blob Get Block List operation.
	*/
	async getBlockList(listType, options = {}) {
		return tracingClient.withSpan("BlockBlobClient-getBlockList", options, async (updatedOptions) => {
			const res = assertResponse(await this.blockBlobContext.getBlockList(listType, {
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions
			}));
			if (!res.committedBlocks) res.committedBlocks = [];
			if (!res.uncommittedBlocks) res.uncommittedBlocks = [];
			return res;
		});
	}
	/**
	* Uploads a Buffer(Node.js)/Blob(browsers)/ArrayBuffer/ArrayBufferView object to a BlockBlob.
	*
	* When data length is no more than the specifiled {@link BlockBlobParallelUploadOptions.maxSingleShotSize} (default is
	* {@link BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES}), this method will use 1 {@link upload} call to finish the upload.
	* Otherwise, this method will call {@link stageBlock} to upload blocks, and finally call {@link commitBlockList}
	* to commit the block list.
	*
	* A common {@link BlockBlobParallelUploadOptions.blobHTTPHeaders} option to set is
	* `blobContentType`, enabling the browser to provide
	* functionality based on file type.
	*
	* @param data - Buffer(Node.js), Blob, ArrayBuffer or ArrayBufferView
	* @param options -
	*/
	async uploadData(data, options = {}) {
		return tracingClient.withSpan("BlockBlobClient-uploadData", options, async (updatedOptions) => {
			if (isNodeLike) {
				let buffer;
				if (data instanceof Buffer) buffer = data;
				else if (data instanceof ArrayBuffer) buffer = Buffer.from(data);
				else {
					data = data;
					buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
				}
				return this.uploadSeekableInternal((offset, size) => buffer.slice(offset, offset + size), buffer.byteLength, updatedOptions);
			} else {
				const browserBlob = new Blob([data]);
				return this.uploadSeekableInternal((offset, size) => browserBlob.slice(offset, offset + size), browserBlob.size, updatedOptions);
			}
		});
	}
	/**
	* ONLY AVAILABLE IN BROWSERS.
	*
	* Uploads a browser Blob/File/ArrayBuffer/ArrayBufferView object to block blob.
	*
	* When buffer length lesser than or equal to 256MB, this method will use 1 upload call to finish the upload.
	* Otherwise, this method will call {@link stageBlock} to upload blocks, and finally call
	* {@link commitBlockList} to commit the block list.
	*
	* A common {@link BlockBlobParallelUploadOptions.blobHTTPHeaders} option to set is
	* `blobContentType`, enabling the browser to provide
	* functionality based on file type.
	*
	* @deprecated Use {@link uploadData} instead.
	*
	* @param browserData - Blob, File, ArrayBuffer or ArrayBufferView
	* @param options - Options to upload browser data.
	* @returns Response data for the Blob Upload operation.
	*/
	async uploadBrowserData(browserData, options = {}) {
		return tracingClient.withSpan("BlockBlobClient-uploadBrowserData", options, async (updatedOptions) => {
			const browserBlob = new Blob([browserData]);
			return this.uploadSeekableInternal((offset, size) => browserBlob.slice(offset, offset + size), browserBlob.size, updatedOptions);
		});
	}
	/**
	*
	* Uploads data to block blob. Requires a bodyFactory as the data source,
	* which need to return a {@link HttpRequestBody} object with the offset and size provided.
	*
	* When data length is no more than the specified {@link BlockBlobParallelUploadOptions.maxSingleShotSize} (default is
	* {@link BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES}), this method will use 1 {@link upload} call to finish the upload.
	* Otherwise, this method will call {@link stageBlock} to upload blocks, and finally call {@link commitBlockList}
	* to commit the block list.
	*
	* @param bodyFactory -
	* @param size - size of the data to upload.
	* @param options - Options to Upload to Block Blob operation.
	* @returns Response data for the Blob Upload operation.
	*/
	async uploadSeekableInternal(bodyFactory, size, options = {}) {
		let blockSize = options.blockSize ?? 0;
		if (blockSize < 0 || blockSize > 4194304e3) throw new RangeError(`blockSize option must be >= 0 and <= ${BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES}`);
		const maxSingleShotSize = options.maxSingleShotSize ?? 268435456;
		if (maxSingleShotSize < 0 || maxSingleShotSize > 268435456) throw new RangeError(`maxSingleShotSize option must be >= 0 and <= ${BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES}`);
		if (blockSize === 0) {
			if (size > 4194304e3 * 5e4) throw new RangeError(`${size} is too larger to upload to a block blob.`);
			if (size > maxSingleShotSize) {
				blockSize = Math.ceil(size / BLOCK_BLOB_MAX_BLOCKS);
				if (blockSize < 4194304) blockSize = DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES;
			}
		}
		if (!options.blobHTTPHeaders) options.blobHTTPHeaders = {};
		if (!options.conditions) options.conditions = {};
		return tracingClient.withSpan("BlockBlobClient-uploadSeekableInternal", options, async (updatedOptions) => {
			if (size <= maxSingleShotSize) return assertResponse(await this.upload(bodyFactory(0, size), size, updatedOptions));
			const numBlocks = Math.floor((size - 1) / blockSize) + 1;
			if (numBlocks > 5e4) throw new RangeError(`The buffer's size is too big or the BlockSize is too small;the number of blocks must be <= ${BLOCK_BLOB_MAX_BLOCKS}`);
			const blockList = [];
			const blockIDPrefix = randomUUID();
			let transferProgress = 0;
			const batch = new Batch(options.concurrency);
			for (let i = 0; i < numBlocks; i++) batch.addOperation(async () => {
				const blockID = generateBlockID(blockIDPrefix, i);
				const start = blockSize * i;
				const contentLength = (i === numBlocks - 1 ? size : start + blockSize) - start;
				blockList.push(blockID);
				await this.stageBlock(blockID, bodyFactory(start, contentLength), contentLength, {
					abortSignal: options.abortSignal,
					conditions: options.conditions,
					encryptionScope: options.encryptionScope,
					tracingOptions: updatedOptions.tracingOptions,
					contentChecksumAlgorithm: options.contentChecksumAlgorithm
				});
				transferProgress += contentLength;
				if (options.onProgress) options.onProgress({ loadedBytes: transferProgress });
			});
			await batch.do();
			return this.commitBlockList(blockList, updatedOptions);
		});
	}
	/**
	* ONLY AVAILABLE IN NODE.JS RUNTIME.
	*
	* Uploads a local file in blocks to a block blob.
	*
	* When file size lesser than or equal to 256MB, this method will use 1 upload call to finish the upload.
	* Otherwise, this method will call stageBlock to upload blocks, and finally call commitBlockList
	* to commit the block list.
	*
	* @param filePath - Full path of local file
	* @param options - Options to Upload to Block Blob operation.
	* @returns Response data for the Blob Upload operation.
	*/
	async uploadFile(filePath, options = {}) {
		return tracingClient.withSpan("BlockBlobClient-uploadFile", options, async (updatedOptions) => {
			const size = (await fsStat(filePath)).size;
			return this.uploadSeekableInternal((offset, count) => {
				return () => fsCreateReadStream(filePath, {
					autoClose: true,
					end: count ? offset + count - 1 : Infinity,
					start: offset
				});
			}, size, {
				...options,
				tracingOptions: updatedOptions.tracingOptions
			});
		});
	}
	/**
	* ONLY AVAILABLE IN NODE.JS RUNTIME.
	*
	* Uploads a Node.js Readable stream into block blob.
	*
	* PERFORMANCE IMPROVEMENT TIPS:
	* * Input stream highWaterMark is better to set a same value with bufferSize
	*    parameter, which will avoid Buffer.concat() operations.
	*
	* @param stream - Node.js Readable stream
	* @param bufferSize - Size of every buffer allocated, also the block size in the uploaded block blob. Default value is 8MB
	* @param maxConcurrency -  Max concurrency indicates the max number of buffers that can be allocated,
	*                                 positive correlation with max uploading concurrency. Default value is 5
	* @param options - Options to Upload Stream to Block Blob operation.
	* @returns Response data for the Blob Upload operation.
	*/
	async uploadStream(stream, bufferSize = DEFAULT_BLOCK_BUFFER_SIZE_BYTES, maxConcurrency = 5, options = {}) {
		if (!options.blobHTTPHeaders) options.blobHTTPHeaders = {};
		if (!options.conditions) options.conditions = {};
		return tracingClient.withSpan("BlockBlobClient-uploadStream", options, async (updatedOptions) => {
			let blockNum = 0;
			const blockIDPrefix = randomUUID();
			let transferProgress = 0;
			const blockList = [];
			await new BufferScheduler(stream, bufferSize, maxConcurrency, async (body, length) => {
				const blockID = generateBlockID(blockIDPrefix, blockNum);
				blockList.push(blockID);
				blockNum++;
				await this.stageBlock(blockID, body, length, {
					customerProvidedKey: options.customerProvidedKey,
					conditions: options.conditions,
					encryptionScope: options.encryptionScope,
					tracingOptions: updatedOptions.tracingOptions,
					contentChecksumAlgorithm: options.contentChecksumAlgorithm
				});
				transferProgress += length;
				if (options.onProgress) options.onProgress({ loadedBytes: transferProgress });
			}, Math.ceil(maxConcurrency / 4 * 3)).do();
			return assertResponse(await this.commitBlockList(blockList, {
				...options,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
};
/**
* PageBlobClient defines a set of operations applicable to page blobs.
*/
var PageBlobClient = class PageBlobClient extends BlobClient {
	/**
	* pageBlobsContext provided by protocol layer.
	*/
	pageBlobContext;
	constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, blobNameOrOptions, options) {
		let pipeline;
		let url;
		options = options || {};
		if (isPipelineLike(credentialOrPipelineOrContainerName)) {
			url = urlOrConnectionString;
			pipeline = credentialOrPipelineOrContainerName;
			options = blobNameOrOptions;
		} else if (isNodeLike && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential || credentialOrPipelineOrContainerName instanceof AnonymousCredential || isTokenCredential(credentialOrPipelineOrContainerName)) {
			url = urlOrConnectionString;
			options = blobNameOrOptions;
			pipeline = newPipeline(credentialOrPipelineOrContainerName, options);
		} else if (!credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName !== "string") {
			url = urlOrConnectionString;
			options = blobNameOrOptions;
			pipeline = newPipeline(new AnonymousCredential(), options);
		} else if (credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName === "string" && blobNameOrOptions && typeof blobNameOrOptions === "string") {
			const containerName = credentialOrPipelineOrContainerName;
			const blobName = blobNameOrOptions;
			const extractedCreds = extractConnectionStringParts(urlOrConnectionString);
			if (extractedCreds.kind === "AccountConnString") {
				if (isNodeLike) {
					const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
					url = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName));
					if (!options.proxyOptions) options.proxyOptions = getDefaultProxySettings(extractedCreds.proxyUri);
					pipeline = newPipeline(sharedKeyCredential, options);
				} else throw new Error("Account connection string is only supported in Node.js environment");
			} else if (extractedCreds.kind === "SASConnString") {
				url = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName)) + "?" + extractedCreds.accountSas;
				pipeline = newPipeline(new AnonymousCredential(), options);
			} else throw new Error("Connection string must be either an Account connection string or a SAS connection string");
		} else throw new Error("Expecting non-empty strings for containerName and blobName parameters");
		super(url, pipeline);
		this.pageBlobContext = this.storageClientContext.pageBlob;
		this.blobClientConfig = options;
	}
	/**
	* Creates a new PageBlobClient object identical to the source but with the
	* specified snapshot timestamp.
	* Provide "" will remove the snapshot and return a Client to the base blob.
	*
	* @param snapshot - The snapshot timestamp.
	* @returns A new PageBlobClient object identical to the source but with the specified snapshot timestamp.
	*/
	withSnapshot(snapshot) {
		return new PageBlobClient(setURLParameter(this.url, URLConstants.Parameters.SNAPSHOT, snapshot.length === 0 ? void 0 : snapshot), this.pipeline, this.blobClientConfig);
	}
	/**
	* Creates a page blob of the specified length. Call uploadPages to upload data
	* data to a page blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-blob
	*
	* @param size - size of the page blob.
	* @param options - Options to the Page Blob Create operation.
	* @returns Response data for the Page Blob Create operation.
	*/
	async create(size, options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("PageBlobClient-create", options, async (updatedOptions) => {
			return assertResponse(await this.pageBlobContext.create(0, size, {
				abortSignal: options.abortSignal,
				blobHttpHeaders: options.blobHTTPHeaders,
				blobSequenceNumber: options.blobSequenceNumber,
				leaseAccessConditions: options.conditions,
				metadata: options.metadata,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				immutabilityPolicyExpiry: options.immutabilityPolicy?.expiriesOn,
				immutabilityPolicyMode: options.immutabilityPolicy?.policyMode,
				legalHold: options.legalHold,
				tier: toAccessTier(options.tier),
				blobTagsString: toBlobTagsString(options.tags),
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Creates a page blob of the specified length. Call uploadPages to upload data
	* data to a page blob. If the blob with the same name already exists, the content
	* of the existing blob will remain unchanged.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-blob
	*
	* @param size - size of the page blob.
	* @param options -
	*/
	async createIfNotExists(size, options = {}) {
		return tracingClient.withSpan("PageBlobClient-createIfNotExists", options, async (updatedOptions) => {
			try {
				const conditions = { ifNoneMatch: "*" };
				const res = assertResponse(await this.create(size, {
					...options,
					conditions,
					tracingOptions: updatedOptions.tracingOptions
				}));
				return {
					succeeded: true,
					...res,
					_response: res._response
				};
			} catch (e) {
				if (e.details?.errorCode === "BlobAlreadyExists") return {
					succeeded: false,
					...e.response?.parsedHeaders,
					_response: e.response
				};
				throw e;
			}
		});
	}
	/**
	* Writes 1 or more pages to the page blob. The start and end offsets must be a multiple of 512.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-page
	*
	* @param body - Data to upload
	* @param offset - Offset of destination page blob
	* @param count - Content length of the body, also number of bytes to be uploaded
	* @param options - Options to the Page Blob Upload Pages operation.
	* @returns Response data for the Page Blob Upload Pages operation.
	*/
	async uploadPages(body, offset, count, options = {}) {
		options.conditions = options.conditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("PageBlobClient-uploadPages", options, async (updatedOptions) => {
			const parameters = {
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				requestOptions: { onUploadProgress: options.onProgress },
				range: rangeToString({
					offset,
					count
				}),
				sequenceNumberAccessConditions: options.conditions,
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				tracingOptions: updatedOptions.tracingOptions
			};
			const uploadBodyParameters = await setUploadChecksumParameters(body, count, parameters, options, this.blobClientConfig?.uploadContentChecksumAlgorithm);
			return assertResponse(await this.pageBlobContext.uploadPages(uploadBodyParameters.contentLength, uploadBodyParameters.body, parameters));
		});
	}
	/**
	* The Upload Pages operation writes a range of pages to a page blob where the
	* contents are read from a URL.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-page-from-url
	*
	* @param sourceURL - Specify a URL to the copy source, Shared Access Signature(SAS) maybe needed for authentication
	* @param sourceOffset - The source offset to copy from. Pass 0 to copy from the beginning of source page blob
	* @param destOffset - Offset of destination page blob
	* @param count - Number of bytes to be uploaded from source page blob
	* @param options -
	*/
	async uploadPagesFromURL(sourceURL, sourceOffset, destOffset, count, options = {}) {
		options.conditions = options.conditions || {};
		options.sourceConditions = options.sourceConditions || {};
		ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
		return tracingClient.withSpan("PageBlobClient-uploadPagesFromURL", options, async (updatedOptions) => {
			return assertResponse(await this.pageBlobContext.uploadPagesFromURL(sourceURL, rangeToString({
				offset: sourceOffset,
				count
			}), 0, rangeToString({
				offset: destOffset,
				count
			}), {
				abortSignal: options.abortSignal,
				sourceContentMD5: options.sourceContentMD5,
				sourceContentCrc64: options.sourceContentCrc64,
				leaseAccessConditions: options.conditions,
				sequenceNumberAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				sourceModifiedAccessConditions: {
					sourceIfMatch: options.sourceConditions?.ifMatch,
					sourceIfModifiedSince: options.sourceConditions?.ifModifiedSince,
					sourceIfNoneMatch: options.sourceConditions?.ifNoneMatch,
					sourceIfUnmodifiedSince: options.sourceConditions?.ifUnmodifiedSince
				},
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization),
				fileRequestIntent: options.sourceShareTokenIntent,
				tracingOptions: updatedOptions.tracingOptions,
				sourceCpkInfo: {
					sourceEncryptionKey: options.sourceCustomerProvidedKey?.encryptionKey,
					sourceEncryptionAlgorithm: options.sourceCustomerProvidedKey?.encryptionAlgorithm,
					sourceEncryptionKeySha256: options.sourceCustomerProvidedKey?.encryptionKeySha256
				}
			}));
		});
	}
	/**
	* Frees the specified pages from the page blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/put-page
	*
	* @param offset - Starting byte position of the pages to clear.
	* @param count - Number of bytes to clear.
	* @param options - Options to the Page Blob Clear Pages operation.
	* @returns Response data for the Page Blob Clear Pages operation.
	*/
	async clearPages(offset = 0, count, options = {}) {
		options.conditions = options.conditions || {};
		return tracingClient.withSpan("PageBlobClient-clearPages", options, async (updatedOptions) => {
			return assertResponse(await this.pageBlobContext.clearPages(0, {
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				range: rangeToString({
					offset,
					count
				}),
				sequenceNumberAccessConditions: options.conditions,
				cpkInfo: options.customerProvidedKey,
				encryptionScope: options.encryptionScope,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Returns the list of valid page ranges for a page blob or snapshot of a page blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-page-ranges
	*
	* @param offset - Starting byte position of the page ranges.
	* @param count - Number of bytes to get.
	* @param options - Options to the Page Blob Get Ranges operation.
	* @returns Response data for the Page Blob Get Ranges operation.
	*/
	async getPageRanges(offset = 0, count, options = {}) {
		options.conditions = options.conditions || {};
		return tracingClient.withSpan("PageBlobClient-getPageRanges", options, async (updatedOptions) => {
			return rangeResponseFromModel(assertResponse(await this.pageBlobContext.getPageRanges({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				range: rangeToString({
					offset,
					count
				}),
				tracingOptions: updatedOptions.tracingOptions
			})));
		});
	}
	/**
	* getPageRangesSegment returns a single segment of page ranges starting from the
	* specified Marker. Use an empty Marker to start enumeration from the beginning.
	* After getting a segment, process it, and then call getPageRangesSegment again
	* (passing the the previously-returned Marker) to get the next segment.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-page-ranges
	*
	* @param offset - Starting byte position of the page ranges.
	* @param count - Number of bytes to get.
	* @param marker - A string value that identifies the portion of the list to be returned with the next list operation.
	* @param options - Options to PageBlob Get Page Ranges Segment operation.
	*/
	async listPageRangesSegment(offset = 0, count, marker, options = {}) {
		return tracingClient.withSpan("PageBlobClient-getPageRangesSegment", options, async (updatedOptions) => {
			return assertResponse(await this.pageBlobContext.getPageRanges({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				range: rangeToString({
					offset,
					count
				}),
				marker,
				maxPageSize: options.maxPageSize,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Returns an AsyncIterableIterator for {@link PageBlobGetPageRangesResponseModel}
	*
	* @param offset - Starting byte position of the page ranges.
	* @param count - Number of bytes to get.
	* @param marker - A string value that identifies the portion of
	*                          the get of page ranges to be returned with the next getting operation. The
	*                          operation returns the ContinuationToken value within the response body if the
	*                          getting operation did not return all page ranges remaining within the current page.
	*                          The ContinuationToken value can be used as the value for
	*                          the marker parameter in a subsequent call to request the next page of get
	*                          items. The marker value is opaque to the client.
	* @param options - Options to List Page Ranges operation.
	*/
	async *listPageRangeItemSegments(offset = 0, count, marker, options = {}) {
		let getPageRangeItemSegmentsResponse;
		if (!!marker || marker === void 0) do {
			getPageRangeItemSegmentsResponse = await this.listPageRangesSegment(offset, count, marker, options);
			marker = getPageRangeItemSegmentsResponse.continuationToken;
			yield await getPageRangeItemSegmentsResponse;
		} while (marker);
	}
	/**
	* Returns an AsyncIterableIterator of {@link PageRangeInfo} objects
	*
	* @param offset - Starting byte position of the page ranges.
	* @param count - Number of bytes to get.
	* @param options - Options to List Page Ranges operation.
	*/
	async *listPageRangeItems(offset = 0, count, options = {}) {
		let marker;
		for await (const getPageRangesSegment of this.listPageRangeItemSegments(offset, count, marker, options)) yield* ExtractPageRangeInfoItems(getPageRangesSegment);
	}
	/**
	* Returns an async iterable iterator to list of page ranges for a page blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-page-ranges
	*
	*  .byPage() returns an async iterable iterator to list of page ranges for a page blob.
	*
	* ```ts snippet:ClientsListPageBlobs
	* import { BlobServiceClient } from "@azure/storage-blob";
	* import { DefaultAzureCredential } from "@azure/identity";
	*
	* const account = "<account>";
	* const blobServiceClient = new BlobServiceClient(
	*   `https://${account}.blob.core.windows.net`,
	*   new DefaultAzureCredential(),
	* );
	*
	* const containerName = "<container name>";
	* const blobName = "<blob name>";
	* const containerClient = blobServiceClient.getContainerClient(containerName);
	* const pageBlobClient = containerClient.getPageBlobClient(blobName);
	*
	* // Example using `for await` syntax
	* let i = 1;
	* for await (const pageRange of pageBlobClient.listPageRanges()) {
	*   console.log(`Page range ${i++}: ${pageRange.start} - ${pageRange.end}`);
	* }
	*
	* // Example using `iter.next()` syntax
	* i = 1;
	* const iter = pageBlobClient.listPageRanges();
	* let { value, done } = await iter.next();
	* while (!done) {
	*   console.log(`Page range ${i++}: ${value.start} - ${value.end}`);
	*   ({ value, done } = await iter.next());
	* }
	*
	* // Example using `byPage()` syntax
	* i = 1;
	* for await (const page of pageBlobClient.listPageRanges().byPage({ maxPageSize: 20 })) {
	*   for (const pageRange of page.pageRange || []) {
	*     console.log(`Page range ${i++}: ${pageRange.start} - ${pageRange.end}`);
	*   }
	* }
	*
	* // Example using paging with a marker
	* i = 1;
	* let iterator = pageBlobClient.listPageRanges().byPage({ maxPageSize: 2 });
	* let response = (await iterator.next()).value;
	* // Prints 2 page ranges
	* if (response.pageRange) {
	*   for (const pageRange of response.pageRange) {
	*     console.log(`Page range ${i++}: ${pageRange.start} - ${pageRange.end}`);
	*   }
	* }
	* // Gets next marker
	* let marker = response.continuationToken;
	* // Passing next marker as continuationToken
	* iterator = pageBlobClient.listPageRanges().byPage({ continuationToken: marker, maxPageSize: 10 });
	* response = (await iterator.next()).value;
	* // Prints 10 page ranges
	* if (response.pageRange) {
	*   for (const pageRange of response.pageRange) {
	*     console.log(`Page range ${i++}: ${pageRange.start} - ${pageRange.end}`);
	*   }
	* }
	* ```
	*
	* @param offset - Starting byte position of the page ranges.
	* @param count - Number of bytes to get.
	* @param options - Options to the Page Blob Get Ranges operation.
	* @returns An asyncIterableIterator that supports paging.
	*/
	listPageRanges(offset = 0, count, options = {}) {
		options.conditions = options.conditions || {};
		const iter = this.listPageRangeItems(offset, count, options);
		return {
			/**
			* The next method, part of the iteration protocol
			*/
			next() {
				return iter.next();
			},
			/**
			* The connection to the async iterator, part of the iteration protocol
			*/
			[Symbol.asyncIterator]() {
				return this;
			},
			/**
			* Return an AsyncIterableIterator that works a page at a time
			*/
			byPage: (settings = {}) => {
				return this.listPageRangeItemSegments(offset, count, settings.continuationToken, {
					maxPageSize: settings.maxPageSize,
					...options
				});
			}
		};
	}
	/**
	* Gets the collection of page ranges that differ between a specified snapshot and this page blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-page-ranges
	*
	* @param offset - Starting byte position of the page blob
	* @param count - Number of bytes to get ranges diff.
	* @param prevSnapshot - Timestamp of snapshot to retrieve the difference.
	* @param options - Options to the Page Blob Get Page Ranges Diff operation.
	* @returns Response data for the Page Blob Get Page Range Diff operation.
	*/
	async getPageRangesDiff(offset, count, prevSnapshot, options = {}) {
		options.conditions = options.conditions || {};
		return tracingClient.withSpan("PageBlobClient-getPageRangesDiff", options, async (updatedOptions) => {
			return rangeResponseFromModel(assertResponse(await this.pageBlobContext.getPageRangesDiff({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				prevsnapshot: prevSnapshot,
				range: rangeToString({
					offset,
					count
				}),
				tracingOptions: updatedOptions.tracingOptions
			})));
		});
	}
	/**
	* getPageRangesDiffSegment returns a single segment of page ranges starting from the
	* specified Marker for difference between previous snapshot and the target page blob.
	* Use an empty Marker to start enumeration from the beginning.
	* After getting a segment, process it, and then call getPageRangesDiffSegment again
	* (passing the the previously-returned Marker) to get the next segment.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-page-ranges
	*
	* @param offset - Starting byte position of the page ranges.
	* @param count - Number of bytes to get.
	* @param prevSnapshotOrUrl - Timestamp of snapshot to retrieve the difference or URL of snapshot to retrieve the difference.
	* @param marker - A string value that identifies the portion of the get to be returned with the next get operation.
	* @param options - Options to the Page Blob Get Page Ranges Diff operation.
	*/
	async listPageRangesDiffSegment(offset, count, prevSnapshotOrUrl, marker, options = {}) {
		return tracingClient.withSpan("PageBlobClient-getPageRangesDiffSegment", options, async (updatedOptions) => {
			return assertResponse(await this.pageBlobContext.getPageRangesDiff({
				abortSignal: options?.abortSignal,
				leaseAccessConditions: options?.conditions,
				modifiedAccessConditions: {
					...options?.conditions,
					ifTags: options?.conditions?.tagConditions
				},
				prevsnapshot: prevSnapshotOrUrl,
				range: rangeToString({
					offset,
					count
				}),
				marker,
				maxPageSize: options?.maxPageSize,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Returns an AsyncIterableIterator for {@link PageBlobGetPageRangesDiffResponseModel}
	*
	*
	* @param offset - Starting byte position of the page ranges.
	* @param count - Number of bytes to get.
	* @param prevSnapshotOrUrl - Timestamp of snapshot to retrieve the difference or URL of snapshot to retrieve the difference.
	* @param marker - A string value that identifies the portion of
	*                          the get of page ranges to be returned with the next getting operation. The
	*                          operation returns the ContinuationToken value within the response body if the
	*                          getting operation did not return all page ranges remaining within the current page.
	*                          The ContinuationToken value can be used as the value for
	*                          the marker parameter in a subsequent call to request the next page of get
	*                          items. The marker value is opaque to the client.
	* @param options - Options to the Page Blob Get Page Ranges Diff operation.
	*/
	async *listPageRangeDiffItemSegments(offset, count, prevSnapshotOrUrl, marker, options) {
		let getPageRangeItemSegmentsResponse;
		if (!!marker || marker === void 0) do {
			getPageRangeItemSegmentsResponse = await this.listPageRangesDiffSegment(offset, count, prevSnapshotOrUrl, marker, options);
			marker = getPageRangeItemSegmentsResponse.continuationToken;
			yield await getPageRangeItemSegmentsResponse;
		} while (marker);
	}
	/**
	* Returns an AsyncIterableIterator of {@link PageRangeInfo} objects
	*
	* @param offset - Starting byte position of the page ranges.
	* @param count - Number of bytes to get.
	* @param prevSnapshotOrUrl - Timestamp of snapshot to retrieve the difference or URL of snapshot to retrieve the difference.
	* @param options - Options to the Page Blob Get Page Ranges Diff operation.
	*/
	async *listPageRangeDiffItems(offset, count, prevSnapshotOrUrl, options) {
		let marker;
		for await (const getPageRangesSegment of this.listPageRangeDiffItemSegments(offset, count, prevSnapshotOrUrl, marker, options)) yield* ExtractPageRangeInfoItems(getPageRangesSegment);
	}
	/**
	* Returns an async iterable iterator to list of page ranges that differ between a specified snapshot and this page blob.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-page-ranges
	*
	*  .byPage() returns an async iterable iterator to list of page ranges that differ between a specified snapshot and this page blob.
	*
	* ```ts snippet:ClientsListPageBlobsDiff
	* import { BlobServiceClient } from "@azure/storage-blob";
	* import { DefaultAzureCredential } from "@azure/identity";
	*
	* const account = "<account>";
	* const blobServiceClient = new BlobServiceClient(
	*   `https://${account}.blob.core.windows.net`,
	*   new DefaultAzureCredential(),
	* );
	*
	* const containerName = "<container name>";
	* const blobName = "<blob name>";
	* const containerClient = blobServiceClient.getContainerClient(containerName);
	* const pageBlobClient = containerClient.getPageBlobClient(blobName);
	*
	* const offset = 0;
	* const count = 1024;
	* const previousSnapshot = "<previous snapshot>";
	* // Example using `for await` syntax
	* let i = 1;
	* for await (const pageRange of pageBlobClient.listPageRangesDiff(offset, count, previousSnapshot)) {
	*   console.log(`Page range ${i++}: ${pageRange.start} - ${pageRange.end}`);
	* }
	*
	* // Example using `iter.next()` syntax
	* i = 1;
	* const iter = pageBlobClient.listPageRangesDiff(offset, count, previousSnapshot);
	* let { value, done } = await iter.next();
	* while (!done) {
	*   console.log(`Page range ${i++}: ${value.start} - ${value.end}`);
	*   ({ value, done } = await iter.next());
	* }
	*
	* // Example using `byPage()` syntax
	* i = 1;
	* for await (const page of pageBlobClient
	*   .listPageRangesDiff(offset, count, previousSnapshot)
	*   .byPage({ maxPageSize: 20 })) {
	*   for (const pageRange of page.pageRange || []) {
	*     console.log(`Page range ${i++}: ${pageRange.start} - ${pageRange.end}`);
	*   }
	* }
	*
	* // Example using paging with a marker
	* i = 1;
	* let iterator = pageBlobClient
	*   .listPageRangesDiff(offset, count, previousSnapshot)
	*   .byPage({ maxPageSize: 2 });
	* let response = (await iterator.next()).value;
	* // Prints 2 page ranges
	* if (response.pageRange) {
	*   for (const pageRange of response.pageRange) {
	*     console.log(`Page range ${i++}: ${pageRange.start} - ${pageRange.end}`);
	*   }
	* }
	* // Gets next marker
	* let marker = response.continuationToken;
	* // Passing next marker as continuationToken
	* iterator = pageBlobClient
	*   .listPageRangesDiff(offset, count, previousSnapshot)
	*   .byPage({ continuationToken: marker, maxPageSize: 10 });
	* response = (await iterator.next()).value;
	* // Prints 10 page ranges
	* if (response.pageRange) {
	*   for (const pageRange of response.pageRange) {
	*     console.log(`Page range ${i++}: ${pageRange.start} - ${pageRange.end}`);
	*   }
	* }
	* ```
	*
	* @param offset - Starting byte position of the page ranges.
	* @param count - Number of bytes to get.
	* @param prevSnapshot - Timestamp of snapshot to retrieve the difference.
	* @param options - Options to the Page Blob Get Ranges operation.
	* @returns An asyncIterableIterator that supports paging.
	*/
	listPageRangesDiff(offset, count, prevSnapshot, options = {}) {
		options.conditions = options.conditions || {};
		const iter = this.listPageRangeDiffItems(offset, count, prevSnapshot, { ...options });
		return {
			/**
			* The next method, part of the iteration protocol
			*/
			next() {
				return iter.next();
			},
			/**
			* The connection to the async iterator, part of the iteration protocol
			*/
			[Symbol.asyncIterator]() {
				return this;
			},
			/**
			* Return an AsyncIterableIterator that works a page at a time
			*/
			byPage: (settings = {}) => {
				return this.listPageRangeDiffItemSegments(offset, count, prevSnapshot, settings.continuationToken, {
					maxPageSize: settings.maxPageSize,
					...options
				});
			}
		};
	}
	/**
	* Gets the collection of page ranges that differ between a specified snapshot and this page blob for managed disks.
	* @see https://learn.microsoft.com/rest/api/storageservices/get-page-ranges
	*
	* @param offset - Starting byte position of the page blob
	* @param count - Number of bytes to get ranges diff.
	* @param prevSnapshotUrl - URL of snapshot to retrieve the difference.
	* @param options - Options to the Page Blob Get Page Ranges Diff operation.
	* @returns Response data for the Page Blob Get Page Range Diff operation.
	*/
	async getPageRangesDiffForManagedDisks(offset, count, prevSnapshotUrl, options = {}) {
		options.conditions = options.conditions || {};
		return tracingClient.withSpan("PageBlobClient-GetPageRangesDiffForManagedDisks", options, async (updatedOptions) => {
			return rangeResponseFromModel(assertResponse(await this.pageBlobContext.getPageRangesDiff({
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				prevSnapshotUrl,
				range: rangeToString({
					offset,
					count
				}),
				tracingOptions: updatedOptions.tracingOptions
			})));
		});
	}
	/**
	* Resizes the page blob to the specified size (which must be a multiple of 512).
	* @see https://learn.microsoft.com/rest/api/storageservices/set-blob-properties
	*
	* @param size - Target size
	* @param options - Options to the Page Blob Resize operation.
	* @returns Response data for the Page Blob Resize operation.
	*/
	async resize(size, options = {}) {
		options.conditions = options.conditions || {};
		return tracingClient.withSpan("PageBlobClient-resize", options, async (updatedOptions) => {
			return assertResponse(await this.pageBlobContext.resize(size, {
				abortSignal: options.abortSignal,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				encryptionScope: options.encryptionScope,
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Sets a page blob's sequence number.
	* @see https://learn.microsoft.com/rest/api/storageservices/set-blob-properties
	*
	* @param sequenceNumberAction - Indicates how the service should modify the blob's sequence number.
	* @param sequenceNumber - Required if sequenceNumberAction is max or update
	* @param options - Options to the Page Blob Update Sequence Number operation.
	* @returns Response data for the Page Blob Update Sequence Number operation.
	*/
	async updateSequenceNumber(sequenceNumberAction, sequenceNumber, options = {}) {
		options.conditions = options.conditions || {};
		return tracingClient.withSpan("PageBlobClient-updateSequenceNumber", options, async (updatedOptions) => {
			return assertResponse(await this.pageBlobContext.updateSequenceNumber(sequenceNumberAction, {
				abortSignal: options.abortSignal,
				blobSequenceNumber: sequenceNumber,
				leaseAccessConditions: options.conditions,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
	/**
	* Begins an operation to start an incremental copy from one page blob's snapshot to this page blob.
	* The snapshot is copied such that only the differential changes between the previously
	* copied snapshot are transferred to the destination.
	* The copied snapshots are complete copies of the original snapshot and can be read or copied from as usual.
	* @see https://learn.microsoft.com/rest/api/storageservices/incremental-copy-blob
	* @see https://learn.microsoft.com/azure/virtual-machines/windows/incremental-snapshots
	*
	* @param copySource - Specifies the name of the source page blob snapshot. For example,
	*                            https://myaccount.blob.core.windows.net/mycontainer/myblob?snapshot=<DateTime>
	* @param options - Options to the Page Blob Copy Incremental operation.
	* @returns Response data for the Page Blob Copy Incremental operation.
	*/
	async startCopyIncremental(copySource, options = {}) {
		return tracingClient.withSpan("PageBlobClient-startCopyIncremental", options, async (updatedOptions) => {
			return assertResponse(await this.pageBlobContext.copyIncremental(copySource, {
				abortSignal: options.abortSignal,
				modifiedAccessConditions: {
					...options.conditions,
					ifTags: options.conditions?.tagConditions
				},
				tracingOptions: updatedOptions.tracingOptions
			}));
		});
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/shared/errors.js
var InvalidResponseError = class extends Error {
	constructor(message) {
		super(message);
		this.name = "InvalidResponseError";
	}
};
var NetworkError = class extends Error {
	constructor(code) {
		const message = `Unable to make request: ${code}\nIf you are using self-hosted runners, please make sure your runner has access to all GitHub endpoints: https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/about-self-hosted-runners#communication-between-self-hosted-runners-and-github`;
		super(message);
		this.code = code;
		this.name = "NetworkError";
	}
};
NetworkError.isNetworkErrorCode = (code) => {
	if (!code) return false;
	return [
		"ECONNRESET",
		"ENOTFOUND",
		"ETIMEDOUT",
		"ECONNREFUSED",
		"EHOSTUNREACH"
	].includes(code);
};
var UsageError = class extends Error {
	constructor() {
		super(`Cache storage quota has been hit. Unable to upload any new cache entries.\nMore info on storage limits: https://docs.github.com/en/billing/managing-billing-for-github-actions/about-billing-for-github-actions#calculating-minute-and-storage-spending`);
		this.name = "UsageError";
	}
};
UsageError.isUsageErrorMessage = (msg) => {
	if (!msg) return false;
	return msg.includes("insufficient usage");
};
var RateLimitError = class extends Error {
	constructor(message) {
		super(message);
		this.name = "RateLimitError";
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/uploadUtils.js
var __awaiter$9 = 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());
	});
};
/**
* Class for tracking the upload state and displaying stats.
*/
var UploadProgress = class {
	constructor(contentLength) {
		this.contentLength = contentLength;
		this.sentBytes = 0;
		this.displayedComplete = false;
		this.startTime = Date.now();
	}
	/**
	* Sets the number of bytes sent
	*
	* @param sentBytes the number of bytes sent
	*/
	setSentBytes(sentBytes) {
		this.sentBytes = sentBytes;
	}
	/**
	* Returns the total number of bytes transferred.
	*/
	getTransferredBytes() {
		return this.sentBytes;
	}
	/**
	* Returns true if the upload is complete.
	*/
	isDone() {
		return this.getTransferredBytes() === this.contentLength;
	}
	/**
	* Prints the current upload stats. Once the upload completes, this will print one
	* last line and then stop.
	*/
	display() {
		if (this.displayedComplete) return;
		const transferredBytes = this.sentBytes;
		const percentage = (100 * (transferredBytes / this.contentLength)).toFixed(1);
		const elapsedTime = Date.now() - this.startTime;
		const uploadSpeed = (transferredBytes / 1048576 / (elapsedTime / 1e3)).toFixed(1);
		info(`Sent ${transferredBytes} of ${this.contentLength} (${percentage}%), ${uploadSpeed} MBs/sec`);
		if (this.isDone()) this.displayedComplete = true;
	}
	/**
	* Returns a function used to handle TransferProgressEvents.
	*/
	onProgress() {
		return (progress) => {
			this.setSentBytes(progress.loadedBytes);
		};
	}
	/**
	* Starts the timer that displays the stats.
	*
	* @param delayInMs the delay between each write
	*/
	startDisplayTimer(delayInMs = 1e3) {
		const displayCallback = () => {
			this.display();
			if (!this.isDone()) this.timeoutHandle = setTimeout(displayCallback, delayInMs);
		};
		this.timeoutHandle = setTimeout(displayCallback, delayInMs);
	}
	/**
	* Stops the timer that displays the stats. As this typically indicates the upload
	* is complete, this will display one last line, unless the last line has already
	* been written.
	*/
	stopDisplayTimer() {
		if (this.timeoutHandle) {
			clearTimeout(this.timeoutHandle);
			this.timeoutHandle = void 0;
		}
		this.display();
	}
};
/**
* Uploads a cache archive directly to Azure Blob Storage using the Azure SDK.
* This function will display progress information to the console. Concurrency of the
* upload is determined by the calling functions.
*
* @param signedUploadURL
* @param archivePath
* @param options
* @returns
*/
function uploadCacheArchiveSDK(signedUploadURL, archivePath, options) {
	return __awaiter$9(this, void 0, void 0, function* () {
		var _a;
		const blobClient = new BlobClient(signedUploadURL);
		const blockBlobClient = blobClient.getBlockBlobClient();
		const uploadProgress = new UploadProgress((_a = options === null || options === void 0 ? void 0 : options.archiveSizeBytes) !== null && _a !== void 0 ? _a : 0);
		const uploadOptions = {
			blockSize: options === null || options === void 0 ? void 0 : options.uploadChunkSize,
			concurrency: options === null || options === void 0 ? void 0 : options.uploadConcurrency,
			maxSingleShotSize: 134217728,
			onProgress: uploadProgress.onProgress()
		};
		try {
			uploadProgress.startDisplayTimer();
			debug(`BlobClient: ${blobClient.name}:${blobClient.accountName}:${blobClient.containerName}`);
			const response = yield blockBlobClient.uploadFile(archivePath, uploadOptions);
			if (response._response.status >= 400) throw new InvalidResponseError(`uploadCacheArchiveSDK: upload failed with status code ${response._response.status}`);
			return response;
		} catch (error) {
			warning(`uploadCacheArchiveSDK: internal error uploading cache archive: ${error.message}`);
			throw error;
		} finally {
			uploadProgress.stopDisplayTimer();
		}
	});
}
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/requestUtils.js
var __awaiter$8 = 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());
	});
};
function isSuccessStatusCode(statusCode) {
	if (!statusCode) return false;
	return statusCode >= 200 && statusCode < 300;
}
function isServerErrorStatusCode(statusCode) {
	if (!statusCode) return true;
	return statusCode >= 500;
}
function isRetryableStatusCode(statusCode) {
	if (!statusCode) return false;
	return [
		HttpCodes.BadGateway,
		HttpCodes.ServiceUnavailable,
		HttpCodes.GatewayTimeout
	].includes(statusCode);
}
function sleep(milliseconds) {
	return __awaiter$8(this, void 0, void 0, function* () {
		return new Promise((resolve) => setTimeout(resolve, milliseconds));
	});
}
function retry(name_1, method_1, getStatusCode_1) {
	return __awaiter$8(this, arguments, void 0, function* (name, method, getStatusCode, maxAttempts = 2, delay = DefaultRetryDelay, onError = void 0) {
		let errorMessage = "";
		let attempt = 1;
		while (attempt <= maxAttempts) {
			let response = void 0;
			let statusCode = void 0;
			let isRetryable = false;
			try {
				response = yield method();
			} catch (error) {
				if (onError) response = onError(error);
				isRetryable = true;
				errorMessage = error.message;
			}
			if (response) {
				statusCode = getStatusCode(response);
				if (!isServerErrorStatusCode(statusCode)) return response;
			}
			if (statusCode) {
				isRetryable = isRetryableStatusCode(statusCode);
				errorMessage = `Cache service responded with ${statusCode}`;
			}
			debug(`${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`);
			if (!isRetryable) {
				debug(`${name} - Error is not retryable`);
				break;
			}
			yield sleep(delay);
			attempt++;
		}
		throw Error(`${name} failed: ${errorMessage}`);
	});
}
function retryTypedResponse(name_1, method_1) {
	return __awaiter$8(this, arguments, void 0, function* (name, method, maxAttempts = 2, delay = DefaultRetryDelay) {
		return yield retry(name, method, (response) => response.statusCode, maxAttempts, delay, (error) => {
			if (error instanceof HttpClientError) return {
				statusCode: error.statusCode,
				result: null,
				headers: {},
				error
			};
			else return;
		});
	});
}
function retryHttpClientResponse(name_1, method_1) {
	return __awaiter$8(this, arguments, void 0, function* (name, method, maxAttempts = 2, delay = DefaultRetryDelay) {
		return yield retry(name, method, (response) => response.message.statusCode, maxAttempts, delay);
	});
}
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/downloadUtils.js
var __awaiter$7 = 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());
	});
};
/**
* Pipes the body of a HTTP response to a stream
*
* @param response the HTTP response
* @param output the writable stream
*/
function pipeResponseToStream(response, output) {
	return __awaiter$7(this, void 0, void 0, function* () {
		yield util$2.promisify(stream.pipeline)(response.message, output);
	});
}
/**
* Class for tracking the download state and displaying stats.
*/
var DownloadProgress = class {
	constructor(contentLength) {
		this.contentLength = contentLength;
		this.segmentIndex = 0;
		this.segmentSize = 0;
		this.segmentOffset = 0;
		this.receivedBytes = 0;
		this.displayedComplete = false;
		this.startTime = Date.now();
	}
	/**
	* Progress to the next segment. Only call this method when the previous segment
	* is complete.
	*
	* @param segmentSize the length of the next segment
	*/
	nextSegment(segmentSize) {
		this.segmentOffset = this.segmentOffset + this.segmentSize;
		this.segmentIndex = this.segmentIndex + 1;
		this.segmentSize = segmentSize;
		this.receivedBytes = 0;
		debug(`Downloading segment at offset ${this.segmentOffset} with length ${this.segmentSize}...`);
	}
	/**
	* Sets the number of bytes received for the current segment.
	*
	* @param receivedBytes the number of bytes received
	*/
	setReceivedBytes(receivedBytes) {
		this.receivedBytes = receivedBytes;
	}
	/**
	* Returns the total number of bytes transferred.
	*/
	getTransferredBytes() {
		return this.segmentOffset + this.receivedBytes;
	}
	/**
	* Returns true if the download is complete.
	*/
	isDone() {
		return this.getTransferredBytes() === this.contentLength;
	}
	/**
	* Prints the current download stats. Once the download completes, this will print one
	* last line and then stop.
	*/
	display() {
		if (this.displayedComplete) return;
		const transferredBytes = this.segmentOffset + this.receivedBytes;
		const percentage = (100 * (transferredBytes / this.contentLength)).toFixed(1);
		const elapsedTime = Date.now() - this.startTime;
		const downloadSpeed = (transferredBytes / 1048576 / (elapsedTime / 1e3)).toFixed(1);
		info(`Received ${transferredBytes} of ${this.contentLength} (${percentage}%), ${downloadSpeed} MBs/sec`);
		if (this.isDone()) this.displayedComplete = true;
	}
	/**
	* Returns a function used to handle TransferProgressEvents.
	*/
	onProgress() {
		return (progress) => {
			this.setReceivedBytes(progress.loadedBytes);
		};
	}
	/**
	* Starts the timer that displays the stats.
	*
	* @param delayInMs the delay between each write
	*/
	startDisplayTimer(delayInMs = 1e3) {
		const displayCallback = () => {
			this.display();
			if (!this.isDone()) this.timeoutHandle = setTimeout(displayCallback, delayInMs);
		};
		this.timeoutHandle = setTimeout(displayCallback, delayInMs);
	}
	/**
	* Stops the timer that displays the stats. As this typically indicates the download
	* is complete, this will display one last line, unless the last line has already
	* been written.
	*/
	stopDisplayTimer() {
		if (this.timeoutHandle) {
			clearTimeout(this.timeoutHandle);
			this.timeoutHandle = void 0;
		}
		this.display();
	}
};
/**
* Download the cache using the Actions toolkit http-client
*
* @param archiveLocation the URL for the cache
* @param archivePath the local path where the cache is saved
*/
function downloadCacheHttpClient(archiveLocation, archivePath) {
	return __awaiter$7(this, void 0, void 0, function* () {
		const writeStream = fs$1.createWriteStream(archivePath);
		const httpClient = new HttpClient("actions/cache");
		const downloadResponse = yield retryHttpClientResponse("downloadCache", () => __awaiter$7(this, void 0, void 0, function* () {
			return httpClient.get(archiveLocation);
		}));
		downloadResponse.message.socket.setTimeout(SocketTimeout, () => {
			downloadResponse.message.destroy();
			debug(`Aborting download, socket timed out after ${SocketTimeout} ms`);
		});
		yield pipeResponseToStream(downloadResponse, writeStream);
		const contentLengthHeader = downloadResponse.message.headers["content-length"];
		if (contentLengthHeader) {
			const expectedLength = parseInt(contentLengthHeader);
			const actualLength = getArchiveFileSizeInBytes(archivePath);
			if (actualLength !== expectedLength) throw new Error(`Incomplete download. Expected file size: ${expectedLength}, actual file size: ${actualLength}`);
		} else debug("Unable to validate download, no Content-Length header");
	});
}
/**
* Download the cache using the Actions toolkit http-client concurrently
*
* @param archiveLocation the URL for the cache
* @param archivePath the local path where the cache is saved
*/
function downloadCacheHttpClientConcurrent(archiveLocation, archivePath, options) {
	return __awaiter$7(this, void 0, void 0, function* () {
		var _a;
		const archiveDescriptor = yield fs$1.promises.open(archivePath, "w");
		const httpClient = new HttpClient("actions/cache", void 0, {
			socketTimeout: options.timeoutInMs,
			keepAlive: true
		});
		try {
			const lengthHeader = (yield retryHttpClientResponse("downloadCacheMetadata", () => __awaiter$7(this, void 0, void 0, function* () {
				return yield httpClient.request("HEAD", archiveLocation, null, {});
			}))).message.headers["content-length"];
			if (lengthHeader === void 0 || lengthHeader === null) throw new Error("Content-Length not found on blob response");
			const length = parseInt(lengthHeader);
			if (Number.isNaN(length)) throw new Error(`Could not interpret Content-Length: ${length}`);
			const downloads = [];
			const blockSize = 4194304;
			for (let offset = 0; offset < length; offset += blockSize) {
				const count = Math.min(blockSize, length - offset);
				downloads.push({
					offset,
					promiseGetter: () => __awaiter$7(this, void 0, void 0, function* () {
						return yield downloadSegmentRetry(httpClient, archiveLocation, offset, count);
					})
				});
			}
			downloads.reverse();
			let actives = 0;
			let bytesDownloaded = 0;
			const progress = new DownloadProgress(length);
			progress.startDisplayTimer();
			const progressFn = progress.onProgress();
			const activeDownloads = [];
			let nextDownload;
			const waitAndWrite = () => __awaiter$7(this, void 0, void 0, function* () {
				const segment = yield Promise.race(Object.values(activeDownloads));
				yield archiveDescriptor.write(segment.buffer, 0, segment.count, segment.offset);
				actives--;
				delete activeDownloads[segment.offset];
				bytesDownloaded += segment.count;
				progressFn({ loadedBytes: bytesDownloaded });
			});
			while (nextDownload = downloads.pop()) {
				activeDownloads[nextDownload.offset] = nextDownload.promiseGetter();
				actives++;
				if (actives >= ((_a = options.downloadConcurrency) !== null && _a !== void 0 ? _a : 10)) yield waitAndWrite();
			}
			while (actives > 0) yield waitAndWrite();
		} finally {
			httpClient.dispose();
			yield archiveDescriptor.close();
		}
	});
}
function downloadSegmentRetry(httpClient, archiveLocation, offset, count) {
	return __awaiter$7(this, void 0, void 0, function* () {
		const retries = 5;
		let failures = 0;
		while (true) try {
			const result = yield promiseWithTimeout(3e4, downloadSegment(httpClient, archiveLocation, offset, count));
			if (typeof result === "string") throw new Error("downloadSegmentRetry failed due to timeout");
			return result;
		} catch (err) {
			if (failures >= retries) throw err;
			failures++;
		}
	});
}
function downloadSegment(httpClient, archiveLocation, offset, count) {
	return __awaiter$7(this, void 0, void 0, function* () {
		const partRes = yield retryHttpClientResponse("downloadCachePart", () => __awaiter$7(this, void 0, void 0, function* () {
			return yield httpClient.get(archiveLocation, { Range: `bytes=${offset}-${offset + count - 1}` });
		}));
		if (!partRes.readBodyBuffer) throw new Error("Expected HttpClientResponse to implement readBodyBuffer");
		return {
			offset,
			count,
			buffer: yield partRes.readBodyBuffer()
		};
	});
}
/**
* Download the cache using the Azure Storage SDK.  Only call this method if the
* URL points to an Azure Storage endpoint.
*
* @param archiveLocation the URL for the cache
* @param archivePath the local path where the cache is saved
* @param options the download options with the defaults set
*/
function downloadCacheStorageSDK(archiveLocation, archivePath, options) {
	return __awaiter$7(this, void 0, void 0, function* () {
		var _a;
		const client = new BlockBlobClient(archiveLocation, void 0, { retryOptions: { tryTimeoutInMs: options.timeoutInMs } });
		const contentLength = (_a = (yield client.getProperties()).contentLength) !== null && _a !== void 0 ? _a : -1;
		if (contentLength < 0) {
			debug("Unable to determine content length, downloading file with http-client...");
			yield downloadCacheHttpClient(archiveLocation, archivePath);
		} else {
			const maxSegmentSize = Math.min(134217728, buffer$1.constants.MAX_LENGTH);
			const downloadProgress = new DownloadProgress(contentLength);
			const fd = fs$1.openSync(archivePath, "w");
			try {
				downloadProgress.startDisplayTimer();
				const controller = new AbortController();
				const abortSignal = controller.signal;
				while (!downloadProgress.isDone()) {
					const segmentStart = downloadProgress.segmentOffset + downloadProgress.segmentSize;
					const segmentSize = Math.min(maxSegmentSize, contentLength - segmentStart);
					downloadProgress.nextSegment(segmentSize);
					const result = yield promiseWithTimeout(options.segmentTimeoutInMs || 36e5, client.downloadToBuffer(segmentStart, segmentSize, {
						abortSignal,
						concurrency: options.downloadConcurrency,
						onProgress: downloadProgress.onProgress()
					}));
					if (result === "timeout") {
						controller.abort();
						throw new Error("Aborting cache download as the download time exceeded the timeout.");
					} else if (Buffer.isBuffer(result)) fs$1.writeFileSync(fd, result);
				}
			} finally {
				downloadProgress.stopDisplayTimer();
				fs$1.closeSync(fd);
			}
		}
	});
}
var promiseWithTimeout = (timeoutMs, promise) => __awaiter$7(void 0, void 0, void 0, function* () {
	let timeoutHandle;
	const timeoutPromise = new Promise((resolve) => {
		timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs);
	});
	return Promise.race([promise, timeoutPromise]).then((result) => {
		clearTimeout(timeoutHandle);
		return result;
	});
});
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/options.js
/**
* Returns a copy of the upload options with defaults filled in.
*
* @param copy the original upload options
*/
function getUploadOptions(copy) {
	const result = {
		useAzureSdk: false,
		uploadConcurrency: 4,
		uploadChunkSize: 33554432
	};
	if (copy) {
		if (typeof copy.useAzureSdk === "boolean") result.useAzureSdk = copy.useAzureSdk;
		if (typeof copy.uploadConcurrency === "number") result.uploadConcurrency = copy.uploadConcurrency;
		if (typeof copy.uploadChunkSize === "number") result.uploadChunkSize = copy.uploadChunkSize;
	}
	/**
	* Add env var overrides
	*/
	result.uploadConcurrency = !isNaN(Number(process.env["CACHE_UPLOAD_CONCURRENCY"])) ? Math.min(32, Number(process.env["CACHE_UPLOAD_CONCURRENCY"])) : result.uploadConcurrency;
	result.uploadChunkSize = !isNaN(Number(process.env["CACHE_UPLOAD_CHUNK_SIZE"])) ? Math.min(134217728, Number(process.env["CACHE_UPLOAD_CHUNK_SIZE"]) * 1024 * 1024) : result.uploadChunkSize;
	debug(`Use Azure SDK: ${result.useAzureSdk}`);
	debug(`Upload concurrency: ${result.uploadConcurrency}`);
	debug(`Upload chunk size: ${result.uploadChunkSize}`);
	return result;
}
/**
* Returns a copy of the download options with defaults filled in.
*
* @param copy the original download options
*/
function getDownloadOptions(copy) {
	const result = {
		useAzureSdk: false,
		concurrentBlobDownloads: true,
		downloadConcurrency: 8,
		timeoutInMs: 3e4,
		segmentTimeoutInMs: 6e5,
		lookupOnly: false
	};
	if (copy) {
		if (typeof copy.useAzureSdk === "boolean") result.useAzureSdk = copy.useAzureSdk;
		if (typeof copy.concurrentBlobDownloads === "boolean") result.concurrentBlobDownloads = copy.concurrentBlobDownloads;
		if (typeof copy.downloadConcurrency === "number") result.downloadConcurrency = copy.downloadConcurrency;
		if (typeof copy.timeoutInMs === "number") result.timeoutInMs = copy.timeoutInMs;
		if (typeof copy.segmentTimeoutInMs === "number") result.segmentTimeoutInMs = copy.segmentTimeoutInMs;
		if (typeof copy.lookupOnly === "boolean") result.lookupOnly = copy.lookupOnly;
	}
	const segmentDownloadTimeoutMins = process.env["SEGMENT_DOWNLOAD_TIMEOUT_MINS"];
	if (segmentDownloadTimeoutMins && !isNaN(Number(segmentDownloadTimeoutMins)) && isFinite(Number(segmentDownloadTimeoutMins))) result.segmentTimeoutInMs = Number(segmentDownloadTimeoutMins) * 60 * 1e3;
	debug(`Use Azure SDK: ${result.useAzureSdk}`);
	debug(`Download concurrency: ${result.downloadConcurrency}`);
	debug(`Request timeout (ms): ${result.timeoutInMs}`);
	debug(`Cache segment download timeout mins env var: ${process.env["SEGMENT_DOWNLOAD_TIMEOUT_MINS"]}`);
	debug(`Segment download timeout (ms): ${result.segmentTimeoutInMs}`);
	debug(`Lookup only: ${result.lookupOnly}`);
	return result;
}
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/config.js
function isGhes() {
	const hostname = new URL(process.env["GITHUB_SERVER_URL"] || "https://github.com").hostname.trimEnd().toUpperCase();
	const isGitHubHost = hostname === "GITHUB.COM";
	const isGheHost = hostname.endsWith(".GHE.COM");
	const isLocalHost = hostname.endsWith(".LOCALHOST");
	return !isGitHubHost && !isGheHost && !isLocalHost;
}
function getCacheServiceVersion() {
	if (isGhes()) return "v1";
	return process.env["ACTIONS_CACHE_SERVICE_V2"] ? "v2" : "v1";
}
var KNOWN_CACHE_MODES = [
	"none",
	"read",
	"write",
	"write-only"
];
function getCacheMode() {
	return (process.env["ACTIONS_CACHE_MODE"] || "").trim().toLowerCase();
}
function isCacheReadable(mode) {
	if (!KNOWN_CACHE_MODES.includes(mode)) return true;
	return mode === "read" || mode === "write";
}
function isCacheWritable(mode) {
	if (!KNOWN_CACHE_MODES.includes(mode)) return true;
	return mode === "write" || mode === "write-only";
}
function getCacheServiceURL() {
	const version = getCacheServiceVersion();
	switch (version) {
		case "v1": return process.env["ACTIONS_CACHE_URL"] || process.env["ACTIONS_RESULTS_URL"] || "";
		case "v2": return process.env["ACTIONS_RESULTS_URL"] || "";
		default: throw new Error(`Unsupported cache service version: ${version}`);
	}
}
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/package.json
var package_exports = /* @__PURE__ */ __exportAll({
	bugs: () => bugs,
	default: () => package_default,
	dependencies: () => dependencies,
	description: () => description,
	devDependencies: () => devDependencies,
	directories: () => directories,
	exports: () => exports$1,
	files: () => files,
	homepage: () => homepage,
	keywords: () => keywords,
	license: () => "MIT",
	main: () => main$1,
	name: () => name,
	overrides: () => overrides,
	publishConfig: () => publishConfig,
	repository: () => repository,
	scripts: () => scripts,
	type: () => type,
	types: () => types,
	version: () => version$1
}), name, version$1, description, keywords, homepage, type, main$1, types, exports$1, directories, files, publishConfig, repository, scripts, bugs, dependencies, devDependencies, overrides, package_default;
var init_package = __esmMin((() => {
	name = "@actions/cache";
	version$1 = "6.2.0";
	description = "Actions cache lib";
	keywords = [
		"github",
		"actions",
		"cache"
	];
	homepage = "https://github.com/actions/toolkit/tree/main/packages/cache";
	type = "module";
	main$1 = "lib/cache.js";
	types = "lib/cache.d.ts";
	exports$1 = { ".": {
		"types": "./lib/cache.d.ts",
		"import": "./lib/cache.js"
	} };
	directories = {
		"lib": "lib",
		"test": "__tests__"
	};
	files = ["lib", "!.DS_Store"];
	publishConfig = { "access": "public" };
	repository = {
		"type": "git",
		"url": "git+https://github.com/actions/toolkit.git",
		"directory": "packages/cache"
	};
	scripts = {
		"audit-moderate": "npm install && npm audit --json --audit-level=moderate > audit.json",
		"test": "echo \"Error: run tests from root\" && exit 1",
		"tsc": "tsc && cp src/internal/shared/package-version.cjs lib/internal/shared/"
	};
	bugs = { "url": "https://github.com/actions/toolkit/issues" };
	dependencies = {
		"@actions/core": "^3.0.1",
		"@actions/exec": "^3.0.0",
		"@actions/glob": "^0.6.1",
		"@actions/http-client": "^4.0.1",
		"@actions/io": "^3.0.2",
		"@azure/core-rest-pipeline": "^1.23.0",
		"@azure/storage-blob": "^12.31.0",
		"@protobuf-ts/runtime-rpc": "^2.11.1",
		"semver": "^7.7.4"
	};
	devDependencies = {
		"@protobuf-ts/plugin": "^2.11.1",
		"@types/node": "^25.6.0",
		"@types/semver": "^7.7.1",
		"typescript": "^5.9.3"
	};
	overrides = {
		"uri-js": "npm:uri-js-replace@^1.0.1",
		"node-fetch": "^3.3.2"
	};
	package_default = {
		name,
		version: version$1,
		description,
		keywords,
		homepage,
		license: "MIT",
		type,
		main: main$1,
		types,
		exports: exports$1,
		directories,
		files,
		publishConfig,
		repository,
		scripts,
		bugs,
		dependencies,
		devDependencies,
		overrides
	};
}));
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/shared/user-agent.js
var import_package_version = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = { version: (init_package(), __toCommonJS(package_exports).default).version };
})))();
/**
* Ensure that this User Agent String is used in all HTTP calls so that we can monitor telemetry between different versions of this package
*/
function getUserAgentString() {
	return `@actions/cache-${import_package_version.version}`;
}
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/cacheHttpClient.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());
	});
};
function getCacheApiUrl(resource) {
	const baseUrl = getCacheServiceURL();
	if (!baseUrl) throw new Error("Cache Service Url not found, unable to restore cache.");
	const url = `${baseUrl}_apis/artifactcache/${resource}`;
	debug(`Resource Url: ${url}`);
	return url;
}
function createAcceptHeader(type, apiVersion) {
	return `${type};api-version=${apiVersion}`;
}
function getRequestOptions() {
	return { headers: { Accept: createAcceptHeader("application/json", "6.0-preview.1") } };
}
function createHttpClient() {
	const bearerCredentialHandler = new BearerCredentialHandler(process.env["ACTIONS_RUNTIME_TOKEN"] || "");
	return new HttpClient(getUserAgentString(), [bearerCredentialHandler], getRequestOptions());
}
function getCacheEntry(keys, paths, options) {
	return __awaiter$6(this, void 0, void 0, function* () {
		var _a;
		const httpClient = createHttpClient();
		const version = getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive);
		const resource = `cache?keys=${encodeURIComponent(keys.join(","))}&version=${version}`;
		const response = yield retryTypedResponse("getCacheEntry", () => __awaiter$6(this, void 0, void 0, function* () {
			return httpClient.getJson(getCacheApiUrl(resource));
		}));
		if (response.statusCode === 204) {
			if (isDebug()) yield printCachesListForDiagnostics(keys[0], httpClient, version);
			return null;
		}
		if (!isSuccessStatusCode(response.statusCode)) {
			const errorMessage = (_a = response.error) === null || _a === void 0 ? void 0 : _a.message;
			if (errorMessage === null || errorMessage === void 0 ? void 0 : errorMessage.includes("cache read denied:")) throw new Error(errorMessage);
			throw new Error(`Cache service responded with ${response.statusCode}`);
		}
		const cacheResult = response.result;
		const cacheDownloadUrl = cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.archiveLocation;
		if (!cacheDownloadUrl) throw new Error("Cache not found.");
		setSecret(cacheDownloadUrl);
		debug(`Cache Result:`);
		debug(JSON.stringify(cacheResult));
		return cacheResult;
	});
}
function printCachesListForDiagnostics(key, httpClient, version) {
	return __awaiter$6(this, void 0, void 0, function* () {
		const resource = `caches?key=${encodeURIComponent(key)}`;
		const response = yield retryTypedResponse("listCache", () => __awaiter$6(this, void 0, void 0, function* () {
			return httpClient.getJson(getCacheApiUrl(resource));
		}));
		if (response.statusCode === 200) {
			const cacheListResult = response.result;
			const totalCount = cacheListResult === null || cacheListResult === void 0 ? void 0 : cacheListResult.totalCount;
			if (totalCount && totalCount > 0) {
				debug(`No matching cache found for cache key '${key}', version '${version} and scope ${process.env["GITHUB_REF"]}. There exist one or more cache(s) with similar key but they have different version or scope. See more info on cache matching here: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#matching-a-cache-key \nOther caches with similar key:`);
				for (const cacheEntry of (cacheListResult === null || cacheListResult === void 0 ? void 0 : cacheListResult.artifactCaches) || []) debug(`Cache Key: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.cacheKey}, Cache Version: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.cacheVersion}, Cache Scope: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.scope}, Cache Created: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.creationTime}`);
			}
		}
	});
}
function downloadCache(archiveLocation, archivePath, options) {
	return __awaiter$6(this, void 0, void 0, function* () {
		const archiveUrl = new URL$1(archiveLocation);
		const downloadOptions = getDownloadOptions(options);
		if (archiveUrl.hostname.endsWith(".blob.core.windows.net")) {
			if (downloadOptions.useAzureSdk) yield downloadCacheStorageSDK(archiveLocation, archivePath, downloadOptions);
			else if (downloadOptions.concurrentBlobDownloads) yield downloadCacheHttpClientConcurrent(archiveLocation, archivePath, downloadOptions);
			else yield downloadCacheHttpClient(archiveLocation, archivePath);
		} else yield downloadCacheHttpClient(archiveLocation, archivePath);
	});
}
function reserveCache(key, paths, options) {
	return __awaiter$6(this, void 0, void 0, function* () {
		const httpClient = createHttpClient();
		const reserveCacheRequest = {
			key,
			version: getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive),
			cacheSize: options === null || options === void 0 ? void 0 : options.cacheSize
		};
		return yield retryTypedResponse("reserveCache", () => __awaiter$6(this, void 0, void 0, function* () {
			return httpClient.postJson(getCacheApiUrl("caches"), reserveCacheRequest);
		}));
	});
}
function getContentRange(start, end) {
	return `bytes ${start}-${end}/*`;
}
function uploadChunk(httpClient, resourceUrl, openStream, start, end) {
	return __awaiter$6(this, void 0, void 0, function* () {
		debug(`Uploading chunk of size ${end - start + 1} bytes at offset ${start} with content range: ${getContentRange(start, end)}`);
		const additionalHeaders = {
			"Content-Type": "application/octet-stream",
			"Content-Range": getContentRange(start, end)
		};
		const uploadChunkResponse = yield retryHttpClientResponse(`uploadChunk (start: ${start}, end: ${end})`, () => __awaiter$6(this, void 0, void 0, function* () {
			return httpClient.sendStream("PATCH", resourceUrl, openStream(), additionalHeaders);
		}));
		if (!isSuccessStatusCode(uploadChunkResponse.message.statusCode)) throw new Error(`Cache service responded with ${uploadChunkResponse.message.statusCode} during upload chunk.`);
	});
}
function uploadFile(httpClient, cacheId, archivePath, options) {
	return __awaiter$6(this, void 0, void 0, function* () {
		const fileSize = getArchiveFileSizeInBytes(archivePath);
		const resourceUrl = getCacheApiUrl(`caches/${cacheId.toString()}`);
		const fd = fs$1.openSync(archivePath, "r");
		const uploadOptions = getUploadOptions(options);
		const concurrency = assertDefined("uploadConcurrency", uploadOptions.uploadConcurrency);
		const maxChunkSize = assertDefined("uploadChunkSize", uploadOptions.uploadChunkSize);
		const parallelUploads = [...new Array(concurrency).keys()];
		debug("Awaiting all uploads");
		let offset = 0;
		try {
			yield Promise.all(parallelUploads.map(() => __awaiter$6(this, void 0, void 0, function* () {
				while (offset < fileSize) {
					const chunkSize = Math.min(fileSize - offset, maxChunkSize);
					const start = offset;
					const end = offset + chunkSize - 1;
					offset += maxChunkSize;
					yield uploadChunk(httpClient, resourceUrl, () => fs$1.createReadStream(archivePath, {
						fd,
						start,
						end,
						autoClose: false
					}).on("error", (error) => {
						throw new Error(`Cache upload failed because file read failed with ${error.message}`);
					}), start, end);
				}
			})));
		} finally {
			fs$1.closeSync(fd);
		}
	});
}
function commitCache(httpClient, cacheId, filesize) {
	return __awaiter$6(this, void 0, void 0, function* () {
		const commitCacheRequest = { size: filesize };
		return yield retryTypedResponse("commitCache", () => __awaiter$6(this, void 0, void 0, function* () {
			return httpClient.postJson(getCacheApiUrl(`caches/${cacheId.toString()}`), commitCacheRequest);
		}));
	});
}
function saveCache$1(cacheId, archivePath, signedUploadURL, options) {
	return __awaiter$6(this, void 0, void 0, function* () {
		if (getUploadOptions(options).useAzureSdk) {
			if (!signedUploadURL) throw new Error("Azure Storage SDK can only be used when a signed URL is provided.");
			yield uploadCacheArchiveSDK(signedUploadURL, archivePath, options);
		} else {
			const httpClient = createHttpClient();
			debug("Upload cache");
			yield uploadFile(httpClient, cacheId, archivePath, options);
			debug("Commiting cache");
			const cacheSize = getArchiveFileSizeInBytes(archivePath);
			info(`Cache Size: ~${Math.round(cacheSize / 1048576)} MB (${cacheSize} B)`);
			const commitCacheResponse = yield commitCache(httpClient, cacheId, cacheSize);
			if (!isSuccessStatusCode(commitCacheResponse.statusCode)) throw new Error(`Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`);
			info("Cache saved successfully");
		}
	});
}
__name(saveCache$1, "saveCache");
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/json-typings.js
/**
* Get the type of a JSON value.
* Distinguishes between array, null and object.
*/
function typeofJsonValue(value) {
	let t = typeof value;
	if (t == "object") {
		if (Array.isArray(value)) return "array";
		if (value === null) return "null";
	}
	return t;
}
/**
* Is this a JSON object (instead of an array or null)?
*/
function isJsonObject(value) {
	return value !== null && typeof value == "object" && !Array.isArray(value);
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/base64.js
var encTable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
var decTable = [];
for (let i = 0; i < encTable.length; i++) decTable[encTable[i].charCodeAt(0)] = i;
decTable["-".charCodeAt(0)] = encTable.indexOf("+");
decTable["_".charCodeAt(0)] = encTable.indexOf("/");
/**
* Decodes a base64 string to a byte array.
*
* - ignores white-space, including line breaks and tabs
* - allows inner padding (can decode concatenated base64 strings)
* - does not require padding
* - understands base64url encoding:
*   "-" instead of "+",
*   "_" instead of "/",
*   no padding
*/
function base64decode(base64Str) {
	let es = base64Str.length * 3 / 4;
	if (base64Str[base64Str.length - 2] == "=") es -= 2;
	else if (base64Str[base64Str.length - 1] == "=") es -= 1;
	let bytes = new Uint8Array(es);
	let bytePos = 0;
	let groupPos = 0;
	let b;
	let p = 0;
	for (let i = 0; i < base64Str.length; i++) {
		b = decTable[base64Str.charCodeAt(i)];
		if (b === void 0) switch (base64Str[i]) {
			case "=": groupPos = 0;
			case "\n":
			case "\r":
			case "	":
			case " ": continue;
			default: throw Error(`invalid base64 string.`);
		}
		switch (groupPos) {
			case 0:
				p = b;
				groupPos = 1;
				break;
			case 1:
				bytes[bytePos++] = p << 2 | (b & 48) >> 4;
				p = b;
				groupPos = 2;
				break;
			case 2:
				bytes[bytePos++] = (p & 15) << 4 | (b & 60) >> 2;
				p = b;
				groupPos = 3;
				break;
			case 3:
				bytes[bytePos++] = (p & 3) << 6 | b;
				groupPos = 0;
		}
	}
	if (groupPos == 1) throw Error(`invalid base64 string.`);
	return bytes.subarray(0, bytePos);
}
/**
* Encodes a byte array to a base64 string.
* Adds padding at the end.
* Does not insert newlines.
*/
function base64encode(bytes) {
	let base64 = "";
	let groupPos = 0;
	let b;
	let p = 0;
	for (let i = 0; i < bytes.length; i++) {
		b = bytes[i];
		switch (groupPos) {
			case 0:
				base64 += encTable[b >> 2];
				p = (b & 3) << 4;
				groupPos = 1;
				break;
			case 1:
				base64 += encTable[p | b >> 4];
				p = (b & 15) << 2;
				groupPos = 2;
				break;
			case 2:
				base64 += encTable[p | b >> 6];
				base64 += encTable[b & 63];
				groupPos = 0;
		}
	}
	if (groupPos) {
		base64 += encTable[p];
		base64 += "=";
		if (groupPos == 1) base64 += "=";
	}
	return base64;
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/binary-format-contract.js
/**
* This handler implements the default behaviour for unknown fields.
* When reading data, unknown fields are stored on the message, in a
* symbol property.
* When writing data, the symbol property is queried and unknown fields
* are serialized into the output again.
*/
var UnknownFieldHandler;
(function(UnknownFieldHandler) {
	/**
	* The symbol used to store unknown fields for a message.
	* The property must conform to `UnknownFieldContainer`.
	*/
	UnknownFieldHandler.symbol = Symbol.for("protobuf-ts/unknown");
	/**
	* Store an unknown field during binary read directly on the message.
	* This method is compatible with `BinaryReadOptions.readUnknownField`.
	*/
	UnknownFieldHandler.onRead = (typeName, message, fieldNo, wireType, data) => {
		(is(message) ? message[UnknownFieldHandler.symbol] : message[UnknownFieldHandler.symbol] = []).push({
			no: fieldNo,
			wireType,
			data
		});
	};
	/**
	* Write unknown fields stored for the message to the writer.
	* This method is compatible with `BinaryWriteOptions.writeUnknownFields`.
	*/
	UnknownFieldHandler.onWrite = (typeName, message, writer) => {
		for (let { no, wireType, data } of UnknownFieldHandler.list(message)) writer.tag(no, wireType).raw(data);
	};
	/**
	* List unknown fields stored for the message.
	* Note that there may be multiples fields with the same number.
	*/
	UnknownFieldHandler.list = (message, fieldNo) => {
		if (is(message)) {
			let all = message[UnknownFieldHandler.symbol];
			return fieldNo ? all.filter((uf) => uf.no == fieldNo) : all;
		}
		return [];
	};
	/**
	* Returns the last unknown field by field number.
	*/
	UnknownFieldHandler.last = (message, fieldNo) => UnknownFieldHandler.list(message, fieldNo).slice(-1)[0];
	const is = (message) => message && Array.isArray(message[UnknownFieldHandler.symbol]);
})(UnknownFieldHandler || (UnknownFieldHandler = {}));
/**
* Protobuf binary format wire types.
*
* A wire type provides just enough information to find the length of the
* following value.
*
* See https://developers.google.com/protocol-buffers/docs/encoding#structure
*/
var WireType;
(function(WireType) {
	/**
	* Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
	*/
	WireType[WireType["Varint"] = 0] = "Varint";
	/**
	* Used for fixed64, sfixed64, double.
	* Always 8 bytes with little-endian byte order.
	*/
	WireType[WireType["Bit64"] = 1] = "Bit64";
	/**
	* Used for string, bytes, embedded messages, packed repeated fields
	*
	* Only repeated numeric types (types which use the varint, 32-bit,
	* or 64-bit wire types) can be packed. In proto3, such fields are
	* packed by default.
	*/
	WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited";
	/**
	* Used for groups
	* @deprecated
	*/
	WireType[WireType["StartGroup"] = 3] = "StartGroup";
	/**
	* Used for groups
	* @deprecated
	*/
	WireType[WireType["EndGroup"] = 4] = "EndGroup";
	/**
	* Used for fixed32, sfixed32, float.
	* Always 4 bytes with little-endian byte order.
	*/
	WireType[WireType["Bit32"] = 5] = "Bit32";
})(WireType || (WireType = {}));
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/goog-varint.js
/**
* Read a 64 bit varint as two JS numbers.
*
* Returns tuple:
* [0]: low bits
* [0]: high bits
*
* Copyright 2008 Google Inc.  All rights reserved.
*
* See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
*/
function varint64read() {
	let lowBits = 0;
	let highBits = 0;
	for (let shift = 0; shift < 28; shift += 7) {
		let b = this.buf[this.pos++];
		lowBits |= (b & 127) << shift;
		if ((b & 128) == 0) {
			this.assertBounds();
			return [lowBits, highBits];
		}
	}
	let middleByte = this.buf[this.pos++];
	lowBits |= (middleByte & 15) << 28;
	highBits = (middleByte & 112) >> 4;
	if ((middleByte & 128) == 0) {
		this.assertBounds();
		return [lowBits, highBits];
	}
	for (let shift = 3; shift <= 31; shift += 7) {
		let b = this.buf[this.pos++];
		highBits |= (b & 127) << shift;
		if ((b & 128) == 0) {
			this.assertBounds();
			return [lowBits, highBits];
		}
	}
	throw new Error("invalid varint");
}
/**
* Write a 64 bit varint, given as two JS numbers, to the given bytes array.
*
* Copyright 2008 Google Inc.  All rights reserved.
*
* See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
*/
function varint64write(lo, hi, bytes) {
	for (let i = 0; i < 28; i = i + 7) {
		const shift = lo >>> i;
		const hasNext = !(shift >>> 7 == 0 && hi == 0);
		const byte = (hasNext ? shift | 128 : shift) & 255;
		bytes.push(byte);
		if (!hasNext) return;
	}
	const splitBits = lo >>> 28 & 15 | (hi & 7) << 4;
	const hasMoreBits = !(hi >> 3 == 0);
	bytes.push((hasMoreBits ? splitBits | 128 : splitBits) & 255);
	if (!hasMoreBits) return;
	for (let i = 3; i < 31; i = i + 7) {
		const shift = hi >>> i;
		const hasNext = !(shift >>> 7 == 0);
		const byte = (hasNext ? shift | 128 : shift) & 255;
		bytes.push(byte);
		if (!hasNext) return;
	}
	bytes.push(hi >>> 31 & 1);
}
var TWO_PWR_32_DBL$1 = 4294967296;
/**
* Parse decimal string of 64 bit integer value as two JS numbers.
*
* Returns tuple:
* [0]: minus sign?
* [1]: low bits
* [2]: high bits
*
* Copyright 2008 Google Inc.
*/
function int64fromString(dec) {
	let minus = dec[0] == "-";
	if (minus) dec = dec.slice(1);
	const base = 1e6;
	let lowBits = 0;
	let highBits = 0;
	function add1e6digit(begin, end) {
		const digit1e6 = Number(dec.slice(begin, end));
		highBits *= base;
		lowBits = lowBits * base + digit1e6;
		if (lowBits >= TWO_PWR_32_DBL$1) {
			highBits = highBits + (lowBits / TWO_PWR_32_DBL$1 | 0);
			lowBits = lowBits % TWO_PWR_32_DBL$1;
		}
	}
	add1e6digit(-24, -18);
	add1e6digit(-18, -12);
	add1e6digit(-12, -6);
	add1e6digit(-6);
	return [
		minus,
		lowBits,
		highBits
	];
}
/**
* Format 64 bit integer value (as two JS numbers) to decimal string.
*
* Copyright 2008 Google Inc.
*/
function int64toString(bitsLow, bitsHigh) {
	if (bitsHigh >>> 0 <= 2097151) return "" + (TWO_PWR_32_DBL$1 * bitsHigh + (bitsLow >>> 0));
	let low = bitsLow & 16777215;
	let mid = (bitsLow >>> 24 | bitsHigh << 8) >>> 0 & 16777215;
	let high = bitsHigh >> 16 & 65535;
	let digitA = low + mid * 6777216 + high * 6710656;
	let digitB = mid + high * 8147497;
	let digitC = high * 2;
	let base = 1e7;
	if (digitA >= base) {
		digitB += Math.floor(digitA / base);
		digitA %= base;
	}
	if (digitB >= base) {
		digitC += Math.floor(digitB / base);
		digitB %= base;
	}
	function decimalFrom1e7(digit1e7, needLeadingZeros) {
		let partial = digit1e7 ? String(digit1e7) : "";
		if (needLeadingZeros) return "0000000".slice(partial.length) + partial;
		return partial;
	}
	return decimalFrom1e7(digitC, 0) + decimalFrom1e7(digitB, digitC) + decimalFrom1e7(digitA, 1);
}
/**
* Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
*
* Copyright 2008 Google Inc.  All rights reserved.
*
* See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
*/
function varint32write(value, bytes) {
	if (value >= 0) {
		while (value > 127) {
			bytes.push(value & 127 | 128);
			value = value >>> 7;
		}
		bytes.push(value);
	} else {
		for (let i = 0; i < 9; i++) {
			bytes.push(value & 127 | 128);
			value = value >> 7;
		}
		bytes.push(1);
	}
}
/**
* Read an unsigned 32 bit varint.
*
* See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
*/
function varint32read() {
	let b = this.buf[this.pos++];
	let result = b & 127;
	if ((b & 128) == 0) {
		this.assertBounds();
		return result;
	}
	b = this.buf[this.pos++];
	result |= (b & 127) << 7;
	if ((b & 128) == 0) {
		this.assertBounds();
		return result;
	}
	b = this.buf[this.pos++];
	result |= (b & 127) << 14;
	if ((b & 128) == 0) {
		this.assertBounds();
		return result;
	}
	b = this.buf[this.pos++];
	result |= (b & 127) << 21;
	if ((b & 128) == 0) {
		this.assertBounds();
		return result;
	}
	b = this.buf[this.pos++];
	result |= (b & 15) << 28;
	for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++) b = this.buf[this.pos++];
	if ((b & 128) != 0) throw new Error("invalid varint");
	this.assertBounds();
	return result >>> 0;
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/pb-long.js
var BI;
function detectBi() {
	const dv = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
	BI = globalThis.BigInt !== void 0 && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function" ? {
		MIN: BigInt("-9223372036854775808"),
		MAX: BigInt("9223372036854775807"),
		UMIN: BigInt("0"),
		UMAX: BigInt("18446744073709551615"),
		C: BigInt,
		V: dv
	} : void 0;
}
detectBi();
function assertBi(bi) {
	if (!bi) throw new Error("BigInt unavailable, see https://github.com/timostamm/protobuf-ts/blob/v1.0.8/MANUAL.md#bigint-support");
}
var RE_DECIMAL_STR = /^-?[0-9]+$/;
var TWO_PWR_32_DBL = 4294967296;
var HALF_2_PWR_32 = 2147483648;
var SharedPbLong = class {
	/**
	* Create a new instance with the given bits.
	*/
	constructor(lo, hi) {
		this.lo = lo | 0;
		this.hi = hi | 0;
	}
	/**
	* Is this instance equal to 0?
	*/
	isZero() {
		return this.lo == 0 && this.hi == 0;
	}
	/**
	* Convert to a native number.
	*/
	toNumber() {
		let result = this.hi * TWO_PWR_32_DBL + (this.lo >>> 0);
		if (!Number.isSafeInteger(result)) throw new Error("cannot convert to safe number");
		return result;
	}
};
/**
* 64-bit unsigned integer as two 32-bit values.
* Converts between `string`, `number` and `bigint` representations.
*/
var PbULong = class PbULong extends SharedPbLong {
	/**
	* Create instance from a `string`, `number` or `bigint`.
	*/
	static from(value) {
		if (BI) switch (typeof value) {
			case "string":
				if (value == "0") return this.ZERO;
				if (value == "") throw new Error("string is no integer");
				value = BI.C(value);
			case "number":
				if (value === 0) return this.ZERO;
				value = BI.C(value);
			case "bigint":
				if (!value) return this.ZERO;
				if (value < BI.UMIN) throw new Error("signed value for ulong");
				if (value > BI.UMAX) throw new Error("ulong too large");
				BI.V.setBigUint64(0, value, true);
				return new PbULong(BI.V.getInt32(0, true), BI.V.getInt32(4, true));
		}
		else switch (typeof value) {
			case "string":
				if (value == "0") return this.ZERO;
				value = value.trim();
				if (!RE_DECIMAL_STR.test(value)) throw new Error("string is no integer");
				let [minus, lo, hi] = int64fromString(value);
				if (minus) throw new Error("signed value for ulong");
				return new PbULong(lo, hi);
			case "number":
				if (value == 0) return this.ZERO;
				if (!Number.isSafeInteger(value)) throw new Error("number is no integer");
				if (value < 0) throw new Error("signed value for ulong");
				return new PbULong(value, value / TWO_PWR_32_DBL);
		}
		throw new Error("unknown value " + typeof value);
	}
	/**
	* Convert to decimal string.
	*/
	toString() {
		return BI ? this.toBigInt().toString() : int64toString(this.lo, this.hi);
	}
	/**
	* Convert to native bigint.
	*/
	toBigInt() {
		assertBi(BI);
		BI.V.setInt32(0, this.lo, true);
		BI.V.setInt32(4, this.hi, true);
		return BI.V.getBigUint64(0, true);
	}
};
/**
* ulong 0 singleton.
*/
PbULong.ZERO = new PbULong(0, 0);
/**
* 64-bit signed integer as two 32-bit values.
* Converts between `string`, `number` and `bigint` representations.
*/
var PbLong = class PbLong extends SharedPbLong {
	/**
	* Create instance from a `string`, `number` or `bigint`.
	*/
	static from(value) {
		if (BI) switch (typeof value) {
			case "string":
				if (value == "0") return this.ZERO;
				if (value == "") throw new Error("string is no integer");
				value = BI.C(value);
			case "number":
				if (value === 0) return this.ZERO;
				value = BI.C(value);
			case "bigint":
				if (!value) return this.ZERO;
				if (value < BI.MIN) throw new Error("signed long too small");
				if (value > BI.MAX) throw new Error("signed long too large");
				BI.V.setBigInt64(0, value, true);
				return new PbLong(BI.V.getInt32(0, true), BI.V.getInt32(4, true));
		}
		else switch (typeof value) {
			case "string":
				if (value == "0") return this.ZERO;
				value = value.trim();
				if (!RE_DECIMAL_STR.test(value)) throw new Error("string is no integer");
				let [minus, lo, hi] = int64fromString(value);
				if (minus) {
					if (hi > HALF_2_PWR_32 || hi == HALF_2_PWR_32 && lo != 0) throw new Error("signed long too small");
				} else if (hi >= HALF_2_PWR_32) throw new Error("signed long too large");
				let pbl = new PbLong(lo, hi);
				return minus ? pbl.negate() : pbl;
			case "number":
				if (value == 0) return this.ZERO;
				if (!Number.isSafeInteger(value)) throw new Error("number is no integer");
				return value > 0 ? new PbLong(value, value / TWO_PWR_32_DBL) : new PbLong(-value, -value / TWO_PWR_32_DBL).negate();
		}
		throw new Error("unknown value " + typeof value);
	}
	/**
	* Do we have a minus sign?
	*/
	isNegative() {
		return (this.hi & HALF_2_PWR_32) !== 0;
	}
	/**
	* Negate two's complement.
	* Invert all the bits and add one to the result.
	*/
	negate() {
		let hi = ~this.hi;
		let lo = this.lo;
		if (lo) lo = ~lo + 1;
		else hi += 1;
		return new PbLong(lo, hi);
	}
	/**
	* Convert to decimal string.
	*/
	toString() {
		if (BI) return this.toBigInt().toString();
		if (this.isNegative()) {
			let n = this.negate();
			return "-" + int64toString(n.lo, n.hi);
		}
		return int64toString(this.lo, this.hi);
	}
	/**
	* Convert to native bigint.
	*/
	toBigInt() {
		assertBi(BI);
		BI.V.setInt32(0, this.lo, true);
		BI.V.setInt32(4, this.hi, true);
		return BI.V.getBigInt64(0, true);
	}
};
/**
* long 0 singleton.
*/
PbLong.ZERO = new PbLong(0, 0);
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/binary-reader.js
var defaultsRead$1 = {
	readUnknownField: true,
	readerFactory: (bytes) => new BinaryReader(bytes)
};
/**
* Make options for reading binary data form partial options.
*/
function binaryReadOptions(options) {
	return options ? Object.assign(Object.assign({}, defaultsRead$1), options) : defaultsRead$1;
}
var BinaryReader = class {
	constructor(buf, textDecoder) {
		this.varint64 = varint64read;
		/**
		* Read a `uint32` field, an unsigned 32 bit varint.
		*/
		this.uint32 = varint32read;
		this.buf = buf;
		this.len = buf.length;
		this.pos = 0;
		this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
		this.textDecoder = textDecoder !== null && textDecoder !== void 0 ? textDecoder : new TextDecoder("utf-8", {
			fatal: true,
			ignoreBOM: true
		});
	}
	/**
	* Reads a tag - field number and wire type.
	*/
	tag() {
		let tag = this.uint32();
		let fieldNo = tag >>> 3;
		let wireType = tag & 7;
		if (fieldNo <= 0 || wireType < 0 || wireType > 5) throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
		return [fieldNo, wireType];
	}
	/**
	* Skip one element on the wire and return the skipped data.
	* Supports WireType.StartGroup since v2.0.0-alpha.23.
	*/
	skip(wireType) {
		let start = this.pos;
		switch (wireType) {
			case WireType.Varint:
				while (this.buf[this.pos++] & 128);
				break;
			case WireType.Bit64: this.pos += 4;
			case WireType.Bit32:
				this.pos += 4;
				break;
			case WireType.LengthDelimited:
				let len = this.uint32();
				this.pos += len;
				break;
			case WireType.StartGroup:
				let t;
				while ((t = this.tag()[1]) !== WireType.EndGroup) this.skip(t);
				break;
			default: throw new Error("cant skip wire type " + wireType);
		}
		this.assertBounds();
		return this.buf.subarray(start, this.pos);
	}
	/**
	* Throws error if position in byte array is out of range.
	*/
	assertBounds() {
		if (this.pos > this.len) throw new RangeError("premature EOF");
	}
	/**
	* Read a `int32` field, a signed 32 bit varint.
	*/
	int32() {
		return this.uint32() | 0;
	}
	/**
	* Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
	*/
	sint32() {
		let zze = this.uint32();
		return zze >>> 1 ^ -(zze & 1);
	}
	/**
	* Read a `int64` field, a signed 64-bit varint.
	*/
	int64() {
		return new PbLong(...this.varint64());
	}
	/**
	* Read a `uint64` field, an unsigned 64-bit varint.
	*/
	uint64() {
		return new PbULong(...this.varint64());
	}
	/**
	* Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
	*/
	sint64() {
		let [lo, hi] = this.varint64();
		let s = -(lo & 1);
		lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
		hi = hi >>> 1 ^ s;
		return new PbLong(lo, hi);
	}
	/**
	* Read a `bool` field, a variant.
	*/
	bool() {
		let [lo, hi] = this.varint64();
		return lo !== 0 || hi !== 0;
	}
	/**
	* Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
	*/
	fixed32() {
		return this.view.getUint32((this.pos += 4) - 4, true);
	}
	/**
	* Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
	*/
	sfixed32() {
		return this.view.getInt32((this.pos += 4) - 4, true);
	}
	/**
	* Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
	*/
	fixed64() {
		return new PbULong(this.sfixed32(), this.sfixed32());
	}
	/**
	* Read a `fixed64` field, a signed, fixed-length 64-bit integer.
	*/
	sfixed64() {
		return new PbLong(this.sfixed32(), this.sfixed32());
	}
	/**
	* Read a `float` field, 32-bit floating point number.
	*/
	float() {
		return this.view.getFloat32((this.pos += 4) - 4, true);
	}
	/**
	* Read a `double` field, a 64-bit floating point number.
	*/
	double() {
		return this.view.getFloat64((this.pos += 8) - 8, true);
	}
	/**
	* Read a `bytes` field, length-delimited arbitrary data.
	*/
	bytes() {
		let len = this.uint32();
		let start = this.pos;
		this.pos += len;
		this.assertBounds();
		return this.buf.subarray(start, start + len);
	}
	/**
	* Read a `string` field, length-delimited data converted to UTF-8 text.
	*/
	string() {
		return this.textDecoder.decode(this.bytes());
	}
};
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/assert.js
/**
* assert that condition is true or throw error (with message)
*/
function assert$1(condition, msg) {
	if (!condition) throw new Error(msg);
}
__name(assert$1, "assert");
var FLOAT32_MAX = 34028234663852886e22;
var FLOAT32_MIN = -34028234663852886e22;
var UINT32_MAX = 4294967295;
var INT32_MAX = 2147483647;
var INT32_MIN = -2147483648;
function assertInt32(arg) {
	if (typeof arg !== "number") throw new Error("invalid int 32: " + typeof arg);
	if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN) throw new Error("invalid int 32: " + arg);
}
function assertUInt32(arg) {
	if (typeof arg !== "number") throw new Error("invalid uint 32: " + typeof arg);
	if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0) throw new Error("invalid uint 32: " + arg);
}
function assertFloat32(arg) {
	if (typeof arg !== "number") throw new Error("invalid float 32: " + typeof arg);
	if (!Number.isFinite(arg)) return;
	if (arg > FLOAT32_MAX || arg < FLOAT32_MIN) throw new Error("invalid float 32: " + arg);
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/binary-writer.js
var defaultsWrite$1 = {
	writeUnknownFields: true,
	writerFactory: () => new BinaryWriter()
};
/**
* Make options for writing binary data form partial options.
*/
function binaryWriteOptions(options) {
	return options ? Object.assign(Object.assign({}, defaultsWrite$1), options) : defaultsWrite$1;
}
var BinaryWriter = class {
	constructor(textEncoder) {
		/**
		* Previous fork states.
		*/
		this.stack = [];
		this.textEncoder = textEncoder !== null && textEncoder !== void 0 ? textEncoder : new TextEncoder();
		this.chunks = [];
		this.buf = [];
	}
	/**
	* Return all bytes written and reset this writer.
	*/
	finish() {
		this.chunks.push(new Uint8Array(this.buf));
		let len = 0;
		for (let i = 0; i < this.chunks.length; i++) len += this.chunks[i].length;
		let bytes = new Uint8Array(len);
		let offset = 0;
		for (let i = 0; i < this.chunks.length; i++) {
			bytes.set(this.chunks[i], offset);
			offset += this.chunks[i].length;
		}
		this.chunks = [];
		return bytes;
	}
	/**
	* Start a new fork for length-delimited data like a message
	* or a packed repeated field.
	*
	* Must be joined later with `join()`.
	*/
	fork() {
		this.stack.push({
			chunks: this.chunks,
			buf: this.buf
		});
		this.chunks = [];
		this.buf = [];
		return this;
	}
	/**
	* Join the last fork. Write its length and bytes, then
	* return to the previous state.
	*/
	join() {
		let chunk = this.finish();
		let prev = this.stack.pop();
		if (!prev) throw new Error("invalid state, fork stack empty");
		this.chunks = prev.chunks;
		this.buf = prev.buf;
		this.uint32(chunk.byteLength);
		return this.raw(chunk);
	}
	/**
	* Writes a tag (field number and wire type).
	*
	* Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
	*
	* Generated code should compute the tag ahead of time and call `uint32()`.
	*/
	tag(fieldNo, type) {
		return this.uint32((fieldNo << 3 | type) >>> 0);
	}
	/**
	* Write a chunk of raw bytes.
	*/
	raw(chunk) {
		if (this.buf.length) {
			this.chunks.push(new Uint8Array(this.buf));
			this.buf = [];
		}
		this.chunks.push(chunk);
		return this;
	}
	/**
	* Write a `uint32` value, an unsigned 32 bit varint.
	*/
	uint32(value) {
		assertUInt32(value);
		while (value > 127) {
			this.buf.push(value & 127 | 128);
			value = value >>> 7;
		}
		this.buf.push(value);
		return this;
	}
	/**
	* Write a `int32` value, a signed 32 bit varint.
	*/
	int32(value) {
		assertInt32(value);
		varint32write(value, this.buf);
		return this;
	}
	/**
	* Write a `bool` value, a variant.
	*/
	bool(value) {
		this.buf.push(value ? 1 : 0);
		return this;
	}
	/**
	* Write a `bytes` value, length-delimited arbitrary data.
	*/
	bytes(value) {
		this.uint32(value.byteLength);
		return this.raw(value);
	}
	/**
	* Write a `string` value, length-delimited data converted to UTF-8 text.
	*/
	string(value) {
		let chunk = this.textEncoder.encode(value);
		this.uint32(chunk.byteLength);
		return this.raw(chunk);
	}
	/**
	* Write a `float` value, 32-bit floating point number.
	*/
	float(value) {
		assertFloat32(value);
		let chunk = /* @__PURE__ */ new Uint8Array(4);
		new DataView(chunk.buffer).setFloat32(0, value, true);
		return this.raw(chunk);
	}
	/**
	* Write a `double` value, a 64-bit floating point number.
	*/
	double(value) {
		let chunk = /* @__PURE__ */ new Uint8Array(8);
		new DataView(chunk.buffer).setFloat64(0, value, true);
		return this.raw(chunk);
	}
	/**
	* Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
	*/
	fixed32(value) {
		assertUInt32(value);
		let chunk = /* @__PURE__ */ new Uint8Array(4);
		new DataView(chunk.buffer).setUint32(0, value, true);
		return this.raw(chunk);
	}
	/**
	* Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
	*/
	sfixed32(value) {
		assertInt32(value);
		let chunk = /* @__PURE__ */ new Uint8Array(4);
		new DataView(chunk.buffer).setInt32(0, value, true);
		return this.raw(chunk);
	}
	/**
	* Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
	*/
	sint32(value) {
		assertInt32(value);
		value = (value << 1 ^ value >> 31) >>> 0;
		varint32write(value, this.buf);
		return this;
	}
	/**
	* Write a `fixed64` value, a signed, fixed-length 64-bit integer.
	*/
	sfixed64(value) {
		let chunk = /* @__PURE__ */ new Uint8Array(8);
		let view = new DataView(chunk.buffer);
		let long = PbLong.from(value);
		view.setInt32(0, long.lo, true);
		view.setInt32(4, long.hi, true);
		return this.raw(chunk);
	}
	/**
	* Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
	*/
	fixed64(value) {
		let chunk = /* @__PURE__ */ new Uint8Array(8);
		let view = new DataView(chunk.buffer);
		let long = PbULong.from(value);
		view.setInt32(0, long.lo, true);
		view.setInt32(4, long.hi, true);
		return this.raw(chunk);
	}
	/**
	* Write a `int64` value, a signed 64-bit varint.
	*/
	int64(value) {
		let long = PbLong.from(value);
		varint64write(long.lo, long.hi, this.buf);
		return this;
	}
	/**
	* Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
	*/
	sint64(value) {
		let long = PbLong.from(value);
		let sign = long.hi >> 31;
		varint64write(long.lo << 1 ^ sign, (long.hi << 1 | long.lo >>> 31) ^ sign, this.buf);
		return this;
	}
	/**
	* Write a `uint64` value, an unsigned 64-bit varint.
	*/
	uint64(value) {
		let long = PbULong.from(value);
		varint64write(long.lo, long.hi, this.buf);
		return this;
	}
};
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/json-format-contract.js
var defaultsWrite = {
	emitDefaultValues: false,
	enumAsInteger: false,
	useProtoFieldName: false,
	prettySpaces: 0
};
var defaultsRead = { ignoreUnknownFields: false };
/**
* Make options for reading JSON data from partial options.
*/
function jsonReadOptions(options) {
	return options ? Object.assign(Object.assign({}, defaultsRead), options) : defaultsRead;
}
/**
* Make options for writing JSON data from partial options.
*/
function jsonWriteOptions(options) {
	return options ? Object.assign(Object.assign({}, defaultsWrite), options) : defaultsWrite;
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/message-type-contract.js
/**
* The symbol used as a key on message objects to store the message type.
*
* Note that this is an experimental feature - it is here to stay, but
* implementation details may change without notice.
*/
var MESSAGE_TYPE = Symbol.for("protobuf-ts/message-type");
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/lower-camel-case.js
/**
* Converts snake_case to lowerCamelCase.
*
* Should behave like protoc:
* https://github.com/protocolbuffers/protobuf/blob/e8ae137c96444ea313485ed1118c5e43b2099cf1/src/google/protobuf/compiler/java/java_helpers.cc#L118
*/
function lowerCamelCase(snakeCase) {
	let capNext = false;
	const sb = [];
	for (let i = 0; i < snakeCase.length; i++) {
		let next = snakeCase.charAt(i);
		if (next == "_") capNext = true;
		else if (/\d/.test(next)) {
			sb.push(next);
			capNext = true;
		} else if (capNext) {
			sb.push(next.toUpperCase());
			capNext = false;
		} else if (i == 0) sb.push(next.toLowerCase());
		else sb.push(next);
	}
	return sb.join("");
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-info.js
/**
* Scalar value types. This is a subset of field types declared by protobuf
* enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
* are omitted, but the numerical values are identical.
*/
var ScalarType;
(function(ScalarType) {
	ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE";
	ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT";
	ScalarType[ScalarType["INT64"] = 3] = "INT64";
	ScalarType[ScalarType["UINT64"] = 4] = "UINT64";
	ScalarType[ScalarType["INT32"] = 5] = "INT32";
	ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64";
	ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32";
	ScalarType[ScalarType["BOOL"] = 8] = "BOOL";
	ScalarType[ScalarType["STRING"] = 9] = "STRING";
	ScalarType[ScalarType["BYTES"] = 12] = "BYTES";
	ScalarType[ScalarType["UINT32"] = 13] = "UINT32";
	ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32";
	ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64";
	ScalarType[ScalarType["SINT32"] = 17] = "SINT32";
	ScalarType[ScalarType["SINT64"] = 18] = "SINT64";
})(ScalarType || (ScalarType = {}));
/**
* JavaScript representation of 64 bit integral types. Equivalent to the
* field option "jstype".
*
* By default, protobuf-ts represents 64 bit types as `bigint`.
*
* You can change the default behaviour by enabling the plugin parameter
* `long_type_string`, which will represent 64 bit types as `string`.
*
* Alternatively, you can change the behaviour for individual fields
* with the field option "jstype":
*
* ```protobuf
* uint64 my_field = 1 [jstype = JS_STRING];
* uint64 other_field = 2 [jstype = JS_NUMBER];
* ```
*/
var LongType;
(function(LongType) {
	/**
	* Use JavaScript `bigint`.
	*
	* Field option `[jstype = JS_NORMAL]`.
	*/
	LongType[LongType["BIGINT"] = 0] = "BIGINT";
	/**
	* Use JavaScript `string`.
	*
	* Field option `[jstype = JS_STRING]`.
	*/
	LongType[LongType["STRING"] = 1] = "STRING";
	/**
	* Use JavaScript `number`.
	*
	* Large values will loose precision.
	*
	* Field option `[jstype = JS_NUMBER]`.
	*/
	LongType[LongType["NUMBER"] = 2] = "NUMBER";
})(LongType || (LongType = {}));
/**
* Protobuf 2.1.0 introduced packed repeated fields.
* Setting the field option `[packed = true]` enables packing.
*
* In proto3, all repeated fields are packed by default.
* Setting the field option `[packed = false]` disables packing.
*
* Packed repeated fields are encoded with a single tag,
* then a length-delimiter, then the element values.
*
* Unpacked repeated fields are encoded with a tag and
* value for each element.
*
* `bytes` and `string` cannot be packed.
*/
var RepeatType;
(function(RepeatType) {
	/**
	* The field is not repeated.
	*/
	RepeatType[RepeatType["NO"] = 0] = "NO";
	/**
	* The field is repeated and should be packed.
	* Invalid for `bytes` and `string`, they cannot be packed.
	*/
	RepeatType[RepeatType["PACKED"] = 1] = "PACKED";
	/**
	* The field is repeated but should not be packed.
	* The only valid repeat type for repeated `bytes` and `string`.
	*/
	RepeatType[RepeatType["UNPACKED"] = 2] = "UNPACKED";
})(RepeatType || (RepeatType = {}));
/**
* Turns PartialFieldInfo into FieldInfo.
*/
function normalizeFieldInfo(field) {
	var _a;
	var _b;
	var _c;
	var _d;
	field.localName = (_a = field.localName) !== null && _a !== void 0 ? _a : lowerCamelCase(field.name);
	field.jsonName = (_b = field.jsonName) !== null && _b !== void 0 ? _b : lowerCamelCase(field.name);
	field.repeat = (_c = field.repeat) !== null && _c !== void 0 ? _c : RepeatType.NO;
	field.opt = (_d = field.opt) !== null && _d !== void 0 ? _d : field.repeat ? false : field.oneof ? false : field.kind == "message";
	return field;
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/oneof.js
/**
* Is the given value a valid oneof group?
*
* We represent protobuf `oneof` as algebraic data types (ADT) in generated
* code. But when working with messages of unknown type, the ADT does not
* help us.
*
* This type guard checks if the given object adheres to the ADT rules, which
* are as follows:
*
* 1) Must be an object.
*
* 2) Must have a "oneofKind" discriminator property.
*
* 3) If "oneofKind" is `undefined`, no member field is selected. The object
* must not have any other properties.
*
* 4) If "oneofKind" is a `string`, the member field with this name is
* selected.
*
* 5) If a member field is selected, the object must have a second property
* with this name. The property must not be `undefined`.
*
* 6) No extra properties are allowed. The object has either one property
* (no selection) or two properties (selection).
*
*/
function isOneofGroup(any) {
	if (typeof any != "object" || any === null || !any.hasOwnProperty("oneofKind")) return false;
	switch (typeof any.oneofKind) {
		case "string":
			if (any[any.oneofKind] === void 0) return false;
			return Object.keys(any).length == 2;
		case "undefined": return Object.keys(any).length == 1;
		default: return false;
	}
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-type-check.js
var ReflectionTypeCheck = class {
	constructor(info) {
		var _a;
		this.fields = (_a = info.fields) !== null && _a !== void 0 ? _a : [];
	}
	prepare() {
		if (this.data) return;
		const req = [];
		const known = [];
		const oneofs = [];
		for (let field of this.fields) if (field.oneof) {
			if (!oneofs.includes(field.oneof)) {
				oneofs.push(field.oneof);
				req.push(field.oneof);
				known.push(field.oneof);
			}
		} else {
			known.push(field.localName);
			switch (field.kind) {
				case "scalar":
				case "enum":
					if (!field.opt || field.repeat) req.push(field.localName);
					break;
				case "message":
					if (field.repeat) req.push(field.localName);
					break;
				case "map": req.push(field.localName);
			}
		}
		this.data = {
			req,
			known,
			oneofs: Object.values(oneofs)
		};
	}
	/**
	* Is the argument a valid message as specified by the
	* reflection information?
	*
	* Checks all field types recursively. The `depth`
	* specifies how deep into the structure the check will be.
	*
	* With a depth of 0, only the presence of fields
	* is checked.
	*
	* With a depth of 1 or more, the field types are checked.
	*
	* With a depth of 2 or more, the members of map, repeated
	* and message fields are checked.
	*
	* Message fields will be checked recursively with depth - 1.
	*
	* The number of map entries / repeated values being checked
	* is < depth.
	*/
	is(message, depth, allowExcessProperties = false) {
		if (depth < 0) return true;
		if (message === null || message === void 0 || typeof message != "object") return false;
		this.prepare();
		let keys = Object.keys(message);
		let data = this.data;
		if (keys.length < data.req.length || data.req.some((n) => !keys.includes(n))) return false;
		if (!allowExcessProperties) {
			if (keys.some((k) => !data.known.includes(k))) return false;
		}
		if (depth < 1) return true;
		for (const name of data.oneofs) {
			const group = message[name];
			if (!isOneofGroup(group)) return false;
			if (group.oneofKind === void 0) continue;
			const field = this.fields.find((f) => f.localName === group.oneofKind);
			if (!field) return false;
			if (!this.field(group[group.oneofKind], field, allowExcessProperties, depth)) return false;
		}
		for (const field of this.fields) {
			if (field.oneof !== void 0) continue;
			if (!this.field(message[field.localName], field, allowExcessProperties, depth)) return false;
		}
		return true;
	}
	field(arg, field, allowExcessProperties, depth) {
		let repeated = field.repeat;
		switch (field.kind) {
			case "scalar":
				if (arg === void 0) return field.opt;
				if (repeated) return this.scalars(arg, field.T, depth, field.L);
				return this.scalar(arg, field.T, field.L);
			case "enum":
				if (arg === void 0) return field.opt;
				if (repeated) return this.scalars(arg, ScalarType.INT32, depth);
				return this.scalar(arg, ScalarType.INT32);
			case "message":
				if (arg === void 0) return true;
				if (repeated) return this.messages(arg, field.T(), allowExcessProperties, depth);
				return this.message(arg, field.T(), allowExcessProperties, depth);
			case "map":
				if (typeof arg != "object" || arg === null) return false;
				if (depth < 2) return true;
				if (!this.mapKeys(arg, field.K, depth)) return false;
				switch (field.V.kind) {
					case "scalar": return this.scalars(Object.values(arg), field.V.T, depth, field.V.L);
					case "enum": return this.scalars(Object.values(arg), ScalarType.INT32, depth);
					case "message": return this.messages(Object.values(arg), field.V.T(), allowExcessProperties, depth);
				}
		}
		return true;
	}
	message(arg, type, allowExcessProperties, depth) {
		if (allowExcessProperties) return type.isAssignable(arg, depth);
		return type.is(arg, depth);
	}
	messages(arg, type, allowExcessProperties, depth) {
		if (!Array.isArray(arg)) return false;
		if (depth < 2) return true;
		if (allowExcessProperties) {
			for (let i = 0; i < arg.length && i < depth; i++) if (!type.isAssignable(arg[i], depth - 1)) return false;
		} else for (let i = 0; i < arg.length && i < depth; i++) if (!type.is(arg[i], depth - 1)) return false;
		return true;
	}
	scalar(arg, type, longType) {
		let argType = typeof arg;
		switch (type) {
			case ScalarType.UINT64:
			case ScalarType.FIXED64:
			case ScalarType.INT64:
			case ScalarType.SFIXED64:
			case ScalarType.SINT64: switch (longType) {
				case LongType.BIGINT: return argType == "bigint";
				case LongType.NUMBER: return argType == "number" && !isNaN(arg);
				default: return argType == "string";
			}
			case ScalarType.BOOL: return argType == "boolean";
			case ScalarType.STRING: return argType == "string";
			case ScalarType.BYTES: return arg instanceof Uint8Array;
			case ScalarType.DOUBLE:
			case ScalarType.FLOAT: return argType == "number" && !isNaN(arg);
			default: return argType == "number" && Number.isInteger(arg);
		}
	}
	scalars(arg, type, depth, longType) {
		if (!Array.isArray(arg)) return false;
		if (depth < 2) return true;
		if (Array.isArray(arg)) {
			for (let i = 0; i < arg.length && i < depth; i++) if (!this.scalar(arg[i], type, longType)) return false;
		}
		return true;
	}
	mapKeys(map, type, depth) {
		let keys = Object.keys(map);
		switch (type) {
			case ScalarType.INT32:
			case ScalarType.FIXED32:
			case ScalarType.SFIXED32:
			case ScalarType.SINT32:
			case ScalarType.UINT32: return this.scalars(keys.slice(0, depth).map((k) => parseInt(k)), type, depth);
			case ScalarType.BOOL: return this.scalars(keys.slice(0, depth).map((k) => k == "true" ? true : k == "false" ? false : k), type, depth);
			default: return this.scalars(keys, type, depth, LongType.STRING);
		}
	}
};
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-long-convert.js
/**
* Utility method to convert a PbLong or PbUlong to a JavaScript
* representation during runtime.
*
* Works with generated field information, `undefined` is equivalent
* to `STRING`.
*/
function reflectionLongConvert(long, type) {
	switch (type) {
		case LongType.BIGINT: return long.toBigInt();
		case LongType.NUMBER: return long.toNumber();
		default: return long.toString();
	}
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-json-reader.js
/**
* Reads proto3 messages in canonical JSON format using reflection information.
*
* https://developers.google.com/protocol-buffers/docs/proto3#json
*/
var ReflectionJsonReader = class {
	constructor(info) {
		this.info = info;
	}
	prepare() {
		var _a;
		if (this.fMap === void 0) {
			this.fMap = {};
			const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : [];
			for (const field of fieldsInput) {
				this.fMap[field.name] = field;
				this.fMap[field.jsonName] = field;
				this.fMap[field.localName] = field;
			}
		}
	}
	assert(condition, fieldName, jsonValue) {
		if (!condition) {
			let what = typeofJsonValue(jsonValue);
			if (what == "number" || what == "boolean") what = jsonValue.toString();
			throw new Error(`Cannot parse JSON ${what} for ${this.info.typeName}#${fieldName}`);
		}
	}
	/**
	* Reads a message from canonical JSON format into the target message.
	*
	* Repeated fields are appended. Map entries are added, overwriting
	* existing keys.
	*
	* If a message field is already present, it will be merged with the
	* new data.
	*/
	read(input, message, options) {
		this.prepare();
		const oneofsHandled = [];
		for (const [jsonKey, jsonValue] of Object.entries(input)) {
			const field = this.fMap[jsonKey];
			if (!field) {
				if (!options.ignoreUnknownFields) throw new Error(`Found unknown field while reading ${this.info.typeName} from JSON format. JSON key: ${jsonKey}`);
				continue;
			}
			const localName = field.localName;
			let target;
			if (field.oneof) {
				if (jsonValue === null && (field.kind !== "enum" || field.T()[0] !== "google.protobuf.NullValue")) continue;
				if (oneofsHandled.includes(field.oneof)) throw new Error(`Multiple members of the oneof group "${field.oneof}" of ${this.info.typeName} are present in JSON.`);
				oneofsHandled.push(field.oneof);
				target = message[field.oneof] = { oneofKind: localName };
			} else target = message;
			if (field.kind == "map") {
				if (jsonValue === null) continue;
				this.assert(isJsonObject(jsonValue), field.name, jsonValue);
				const fieldObj = target[localName];
				for (const [jsonObjKey, jsonObjValue] of Object.entries(jsonValue)) {
					this.assert(jsonObjValue !== null, field.name + " map value", null);
					let val;
					switch (field.V.kind) {
						case "message":
							val = field.V.T().internalJsonRead(jsonObjValue, options);
							break;
						case "enum":
							val = this.enum(field.V.T(), jsonObjValue, field.name, options.ignoreUnknownFields);
							if (val === false) continue;
							break;
						case "scalar": val = this.scalar(jsonObjValue, field.V.T, field.V.L, field.name);
					}
					this.assert(val !== void 0, field.name + " map value", jsonObjValue);
					let key = jsonObjKey;
					if (field.K == ScalarType.BOOL) key = key == "true" ? true : key == "false" ? false : key;
					key = this.scalar(key, field.K, LongType.STRING, field.name).toString();
					fieldObj[key] = val;
				}
			} else if (field.repeat) {
				if (jsonValue === null) continue;
				this.assert(Array.isArray(jsonValue), field.name, jsonValue);
				const fieldArr = target[localName];
				for (const jsonItem of jsonValue) {
					this.assert(jsonItem !== null, field.name, null);
					let val;
					switch (field.kind) {
						case "message":
							val = field.T().internalJsonRead(jsonItem, options);
							break;
						case "enum":
							val = this.enum(field.T(), jsonItem, field.name, options.ignoreUnknownFields);
							if (val === false) continue;
							break;
						case "scalar": val = this.scalar(jsonItem, field.T, field.L, field.name);
					}
					this.assert(val !== void 0, field.name, jsonValue);
					fieldArr.push(val);
				}
			} else switch (field.kind) {
				case "message":
					if (jsonValue === null && field.T().typeName != "google.protobuf.Value") {
						this.assert(field.oneof === void 0, field.name + " (oneof member)", null);
						continue;
					}
					target[localName] = field.T().internalJsonRead(jsonValue, options, target[localName]);
					break;
				case "enum":
					if (jsonValue === null) continue;
					let val = this.enum(field.T(), jsonValue, field.name, options.ignoreUnknownFields);
					if (val === false) continue;
					target[localName] = val;
					break;
				case "scalar":
					if (jsonValue === null) continue;
					target[localName] = this.scalar(jsonValue, field.T, field.L, field.name);
			}
		}
	}
	/**
	* Returns `false` for unrecognized string representations.
	*
	* google.protobuf.NullValue accepts only JSON `null` (or the old `"NULL_VALUE"`).
	*/
	enum(type, json, fieldName, ignoreUnknownFields) {
		if (type[0] == "google.protobuf.NullValue") assert$1(json === null || json === "NULL_VALUE", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} only accepts null.`);
		if (json === null) return 0;
		switch (typeof json) {
			case "number":
				assert$1(Number.isInteger(json), `Unable to parse field ${this.info.typeName}#${fieldName}, enum can only be integral number, got ${json}.`);
				return json;
			case "string":
				let localEnumName = json;
				if (type[2] && json.substring(0, type[2].length) === type[2]) localEnumName = json.substring(type[2].length);
				let enumNumber = type[1][localEnumName];
				if (typeof enumNumber === "undefined" && ignoreUnknownFields) return false;
				assert$1(typeof enumNumber == "number", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} has no value for "${json}".`);
				return enumNumber;
		}
		assert$1(false, `Unable to parse field ${this.info.typeName}#${fieldName}, cannot parse enum value from ${typeof json}".`);
	}
	scalar(json, type, longType, fieldName) {
		let e;
		try {
			switch (type) {
				case ScalarType.DOUBLE:
				case ScalarType.FLOAT:
					if (json === null) return 0;
					if (json === "NaN") return NaN;
					if (json === "Infinity") return Number.POSITIVE_INFINITY;
					if (json === "-Infinity") return Number.NEGATIVE_INFINITY;
					if (json === "") {
						e = "empty string";
						break;
					}
					if (typeof json == "string" && json.trim().length !== json.length) {
						e = "extra whitespace";
						break;
					}
					if (typeof json != "string" && typeof json != "number") break;
					let float = Number(json);
					if (Number.isNaN(float)) {
						e = "not a number";
						break;
					}
					if (!Number.isFinite(float)) {
						e = "too large or small";
						break;
					}
					if (type == ScalarType.FLOAT) assertFloat32(float);
					return float;
				case ScalarType.INT32:
				case ScalarType.FIXED32:
				case ScalarType.SFIXED32:
				case ScalarType.SINT32:
				case ScalarType.UINT32:
					if (json === null) return 0;
					let int32;
					if (typeof json == "number") int32 = json;
					else if (json === "") e = "empty string";
					else if (typeof json == "string") {
						if (json.trim().length !== json.length) e = "extra whitespace";
						else int32 = Number(json);
					}
					if (int32 === void 0) break;
					if (type == ScalarType.UINT32) assertUInt32(int32);
					else assertInt32(int32);
					return int32;
				case ScalarType.INT64:
				case ScalarType.SFIXED64:
				case ScalarType.SINT64:
					if (json === null) return reflectionLongConvert(PbLong.ZERO, longType);
					if (typeof json != "number" && typeof json != "string") break;
					return reflectionLongConvert(PbLong.from(json), longType);
				case ScalarType.FIXED64:
				case ScalarType.UINT64:
					if (json === null) return reflectionLongConvert(PbULong.ZERO, longType);
					if (typeof json != "number" && typeof json != "string") break;
					return reflectionLongConvert(PbULong.from(json), longType);
				case ScalarType.BOOL:
					if (json === null) return false;
					if (typeof json !== "boolean") break;
					return json;
				case ScalarType.STRING:
					if (json === null) return "";
					if (typeof json !== "string") {
						e = "extra whitespace";
						break;
					}
					return json;
				case ScalarType.BYTES:
					if (json === null || json === "") return /* @__PURE__ */ new Uint8Array(0);
					if (typeof json !== "string") break;
					return base64decode(json);
			}
		} catch (error) {
			e = error.message;
		}
		this.assert(false, fieldName + (e ? " - " + e : ""), json);
	}
};
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-json-writer.js
/**
* Writes proto3 messages in canonical JSON format using reflection
* information.
*
* https://developers.google.com/protocol-buffers/docs/proto3#json
*/
var ReflectionJsonWriter = class {
	constructor(info) {
		var _a;
		this.fields = (_a = info.fields) !== null && _a !== void 0 ? _a : [];
	}
	/**
	* Converts the message to a JSON object, based on the field descriptors.
	*/
	write(message, options) {
		const json = {};
		const source = message;
		for (const field of this.fields) {
			if (!field.oneof) {
				let jsonValue = this.field(field, source[field.localName], options);
				if (jsonValue !== void 0) json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue;
				continue;
			}
			const group = source[field.oneof];
			if (group.oneofKind !== field.localName) continue;
			const opt = field.kind == "scalar" || field.kind == "enum" ? Object.assign(Object.assign({}, options), { emitDefaultValues: true }) : options;
			let jsonValue = this.field(field, group[field.localName], opt);
			assert$1(jsonValue !== void 0);
			json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue;
		}
		return json;
	}
	field(field, value, options) {
		let jsonValue = void 0;
		if (field.kind == "map") {
			assert$1(typeof value == "object" && value !== null);
			const jsonObj = {};
			switch (field.V.kind) {
				case "scalar":
					for (const [entryKey, entryValue] of Object.entries(value)) {
						const val = this.scalar(field.V.T, entryValue, field.name, false, true);
						assert$1(val !== void 0);
						jsonObj[entryKey.toString()] = val;
					}
					break;
				case "message":
					const messageType = field.V.T();
					for (const [entryKey, entryValue] of Object.entries(value)) {
						const val = this.message(messageType, entryValue, field.name, options);
						assert$1(val !== void 0);
						jsonObj[entryKey.toString()] = val;
					}
					break;
				case "enum":
					const enumInfo = field.V.T();
					for (const [entryKey, entryValue] of Object.entries(value)) {
						assert$1(entryValue === void 0 || typeof entryValue == "number");
						const val = this.enum(enumInfo, entryValue, field.name, false, true, options.enumAsInteger);
						assert$1(val !== void 0);
						jsonObj[entryKey.toString()] = val;
					}
			}
			if (options.emitDefaultValues || Object.keys(jsonObj).length > 0) jsonValue = jsonObj;
		} else if (field.repeat) {
			assert$1(Array.isArray(value));
			const jsonArr = [];
			switch (field.kind) {
				case "scalar":
					for (let i = 0; i < value.length; i++) {
						const val = this.scalar(field.T, value[i], field.name, field.opt, true);
						assert$1(val !== void 0);
						jsonArr.push(val);
					}
					break;
				case "enum":
					const enumInfo = field.T();
					for (let i = 0; i < value.length; i++) {
						assert$1(value[i] === void 0 || typeof value[i] == "number");
						const val = this.enum(enumInfo, value[i], field.name, field.opt, true, options.enumAsInteger);
						assert$1(val !== void 0);
						jsonArr.push(val);
					}
					break;
				case "message":
					const messageType = field.T();
					for (let i = 0; i < value.length; i++) {
						const val = this.message(messageType, value[i], field.name, options);
						assert$1(val !== void 0);
						jsonArr.push(val);
					}
			}
			if (options.emitDefaultValues || jsonArr.length > 0 || options.emitDefaultValues) jsonValue = jsonArr;
		} else switch (field.kind) {
			case "scalar":
				jsonValue = this.scalar(field.T, value, field.name, field.opt, options.emitDefaultValues);
				break;
			case "enum":
				jsonValue = this.enum(field.T(), value, field.name, field.opt, options.emitDefaultValues, options.enumAsInteger);
				break;
			case "message": jsonValue = this.message(field.T(), value, field.name, options);
		}
		return jsonValue;
	}
	/**
	* Returns `null` as the default for google.protobuf.NullValue.
	*/
	enum(type, value, fieldName, optional, emitDefaultValues, enumAsInteger) {
		if (type[0] == "google.protobuf.NullValue") return !emitDefaultValues && !optional ? void 0 : null;
		if (value === void 0) {
			assert$1(optional);
			return;
		}
		if (value === 0 && !emitDefaultValues && !optional) return void 0;
		assert$1(typeof value == "number");
		assert$1(Number.isInteger(value));
		if (enumAsInteger || !type[1].hasOwnProperty(value)) return value;
		if (type[2]) return type[2] + type[1][value];
		return type[1][value];
	}
	message(type, value, fieldName, options) {
		if (value === void 0) return options.emitDefaultValues ? null : void 0;
		return type.internalJsonWrite(value, options);
	}
	scalar(type, value, fieldName, optional, emitDefaultValues) {
		if (value === void 0) {
			assert$1(optional);
			return;
		}
		const ed = emitDefaultValues || optional;
		switch (type) {
			case ScalarType.INT32:
			case ScalarType.SFIXED32:
			case ScalarType.SINT32:
				if (value === 0) return ed ? 0 : void 0;
				assertInt32(value);
				return value;
			case ScalarType.FIXED32:
			case ScalarType.UINT32:
				if (value === 0) return ed ? 0 : void 0;
				assertUInt32(value);
				return value;
			case ScalarType.FLOAT: assertFloat32(value);
			case ScalarType.DOUBLE:
				if (value === 0) return ed ? 0 : void 0;
				assert$1(typeof value == "number");
				if (Number.isNaN(value)) return "NaN";
				if (value === Number.POSITIVE_INFINITY) return "Infinity";
				if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
				return value;
			case ScalarType.STRING:
				if (value === "") return ed ? "" : void 0;
				assert$1(typeof value == "string");
				return value;
			case ScalarType.BOOL:
				if (value === false) return ed ? false : void 0;
				assert$1(typeof value == "boolean");
				return value;
			case ScalarType.UINT64:
			case ScalarType.FIXED64:
				assert$1(typeof value == "number" || typeof value == "string" || typeof value == "bigint");
				let ulong = PbULong.from(value);
				if (ulong.isZero() && !ed) return void 0;
				return ulong.toString();
			case ScalarType.INT64:
			case ScalarType.SFIXED64:
			case ScalarType.SINT64:
				assert$1(typeof value == "number" || typeof value == "string" || typeof value == "bigint");
				let long = PbLong.from(value);
				if (long.isZero() && !ed) return void 0;
				return long.toString();
			case ScalarType.BYTES:
				assert$1(value instanceof Uint8Array);
				if (!value.byteLength) return ed ? "" : void 0;
				return base64encode(value);
		}
	}
};
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-scalar-default.js
/**
* Creates the default value for a scalar type.
*/
function reflectionScalarDefault(type, longType = LongType.STRING) {
	switch (type) {
		case ScalarType.BOOL: return false;
		case ScalarType.UINT64:
		case ScalarType.FIXED64: return reflectionLongConvert(PbULong.ZERO, longType);
		case ScalarType.INT64:
		case ScalarType.SFIXED64:
		case ScalarType.SINT64: return reflectionLongConvert(PbLong.ZERO, longType);
		case ScalarType.DOUBLE:
		case ScalarType.FLOAT: return 0;
		case ScalarType.BYTES: return /* @__PURE__ */ new Uint8Array(0);
		case ScalarType.STRING: return "";
		default: return 0;
	}
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-binary-reader.js
/**
* Reads proto3 messages in binary format using reflection information.
*
* https://developers.google.com/protocol-buffers/docs/encoding
*/
var ReflectionBinaryReader = class {
	constructor(info) {
		this.info = info;
	}
	prepare() {
		var _a;
		if (!this.fieldNoToField) {
			const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : [];
			this.fieldNoToField = new Map(fieldsInput.map((field) => [field.no, field]));
		}
	}
	/**
	* Reads a message from binary format into the target message.
	*
	* Repeated fields are appended. Map entries are added, overwriting
	* existing keys.
	*
	* If a message field is already present, it will be merged with the
	* new data.
	*/
	read(reader, message, options, length) {
		this.prepare();
		const end = length === void 0 ? reader.len : reader.pos + length;
		while (reader.pos < end) {
			const [fieldNo, wireType] = reader.tag(), field = this.fieldNoToField.get(fieldNo);
			if (!field) {
				let u = options.readUnknownField;
				if (u == "throw") throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.info.typeName}`);
				let d = reader.skip(wireType);
				if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.info.typeName, message, fieldNo, wireType, d);
				continue;
			}
			let target = message;
			let repeated = field.repeat;
			let localName = field.localName;
			if (field.oneof) {
				target = target[field.oneof];
				if (target.oneofKind !== localName) target = message[field.oneof] = { oneofKind: localName };
			}
			switch (field.kind) {
				case "scalar":
				case "enum":
					let T = field.kind == "enum" ? ScalarType.INT32 : field.T;
					let L = field.kind == "scalar" ? field.L : void 0;
					if (repeated) {
						let arr = target[localName];
						if (wireType == WireType.LengthDelimited && T != ScalarType.STRING && T != ScalarType.BYTES) {
							let e = reader.uint32() + reader.pos;
							while (reader.pos < e) arr.push(this.scalar(reader, T, L));
						} else arr.push(this.scalar(reader, T, L));
					} else target[localName] = this.scalar(reader, T, L);
					break;
				case "message":
					if (repeated) {
						let arr = target[localName];
						let msg = field.T().internalBinaryRead(reader, reader.uint32(), options);
						arr.push(msg);
					} else target[localName] = field.T().internalBinaryRead(reader, reader.uint32(), options, target[localName]);
					break;
				case "map":
					let [mapKey, mapVal] = this.mapEntry(field, reader, options);
					target[localName][mapKey] = mapVal;
			}
		}
	}
	/**
	* Read a map field, expecting key field = 1, value field = 2
	*/
	mapEntry(field, reader, options) {
		let length = reader.uint32();
		let end = reader.pos + length;
		let key = void 0;
		let val = void 0;
		while (reader.pos < end) {
			let [fieldNo, wireType] = reader.tag();
			switch (fieldNo) {
				case 1:
					if (field.K == ScalarType.BOOL) key = reader.bool().toString();
					else key = this.scalar(reader, field.K, LongType.STRING);
					break;
				case 2:
					switch (field.V.kind) {
						case "scalar":
							val = this.scalar(reader, field.V.T, field.V.L);
							break;
						case "enum":
							val = reader.int32();
							break;
						case "message": val = field.V.T().internalBinaryRead(reader, reader.uint32(), options);
					}
					break;
				default: throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) in map entry for ${this.info.typeName}#${field.name}`);
			}
		}
		if (key === void 0) {
			let keyRaw = reflectionScalarDefault(field.K);
			key = field.K == ScalarType.BOOL ? keyRaw.toString() : keyRaw;
		}
		if (val === void 0) switch (field.V.kind) {
			case "scalar":
				val = reflectionScalarDefault(field.V.T, field.V.L);
				break;
			case "enum":
				val = 0;
				break;
			case "message":
				val = field.V.T().create();
				break;
		}
		return [key, val];
	}
	scalar(reader, type, longType) {
		switch (type) {
			case ScalarType.INT32: return reader.int32();
			case ScalarType.STRING: return reader.string();
			case ScalarType.BOOL: return reader.bool();
			case ScalarType.DOUBLE: return reader.double();
			case ScalarType.FLOAT: return reader.float();
			case ScalarType.INT64: return reflectionLongConvert(reader.int64(), longType);
			case ScalarType.UINT64: return reflectionLongConvert(reader.uint64(), longType);
			case ScalarType.FIXED64: return reflectionLongConvert(reader.fixed64(), longType);
			case ScalarType.FIXED32: return reader.fixed32();
			case ScalarType.BYTES: return reader.bytes();
			case ScalarType.UINT32: return reader.uint32();
			case ScalarType.SFIXED32: return reader.sfixed32();
			case ScalarType.SFIXED64: return reflectionLongConvert(reader.sfixed64(), longType);
			case ScalarType.SINT32: return reader.sint32();
			case ScalarType.SINT64: return reflectionLongConvert(reader.sint64(), longType);
		}
	}
};
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-binary-writer.js
/**
* Writes proto3 messages in binary format using reflection information.
*
* https://developers.google.com/protocol-buffers/docs/encoding
*/
var ReflectionBinaryWriter = class {
	constructor(info) {
		this.info = info;
	}
	prepare() {
		if (!this.fields) {
			const fieldsInput = this.info.fields ? this.info.fields.concat() : [];
			this.fields = fieldsInput.sort((a, b) => a.no - b.no);
		}
	}
	/**
	* Writes the message to binary format.
	*/
	write(message, writer, options) {
		this.prepare();
		for (const field of this.fields) {
			let value;
			let emitDefault;
			let repeated = field.repeat;
			let localName = field.localName;
			if (field.oneof) {
				const group = message[field.oneof];
				if (group.oneofKind !== localName) continue;
				value = group[localName];
				emitDefault = true;
			} else {
				value = message[localName];
				emitDefault = false;
			}
			switch (field.kind) {
				case "scalar":
				case "enum":
					let T = field.kind == "enum" ? ScalarType.INT32 : field.T;
					if (repeated) {
						assert$1(Array.isArray(value));
						if (repeated == RepeatType.PACKED) this.packed(writer, T, field.no, value);
						else for (const item of value) this.scalar(writer, T, field.no, item, true);
					} else if (value === void 0) assert$1(field.opt);
					else this.scalar(writer, T, field.no, value, emitDefault || field.opt);
					break;
				case "message":
					if (repeated) {
						assert$1(Array.isArray(value));
						for (const item of value) this.message(writer, options, field.T(), field.no, item);
					} else this.message(writer, options, field.T(), field.no, value);
					break;
				case "map":
					assert$1(typeof value == "object" && value !== null);
					for (const [key, val] of Object.entries(value)) this.mapEntry(writer, options, field, key, val);
			}
		}
		let u = options.writeUnknownFields;
		if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.info.typeName, message, writer);
	}
	mapEntry(writer, options, field, key, value) {
		writer.tag(field.no, WireType.LengthDelimited);
		writer.fork();
		let keyValue = key;
		switch (field.K) {
			case ScalarType.INT32:
			case ScalarType.FIXED32:
			case ScalarType.UINT32:
			case ScalarType.SFIXED32:
			case ScalarType.SINT32:
				keyValue = Number.parseInt(key);
				break;
			case ScalarType.BOOL:
				assert$1(key == "true" || key == "false");
				keyValue = key == "true";
		}
		this.scalar(writer, field.K, 1, keyValue, true);
		switch (field.V.kind) {
			case "scalar":
				this.scalar(writer, field.V.T, 2, value, true);
				break;
			case "enum":
				this.scalar(writer, ScalarType.INT32, 2, value, true);
				break;
			case "message": this.message(writer, options, field.V.T(), 2, value);
		}
		writer.join();
	}
	message(writer, options, handler, fieldNo, value) {
		if (value === void 0) return;
		handler.internalBinaryWrite(value, writer.tag(fieldNo, WireType.LengthDelimited).fork(), options);
		writer.join();
	}
	/**
	* Write a single scalar value.
	*/
	scalar(writer, type, fieldNo, value, emitDefault) {
		let [wireType, method, isDefault] = this.scalarInfo(type, value);
		if (!isDefault || emitDefault) {
			writer.tag(fieldNo, wireType);
			writer[method](value);
		}
	}
	/**
	* Write an array of scalar values in packed format.
	*/
	packed(writer, type, fieldNo, value) {
		if (!value.length) return;
		assert$1(type !== ScalarType.BYTES && type !== ScalarType.STRING);
		writer.tag(fieldNo, WireType.LengthDelimited);
		writer.fork();
		let [, method] = this.scalarInfo(type);
		for (let i = 0; i < value.length; i++) writer[method](value[i]);
		writer.join();
	}
	/**
	* Get information for writing a scalar value.
	*
	* Returns tuple:
	* [0]: appropriate WireType
	* [1]: name of the appropriate method of IBinaryWriter
	* [2]: whether the given value is a default value
	*
	* If argument `value` is omitted, [2] is always false.
	*/
	scalarInfo(type, value) {
		let t = WireType.Varint;
		let m;
		let i = value === void 0;
		let d = value === 0;
		switch (type) {
			case ScalarType.INT32:
				m = "int32";
				break;
			case ScalarType.STRING:
				d = i || !value.length;
				t = WireType.LengthDelimited;
				m = "string";
				break;
			case ScalarType.BOOL:
				d = value === false;
				m = "bool";
				break;
			case ScalarType.UINT32:
				m = "uint32";
				break;
			case ScalarType.DOUBLE:
				t = WireType.Bit64;
				m = "double";
				break;
			case ScalarType.FLOAT:
				t = WireType.Bit32;
				m = "float";
				break;
			case ScalarType.INT64:
				d = i || PbLong.from(value).isZero();
				m = "int64";
				break;
			case ScalarType.UINT64:
				d = i || PbULong.from(value).isZero();
				m = "uint64";
				break;
			case ScalarType.FIXED64:
				d = i || PbULong.from(value).isZero();
				t = WireType.Bit64;
				m = "fixed64";
				break;
			case ScalarType.BYTES:
				d = i || !value.byteLength;
				t = WireType.LengthDelimited;
				m = "bytes";
				break;
			case ScalarType.FIXED32:
				t = WireType.Bit32;
				m = "fixed32";
				break;
			case ScalarType.SFIXED32:
				t = WireType.Bit32;
				m = "sfixed32";
				break;
			case ScalarType.SFIXED64:
				d = i || PbLong.from(value).isZero();
				t = WireType.Bit64;
				m = "sfixed64";
				break;
			case ScalarType.SINT32:
				m = "sint32";
				break;
			case ScalarType.SINT64:
				d = i || PbLong.from(value).isZero();
				m = "sint64";
		}
		return [
			t,
			m,
			i || d
		];
	}
};
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-create.js
/**
* Creates an instance of the generic message, using the field
* information.
*/
function reflectionCreate(type) {
	/**
	* This ternary can be removed in the next major version.
	* The `Object.create()` code path utilizes a new `messagePrototype`
	* property on the `IMessageType` which has this same `MESSAGE_TYPE`
	* non-enumerable property on it. Doing it this way means that we only
	* pay the cost of `Object.defineProperty()` once per `IMessageType`
	* class of once per "instance". The falsy code path is only provided
	* for backwards compatibility in cases where the runtime library is
	* updated without also updating the generated code.
	*/
	const msg = type.messagePrototype ? Object.create(type.messagePrototype) : Object.defineProperty({}, MESSAGE_TYPE, { value: type });
	for (let field of type.fields) {
		let name = field.localName;
		if (field.opt) continue;
		if (field.oneof) msg[field.oneof] = { oneofKind: void 0 };
		else if (field.repeat) msg[name] = [];
		else switch (field.kind) {
			case "scalar":
				msg[name] = reflectionScalarDefault(field.T, field.L);
				break;
			case "enum":
				msg[name] = 0;
				break;
			case "map":
				msg[name] = {};
				break;
		}
	}
	return msg;
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-merge-partial.js
/**
* Copy partial data into the target message.
*
* If a singular scalar or enum field is present in the source, it
* replaces the field in the target.
*
* If a singular message field is present in the source, it is merged
* with the target field by calling mergePartial() of the responsible
* message type.
*
* If a repeated field is present in the source, its values replace
* all values in the target array, removing extraneous values.
* Repeated message fields are copied, not merged.
*
* If a map field is present in the source, entries are added to the
* target map, replacing entries with the same key. Entries that only
* exist in the target remain. Entries with message values are copied,
* not merged.
*
* Note that this function differs from protobuf merge semantics,
* which appends repeated fields.
*/
function reflectionMergePartial(info, target, source) {
	let fieldValue;
	let input = source;
	let output;
	for (let field of info.fields) {
		let name = field.localName;
		if (field.oneof) {
			const group = input[field.oneof];
			if ((group === null || group === void 0 ? void 0 : group.oneofKind) == void 0) continue;
			fieldValue = group[name];
			output = target[field.oneof];
			output.oneofKind = group.oneofKind;
			if (fieldValue == void 0) {
				delete output[name];
				continue;
			}
		} else {
			fieldValue = input[name];
			output = target;
			if (fieldValue == void 0) continue;
		}
		if (field.repeat) output[name].length = fieldValue.length;
		switch (field.kind) {
			case "scalar":
			case "enum":
				if (field.repeat) for (let i = 0; i < fieldValue.length; i++) output[name][i] = fieldValue[i];
				else output[name] = fieldValue;
				break;
			case "message":
				let T = field.T();
				if (field.repeat) for (let i = 0; i < fieldValue.length; i++) output[name][i] = T.create(fieldValue[i]);
				else if (output[name] === void 0) output[name] = T.create(fieldValue);
				else T.mergePartial(output[name], fieldValue);
				break;
			case "map": switch (field.V.kind) {
				case "scalar":
				case "enum":
					Object.assign(output[name], fieldValue);
					break;
				case "message":
					let T = field.V.T();
					for (let k of Object.keys(fieldValue)) output[name][k] = T.create(fieldValue[k]);
			}
		}
	}
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/reflection-equals.js
/**
* Determines whether two message of the same type have the same field values.
* Checks for deep equality, traversing repeated fields, oneof groups, maps
* and messages recursively.
* Will also return true if both messages are `undefined`.
*/
function reflectionEquals(info, a, b) {
	if (a === b) return true;
	if (!a || !b) return false;
	for (let field of info.fields) {
		let localName = field.localName;
		let val_a = field.oneof ? a[field.oneof][localName] : a[localName];
		let val_b = field.oneof ? b[field.oneof][localName] : b[localName];
		switch (field.kind) {
			case "enum":
			case "scalar":
				let t = field.kind == "enum" ? ScalarType.INT32 : field.T;
				if (!(field.repeat ? repeatedPrimitiveEq(t, val_a, val_b) : primitiveEq(t, val_a, val_b))) return false;
				break;
			case "map":
				if (!(field.V.kind == "message" ? repeatedMsgEq(field.V.T(), objectValues(val_a), objectValues(val_b)) : repeatedPrimitiveEq(field.V.kind == "enum" ? ScalarType.INT32 : field.V.T, objectValues(val_a), objectValues(val_b)))) return false;
				break;
			case "message":
				let T = field.T();
				if (!(field.repeat ? repeatedMsgEq(T, val_a, val_b) : T.equals(val_a, val_b))) return false;
		}
	}
	return true;
}
var objectValues = Object.values;
function primitiveEq(type, a, b) {
	if (a === b) return true;
	if (type !== ScalarType.BYTES) return false;
	let ba = a;
	let bb = b;
	if (ba.length !== bb.length) return false;
	for (let i = 0; i < ba.length; i++) if (ba[i] != bb[i]) return false;
	return true;
}
function repeatedPrimitiveEq(type, a, b) {
	if (a.length !== b.length) return false;
	for (let i = 0; i < a.length; i++) if (!primitiveEq(type, a[i], b[i])) return false;
	return true;
}
function repeatedMsgEq(type, a, b) {
	if (a.length !== b.length) return false;
	for (let i = 0; i < a.length; i++) if (!type.equals(a[i], b[i])) return false;
	return true;
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime@2.11.1/node_modules/@protobuf-ts/runtime/build/es2015/message-type.js
var baseDescriptors = Object.getOwnPropertyDescriptors(Object.getPrototypeOf({}));
var messageTypeDescriptor = baseDescriptors[MESSAGE_TYPE] = {};
/**
* This standard message type provides reflection-based
* operations to work with a message.
*/
var MessageType = class {
	constructor(name, fields, options) {
		this.defaultCheckDepth = 16;
		this.typeName = name;
		this.fields = fields.map(normalizeFieldInfo);
		this.options = options !== null && options !== void 0 ? options : {};
		messageTypeDescriptor.value = this;
		this.messagePrototype = Object.create(null, baseDescriptors);
		this.refTypeCheck = new ReflectionTypeCheck(this);
		this.refJsonReader = new ReflectionJsonReader(this);
		this.refJsonWriter = new ReflectionJsonWriter(this);
		this.refBinReader = new ReflectionBinaryReader(this);
		this.refBinWriter = new ReflectionBinaryWriter(this);
	}
	create(value) {
		let message = reflectionCreate(this);
		if (value !== void 0) reflectionMergePartial(this, message, value);
		return message;
	}
	/**
	* Clone the message.
	*
	* Unknown fields are discarded.
	*/
	clone(message) {
		let copy = this.create();
		reflectionMergePartial(this, copy, message);
		return copy;
	}
	/**
	* Determines whether two message of the same type have the same field values.
	* Checks for deep equality, traversing repeated fields, oneof groups, maps
	* and messages recursively.
	* Will also return true if both messages are `undefined`.
	*/
	equals(a, b) {
		return reflectionEquals(this, a, b);
	}
	/**
	* Is the given value assignable to our message type
	* and contains no [excess properties](https://www.typescriptlang.org/docs/handbook/interfaces.html#excess-property-checks)?
	*/
	is(arg, depth = this.defaultCheckDepth) {
		return this.refTypeCheck.is(arg, depth, false);
	}
	/**
	* Is the given value assignable to our message type,
	* regardless of [excess properties](https://www.typescriptlang.org/docs/handbook/interfaces.html#excess-property-checks)?
	*/
	isAssignable(arg, depth = this.defaultCheckDepth) {
		return this.refTypeCheck.is(arg, depth, true);
	}
	/**
	* Copy partial data into the target message.
	*/
	mergePartial(target, source) {
		reflectionMergePartial(this, target, source);
	}
	/**
	* Create a new message from binary format.
	*/
	fromBinary(data, options) {
		let opt = binaryReadOptions(options);
		return this.internalBinaryRead(opt.readerFactory(data), data.byteLength, opt);
	}
	/**
	* Read a new message from a JSON value.
	*/
	fromJson(json, options) {
		return this.internalJsonRead(json, jsonReadOptions(options));
	}
	/**
	* Read a new message from a JSON string.
	* This is equivalent to `T.fromJson(JSON.parse(json))`.
	*/
	fromJsonString(json, options) {
		let value = JSON.parse(json);
		return this.fromJson(value, options);
	}
	/**
	* Write the message to canonical JSON value.
	*/
	toJson(message, options) {
		return this.internalJsonWrite(message, jsonWriteOptions(options));
	}
	/**
	* Convert the message to canonical JSON string.
	* This is equivalent to `JSON.stringify(T.toJson(t))`
	*/
	toJsonString(message, options) {
		var _a;
		let value = this.toJson(message, options);
		return JSON.stringify(value, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0);
	}
	/**
	* Write the message to binary format.
	*/
	toBinary(message, options) {
		let opt = binaryWriteOptions(options);
		return this.internalBinaryWrite(message, opt.writerFactory(), opt).finish();
	}
	/**
	* This is an internal method. If you just want to read a message from
	* JSON, use `fromJson()` or `fromJsonString()`.
	*
	* Reads JSON value and merges the fields into the target
	* according to protobuf rules. If the target is omitted,
	* a new instance is created first.
	*/
	internalJsonRead(json, options, target) {
		if (json !== null && typeof json == "object" && !Array.isArray(json)) {
			let message = target !== null && target !== void 0 ? target : this.create();
			this.refJsonReader.read(json, message, options);
			return message;
		}
		throw new Error(`Unable to parse message ${this.typeName} from JSON ${typeofJsonValue(json)}.`);
	}
	/**
	* This is an internal method. If you just want to write a message
	* to JSON, use `toJson()` or `toJsonString().
	*
	* Writes JSON value and returns it.
	*/
	internalJsonWrite(message, options) {
		return this.refJsonWriter.write(message, options);
	}
	/**
	* This is an internal method. If you just want to write a message
	* in binary format, use `toBinary()`.
	*
	* Serializes the message in binary format and appends it to the given
	* writer. Returns passed writer.
	*/
	internalBinaryWrite(message, writer, options) {
		this.refBinWriter.write(message, writer, options);
		return writer;
	}
	/**
	* This is an internal method. If you just want to read a message from
	* binary data, use `fromBinary()`.
	*
	* Reads data from binary format and merges the fields into
	* the target according to protobuf rules. If the target is
	* omitted, a new instance is created first.
	*/
	internalBinaryRead(reader, length, options, target) {
		let message = target !== null && target !== void 0 ? target : this.create();
		this.refBinReader.read(reader, message, options, length);
		return message;
	}
};
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime-rpc@2.11.1/node_modules/@protobuf-ts/runtime-rpc/build/es2015/reflection-info.js
/**
* Turns PartialMethodInfo into MethodInfo.
*/
function normalizeMethodInfo(method, service) {
	var _a;
	var _b;
	var _c;
	let m = method;
	m.service = service;
	m.localName = (_a = m.localName) !== null && _a !== void 0 ? _a : lowerCamelCase(m.name);
	m.serverStreaming = !!m.serverStreaming;
	m.clientStreaming = !!m.clientStreaming;
	m.options = (_b = m.options) !== null && _b !== void 0 ? _b : {};
	m.idempotency = (_c = m.idempotency) !== null && _c !== void 0 ? _c : void 0;
	return m;
}
//#endregion
//#region node_modules/.pnpm/@protobuf-ts+runtime-rpc@2.11.1/node_modules/@protobuf-ts/runtime-rpc/build/es2015/service-type.js
var ServiceType = class {
	constructor(typeName, methods, options) {
		this.typeName = typeName;
		this.methods = methods.map((i) => normalizeMethodInfo(i, this));
		this.options = options !== null && options !== void 0 ? options : {};
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/generated/results/entities/v1/cachescope.js
var CacheScope$Type = class extends MessageType {
	constructor() {
		super("github.actions.results.entities.v1.CacheScope", [{
			no: 1,
			name: "scope",
			kind: "scalar",
			T: 9
		}, {
			no: 2,
			name: "permission",
			kind: "scalar",
			T: 3
		}]);
	}
	create(value) {
		const message = {
			scope: "",
			permission: "0"
		};
		globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
			enumerable: false,
			value: this
		});
		if (value !== void 0) reflectionMergePartial(this, message, value);
		return message;
	}
	internalBinaryRead(reader, length, options, target) {
		let message = target !== null && target !== void 0 ? target : this.create();
		let end = reader.pos + length;
		while (reader.pos < end) {
			let [fieldNo, wireType] = reader.tag();
			switch (fieldNo) {
				case 1:
					message.scope = reader.string();
					break;
				case 2:
					message.permission = reader.int64().toString();
					break;
				default:
					let u = options.readUnknownField;
					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
					let d = reader.skip(wireType);
					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
			}
		}
		return message;
	}
	internalBinaryWrite(message, writer, options) {
		if (message.scope !== "") writer.tag(1, WireType.LengthDelimited).string(message.scope);
		if (message.permission !== "0") writer.tag(2, WireType.Varint).int64(message.permission);
		let u = options.writeUnknownFields;
		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
		return writer;
	}
};
/**
* @generated MessageType for protobuf message github.actions.results.entities.v1.CacheScope
*/
var CacheScope = new CacheScope$Type();
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/generated/results/entities/v1/cachemetadata.js
var CacheMetadata$Type = class extends MessageType {
	constructor() {
		super("github.actions.results.entities.v1.CacheMetadata", [{
			no: 1,
			name: "repository_id",
			kind: "scalar",
			T: 3
		}, {
			no: 2,
			name: "scope",
			kind: "message",
			repeat: 1,
			T: () => CacheScope
		}]);
	}
	create(value) {
		const message = {
			repositoryId: "0",
			scope: []
		};
		globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
			enumerable: false,
			value: this
		});
		if (value !== void 0) reflectionMergePartial(this, message, value);
		return message;
	}
	internalBinaryRead(reader, length, options, target) {
		let message = target !== null && target !== void 0 ? target : this.create();
		let end = reader.pos + length;
		while (reader.pos < end) {
			let [fieldNo, wireType] = reader.tag();
			switch (fieldNo) {
				case 1:
					message.repositoryId = reader.int64().toString();
					break;
				case 2:
					message.scope.push(CacheScope.internalBinaryRead(reader, reader.uint32(), options));
					break;
				default:
					let u = options.readUnknownField;
					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
					let d = reader.skip(wireType);
					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
			}
		}
		return message;
	}
	internalBinaryWrite(message, writer, options) {
		if (message.repositoryId !== "0") writer.tag(1, WireType.Varint).int64(message.repositoryId);
		for (let i = 0; i < message.scope.length; i++) CacheScope.internalBinaryWrite(message.scope[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
		let u = options.writeUnknownFields;
		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
		return writer;
	}
};
/**
* @generated MessageType for protobuf message github.actions.results.entities.v1.CacheMetadata
*/
var CacheMetadata = new CacheMetadata$Type();
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/generated/results/api/v1/cache.js
var CreateCacheEntryRequest$Type = class extends MessageType {
	constructor() {
		super("github.actions.results.api.v1.CreateCacheEntryRequest", [
			{
				no: 1,
				name: "metadata",
				kind: "message",
				T: () => CacheMetadata
			},
			{
				no: 2,
				name: "key",
				kind: "scalar",
				T: 9
			},
			{
				no: 3,
				name: "version",
				kind: "scalar",
				T: 9
			}
		]);
	}
	create(value) {
		const message = {
			key: "",
			version: ""
		};
		globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
			enumerable: false,
			value: this
		});
		if (value !== void 0) reflectionMergePartial(this, message, value);
		return message;
	}
	internalBinaryRead(reader, length, options, target) {
		let message = target !== null && target !== void 0 ? target : this.create();
		let end = reader.pos + length;
		while (reader.pos < end) {
			let [fieldNo, wireType] = reader.tag();
			switch (fieldNo) {
				case 1:
					message.metadata = CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
					break;
				case 2:
					message.key = reader.string();
					break;
				case 3:
					message.version = reader.string();
					break;
				default:
					let u = options.readUnknownField;
					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
					let d = reader.skip(wireType);
					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
			}
		}
		return message;
	}
	internalBinaryWrite(message, writer, options) {
		if (message.metadata) CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
		if (message.key !== "") writer.tag(2, WireType.LengthDelimited).string(message.key);
		if (message.version !== "") writer.tag(3, WireType.LengthDelimited).string(message.version);
		let u = options.writeUnknownFields;
		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
		return writer;
	}
};
/**
* @generated MessageType for protobuf message github.actions.results.api.v1.CreateCacheEntryRequest
*/
var CreateCacheEntryRequest = new CreateCacheEntryRequest$Type();
var CreateCacheEntryResponse$Type = class extends MessageType {
	constructor() {
		super("github.actions.results.api.v1.CreateCacheEntryResponse", [
			{
				no: 1,
				name: "ok",
				kind: "scalar",
				T: 8
			},
			{
				no: 2,
				name: "signed_upload_url",
				kind: "scalar",
				T: 9
			},
			{
				no: 3,
				name: "message",
				kind: "scalar",
				T: 9
			}
		]);
	}
	create(value) {
		const message = {
			ok: false,
			signedUploadUrl: "",
			message: ""
		};
		globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
			enumerable: false,
			value: this
		});
		if (value !== void 0) reflectionMergePartial(this, message, value);
		return message;
	}
	internalBinaryRead(reader, length, options, target) {
		let message = target !== null && target !== void 0 ? target : this.create();
		let end = reader.pos + length;
		while (reader.pos < end) {
			let [fieldNo, wireType] = reader.tag();
			switch (fieldNo) {
				case 1:
					message.ok = reader.bool();
					break;
				case 2:
					message.signedUploadUrl = reader.string();
					break;
				case 3:
					message.message = reader.string();
					break;
				default:
					let u = options.readUnknownField;
					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
					let d = reader.skip(wireType);
					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
			}
		}
		return message;
	}
	internalBinaryWrite(message, writer, options) {
		if (message.ok !== false) writer.tag(1, WireType.Varint).bool(message.ok);
		if (message.signedUploadUrl !== "") writer.tag(2, WireType.LengthDelimited).string(message.signedUploadUrl);
		if (message.message !== "") writer.tag(3, WireType.LengthDelimited).string(message.message);
		let u = options.writeUnknownFields;
		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
		return writer;
	}
};
/**
* @generated MessageType for protobuf message github.actions.results.api.v1.CreateCacheEntryResponse
*/
var CreateCacheEntryResponse = new CreateCacheEntryResponse$Type();
var FinalizeCacheEntryUploadRequest$Type = class extends MessageType {
	constructor() {
		super("github.actions.results.api.v1.FinalizeCacheEntryUploadRequest", [
			{
				no: 1,
				name: "metadata",
				kind: "message",
				T: () => CacheMetadata
			},
			{
				no: 2,
				name: "key",
				kind: "scalar",
				T: 9
			},
			{
				no: 3,
				name: "size_bytes",
				kind: "scalar",
				T: 3
			},
			{
				no: 4,
				name: "version",
				kind: "scalar",
				T: 9
			}
		]);
	}
	create(value) {
		const message = {
			key: "",
			sizeBytes: "0",
			version: ""
		};
		globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
			enumerable: false,
			value: this
		});
		if (value !== void 0) reflectionMergePartial(this, message, value);
		return message;
	}
	internalBinaryRead(reader, length, options, target) {
		let message = target !== null && target !== void 0 ? target : this.create();
		let end = reader.pos + length;
		while (reader.pos < end) {
			let [fieldNo, wireType] = reader.tag();
			switch (fieldNo) {
				case 1:
					message.metadata = CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
					break;
				case 2:
					message.key = reader.string();
					break;
				case 3:
					message.sizeBytes = reader.int64().toString();
					break;
				case 4:
					message.version = reader.string();
					break;
				default:
					let u = options.readUnknownField;
					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
					let d = reader.skip(wireType);
					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
			}
		}
		return message;
	}
	internalBinaryWrite(message, writer, options) {
		if (message.metadata) CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
		if (message.key !== "") writer.tag(2, WireType.LengthDelimited).string(message.key);
		if (message.sizeBytes !== "0") writer.tag(3, WireType.Varint).int64(message.sizeBytes);
		if (message.version !== "") writer.tag(4, WireType.LengthDelimited).string(message.version);
		let u = options.writeUnknownFields;
		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
		return writer;
	}
};
/**
* @generated MessageType for protobuf message github.actions.results.api.v1.FinalizeCacheEntryUploadRequest
*/
var FinalizeCacheEntryUploadRequest = new FinalizeCacheEntryUploadRequest$Type();
var FinalizeCacheEntryUploadResponse$Type = class extends MessageType {
	constructor() {
		super("github.actions.results.api.v1.FinalizeCacheEntryUploadResponse", [
			{
				no: 1,
				name: "ok",
				kind: "scalar",
				T: 8
			},
			{
				no: 2,
				name: "entry_id",
				kind: "scalar",
				T: 3
			},
			{
				no: 3,
				name: "message",
				kind: "scalar",
				T: 9
			}
		]);
	}
	create(value) {
		const message = {
			ok: false,
			entryId: "0",
			message: ""
		};
		globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
			enumerable: false,
			value: this
		});
		if (value !== void 0) reflectionMergePartial(this, message, value);
		return message;
	}
	internalBinaryRead(reader, length, options, target) {
		let message = target !== null && target !== void 0 ? target : this.create();
		let end = reader.pos + length;
		while (reader.pos < end) {
			let [fieldNo, wireType] = reader.tag();
			switch (fieldNo) {
				case 1:
					message.ok = reader.bool();
					break;
				case 2:
					message.entryId = reader.int64().toString();
					break;
				case 3:
					message.message = reader.string();
					break;
				default:
					let u = options.readUnknownField;
					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
					let d = reader.skip(wireType);
					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
			}
		}
		return message;
	}
	internalBinaryWrite(message, writer, options) {
		if (message.ok !== false) writer.tag(1, WireType.Varint).bool(message.ok);
		if (message.entryId !== "0") writer.tag(2, WireType.Varint).int64(message.entryId);
		if (message.message !== "") writer.tag(3, WireType.LengthDelimited).string(message.message);
		let u = options.writeUnknownFields;
		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
		return writer;
	}
};
/**
* @generated MessageType for protobuf message github.actions.results.api.v1.FinalizeCacheEntryUploadResponse
*/
var FinalizeCacheEntryUploadResponse = new FinalizeCacheEntryUploadResponse$Type();
var GetCacheEntryDownloadURLRequest$Type = class extends MessageType {
	constructor() {
		super("github.actions.results.api.v1.GetCacheEntryDownloadURLRequest", [
			{
				no: 1,
				name: "metadata",
				kind: "message",
				T: () => CacheMetadata
			},
			{
				no: 2,
				name: "key",
				kind: "scalar",
				T: 9
			},
			{
				no: 3,
				name: "restore_keys",
				kind: "scalar",
				repeat: 2,
				T: 9
			},
			{
				no: 4,
				name: "version",
				kind: "scalar",
				T: 9
			}
		]);
	}
	create(value) {
		const message = {
			key: "",
			restoreKeys: [],
			version: ""
		};
		globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
			enumerable: false,
			value: this
		});
		if (value !== void 0) reflectionMergePartial(this, message, value);
		return message;
	}
	internalBinaryRead(reader, length, options, target) {
		let message = target !== null && target !== void 0 ? target : this.create();
		let end = reader.pos + length;
		while (reader.pos < end) {
			let [fieldNo, wireType] = reader.tag();
			switch (fieldNo) {
				case 1:
					message.metadata = CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
					break;
				case 2:
					message.key = reader.string();
					break;
				case 3:
					message.restoreKeys.push(reader.string());
					break;
				case 4:
					message.version = reader.string();
					break;
				default:
					let u = options.readUnknownField;
					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
					let d = reader.skip(wireType);
					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
			}
		}
		return message;
	}
	internalBinaryWrite(message, writer, options) {
		if (message.metadata) CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
		if (message.key !== "") writer.tag(2, WireType.LengthDelimited).string(message.key);
		for (let i = 0; i < message.restoreKeys.length; i++) writer.tag(3, WireType.LengthDelimited).string(message.restoreKeys[i]);
		if (message.version !== "") writer.tag(4, WireType.LengthDelimited).string(message.version);
		let u = options.writeUnknownFields;
		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
		return writer;
	}
};
/**
* @generated MessageType for protobuf message github.actions.results.api.v1.GetCacheEntryDownloadURLRequest
*/
var GetCacheEntryDownloadURLRequest = new GetCacheEntryDownloadURLRequest$Type();
var GetCacheEntryDownloadURLResponse$Type = class extends MessageType {
	constructor() {
		super("github.actions.results.api.v1.GetCacheEntryDownloadURLResponse", [
			{
				no: 1,
				name: "ok",
				kind: "scalar",
				T: 8
			},
			{
				no: 2,
				name: "signed_download_url",
				kind: "scalar",
				T: 9
			},
			{
				no: 3,
				name: "matched_key",
				kind: "scalar",
				T: 9
			}
		]);
	}
	create(value) {
		const message = {
			ok: false,
			signedDownloadUrl: "",
			matchedKey: ""
		};
		globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
			enumerable: false,
			value: this
		});
		if (value !== void 0) reflectionMergePartial(this, message, value);
		return message;
	}
	internalBinaryRead(reader, length, options, target) {
		let message = target !== null && target !== void 0 ? target : this.create();
		let end = reader.pos + length;
		while (reader.pos < end) {
			let [fieldNo, wireType] = reader.tag();
			switch (fieldNo) {
				case 1:
					message.ok = reader.bool();
					break;
				case 2:
					message.signedDownloadUrl = reader.string();
					break;
				case 3:
					message.matchedKey = reader.string();
					break;
				default:
					let u = options.readUnknownField;
					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
					let d = reader.skip(wireType);
					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
			}
		}
		return message;
	}
	internalBinaryWrite(message, writer, options) {
		if (message.ok !== false) writer.tag(1, WireType.Varint).bool(message.ok);
		if (message.signedDownloadUrl !== "") writer.tag(2, WireType.LengthDelimited).string(message.signedDownloadUrl);
		if (message.matchedKey !== "") writer.tag(3, WireType.LengthDelimited).string(message.matchedKey);
		let u = options.writeUnknownFields;
		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
		return writer;
	}
};
/**
* @generated MessageType for protobuf message github.actions.results.api.v1.GetCacheEntryDownloadURLResponse
*/
var GetCacheEntryDownloadURLResponse = new GetCacheEntryDownloadURLResponse$Type();
new ServiceType("github.actions.results.api.v1.CacheService", [
	{
		name: "CreateCacheEntry",
		options: {},
		I: CreateCacheEntryRequest,
		O: CreateCacheEntryResponse
	},
	{
		name: "FinalizeCacheEntryUpload",
		options: {},
		I: FinalizeCacheEntryUploadRequest,
		O: FinalizeCacheEntryUploadResponse
	},
	{
		name: "GetCacheEntryDownloadURL",
		options: {},
		I: GetCacheEntryDownloadURLRequest,
		O: GetCacheEntryDownloadURLResponse
	}
]);
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/generated/results/api/v1/cache.twirp-client.js
var CacheServiceClientJSON = class {
	constructor(rpc) {
		this.rpc = rpc;
		this.CreateCacheEntry.bind(this);
		this.FinalizeCacheEntryUpload.bind(this);
		this.GetCacheEntryDownloadURL.bind(this);
	}
	CreateCacheEntry(request) {
		const data = CreateCacheEntryRequest.toJson(request, {
			useProtoFieldName: true,
			emitDefaultValues: false
		});
		return this.rpc.request("github.actions.results.api.v1.CacheService", "CreateCacheEntry", "application/json", data).then((data) => CreateCacheEntryResponse.fromJson(data, { ignoreUnknownFields: true }));
	}
	FinalizeCacheEntryUpload(request) {
		const data = FinalizeCacheEntryUploadRequest.toJson(request, {
			useProtoFieldName: true,
			emitDefaultValues: false
		});
		return this.rpc.request("github.actions.results.api.v1.CacheService", "FinalizeCacheEntryUpload", "application/json", data).then((data) => FinalizeCacheEntryUploadResponse.fromJson(data, { ignoreUnknownFields: true }));
	}
	GetCacheEntryDownloadURL(request) {
		const data = GetCacheEntryDownloadURLRequest.toJson(request, {
			useProtoFieldName: true,
			emitDefaultValues: false
		});
		return this.rpc.request("github.actions.results.api.v1.CacheService", "GetCacheEntryDownloadURL", "application/json", data).then((data) => GetCacheEntryDownloadURLResponse.fromJson(data, { ignoreUnknownFields: true }));
	}
};
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/shared/util.js
/**
* Masks the `sig` parameter in a URL and sets it as a secret.
*
* @param url - The URL containing the signature parameter to mask
* @remarks
* This function attempts to parse the provided URL and identify the 'sig' query parameter.
* If found, it registers both the raw and URL-encoded signature values as secrets using
* the Actions `setSecret` API, which prevents them from being displayed in logs.
*
* The function handles errors gracefully if URL parsing fails, logging them as debug messages.
*
* @example
* ```typescript
* // Mask a signature in an Azure SAS token URL
* maskSigUrl('https://example.blob.core.windows.net/container/file.txt?sig=abc123&se=2023-01-01');
* ```
*/
function maskSigUrl(url) {
	if (!url) return;
	try {
		const signature = new URL(url).searchParams.get("sig");
		if (signature) {
			setSecret(signature);
			setSecret(encodeURIComponent(signature));
		}
	} catch (error) {
		debug(`Failed to parse URL: ${url} ${error instanceof Error ? error.message : String(error)}`);
	}
}
/**
* Masks sensitive information in URLs containing signature parameters.
* Currently supports masking 'sig' parameters in the 'signed_upload_url'
* and 'signed_download_url' properties of the provided object.
*
* @param body - The object should contain a signature
* @remarks
* This function extracts URLs from the object properties and calls maskSigUrl
* on each one to redact sensitive signature information. The function doesn't
* modify the original object; it only marks the signatures as secrets for
* logging purposes.
*
* @example
* ```typescript
* const responseBody = {
*   signed_upload_url: 'https://blob.core.windows.net/?sig=abc123',
*   signed_download_url: 'https://blob.core/windows.net/?sig=def456'
* };
* maskSecretUrls(responseBody);
* ```
*/
function maskSecretUrls(body) {
	if (typeof body !== "object" || body === null) {
		debug("body is not an object or is null");
		return;
	}
	if ("signed_upload_url" in body && typeof body.signed_upload_url === "string") maskSigUrl(body.signed_upload_url);
	if ("signed_download_url" in body && typeof body.signed_download_url === "string") maskSigUrl(body.signed_download_url);
}
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/shared/cacheTwirpClient.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());
	});
};
/**
* This class is a wrapper around the CacheServiceClientJSON class generated by Twirp.
*
* It adds retry logic to the request method, which is not present in the generated client.
*
* This class is used to interact with cache service v2.
*/
var CacheServiceClient = class {
	constructor(userAgent, maxAttempts, baseRetryIntervalMilliseconds, retryMultiplier) {
		this.maxAttempts = 5;
		this.baseRetryIntervalMilliseconds = 3e3;
		this.retryMultiplier = 1.5;
		const token = getRuntimeToken();
		this.baseUrl = getCacheServiceURL();
		if (maxAttempts) this.maxAttempts = maxAttempts;
		if (baseRetryIntervalMilliseconds) this.baseRetryIntervalMilliseconds = baseRetryIntervalMilliseconds;
		if (retryMultiplier) this.retryMultiplier = retryMultiplier;
		this.httpClient = new HttpClient(userAgent, [new BearerCredentialHandler(token)]);
	}
	request(service, method, contentType, data) {
		return __awaiter$5(this, void 0, void 0, function* () {
			const url = new URL(`/twirp/${service}/${method}`, this.baseUrl).href;
			debug(`[Request] ${method} ${url}`);
			const headers = { "Content-Type": contentType };
			try {
				const { body } = yield this.retryableRequest(() => __awaiter$5(this, void 0, void 0, function* () {
					return this.httpClient.post(url, JSON.stringify(data), headers);
				}));
				return body;
			} catch (error) {
				throw new Error(`Failed to ${method}: ${error.message}`);
			}
		});
	}
	retryableRequest(operation) {
		return __awaiter$5(this, void 0, void 0, function* () {
			let attempt = 0;
			let errorMessage = "";
			let rawBody = "";
			while (attempt < this.maxAttempts) {
				let isRetryable = false;
				try {
					const response = yield operation();
					const statusCode = response.message.statusCode;
					rawBody = yield response.readBody();
					debug(`[Response] - ${response.message.statusCode}`);
					debug(`Headers: ${JSON.stringify(response.message.headers, null, 2)}`);
					const body = JSON.parse(rawBody);
					maskSecretUrls(body);
					debug(`Body: ${JSON.stringify(body, null, 2)}`);
					if (this.isSuccessStatusCode(statusCode)) return {
						response,
						body
					};
					isRetryable = this.isRetryableHttpStatusCode(statusCode);
					errorMessage = `Failed request: (${statusCode}) ${response.message.statusMessage}`;
					if (body.msg) {
						if (UsageError.isUsageErrorMessage(body.msg)) throw new UsageError();
						errorMessage = `${errorMessage}: ${body.msg}`;
					}
					if (statusCode === HttpCodes.TooManyRequests) {
						const retryAfterHeader = response.message.headers["retry-after"];
						if (retryAfterHeader) {
							const parsedSeconds = parseInt(retryAfterHeader, 10);
							if (!isNaN(parsedSeconds) && parsedSeconds > 0) warning(`You've hit a rate limit, your rate limit will reset in ${parsedSeconds} seconds`);
						}
						throw new RateLimitError(`Rate limited: ${errorMessage}`);
					}
				} catch (error) {
					if (error instanceof SyntaxError) debug(`Raw Body: ${rawBody}`);
					if (error instanceof UsageError) throw error;
					if (error instanceof RateLimitError) throw error;
					if (NetworkError.isNetworkErrorCode(error === null || error === void 0 ? void 0 : error.code)) throw new NetworkError(error === null || error === void 0 ? void 0 : error.code);
					isRetryable = true;
					errorMessage = error.message;
				}
				if (!isRetryable) throw new Error(`Received non-retryable error: ${errorMessage}`);
				if (attempt + 1 === this.maxAttempts) throw new Error(`Failed to make request after ${this.maxAttempts} attempts: ${errorMessage}`);
				const retryTimeMilliseconds = this.getExponentialRetryTimeMilliseconds(attempt);
				info(`Attempt ${attempt + 1} of ${this.maxAttempts} failed with error: ${errorMessage}. Retrying request in ${retryTimeMilliseconds} ms...`);
				yield this.sleep(retryTimeMilliseconds);
				attempt++;
			}
			throw new Error(`Request failed`);
		});
	}
	isSuccessStatusCode(statusCode) {
		if (!statusCode) return false;
		return statusCode >= 200 && statusCode < 300;
	}
	isRetryableHttpStatusCode(statusCode) {
		if (!statusCode) return false;
		return [
			HttpCodes.BadGateway,
			HttpCodes.GatewayTimeout,
			HttpCodes.InternalServerError,
			HttpCodes.ServiceUnavailable
		].includes(statusCode);
	}
	sleep(milliseconds) {
		return __awaiter$5(this, void 0, void 0, function* () {
			return new Promise((resolve) => setTimeout(resolve, milliseconds));
		});
	}
	getExponentialRetryTimeMilliseconds(attempt) {
		if (attempt < 0) throw new Error("attempt should be a positive integer");
		if (attempt === 0) return this.baseRetryIntervalMilliseconds;
		const minTime = this.baseRetryIntervalMilliseconds * Math.pow(this.retryMultiplier, attempt);
		const maxTime = minTime * this.retryMultiplier;
		return Math.trunc(Math.random() * (maxTime - minTime) + minTime);
	}
};
function internalCacheTwirpClient(options) {
	return new CacheServiceClientJSON(new CacheServiceClient(getUserAgentString(), options === null || options === void 0 ? void 0 : options.maxAttempts, options === null || options === void 0 ? void 0 : options.retryIntervalMs, options === null || options === void 0 ? void 0 : options.retryMultiplier));
}
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/internal/tar.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());
	});
};
var IS_WINDOWS$1 = process.platform === "win32";
function getTarPath() {
	return __awaiter$4(this, void 0, void 0, function* () {
		switch (process.platform) {
			case "win32": {
				const gnuTar = yield getGnuTarPathOnWindows();
				const systemTar = SystemTarPathOnWindows;
				if (gnuTar) return {
					path: gnuTar,
					type: ArchiveToolType.GNU
				};
				else if (existsSync(systemTar)) return {
					path: systemTar,
					type: ArchiveToolType.BSD
				};
				break;
			}
			case "darwin": {
				const gnuTar = yield which("gtar", false);
				if (gnuTar) return {
					path: gnuTar,
					type: ArchiveToolType.GNU
				};
				else return {
					path: yield which("tar", true),
					type: ArchiveToolType.BSD
				};
			}
		}
		return {
			path: yield which("tar", true),
			type: ArchiveToolType.GNU
		};
	});
}
function getTarArgs(tarPath_1, compressionMethod_1, type_1) {
	return __awaiter$4(this, arguments, void 0, function* (tarPath, compressionMethod, type, archivePath = "") {
		const args = [`"${tarPath.path}"`];
		const cacheFileName = getCacheFileName(compressionMethod);
		const tarFile = "cache.tar";
		const workingDirectory = getWorkingDirectory();
		const BSD_TAR_ZSTD = tarPath.type === ArchiveToolType.BSD && compressionMethod !== CompressionMethod.Gzip && IS_WINDOWS$1;
		switch (type) {
			case "create":
				args.push("--posix", "-cf", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path$2.sep}`, "g"), "/"), "--exclude", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path$2.sep}`, "g"), "/"), "-P", "-C", workingDirectory.replace(new RegExp(`\\${path$2.sep}`, "g"), "/"), "--files-from", ManifestFilename);
				break;
			case "extract":
				args.push("-xf", BSD_TAR_ZSTD ? tarFile : archivePath.replace(new RegExp(`\\${path$2.sep}`, "g"), "/"), "-P", "-C", workingDirectory.replace(new RegExp(`\\${path$2.sep}`, "g"), "/"));
				break;
			case "list": args.push("-tf", BSD_TAR_ZSTD ? tarFile : archivePath.replace(new RegExp(`\\${path$2.sep}`, "g"), "/"), "-P");
		}
		if (tarPath.type === ArchiveToolType.GNU) switch (process.platform) {
			case "win32":
				args.push("--force-local");
				break;
			case "darwin": args.push("--delay-directory-restore");
		}
		return args;
	});
}
function getCommands(compressionMethod_1, type_1) {
	return __awaiter$4(this, arguments, void 0, function* (compressionMethod, type, archivePath = "") {
		let args;
		const tarPath = yield getTarPath();
		const tarArgs = yield getTarArgs(tarPath, compressionMethod, type, archivePath);
		const compressionArgs = type !== "create" ? yield getDecompressionProgram(tarPath, compressionMethod, archivePath) : yield getCompressionProgram(tarPath, compressionMethod);
		const BSD_TAR_ZSTD = tarPath.type === ArchiveToolType.BSD && compressionMethod !== CompressionMethod.Gzip && IS_WINDOWS$1;
		if (BSD_TAR_ZSTD && type !== "create") args = [[...compressionArgs].join(" "), [...tarArgs].join(" ")];
		else args = [[...tarArgs].join(" "), [...compressionArgs].join(" ")];
		if (BSD_TAR_ZSTD) return args;
		return [args.join(" ")];
	});
}
function getWorkingDirectory() {
	var _a;
	return (_a = process.env["GITHUB_WORKSPACE"]) !== null && _a !== void 0 ? _a : process.cwd();
}
function getDecompressionProgram(tarPath, compressionMethod, archivePath) {
	return __awaiter$4(this, void 0, void 0, function* () {
		const BSD_TAR_ZSTD = tarPath.type === ArchiveToolType.BSD && compressionMethod !== CompressionMethod.Gzip && IS_WINDOWS$1;
		switch (compressionMethod) {
			case CompressionMethod.Zstd: return BSD_TAR_ZSTD ? [
				"zstd -d --long=30 --force -o",
				TarFilename,
				archivePath.replace(new RegExp(`\\${path$2.sep}`, "g"), "/")
			] : ["--use-compress-program", IS_WINDOWS$1 ? "\"zstd -d --long=30\"" : "unzstd --long=30"];
			case CompressionMethod.ZstdWithoutLong: return BSD_TAR_ZSTD ? [
				"zstd -d --force -o",
				TarFilename,
				archivePath.replace(new RegExp(`\\${path$2.sep}`, "g"), "/")
			] : ["--use-compress-program", IS_WINDOWS$1 ? "\"zstd -d\"" : "unzstd"];
			default: return ["-z"];
		}
	});
}
function getCompressionProgram(tarPath, compressionMethod) {
	return __awaiter$4(this, void 0, void 0, function* () {
		const cacheFileName = getCacheFileName(compressionMethod);
		const BSD_TAR_ZSTD = tarPath.type === ArchiveToolType.BSD && compressionMethod !== CompressionMethod.Gzip && IS_WINDOWS$1;
		switch (compressionMethod) {
			case CompressionMethod.Zstd: return BSD_TAR_ZSTD ? [
				"zstd -T0 --long=30 --force -o",
				cacheFileName.replace(new RegExp(`\\${path$2.sep}`, "g"), "/"),
				TarFilename
			] : ["--use-compress-program", IS_WINDOWS$1 ? "\"zstd -T0 --long=30\"" : "zstdmt --long=30"];
			case CompressionMethod.ZstdWithoutLong: return BSD_TAR_ZSTD ? [
				"zstd -T0 --force -o",
				cacheFileName.replace(new RegExp(`\\${path$2.sep}`, "g"), "/"),
				TarFilename
			] : ["--use-compress-program", IS_WINDOWS$1 ? "\"zstd -T0\"" : "zstdmt"];
			default: return ["-z"];
		}
	});
}
function execCommands(commands, cwd) {
	return __awaiter$4(this, void 0, void 0, function* () {
		for (const command of commands) try {
			yield exec(command, void 0, {
				cwd,
				env: Object.assign(Object.assign({}, process.env), { MSYS: "winsymlinks:nativestrict" })
			});
		} catch (error) {
			throw new Error(`${command.split(" ")[0]} failed with error: ${error === null || error === void 0 ? void 0 : error.message}`);
		}
	});
}
function listTar(archivePath, compressionMethod) {
	return __awaiter$4(this, void 0, void 0, function* () {
		yield execCommands(yield getCommands(compressionMethod, "list", archivePath));
	});
}
function extractTar(archivePath, compressionMethod) {
	return __awaiter$4(this, void 0, void 0, function* () {
		yield mkdirP(getWorkingDirectory());
		yield execCommands(yield getCommands(compressionMethod, "extract", archivePath));
	});
}
function createTar(archiveFolder, sourceDirectories, compressionMethod) {
	return __awaiter$4(this, void 0, void 0, function* () {
		writeFileSync(path$2.join(archiveFolder, ManifestFilename), sourceDirectories.join("\n"));
		yield execCommands(yield getCommands(compressionMethod, "create"), archiveFolder);
	});
}
//#endregion
//#region node_modules/.pnpm/@actions+cache@6.2.0_supports-color@7.2.0/node_modules/@actions/cache/lib/cache.js
var __awaiter$3 = 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 ValidationError = class ValidationError extends Error {
	constructor(message) {
		super(message);
		this.name = "ValidationError";
		Object.setPrototypeOf(this, ValidationError.prototype);
	}
};
var ReserveCacheError = class ReserveCacheError extends Error {
	constructor(message) {
		super(message);
		this.name = "ReserveCacheError";
		Object.setPrototypeOf(this, ReserveCacheError.prototype);
	}
};
/**
* Raised when the cache backend refuses to reserve a writable cache entry
* because the JWT issued for this run was scoped read-only (for example, the
* run was triggered by an event the repository administrator classified as
* untrusted). The service-supplied detail message always begins with
* `cache write denied:` (the full error message includes additional context
* like the cache key).
*
* Extends ReserveCacheError for source-compatibility: existing
* `instanceof ReserveCacheError` checks and `typedError.name ===
* ReserveCacheError.name` paths keep working, while consumers that want to
* distinguish the policy case can match on this subclass.
*/
var CacheWriteDeniedError = class CacheWriteDeniedError extends ReserveCacheError {
	constructor(message) {
		super(message);
		this.name = "CacheWriteDeniedError";
		Object.setPrototypeOf(this, CacheWriteDeniedError.prototype);
	}
};
var CACHE_READ_DENIED_PREFIX = CacheReadDeniedMessagePrefix;
var CacheReadDeniedError = class CacheReadDeniedError extends Error {
	constructor(message) {
		super(message);
		this.name = "CacheReadDeniedError";
		Object.setPrototypeOf(this, CacheReadDeniedError.prototype);
	}
};
var FinalizeCacheError = class FinalizeCacheError extends Error {
	constructor(message) {
		super(message);
		this.name = "FinalizeCacheError";
		Object.setPrototypeOf(this, FinalizeCacheError.prototype);
	}
};
function checkPaths(paths) {
	if (!paths || paths.length === 0) throw new ValidationError(`Path Validation Error: At least one directory or file path is required`);
}
function checkKey(key) {
	if (key.length > 512) throw new ValidationError(`Key Validation Error: ${key} cannot be larger than 512 characters.`);
	if (!/^[^,]*$/.test(key)) throw new ValidationError(`Key Validation Error: ${key} cannot contain commas.`);
}
/**
* Restores cache from keys
*
* @param paths a list of file paths to restore from the cache
* @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching.
* @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey
* @param downloadOptions cache download options
* @param enableCrossOsArchive an optional boolean enabled to restore on windows any cache created on any platform
* @returns string returns the key for the cache hit, otherwise returns undefined
*/
function restoreCache(paths_1, primaryKey_1, restoreKeys_1, options_1) {
	return __awaiter$3(this, arguments, void 0, function* (paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) {
		const cacheServiceVersion = getCacheServiceVersion();
		debug(`Cache service version: ${cacheServiceVersion}`);
		checkPaths(paths);
		const cacheMode = getCacheMode();
		if (!isCacheReadable(cacheMode)) {
			info(`Cache restore skipped: the effective cache-mode '${cacheMode}' does not permit reads.`);
			debug(`Skipped restore for paths [${paths.join(", ")}] with primary key '${primaryKey}'.`);
			return;
		}
		switch (cacheServiceVersion) {
			case "v2": return yield restoreCacheV2(paths, primaryKey, restoreKeys, options, enableCrossOsArchive);
			default: return yield restoreCacheV1(paths, primaryKey, restoreKeys, options, enableCrossOsArchive);
		}
	});
}
/**
* Restores cache using the legacy Cache Service
*
* @param paths a list of file paths to restore from the cache
* @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching.
* @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey
* @param options cache download options
* @param enableCrossOsArchive an optional boolean enabled to restore on Windows any cache created on any platform
* @returns string returns the key for the cache hit, otherwise returns undefined
*/
function restoreCacheV1(paths_1, primaryKey_1, restoreKeys_1, options_1) {
	return __awaiter$3(this, arguments, void 0, function* (paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) {
		var _a;
		restoreKeys = restoreKeys || [];
		const keys = [primaryKey, ...restoreKeys];
		debug("Resolved Keys:");
		debug(JSON.stringify(keys));
		if (keys.length > 10) throw new ValidationError(`Key Validation Error: Keys are limited to a maximum of 10.`);
		for (const key of keys) checkKey(key);
		const compressionMethod = yield getCompressionMethod();
		let archivePath = "";
		try {
			let cacheEntry;
			try {
				cacheEntry = yield getCacheEntry(keys, paths, {
					compressionMethod,
					enableCrossOsArchive
				});
			} catch (error) {
				const errorMessage = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : "";
				if (errorMessage.includes(CACHE_READ_DENIED_PREFIX)) throw new CacheReadDeniedError(errorMessage);
				throw error;
			}
			if (!(cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.archiveLocation)) return;
			if (options === null || options === void 0 ? void 0 : options.lookupOnly) {
				info("Lookup only - skipping download");
				return cacheEntry.cacheKey;
			}
			archivePath = path$2.join(yield createTempDirectory(), getCacheFileName(compressionMethod));
			debug(`Archive Path: ${archivePath}`);
			yield downloadCache(cacheEntry.archiveLocation, archivePath, options);
			if (isDebug()) yield listTar(archivePath, compressionMethod);
			const archiveFileSize = getArchiveFileSizeInBytes(archivePath);
			info(`Cache Size: ~${Math.round(archiveFileSize / 1048576)} MB (${archiveFileSize} B)`);
			yield extractTar(archivePath, compressionMethod);
			info("Cache restored successfully");
			return cacheEntry.cacheKey;
		} catch (error$2) {
			const typedError = error$2;
			if (typedError.name === ValidationError.name) throw error$2;
			else if (typedError instanceof HttpClientError && typeof typedError.statusCode === "number" && typedError.statusCode >= 500) error(`Failed to restore: ${error$2.message}`);
			else warning(`Failed to restore: ${error$2.message}`);
		} finally {
			try {
				yield unlinkFile(archivePath);
			} catch (error) {
				debug(`Failed to delete archive: ${error}`);
			}
		}
	});
}
/**
* Restores cache using Cache Service v2
*
* @param paths a list of file paths to restore from the cache
* @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching
* @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey
* @param downloadOptions cache download options
* @param enableCrossOsArchive an optional boolean enabled to restore on windows any cache created on any platform
* @returns string returns the key for the cache hit, otherwise returns undefined
*/
function restoreCacheV2(paths_1, primaryKey_1, restoreKeys_1, options_1) {
	return __awaiter$3(this, arguments, void 0, function* (paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) {
		var _a;
		options = Object.assign(Object.assign({}, options), { useAzureSdk: true });
		restoreKeys = restoreKeys || [];
		const keys = [primaryKey, ...restoreKeys];
		debug("Resolved Keys:");
		debug(JSON.stringify(keys));
		if (keys.length > 10) throw new ValidationError(`Key Validation Error: Keys are limited to a maximum of 10.`);
		for (const key of keys) checkKey(key);
		let archivePath = "";
		try {
			const twirpClient = internalCacheTwirpClient();
			const compressionMethod = yield getCompressionMethod();
			const request = {
				key: primaryKey,
				restoreKeys,
				version: getCacheVersion(paths, compressionMethod, enableCrossOsArchive)
			};
			let response;
			try {
				response = yield twirpClient.GetCacheEntryDownloadURL(request);
			} catch (error) {
				const errorMessage = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : "";
				if (errorMessage.includes(CACHE_READ_DENIED_PREFIX)) throw new CacheReadDeniedError(errorMessage);
				throw error;
			}
			if (!response.ok) {
				debug(`Cache not found for version ${request.version} of keys: ${keys.join(", ")}`);
				return;
			}
			if (request.key !== response.matchedKey) info(`Cache hit for restore-key: ${response.matchedKey}`);
			else info(`Cache hit for: ${response.matchedKey}`);
			if (options === null || options === void 0 ? void 0 : options.lookupOnly) {
				info("Lookup only - skipping download");
				return response.matchedKey;
			}
			archivePath = path$2.join(yield createTempDirectory(), getCacheFileName(compressionMethod));
			debug(`Archive path: ${archivePath}`);
			debug(`Starting download of archive to: ${archivePath}`);
			yield downloadCache(response.signedDownloadUrl, archivePath, options);
			const archiveFileSize = getArchiveFileSizeInBytes(archivePath);
			info(`Cache Size: ~${Math.round(archiveFileSize / 1048576)} MB (${archiveFileSize} B)`);
			if (isDebug()) yield listTar(archivePath, compressionMethod);
			yield extractTar(archivePath, compressionMethod);
			info("Cache restored successfully");
			return response.matchedKey;
		} catch (error$5) {
			const typedError = error$5;
			if (typedError.name === ValidationError.name) throw error$5;
			else if (typedError instanceof HttpClientError && typeof typedError.statusCode === "number" && typedError.statusCode >= 500) error(`Failed to restore: ${error$5.message}`);
			else warning(`Failed to restore: ${error$5.message}`);
		} finally {
			try {
				if (archivePath) yield unlinkFile(archivePath);
			} catch (error) {
				debug(`Failed to delete archive: ${error}`);
			}
		}
	});
}
/**
* Saves a list of files with the specified key
*
* @param paths a list of file paths to be cached
* @param key an explicit key for restoring the cache
* @param enableCrossOsArchive an optional boolean enabled to save cache on windows which could be restored on any platform
* @param options cache upload options
* @returns number returns cacheId if the cache was saved successfully and throws an error if save fails
*/
function saveCache(paths_1, key_1, options_1) {
	return __awaiter$3(this, arguments, void 0, function* (paths, key, options, enableCrossOsArchive = false) {
		const cacheServiceVersion = getCacheServiceVersion();
		debug(`Cache service version: ${cacheServiceVersion}`);
		checkPaths(paths);
		checkKey(key);
		const cacheMode = getCacheMode();
		if (!isCacheWritable(cacheMode)) {
			info(`Cache save skipped: the effective cache-mode '${cacheMode}' does not permit writes.`);
			debug(`Skipped save for paths [${paths.join(", ")}] with key '${key}'.`);
			return -1;
		}
		switch (cacheServiceVersion) {
			case "v2": return yield saveCacheV2(paths, key, options, enableCrossOsArchive);
			default: return yield saveCacheV1(paths, key, options, enableCrossOsArchive);
		}
	});
}
/**
* Save cache using the legacy Cache Service
*
* @param paths
* @param key
* @param options
* @param enableCrossOsArchive
* @returns
*/
function saveCacheV1(paths_1, key_1, options_1) {
	return __awaiter$3(this, arguments, void 0, function* (paths, key, options, enableCrossOsArchive = false) {
		var _a;
		var _b;
		var _c;
		var _d;
		var _e;
		var _f;
		const compressionMethod = yield getCompressionMethod();
		let cacheId = -1;
		const cachePaths = yield resolvePaths(paths);
		debug("Cache Paths:");
		debug(`${JSON.stringify(cachePaths)}`);
		if (cachePaths.length === 0) throw new Error(`Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`);
		const archiveFolder = yield createTempDirectory();
		const archivePath = path$2.join(archiveFolder, getCacheFileName(compressionMethod));
		debug(`Archive Path: ${archivePath}`);
		try {
			yield createTar(archiveFolder, cachePaths, compressionMethod);
			if (isDebug()) yield listTar(archivePath, compressionMethod);
			const fileSizeLimit = 10737418240;
			const archiveFileSize = getArchiveFileSizeInBytes(archivePath);
			debug(`File Size: ${archiveFileSize}`);
			if (archiveFileSize > fileSizeLimit && !isGhes()) throw new Error(`Cache size of ~${Math.round(archiveFileSize / 1048576)} MB (${archiveFileSize} B) is over the 10GB limit, not saving cache.`);
			debug("Reserving Cache");
			const reserveCacheResponse = yield reserveCache(key, paths, {
				compressionMethod,
				enableCrossOsArchive,
				cacheSize: archiveFileSize
			});
			if ((_a = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.result) === null || _a === void 0 ? void 0 : _a.cacheId) cacheId = (_b = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.result) === null || _b === void 0 ? void 0 : _b.cacheId;
			else if ((reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.statusCode) === 400) throw new Error((_d = (_c = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : `Cache size of ~${Math.round(archiveFileSize / 1048576)} MB (${archiveFileSize} B) is over the data cap limit, not saving cache.`);
			else {
				const detailMessage = (_e = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _e === void 0 ? void 0 : _e.message;
				if (detailMessage === null || detailMessage === void 0 ? void 0 : detailMessage.startsWith("cache write denied:")) throw new CacheWriteDeniedError(`Unable to reserve cache with key ${key}. More details: ${detailMessage}`);
				throw new ReserveCacheError(`Unable to reserve cache with key ${key}, another job may be creating this cache. More details: ${(_f = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _f === void 0 ? void 0 : _f.message}`);
			}
			debug(`Saving Cache (ID: ${cacheId})`);
			yield saveCache$1(cacheId, archivePath, "", options);
		} catch (error$4) {
			const typedError = error$4;
			if (typedError.name === ValidationError.name) throw error$4;
			else if (typedError.name === ReserveCacheError.name) info(`Failed to save: ${typedError.message}`);
			else if (typedError instanceof HttpClientError && typeof typedError.statusCode === "number" && typedError.statusCode >= 500) error(`Failed to save: ${typedError.message}`);
			else warning(`Failed to save: ${typedError.message}`);
		} finally {
			try {
				yield unlinkFile(archivePath);
			} catch (error) {
				debug(`Failed to delete archive: ${error}`);
			}
		}
		return cacheId;
	});
}
/**
* Save cache using Cache Service v2
*
* @param paths a list of file paths to restore from the cache
* @param key an explicit key for restoring the cache
* @param options cache upload options
* @param enableCrossOsArchive an optional boolean enabled to save cache on windows which could be restored on any platform
* @returns
*/
function saveCacheV2(paths_1, key_1, options_1) {
	return __awaiter$3(this, arguments, void 0, function* (paths, key, options, enableCrossOsArchive = false) {
		var _a;
		options = Object.assign(Object.assign({}, options), {
			uploadChunkSize: 67108864,
			uploadConcurrency: 8,
			useAzureSdk: true
		});
		const compressionMethod = yield getCompressionMethod();
		const twirpClient = internalCacheTwirpClient();
		let cacheId = -1;
		const cachePaths = yield resolvePaths(paths);
		debug("Cache Paths:");
		debug(`${JSON.stringify(cachePaths)}`);
		if (cachePaths.length === 0) throw new Error(`Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`);
		const archiveFolder = yield createTempDirectory();
		const archivePath = path$2.join(archiveFolder, getCacheFileName(compressionMethod));
		debug(`Archive Path: ${archivePath}`);
		try {
			yield createTar(archiveFolder, cachePaths, compressionMethod);
			if (isDebug()) yield listTar(archivePath, compressionMethod);
			const archiveFileSize = getArchiveFileSizeInBytes(archivePath);
			debug(`File Size: ${archiveFileSize}`);
			options.archiveSizeBytes = archiveFileSize;
			debug("Reserving Cache");
			const version = getCacheVersion(paths, compressionMethod, enableCrossOsArchive);
			const request = {
				key,
				version
			};
			let signedUploadUrl;
			try {
				const response = yield twirpClient.CreateCacheEntry(request);
				if (!response.ok) {
					if (response.message && !response.message.startsWith("cache write denied:")) warning(`Cache reservation failed: ${response.message}`);
					throw new Error(response.message || "Response was not ok");
				}
				signedUploadUrl = response.signedUploadUrl;
			} catch (error) {
				debug(`Failed to reserve cache: ${error}`);
				const errorMessage = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : "";
				if (errorMessage.startsWith("cache write denied:")) throw new CacheWriteDeniedError(`Unable to reserve cache with key ${key}. More details: ${errorMessage}`);
				throw new ReserveCacheError(`Unable to reserve cache with key ${key}, another job may be creating this cache.`);
			}
			debug(`Attempting to upload cache located at: ${archivePath}`);
			yield saveCache$1(cacheId, archivePath, signedUploadUrl, options);
			const finalizeRequest = {
				key,
				version,
				sizeBytes: `${archiveFileSize}`
			};
			const finalizeResponse = yield twirpClient.FinalizeCacheEntryUpload(finalizeRequest);
			debug(`FinalizeCacheEntryUploadResponse: ${finalizeResponse.ok}`);
			if (!finalizeResponse.ok) {
				if (finalizeResponse.message) throw new FinalizeCacheError(finalizeResponse.message);
				throw new Error(`Unable to finalize cache with key ${key}, another job may be finalizing this cache.`);
			}
			cacheId = parseInt(finalizeResponse.entryId);
		} catch (error$3) {
			const typedError = error$3;
			if (typedError.name === ValidationError.name) throw error$3;
			else if (typedError.name === ReserveCacheError.name) info(`Failed to save: ${typedError.message}`);
			else if (typedError.name === FinalizeCacheError.name) warning(typedError.message);
			else if (typedError instanceof HttpClientError && typeof typedError.statusCode === "number" && typedError.statusCode >= 500) error(`Failed to save: ${typedError.message}`);
			else warning(`Failed to save: ${typedError.message}`);
		} finally {
			try {
				yield unlinkFile(archivePath);
			} catch (error) {
				debug(`Failed to delete archive: ${error}`);
			}
		}
		return cacheId;
	});
}
//#endregion
//#region node_modules/.pnpm/@actions-rs-plus+core@0.10.0_supports-color@7.2.0/node_modules/@actions-rs-plus/core/dist/commands/cargo.js
var Cargo = class Cargo extends BaseProgram {
	constructor(pathToCargo) {
		super(pathToCargo);
	}
	static async get() {
		try {
			const pathToCargo = await which("cargo", true);
			return new Cargo(pathToCargo);
		} catch (error$1) {
			error("cargo is not installed by default for some virtual environments, see https://help.github.com/en/articles/software-in-virtual-environments-for-github-actions");
			error("To install it, use this action: https://github.com/actions-rs/toolchain");
			throw error$1;
		}
	}
	/**
	Executes `cargo install ${program}`.
	
	TODO: Caching ability implementation is blocked,
	see https://github.com/actions-rs/core/issues/31
	As for now it acts just like an stub and simply installs the program
	on each call.
	
	`version` argument could be either actual program version or `"latest"` string,
	which can be provided by user input.
	
	If `version` is `undefined` or `"latest"`, this method could call the Crates.io API,
	fetch the latest version and search for it in cache.
	TODO: Actually implement this.
	
	## Returns
	
	Path to the installed program.
	As the $PATH should be already tuned properly at this point,
	returned value at the moment is simply equal to the `program` argument.
	*/
	async installCached(program, version, primaryKey, restoreKeys = []) {
		if (version === "latest") version = await resolveVersion(program);
		if (primaryKey === void 0) return this.install(program, version);
		const paths = [path.join(path.dirname(this.path), program)];
		const versionForKey = version === void 0 ? "" : `-${version}`;
		const programKey = `${program}${versionForKey}-${primaryKey}`;
		const cacheKey = await restoreCache(paths, programKey, restoreKeys.map((key) => {
			return `${program}${versionForKey}-${key}`;
		}));
		if (cacheKey !== void 0) {
			info(`Using cached \`${program}\` with version ${version ?? "installed-version"} from ${cacheKey}`);
			return program;
		}
		const result = await this.install(program, version);
		try {
			info(`Caching \`${program}\` with key ${programKey}`);
			await saveCache(paths, programKey);
		} catch (error) {
			if (Error.isError(error)) {
				if (error.name === ValidationError.name) throw error;
				if (error.name === ReserveCacheError.name) warning(error.message);
			} else if (typeof error === "string") warning(error);
			else throw error;
		}
		return result;
	}
	async install(program, version) {
		const arguments_ = ["install"];
		if (version !== void 0 && version !== "latest") arguments_.push("--version", version);
		arguments_.push(program);
		startGroup(`Installing "${program} = ${version ?? "latest"}"`);
		try {
			await this.call(arguments_);
		} finally {
			endGroup();
		}
		return program;
	}
	/**
	Find the cargo sub-command or install it
	*/
	async findOrInstall(program, version) {
		try {
			await which(program, true);
			return program;
		} catch {
			info(`${program} is not installed, installing it now`);
		}
		return this.installCached(program, version);
	}
};
//#endregion
//#region node_modules/.pnpm/@actions-rs-plus+core@0.10.0_supports-color@7.2.0/node_modules/@actions-rs-plus/core/dist/commands/cross.js
var Cross = class Cross extends BaseProgram {
	constructor(path) {
		super(path);
	}
	static async getOrInstall() {
		try {
			return await Cross.get();
		} catch (error) {
			debug(String(error));
			return Cross.install();
		}
	}
	static async get() {
		const path = await which("cross", true);
		return new Cross(path);
	}
	static async install(version) {
		const cargo = await Cargo.get();
		const cwd = process.cwd();
		process.chdir(os$2.tmpdir());
		try {
			const crossPath = await cargo.installCached("cross", version);
			return new Cross(crossPath);
		} finally {
			process.chdir(cwd);
		}
	}
};
process.platform;
process.platform;
//#endregion
//#region node_modules/.pnpm/@actions-rs-plus+core@0.10.0_supports-color@7.2.0/node_modules/@actions-rs-plus/core/dist/input.js
/**
Workaround for a GitHub weird input naming.

For input `all-features: true` it will generate the `INPUT_ALL-FEATURES: true`
env variable, which looks too weird.
Here we are trying to get proper name `INPUT_NO_DEFAULT_FEATURES` first,
and if it does not exist, trying the `INPUT_NO-DEFAULT-FEATURES`.
*/
function getInput(name, options) {
	const value = getInput$1(name.replaceAll("-", "_"), options);
	if (value.length > 0) return value;
	return getInput$1(name, options);
}
function getInputBool(name, options) {
	const normalized = getInput(name, options).trim().toLowerCase();
	return normalized === "true" || normalized === "1";
}
//#endregion
//#region src/schema.ts
var AnnotationLevel = /* @__PURE__ */ function(AnnotationLevel) {
	AnnotationLevel[AnnotationLevel["Error"] = 0] = "Error";
	AnnotationLevel[AnnotationLevel["Warning"] = 1] = "Warning";
	AnnotationLevel[AnnotationLevel["Notice"] = 2] = "Notice";
	return AnnotationLevel;
}({});
//#endregion
//#region src/output-parser.ts
var OutputParser = class OutputParser {
	_workingDirectory;
	_uniqueAnnotations;
	_stats;
	constructor(workingDirectory) {
		this._workingDirectory = workingDirectory ?? null;
		this._uniqueAnnotations = /* @__PURE__ */ new Map();
		this._stats = {
			ice: 0,
			error: 0,
			warning: 0,
			note: 0,
			help: 0
		};
	}
	get stats() {
		return this._stats;
	}
	get annotations() {
		return this._uniqueAnnotations.values().toArray().flat();
	}
	static parseCargoJson(line) {
		try {
			return JSON.parse(line);
		} catch {
			return null;
		}
	}
	static validateMessageIsCargoMessage(contents) {
		if (contents.reason !== "compiler-message") {
			debug(`Unexpected reason field, ignoring it: ${contents.reason}`);
			return false;
		}
		if (contents.message?.code === void 0 || contents.message.code === null) {
			debug("Message code is missing, ignoring it");
			return false;
		}
		return true;
	}
	static parseLevel(level) {
		switch (level) {
			case "help":
			case "note": return AnnotationLevel.Notice;
			case "warning": return AnnotationLevel.Warning;
			default: return AnnotationLevel.Error;
		}
	}
	tryParseClippyLine(line) {
		const message = OutputParser.parseCargoJson(line);
		if (message === null) {
			debug("Not valid JSON or null, ignoring it");
			return;
		}
		if (!OutputParser.validateMessageIsCargoMessage(message)) return;
		const parsedAnnotations = this.makeAnnotations(message);
		const key = JSON.stringify(parsedAnnotations);
		if (this._uniqueAnnotations.has(key)) return;
		switch (message.message.level) {
			case "help":
				this._stats.help += 1;
				break;
			case "note":
				this._stats.note += 1;
				break;
			case "warning":
				this._stats.warning += 1;
				break;
			case "error":
				this._stats.error += 1;
				break;
			case "error: internal compiler error": this._stats.ice += 1;
		}
		this._uniqueAnnotations.set(key, parsedAnnotations);
	}
	makeAnnotations(contents) {
		const level = OutputParser.parseLevel(contents.message.level);
		const primarySpans = contents.message.spans.filter((span) => {
			return span.is_primary;
		});
		if (primarySpans.length === 0) return [{
			level,
			message: contents.message.rendered,
			properties: { title: contents.message.message }
		}];
		return primarySpans.map((primarySpan) => {
			let pathToFile = primarySpan.file_name;
			if (this._workingDirectory !== null) pathToFile = path.join(this._workingDirectory, pathToFile);
			if (os$1.platform() === "win32") pathToFile = pathToFile.split(path.win32.sep).join(path.posix.sep);
			const annotation = {
				level,
				message: contents.message.rendered,
				properties: {
					file: pathToFile,
					startLine: primarySpan.line_start,
					endLine: primarySpan.line_end,
					title: contents.message.message
				}
			};
			if (primarySpan.line_start === primarySpan.line_end) {
				annotation.properties.startColumn = primarySpan.column_start;
				annotation.properties.endColumn = primarySpan.column_end;
			}
			return annotation;
		});
	}
};
//#endregion
//#region src/reporter.ts
function logAnnotation(annotation) {
	switch (annotation.level) {
		case AnnotationLevel.Error:
			error(annotation.message, annotation.properties);
			break;
		case AnnotationLevel.Notice:
			notice(annotation.message, annotation.properties);
			break;
		case AnnotationLevel.Warning: warning(annotation.message, annotation.properties);
	}
}
async function report(stats, annotations, context) {
	for (const annotation of annotations) logAnnotation(annotation);
	summary.addHeading("Clippy summary", 2);
	summary.addTable([
		[{
			header: true,
			data: "Message level"
		}, {
			header: true,
			data: "Amount"
		}],
		[{ data: "Internal compiler error" }, { data: stats.ice.toString() }],
		[{ data: "Error" }, { data: stats.error.toString() }],
		[{ data: "Warning" }, { data: stats.warning.toString() }],
		[{ data: "Note" }, { data: stats.note.toString() }],
		[{ data: "Help" }, { data: stats.help.toString() }]
	]);
	summary.addHeading("Versions", 2);
	summary.addList([
		context.rustc,
		context.cargo,
		context.clippy
	]);
	await summary.write();
}
//#endregion
//#region src/clippy.ts
async function buildContext(program, toolchain) {
	const context = {
		cargo: "",
		clippy: "",
		rustc: ""
	};
	await Promise.all([
		exec("rustc", buildToolchainArguments(toolchain, ["-V"]), {
			listeners: { stdout: (buffer) => {
				context.rustc = buffer.toString().trim();
			} },
			silent: false
		}),
		program.call(buildToolchainArguments(toolchain, ["-V"]), {
			listeners: { stdout: (buffer) => {
				context.cargo = buffer.toString().trim();
			} },
			silent: false
		}),
		program.call(buildToolchainArguments(toolchain, ["clippy", "-V"]), {
			listeners: { stdout: (buffer) => {
				context.clippy = buffer.toString().trim();
			} },
			silent: false
		})
	]);
	return context;
}
function _processLineBuffer(data, stringBuffer, onLine) {
	const POSIX_EOL = "\n";
	let s = stringBuffer + data.toString();
	let n = s.indexOf(POSIX_EOL);
	while (n > -1) {
		onLine(s.slice(0, Math.max(0, n)));
		s = s.slice(Math.max(0, n + 1));
		n = s.indexOf(POSIX_EOL);
	}
	return s;
}
async function runClippy(actionInput, program) {
	const arguments_ = buildClippyArguments(actionInput);
	const outputParser = new OutputParser(actionInput.workingDirectory);
	let stdbuffer = "";
	const options = {
		failOnStdErr: false,
		ignoreReturnCode: true,
		listeners: { stdout: (data) => {
			stdbuffer = _processLineBuffer(data, stdbuffer, (line) => {
				outputParser.tryParseClippyLine(line);
			});
		} }
	};
	if (actionInput.workingDirectory !== void 0 && actionInput.workingDirectory !== "") options.cwd = path.join(process.cwd(), actionInput.workingDirectory);
	let exitCode;
	try {
		startGroup("Executing cargo clippy (JSON output)");
		exitCode = await program.call(arguments_, options);
	} finally {
		endGroup();
	}
	return {
		stats: outputParser.stats,
		annotations: outputParser.annotations,
		exitCode
	};
}
function getProgram(useCross) {
	if (useCross) return Cross.getOrInstall();
	return Cargo.get();
}
async function run(actionInput) {
	const program = await getProgram(actionInput.useCross);
	const context = await buildContext(program, actionInput.toolchain);
	const { stats, annotations, exitCode } = await runClippy(actionInput, program);
	await report(stats, annotations, context);
	if (exitCode !== 0) throw new Error(`Clippy had exited with the ${exitCode} exit code`);
}
function buildToolchainArguments(toolchain, after) {
	const arguments_ = [];
	if (toolchain !== void 0 && toolchain !== "") arguments_.push(`+${toolchain}`);
	arguments_.push(...after);
	return arguments_;
}
function buildClippyArguments(actionInput) {
	return buildToolchainArguments(actionInput.toolchain, [
		"clippy",
		"--message-format=json",
		...actionInput.args
	]);
}
//#endregion
//#region node_modules/.pnpm/string-argv@0.3.2/node_modules/string-argv/index.js
function parseArgsStringToArgv(value, env, file) {
	var myRegexp = /([^\s'"]([^\s'"]*(['"])([^\3]*?)\3)+[^\s'"]*)|[^\s'"]+|(['"])([^\5]*?)\5/gi;
	var myString = value;
	var myArray = [];
	if (env) myArray.push(env);
	if (file) myArray.push(file);
	var match;
	do {
		match = myRegexp.exec(myString);
		if (match !== null) myArray.push(firstString(match[1], match[6], match[0]));
	} while (match !== null);
	return myArray;
}
function firstString() {
	var args = [];
	for (var _i = 0; _i < arguments.length; _i++) args[_i] = arguments[_i];
	for (var i = 0; i < args.length; i++) {
		var arg = args[i];
		if (typeof arg === "string") return arg;
	}
}
//#endregion
//#region src/input.ts
function get() {
	let toolchain = getInput("toolchain");
	if (toolchain.startsWith("+")) toolchain = toolchain.slice(1);
	const workingDirectory = getInput("working-directory");
	return {
		args: parseArgsStringToArgv(getInput("args")),
		useCross: getInputBool("use-cross"),
		workingDirectory: workingDirectory === "" ? void 0 : workingDirectory,
		toolchain: toolchain === "" ? void 0 : toolchain
	};
}
//#endregion
//#region src/index.ts
async function main() {
	try {
		await run(get());
	} catch (error) {
		if (Error.isError(error)) setFailed(error.message);
		else setFailed(String(error));
	}
}
await main();
//#endregion
export {};

//# sourceMappingURL=index.js.map