pecunia-root 0.1.1 → 0.1.3

package/dist/node_modules/.pnpm/mongodb@6.21.0/node_modules/mongodb/lib/connection_string.mjs

@@ -1,805 +0,0 @@
-import { __commonJSMin, __require } from "../../../../../../_virtual/rolldown_runtime.mjs";
-import { require_error } from "./error.mjs";
-import { require_read_preference } from "./read_preference.mjs";
-import { require_read_concern } from "./read_concern.mjs";
-import { require_write_concern } from "./write_concern.mjs";
-import { require_utils } from "./utils.mjs";
-import { require_mongo_logger } from "./mongo_logger.mjs";
-import { require_providers } from "./cmap/auth/providers.mjs";
-import { require_mongo_credentials } from "./cmap/auth/mongo_credentials.mjs";
-import { require_lib } from "../../../../mongodb-connection-string-url@3.0.2/node_modules/mongodb-connection-string-url/lib/index.mjs";
-import { require_compression } from "./cmap/wire_protocol/compression.mjs";
-import { require_encrypter } from "./encrypter.mjs";
-import { require_monitor } from "./sdam/monitor.mjs";
-import { require_mongo_client } from "./mongo_client.mjs";
-
-//#region ../../node_modules/.pnpm/mongodb@6.21.0/node_modules/mongodb/lib/connection_string.js
-var require_connection_string = /* @__PURE__ */ __commonJSMin(((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.DEFAULT_OPTIONS = exports.OPTIONS = void 0;
-	exports.resolveSRVRecord = resolveSRVRecord;
-	exports.parseOptions = parseOptions;
-	const dns = __require("dns");
-	const mongodb_connection_string_url_1 = require_lib();
-	const url_1 = __require("url");
-	const mongo_credentials_1 = require_mongo_credentials();
-	const providers_1 = require_providers();
-	const compression_1 = require_compression();
-	const encrypter_1 = require_encrypter();
-	const error_1 = require_error();
-	const mongo_client_1 = require_mongo_client();
-	const mongo_logger_1 = require_mongo_logger();
-	const read_concern_1 = require_read_concern();
-	const read_preference_1 = require_read_preference();
-	const monitor_1 = require_monitor();
-	const utils_1 = require_utils();
-	const write_concern_1 = require_write_concern();
-	const VALID_TXT_RECORDS = [
-		"authSource",
-		"replicaSet",
-		"loadBalanced"
-	];
-	const LB_SINGLE_HOST_ERROR = "loadBalanced option only supported with a single host in the URI";
-	const LB_REPLICA_SET_ERROR = "loadBalanced option not supported with a replicaSet option";
-	const LB_DIRECT_CONNECTION_ERROR = "loadBalanced option not supported when directConnection is provided";
-	function retryDNSTimeoutFor(api) {
-		return async function dnsReqRetryTimeout(lookupAddress) {
-			try {
-				return await dns.promises[api](lookupAddress);
-			} catch (firstDNSError) {
-				if (firstDNSError.code === dns.TIMEOUT) return await dns.promises[api](lookupAddress);
-				else throw firstDNSError;
-			}
-		};
-	}
-	const resolveSrv = retryDNSTimeoutFor("resolveSrv");
-	const resolveTxt = retryDNSTimeoutFor("resolveTxt");
-	/**
-	* Lookup a `mongodb+srv` connection string, combine the parts and reparse it as a normal
-	* connection string.
-	*
-	* @param uri - The connection string to parse
-	* @param options - Optional user provided connection string options
-	*/
-	async function resolveSRVRecord(options) {
-		if (typeof options.srvHost !== "string") throw new error_1.MongoAPIError("Option \"srvHost\" must not be empty");
-		const lookupAddress = options.srvHost;
-		const txtResolutionPromise = resolveTxt(lookupAddress);
-		txtResolutionPromise.then(void 0, utils_1.squashError);
-		const addresses = await resolveSrv(`_${options.srvServiceName}._tcp.${lookupAddress}`);
-		if (addresses.length === 0) throw new error_1.MongoAPIError("No addresses found at host");
-		for (const { name } of addresses) (0, utils_1.checkParentDomainMatch)(name, lookupAddress);
-		const hostAddresses = addresses.map((r) => utils_1.HostAddress.fromString(`${r.name}:${r.port ?? 27017}`));
-		validateLoadBalancedOptions(hostAddresses, options, true);
-		let record;
-		try {
-			record = await txtResolutionPromise;
-		} catch (error) {
-			if (error.code !== "ENODATA" && error.code !== "ENOTFOUND") throw error;
-			return hostAddresses;
-		}
-		if (record.length > 1) throw new error_1.MongoParseError("Multiple text records not allowed");
-		const txtRecordOptions = new url_1.URLSearchParams(record[0].join(""));
-		if ([...txtRecordOptions.keys()].some((key) => !VALID_TXT_RECORDS.includes(key))) throw new error_1.MongoParseError(`Text record may only set any of: ${VALID_TXT_RECORDS.join(", ")}`);
-		if (VALID_TXT_RECORDS.some((option) => txtRecordOptions.get(option) === "")) throw new error_1.MongoParseError("Cannot have empty URI params in DNS TXT Record");
-		const source = txtRecordOptions.get("authSource") ?? void 0;
-		const replicaSet = txtRecordOptions.get("replicaSet") ?? void 0;
-		const loadBalanced = txtRecordOptions.get("loadBalanced") ?? void 0;
-		if (!options.userSpecifiedAuthSource && source && options.credentials && !providers_1.AUTH_MECHS_AUTH_SRC_EXTERNAL.has(options.credentials.mechanism)) options.credentials = mongo_credentials_1.MongoCredentials.merge(options.credentials, { source });
-		if (!options.userSpecifiedReplicaSet && replicaSet) options.replicaSet = replicaSet;
-		if (loadBalanced === "true") options.loadBalanced = true;
-		if (options.replicaSet && options.srvMaxHosts > 0) throw new error_1.MongoParseError("Cannot combine replicaSet option with srvMaxHosts");
-		validateLoadBalancedOptions(hostAddresses, options, true);
-		return hostAddresses;
-	}
-	/**
-	* Checks if TLS options are valid
-	*
-	* @param allOptions - All options provided by user or included in default options map
-	* @throws MongoAPIError if TLS options are invalid
-	*/
-	function checkTLSOptions(allOptions) {
-		if (!allOptions) return;
-		const check = (a, b) => {
-			if (allOptions.has(a) && allOptions.has(b)) throw new error_1.MongoAPIError(`The '${a}' option cannot be used with the '${b}' option`);
-		};
-		check("tlsInsecure", "tlsAllowInvalidCertificates");
-		check("tlsInsecure", "tlsAllowInvalidHostnames");
-	}
-	function getBoolean(name, value) {
-		if (typeof value === "boolean") return value;
-		switch (value) {
-			case "true": return true;
-			case "false": return false;
-			default: throw new error_1.MongoParseError(`${name} must be either "true" or "false"`);
-		}
-	}
-	function getIntFromOptions(name, value) {
-		const parsedInt = (0, utils_1.parseInteger)(value);
-		if (parsedInt != null) return parsedInt;
-		throw new error_1.MongoParseError(`Expected ${name} to be stringified int value, got: ${value}`);
-	}
-	function getUIntFromOptions(name, value) {
-		const parsedValue = getIntFromOptions(name, value);
-		if (parsedValue < 0) throw new error_1.MongoParseError(`${name} can only be a positive int value, got: ${value}`);
-		return parsedValue;
-	}
-	function* entriesFromString(value) {
-		if (value === "") return;
-		const keyValuePairs = value.split(",");
-		for (const keyValue of keyValuePairs) {
-			const [key, value$1] = keyValue.split(/:(.*)/);
-			if (value$1 == null) throw new error_1.MongoParseError("Cannot have undefined values in key value pairs");
-			yield [key, value$1];
-		}
-	}
-	var CaseInsensitiveMap = class extends Map {
-		constructor(entries = []) {
-			super(entries.map(([k, v]) => [k.toLowerCase(), v]));
-		}
-		has(k) {
-			return super.has(k.toLowerCase());
-		}
-		get(k) {
-			return super.get(k.toLowerCase());
-		}
-		set(k, v) {
-			return super.set(k.toLowerCase(), v);
-		}
-		delete(k) {
-			return super.delete(k.toLowerCase());
-		}
-	};
-	function parseOptions(uri, mongoClient = void 0, options = {}) {
-		if (mongoClient != null && !(mongoClient instanceof mongo_client_1.MongoClient)) {
-			options = mongoClient;
-			mongoClient = void 0;
-		}
-		if (options.useBigInt64 && typeof options.promoteLongs === "boolean" && !options.promoteLongs) throw new error_1.MongoAPIError("Must request either bigint or Long for int64 deserialization");
-		if (options.useBigInt64 && typeof options.promoteValues === "boolean" && !options.promoteValues) throw new error_1.MongoAPIError("Must request either bigint or Long for int64 deserialization");
-		const url = new mongodb_connection_string_url_1.default(uri);
-		const { hosts, isSRV } = url;
-		const mongoOptions = Object.create(null);
-		mongoOptions.hosts = isSRV ? [] : hosts.map(utils_1.HostAddress.fromString);
-		const urlOptions = new CaseInsensitiveMap();
-		if (url.pathname !== "/" && url.pathname !== "") {
-			const dbName = decodeURIComponent(url.pathname[0] === "/" ? url.pathname.slice(1) : url.pathname);
-			if (dbName) urlOptions.set("dbName", [dbName]);
-		}
-		if (url.username !== "") {
-			const auth = { username: decodeURIComponent(url.username) };
-			if (typeof url.password === "string") auth.password = decodeURIComponent(url.password);
-			urlOptions.set("auth", [auth]);
-		}
-		for (const key of url.searchParams.keys()) {
-			const values = url.searchParams.getAll(key);
-			const isReadPreferenceTags = /readPreferenceTags/i.test(key);
-			if (!isReadPreferenceTags && values.length > 1) throw new error_1.MongoInvalidArgumentError(`URI option "${key}" cannot appear more than once in the connection string`);
-			if (!isReadPreferenceTags && values.includes("")) throw new error_1.MongoAPIError(`URI option "${key}" cannot be specified with no value`);
-			if (!urlOptions.has(key)) urlOptions.set(key, values);
-		}
-		const objectOptions = new CaseInsensitiveMap(Object.entries(options).filter(([, v]) => v != null));
-		if (urlOptions.has("serverApi")) throw new error_1.MongoParseError("URI cannot contain `serverApi`, it can only be passed to the client");
-		const uriMechanismProperties = urlOptions.get("authMechanismProperties");
-		if (uriMechanismProperties) {
-			for (const property of uriMechanismProperties) if (/(^|,)ALLOWED_HOSTS:/.test(property)) throw new error_1.MongoParseError("Auth mechanism property ALLOWED_HOSTS is not allowed in the connection string.");
-		}
-		if (objectOptions.has("loadBalanced")) throw new error_1.MongoParseError("loadBalanced is only a valid option in the URI");
-		const allProvidedOptions = new CaseInsensitiveMap();
-		const allProvidedKeys = new Set([...urlOptions.keys(), ...objectOptions.keys()]);
-		for (const key of allProvidedKeys) {
-			const values = [];
-			const objectOptionValue = objectOptions.get(key);
-			if (objectOptionValue != null) values.push(objectOptionValue);
-			const urlValues = urlOptions.get(key) ?? [];
-			values.push(...urlValues);
-			allProvidedOptions.set(key, values);
-		}
-		if (allProvidedOptions.has("tls") || allProvidedOptions.has("ssl")) {
-			const tlsAndSslOpts = (allProvidedOptions.get("tls") || []).concat(allProvidedOptions.get("ssl") || []).map(getBoolean.bind(null, "tls/ssl"));
-			if (new Set(tlsAndSslOpts).size !== 1) throw new error_1.MongoParseError("All values of tls/ssl must be the same.");
-		}
-		checkTLSOptions(allProvidedOptions);
-		const unsupportedOptions = (0, utils_1.setDifference)(allProvidedKeys, Array.from(Object.keys(exports.OPTIONS)).map((s) => s.toLowerCase()));
-		if (unsupportedOptions.size !== 0) {
-			const optionWord = unsupportedOptions.size > 1 ? "options" : "option";
-			const isOrAre = unsupportedOptions.size > 1 ? "are" : "is";
-			throw new error_1.MongoParseError(`${optionWord} ${Array.from(unsupportedOptions).join(", ")} ${isOrAre} not supported`);
-		}
-		for (const [key, descriptor] of Object.entries(exports.OPTIONS)) {
-			const values = allProvidedOptions.get(key);
-			if (!values || values.length === 0) {
-				if (exports.DEFAULT_OPTIONS.has(key)) setOption(mongoOptions, key, descriptor, [exports.DEFAULT_OPTIONS.get(key)]);
-			} else {
-				const { deprecated } = descriptor;
-				if (deprecated) {
-					const deprecatedMsg = typeof deprecated === "string" ? `: ${deprecated}` : "";
-					(0, utils_1.emitWarning)(`${key} is a deprecated option${deprecatedMsg}`);
-				}
-				setOption(mongoOptions, key, descriptor, values);
-			}
-		}
-		if (mongoOptions.credentials) {
-			const isGssapi = mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_GSSAPI;
-			const isX509 = mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_X509;
-			const isAws = mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_AWS;
-			const isOidc = mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_OIDC;
-			if ((isGssapi || isX509) && allProvidedOptions.has("authSource") && mongoOptions.credentials.source !== "$external") throw new error_1.MongoParseError(`authMechanism ${mongoOptions.credentials.mechanism} requires an authSource of '$external'`);
-			if (!(isGssapi || isX509 || isAws || isOidc) && mongoOptions.dbName && !allProvidedOptions.has("authSource")) mongoOptions.credentials = mongo_credentials_1.MongoCredentials.merge(mongoOptions.credentials, { source: mongoOptions.dbName });
-			if (isAws && mongoOptions.credentials.username && !mongoOptions.credentials.password) throw new error_1.MongoMissingCredentialsError(`When using ${mongoOptions.credentials.mechanism} password must be set when a username is specified`);
-			mongoOptions.credentials.validate();
-			if (mongoOptions.credentials.password === "" && mongoOptions.credentials.username === "" && mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_DEFAULT && Object.keys(mongoOptions.credentials.mechanismProperties).length === 0) delete mongoOptions.credentials;
-		}
-		if (!mongoOptions.dbName) mongoOptions.dbName = "test";
-		validateLoadBalancedOptions(hosts, mongoOptions, isSRV);
-		if (mongoClient && mongoOptions.autoEncryption) {
-			encrypter_1.Encrypter.checkForMongoCrypt();
-			mongoOptions.encrypter = new encrypter_1.Encrypter(mongoClient, uri, options);
-			mongoOptions.autoEncrypter = mongoOptions.encrypter.autoEncrypter;
-		}
-		mongoOptions.userSpecifiedAuthSource = objectOptions.has("authSource") || urlOptions.has("authSource");
-		mongoOptions.userSpecifiedReplicaSet = objectOptions.has("replicaSet") || urlOptions.has("replicaSet");
-		if (isSRV) {
-			mongoOptions.srvHost = hosts[0];
-			if (mongoOptions.directConnection) throw new error_1.MongoAPIError("SRV URI does not support directConnection");
-			if (mongoOptions.srvMaxHosts > 0 && typeof mongoOptions.replicaSet === "string") throw new error_1.MongoParseError("Cannot use srvMaxHosts option with replicaSet");
-			const noUserSpecifiedTLS = !objectOptions.has("tls") && !urlOptions.has("tls");
-			const noUserSpecifiedSSL = !objectOptions.has("ssl") && !urlOptions.has("ssl");
-			if (noUserSpecifiedTLS && noUserSpecifiedSSL) mongoOptions.tls = true;
-		} else if (urlOptions.has("srvMaxHosts") || objectOptions.has("srvMaxHosts") || urlOptions.has("srvServiceName") || objectOptions.has("srvServiceName")) throw new error_1.MongoParseError("Cannot use srvMaxHosts or srvServiceName with a non-srv connection string");
-		if (mongoOptions.directConnection && mongoOptions.hosts.length !== 1) throw new error_1.MongoParseError("directConnection option requires exactly one host");
-		if (!mongoOptions.proxyHost && (mongoOptions.proxyPort || mongoOptions.proxyUsername || mongoOptions.proxyPassword)) throw new error_1.MongoParseError("Must specify proxyHost if other proxy options are passed");
-		if (mongoOptions.proxyUsername && !mongoOptions.proxyPassword || !mongoOptions.proxyUsername && mongoOptions.proxyPassword) throw new error_1.MongoParseError("Can only specify both of proxy username/password or neither");
-		if ([
-			"proxyHost",
-			"proxyPort",
-			"proxyUsername",
-			"proxyPassword"
-		].map((key) => urlOptions.get(key) ?? []).some((options$1) => options$1.length > 1)) throw new error_1.MongoParseError("Proxy options cannot be specified multiple times in the connection string");
-		mongoOptions.mongoLoggerOptions = mongo_logger_1.MongoLogger.resolveOptions({
-			MONGODB_LOG_COMMAND: process.env.MONGODB_LOG_COMMAND,
-			MONGODB_LOG_TOPOLOGY: process.env.MONGODB_LOG_TOPOLOGY,
-			MONGODB_LOG_SERVER_SELECTION: process.env.MONGODB_LOG_SERVER_SELECTION,
-			MONGODB_LOG_CONNECTION: process.env.MONGODB_LOG_CONNECTION,
-			MONGODB_LOG_CLIENT: process.env.MONGODB_LOG_CLIENT,
-			MONGODB_LOG_ALL: process.env.MONGODB_LOG_ALL,
-			MONGODB_LOG_MAX_DOCUMENT_LENGTH: process.env.MONGODB_LOG_MAX_DOCUMENT_LENGTH,
-			MONGODB_LOG_PATH: process.env.MONGODB_LOG_PATH
-		}, {
-			mongodbLogPath: mongoOptions.mongodbLogPath,
-			mongodbLogComponentSeverities: mongoOptions.mongodbLogComponentSeverities,
-			mongodbLogMaxDocumentLength: mongoOptions.mongodbLogMaxDocumentLength
-		});
-		return mongoOptions;
-	}
-	/**
-	* #### Throws if LB mode is true:
-	* - hosts contains more than one host
-	* - there is a replicaSet name set
-	* - directConnection is set
-	* - if srvMaxHosts is used when an srv connection string is passed in
-	*
-	* @throws MongoParseError
-	*/
-	function validateLoadBalancedOptions(hosts, mongoOptions, isSrv) {
-		if (mongoOptions.loadBalanced) {
-			if (hosts.length > 1) throw new error_1.MongoParseError(LB_SINGLE_HOST_ERROR);
-			if (mongoOptions.replicaSet) throw new error_1.MongoParseError(LB_REPLICA_SET_ERROR);
-			if (mongoOptions.directConnection) throw new error_1.MongoParseError(LB_DIRECT_CONNECTION_ERROR);
-			if (isSrv && mongoOptions.srvMaxHosts > 0) throw new error_1.MongoParseError("Cannot limit srv hosts with loadBalanced enabled");
-		}
-	}
-	function setOption(mongoOptions, key, descriptor, values) {
-		const { target, type, transform } = descriptor;
-		const name = target ?? key;
-		switch (type) {
-			case "boolean":
-				mongoOptions[name] = getBoolean(name, values[0]);
-				break;
-			case "int":
-				mongoOptions[name] = getIntFromOptions(name, values[0]);
-				break;
-			case "uint":
-				mongoOptions[name] = getUIntFromOptions(name, values[0]);
-				break;
-			case "string":
-				if (values[0] == null) break;
-				mongoOptions[name] = String(values[0]);
-				break;
-			case "record":
-				if (!(0, utils_1.isRecord)(values[0])) throw new error_1.MongoParseError(`${name} must be an object`);
-				mongoOptions[name] = values[0];
-				break;
-			case "any":
-				mongoOptions[name] = values[0];
-				break;
-			default:
-				if (!transform) throw new error_1.MongoParseError("Descriptors missing a type must define a transform");
-				mongoOptions[name] = transform({
-					name,
-					options: mongoOptions,
-					values
-				});
-				break;
-		}
-	}
-	exports.OPTIONS = {
-		appName: { type: "string" },
-		auth: {
-			target: "credentials",
-			transform({ name, options, values: [value] }) {
-				if (!(0, utils_1.isRecord)(value, ["username", "password"])) throw new error_1.MongoParseError(`${name} must be an object with 'username' and 'password' properties`);
-				return mongo_credentials_1.MongoCredentials.merge(options.credentials, {
-					username: value.username,
-					password: value.password
-				});
-			}
-		},
-		authMechanism: {
-			target: "credentials",
-			transform({ options, values: [value] }) {
-				const mechanisms = Object.values(providers_1.AuthMechanism);
-				const [mechanism] = mechanisms.filter((m) => m.match(RegExp(String.raw`\b${value}\b`, "i")));
-				if (!mechanism) throw new error_1.MongoParseError(`authMechanism one of ${mechanisms}, got ${value}`);
-				let source = options.credentials?.source;
-				if (mechanism === providers_1.AuthMechanism.MONGODB_PLAIN || providers_1.AUTH_MECHS_AUTH_SRC_EXTERNAL.has(mechanism)) source = "$external";
-				let password = options.credentials?.password;
-				if (mechanism === providers_1.AuthMechanism.MONGODB_X509 && password === "") password = void 0;
-				return mongo_credentials_1.MongoCredentials.merge(options.credentials, {
-					mechanism,
-					source,
-					password
-				});
-			}
-		},
-		authMechanismProperties: {
-			target: "credentials",
-			transform({ options, values }) {
-				let mechanismProperties = Object.create(null);
-				for (const optionValue of values) if (typeof optionValue === "string") for (const [key, value] of entriesFromString(optionValue)) try {
-					mechanismProperties[key] = getBoolean(key, value);
-				} catch {
-					mechanismProperties[key] = value;
-				}
-				else {
-					if (!(0, utils_1.isRecord)(optionValue)) throw new error_1.MongoParseError("AuthMechanismProperties must be an object");
-					mechanismProperties = { ...optionValue };
-				}
-				return mongo_credentials_1.MongoCredentials.merge(options.credentials, { mechanismProperties });
-			}
-		},
-		authSource: {
-			target: "credentials",
-			transform({ options, values: [value] }) {
-				const source = String(value);
-				return mongo_credentials_1.MongoCredentials.merge(options.credentials, { source });
-			}
-		},
-		autoEncryption: { type: "record" },
-		autoSelectFamily: {
-			type: "boolean",
-			default: true
-		},
-		autoSelectFamilyAttemptTimeout: { type: "uint" },
-		bsonRegExp: { type: "boolean" },
-		serverApi: {
-			target: "serverApi",
-			transform({ values: [version] }) {
-				const serverApiToValidate = typeof version === "string" ? { version } : version;
-				const versionToValidate = serverApiToValidate && serverApiToValidate.version;
-				if (!versionToValidate) throw new error_1.MongoParseError(`Invalid \`serverApi\` property; must specify a version from the following enum: ["${Object.values(mongo_client_1.ServerApiVersion).join("\", \"")}"]`);
-				if (!Object.values(mongo_client_1.ServerApiVersion).some((v) => v === versionToValidate)) throw new error_1.MongoParseError(`Invalid server API version=${versionToValidate}; must be in the following enum: ["${Object.values(mongo_client_1.ServerApiVersion).join("\", \"")}"]`);
-				return serverApiToValidate;
-			}
-		},
-		checkKeys: { type: "boolean" },
-		compressors: {
-			default: "none",
-			target: "compressors",
-			transform({ values }) {
-				const compressionList = /* @__PURE__ */ new Set();
-				for (const compVal of values) {
-					const compValArray = typeof compVal === "string" ? compVal.split(",") : compVal;
-					if (!Array.isArray(compValArray)) throw new error_1.MongoInvalidArgumentError("compressors must be an array or a comma-delimited list of strings");
-					for (const c of compValArray) if (Object.keys(compression_1.Compressor).includes(String(c))) compressionList.add(String(c));
-					else throw new error_1.MongoInvalidArgumentError(`${c} is not a valid compression mechanism. Must be one of: ${Object.keys(compression_1.Compressor)}.`);
-				}
-				return [...compressionList];
-			}
-		},
-		connectTimeoutMS: {
-			default: 3e4,
-			type: "uint"
-		},
-		dbName: { type: "string" },
-		directConnection: {
-			default: false,
-			type: "boolean"
-		},
-		driverInfo: {
-			default: {},
-			type: "record"
-		},
-		enableUtf8Validation: {
-			type: "boolean",
-			default: true
-		},
-		family: { transform({ name, values: [value] }) {
-			const transformValue = getIntFromOptions(name, value);
-			if (transformValue === 4 || transformValue === 6) return transformValue;
-			throw new error_1.MongoParseError(`Option 'family' must be 4 or 6 got ${transformValue}.`);
-		} },
-		fieldsAsRaw: { type: "record" },
-		forceServerObjectId: {
-			default: false,
-			type: "boolean"
-		},
-		fsync: {
-			deprecated: "Please use journal instead",
-			target: "writeConcern",
-			transform({ name, options, values: [value] }) {
-				const wc = write_concern_1.WriteConcern.fromOptions({ writeConcern: {
-					...options.writeConcern,
-					fsync: getBoolean(name, value)
-				} });
-				if (!wc) throw new error_1.MongoParseError(`Unable to make a writeConcern from fsync=${value}`);
-				return wc;
-			}
-		},
-		heartbeatFrequencyMS: {
-			default: 1e4,
-			type: "uint"
-		},
-		ignoreUndefined: { type: "boolean" },
-		j: {
-			deprecated: "Please use journal instead",
-			target: "writeConcern",
-			transform({ name, options, values: [value] }) {
-				const wc = write_concern_1.WriteConcern.fromOptions({ writeConcern: {
-					...options.writeConcern,
-					journal: getBoolean(name, value)
-				} });
-				if (!wc) throw new error_1.MongoParseError(`Unable to make a writeConcern from journal=${value}`);
-				return wc;
-			}
-		},
-		journal: {
-			target: "writeConcern",
-			transform({ name, options, values: [value] }) {
-				const wc = write_concern_1.WriteConcern.fromOptions({ writeConcern: {
-					...options.writeConcern,
-					journal: getBoolean(name, value)
-				} });
-				if (!wc) throw new error_1.MongoParseError(`Unable to make a writeConcern from journal=${value}`);
-				return wc;
-			}
-		},
-		loadBalanced: {
-			default: false,
-			type: "boolean"
-		},
-		localThresholdMS: {
-			default: 15,
-			type: "uint"
-		},
-		maxConnecting: {
-			default: 2,
-			transform({ name, values: [value] }) {
-				const maxConnecting = getUIntFromOptions(name, value);
-				if (maxConnecting === 0) throw new error_1.MongoInvalidArgumentError("maxConnecting must be > 0 if specified");
-				return maxConnecting;
-			}
-		},
-		maxIdleTimeMS: {
-			default: 0,
-			type: "uint"
-		},
-		maxPoolSize: {
-			default: 100,
-			type: "uint"
-		},
-		maxStalenessSeconds: {
-			target: "readPreference",
-			transform({ name, options, values: [value] }) {
-				const maxStalenessSeconds = getUIntFromOptions(name, value);
-				if (options.readPreference) return read_preference_1.ReadPreference.fromOptions({ readPreference: {
-					...options.readPreference,
-					maxStalenessSeconds
-				} });
-				else return new read_preference_1.ReadPreference("secondary", void 0, { maxStalenessSeconds });
-			}
-		},
-		minInternalBufferSize: { type: "uint" },
-		minPoolSize: {
-			default: 0,
-			type: "uint"
-		},
-		minHeartbeatFrequencyMS: {
-			default: 500,
-			type: "uint"
-		},
-		monitorCommands: {
-			default: false,
-			type: "boolean"
-		},
-		name: {
-			target: "driverInfo",
-			transform({ values: [value], options }) {
-				return {
-					...options.driverInfo,
-					name: String(value)
-				};
-			}
-		},
-		noDelay: {
-			default: true,
-			type: "boolean"
-		},
-		pkFactory: {
-			default: utils_1.DEFAULT_PK_FACTORY,
-			transform({ values: [value] }) {
-				if ((0, utils_1.isRecord)(value, ["createPk"]) && typeof value.createPk === "function") return value;
-				throw new error_1.MongoParseError(`Option pkFactory must be an object with a createPk function, got ${value}`);
-			}
-		},
-		promoteBuffers: { type: "boolean" },
-		promoteLongs: { type: "boolean" },
-		promoteValues: { type: "boolean" },
-		useBigInt64: { type: "boolean" },
-		proxyHost: { type: "string" },
-		proxyPassword: { type: "string" },
-		proxyPort: { type: "uint" },
-		proxyUsername: { type: "string" },
-		raw: {
-			default: false,
-			type: "boolean"
-		},
-		readConcern: { transform({ values: [value], options }) {
-			if (value instanceof read_concern_1.ReadConcern || (0, utils_1.isRecord)(value, ["level"])) return read_concern_1.ReadConcern.fromOptions({
-				...options.readConcern,
-				...value
-			});
-			throw new error_1.MongoParseError(`ReadConcern must be an object, got ${JSON.stringify(value)}`);
-		} },
-		readConcernLevel: {
-			target: "readConcern",
-			transform({ values: [level], options }) {
-				return read_concern_1.ReadConcern.fromOptions({
-					...options.readConcern,
-					level
-				});
-			}
-		},
-		readPreference: {
-			default: read_preference_1.ReadPreference.primary,
-			transform({ values: [value], options }) {
-				if (value instanceof read_preference_1.ReadPreference) return read_preference_1.ReadPreference.fromOptions({
-					readPreference: {
-						...options.readPreference,
-						...value
-					},
-					...value
-				});
-				if ((0, utils_1.isRecord)(value, ["mode"])) {
-					const rp = read_preference_1.ReadPreference.fromOptions({
-						readPreference: {
-							...options.readPreference,
-							...value
-						},
-						...value
-					});
-					if (rp) return rp;
-					else throw new error_1.MongoParseError(`Cannot make read preference from ${JSON.stringify(value)}`);
-				}
-				if (typeof value === "string") {
-					const rpOpts = {
-						hedge: options.readPreference?.hedge,
-						maxStalenessSeconds: options.readPreference?.maxStalenessSeconds
-					};
-					return new read_preference_1.ReadPreference(value, options.readPreference?.tags, rpOpts);
-				}
-				throw new error_1.MongoParseError(`Unknown ReadPreference value: ${value}`);
-			}
-		},
-		readPreferenceTags: {
-			target: "readPreference",
-			transform({ values, options }) {
-				const tags = Array.isArray(values[0]) ? values[0] : values;
-				const readPreferenceTags = [];
-				for (const tag of tags) {
-					const readPreferenceTag = Object.create(null);
-					if (typeof tag === "string") for (const [k, v] of entriesFromString(tag)) readPreferenceTag[k] = v;
-					if ((0, utils_1.isRecord)(tag)) for (const [k, v] of Object.entries(tag)) readPreferenceTag[k] = v;
-					readPreferenceTags.push(readPreferenceTag);
-				}
-				return read_preference_1.ReadPreference.fromOptions({
-					readPreference: options.readPreference,
-					readPreferenceTags
-				});
-			}
-		},
-		replicaSet: { type: "string" },
-		retryReads: {
-			default: true,
-			type: "boolean"
-		},
-		retryWrites: {
-			default: true,
-			type: "boolean"
-		},
-		serializeFunctions: { type: "boolean" },
-		serverMonitoringMode: {
-			default: "auto",
-			transform({ values: [value] }) {
-				if (!Object.values(monitor_1.ServerMonitoringMode).includes(value)) throw new error_1.MongoParseError("serverMonitoringMode must be one of `auto`, `poll`, or `stream`");
-				return value;
-			}
-		},
-		serverSelectionTimeoutMS: {
-			default: 3e4,
-			type: "uint"
-		},
-		servername: { type: "string" },
-		socketTimeoutMS: {
-			default: 0,
-			type: "uint"
-		},
-		srvMaxHosts: {
-			type: "uint",
-			default: 0
-		},
-		srvServiceName: {
-			type: "string",
-			default: "mongodb"
-		},
-		ssl: {
-			target: "tls",
-			type: "boolean"
-		},
-		timeoutMS: { type: "uint" },
-		tls: { type: "boolean" },
-		tlsAllowInvalidCertificates: {
-			target: "rejectUnauthorized",
-			transform({ name, values: [value] }) {
-				return !getBoolean(name, value);
-			}
-		},
-		tlsAllowInvalidHostnames: {
-			target: "checkServerIdentity",
-			transform({ name, values: [value] }) {
-				return getBoolean(name, value) ? () => void 0 : void 0;
-			}
-		},
-		tlsCAFile: { type: "string" },
-		tlsCRLFile: { type: "string" },
-		tlsCertificateKeyFile: { type: "string" },
-		tlsCertificateKeyFilePassword: {
-			target: "passphrase",
-			type: "any"
-		},
-		tlsInsecure: { transform({ name, options, values: [value] }) {
-			const tlsInsecure = getBoolean(name, value);
-			if (tlsInsecure) {
-				options.checkServerIdentity = () => void 0;
-				options.rejectUnauthorized = false;
-			} else {
-				options.checkServerIdentity = options.tlsAllowInvalidHostnames ? () => void 0 : void 0;
-				options.rejectUnauthorized = options.tlsAllowInvalidCertificates ? false : true;
-			}
-			return tlsInsecure;
-		} },
-		w: {
-			target: "writeConcern",
-			transform({ values: [value], options }) {
-				return write_concern_1.WriteConcern.fromOptions({ writeConcern: {
-					...options.writeConcern,
-					w: value
-				} });
-			}
-		},
-		waitQueueTimeoutMS: {
-			default: 0,
-			type: "uint"
-		},
-		writeConcern: {
-			target: "writeConcern",
-			transform({ values: [value], options }) {
-				if ((0, utils_1.isRecord)(value) || value instanceof write_concern_1.WriteConcern) return write_concern_1.WriteConcern.fromOptions({ writeConcern: {
-					...options.writeConcern,
-					...value
-				} });
-				else if (value === "majority" || typeof value === "number") return write_concern_1.WriteConcern.fromOptions({ writeConcern: {
-					...options.writeConcern,
-					w: value
-				} });
-				throw new error_1.MongoParseError(`Invalid WriteConcern cannot parse: ${JSON.stringify(value)}`);
-			}
-		},
-		wtimeout: {
-			deprecated: "Please use wtimeoutMS instead",
-			target: "writeConcern",
-			transform({ values: [value], options }) {
-				const wc = write_concern_1.WriteConcern.fromOptions({ writeConcern: {
-					...options.writeConcern,
-					wtimeout: getUIntFromOptions("wtimeout", value)
-				} });
-				if (wc) return wc;
-				throw new error_1.MongoParseError(`Cannot make WriteConcern from wtimeout`);
-			}
-		},
-		wtimeoutMS: {
-			target: "writeConcern",
-			transform({ values: [value], options }) {
-				const wc = write_concern_1.WriteConcern.fromOptions({ writeConcern: {
-					...options.writeConcern,
-					wtimeoutMS: getUIntFromOptions("wtimeoutMS", value)
-				} });
-				if (wc) return wc;
-				throw new error_1.MongoParseError(`Cannot make WriteConcern from wtimeout`);
-			}
-		},
-		zlibCompressionLevel: {
-			default: 0,
-			type: "int"
-		},
-		mongodbLogPath: { transform({ values: [value] }) {
-			if (!(typeof value === "string" && ["stderr", "stdout"].includes(value) || value && typeof value === "object" && "write" in value && typeof value.write === "function")) throw new error_1.MongoAPIError(`Option 'mongodbLogPath' must be of type 'stderr' | 'stdout' | MongoDBLogWritable`);
-			return value;
-		} },
-		mongodbLogComponentSeverities: { transform({ values: [value] }) {
-			if (typeof value !== "object" || !value) throw new error_1.MongoAPIError(`Option 'mongodbLogComponentSeverities' must be a non-null object`);
-			for (const [k, v] of Object.entries(value)) {
-				if (typeof v !== "string" || typeof k !== "string") throw new error_1.MongoAPIError(`User input for option 'mongodbLogComponentSeverities' object cannot include a non-string key or value`);
-				if (!Object.values(mongo_logger_1.MongoLoggableComponent).some((val) => val === k) && k !== "default") throw new error_1.MongoAPIError(`User input for option 'mongodbLogComponentSeverities' contains invalid key: ${k}`);
-				if (!Object.values(mongo_logger_1.SeverityLevel).some((val) => val === v)) throw new error_1.MongoAPIError(`Option 'mongodbLogComponentSeverities' does not support ${v} as a value for ${k}`);
-			}
-			return value;
-		} },
-		mongodbLogMaxDocumentLength: { type: "uint" },
-		connectionType: { type: "any" },
-		srvPoller: { type: "any" },
-		allowPartialTrustChain: { type: "any" },
-		minDHSize: { type: "any" },
-		pskCallback: { type: "any" },
-		secureContext: { type: "any" },
-		enableTrace: { type: "any" },
-		requestCert: { type: "any" },
-		rejectUnauthorized: { type: "any" },
-		checkServerIdentity: { type: "any" },
-		keepAliveInitialDelay: { type: "any" },
-		ALPNProtocols: { type: "any" },
-		SNICallback: { type: "any" },
-		session: { type: "any" },
-		requestOCSP: { type: "any" },
-		localAddress: { type: "any" },
-		localPort: { type: "any" },
-		hints: { type: "any" },
-		lookup: { type: "any" },
-		ca: { type: "any" },
-		cert: { type: "any" },
-		ciphers: { type: "any" },
-		crl: { type: "any" },
-		ecdhCurve: { type: "any" },
-		key: { type: "any" },
-		passphrase: { type: "any" },
-		pfx: { type: "any" },
-		secureProtocol: { type: "any" },
-		index: { type: "any" },
-		useNewUrlParser: {
-			type: "boolean",
-			deprecated: "useNewUrlParser has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version"
-		},
-		useUnifiedTopology: {
-			type: "boolean",
-			deprecated: "useUnifiedTopology has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version"
-		},
-		__skipPingOnConnect: { type: "boolean" }
-	};
-	exports.DEFAULT_OPTIONS = new CaseInsensitiveMap(Object.entries(exports.OPTIONS).filter(([, descriptor]) => descriptor.default != null).map(([k, d]) => [k, d.default]));
-}));
-
-//#endregion
-export default require_connection_string();
-
-export { require_connection_string };
-//# sourceMappingURL=connection_string.mjs.map