nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/_libs/deepmerge.mjs

@@ -0,0 +1,86 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js
+var require_cjs = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js": ((exports, module) => {
+	var isMergeableObject = function isMergeableObject$1(value) {
+		return isNonNullObject(value) && !isSpecial(value);
+	};
+	function isNonNullObject(value) {
+		return !!value && typeof value === "object";
+	}
+	function isSpecial(value) {
+		var stringValue = Object.prototype.toString.call(value);
+		return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
+	}
+	var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for ? Symbol.for("react.element") : 60103;
+	function isReactElement(value) {
+		return value.$$typeof === REACT_ELEMENT_TYPE;
+	}
+	function emptyTarget(val) {
+		return Array.isArray(val) ? [] : {};
+	}
+	function cloneUnlessOtherwiseSpecified(value, options) {
+		return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
+	}
+	function defaultArrayMerge(target, source, options) {
+		return target.concat(source).map(function(element) {
+			return cloneUnlessOtherwiseSpecified(element, options);
+		});
+	}
+	function getMergeFunction(key, options) {
+		if (!options.customMerge) return deepmerge;
+		var customMerge = options.customMerge(key);
+		return typeof customMerge === "function" ? customMerge : deepmerge;
+	}
+	function getEnumerableOwnPropertySymbols(target) {
+		return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+			return Object.propertyIsEnumerable.call(target, symbol);
+		}) : [];
+	}
+	function getKeys(target) {
+		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+	}
+	function propertyIsOnObject(object, property) {
+		try {
+			return property in object;
+		} catch (_) {
+			return false;
+		}
+	}
+	function propertyIsUnsafe(target, key) {
+		return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+	}
+	function mergeObject(target, source, options) {
+		var destination = {};
+		if (options.isMergeableObject(target)) getKeys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+		});
+		getKeys(source).forEach(function(key) {
+			if (propertyIsUnsafe(target, key)) return;
+			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+			else destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+		});
+		return destination;
+	}
+	function deepmerge(target, source, options) {
+		options = options || {};
+		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+		var sourceIsArray = Array.isArray(source);
+		if (!(sourceIsArray === Array.isArray(target))) return cloneUnlessOtherwiseSpecified(source, options);
+		else if (sourceIsArray) return options.arrayMerge(target, source, options);
+		else return mergeObject(target, source, options);
+	}
+	deepmerge.all = function deepmergeAll(array, options) {
+		if (!Array.isArray(array)) throw new Error("first argument should be an array");
+		return array.reduce(function(prev, next) {
+			return deepmerge(prev, next, options);
+		}, {});
+	};
+	var deepmerge_1 = deepmerge;
+	module.exports = deepmerge_1;
+}) });
+
+//#endregion
+export { require_cjs as t };

package/dist/_libs/depd.mjs

@@ -0,0 +1,314 @@
+import { i as __require, t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/depd@2.0.0/node_modules/depd/index.js
+var require_depd = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/depd@2.0.0/node_modules/depd/index.js": ((exports, module) => {
+	/*!
+	* depd
+	* Copyright(c) 2014-2018 Douglas Christopher Wilson
+	* MIT Licensed
+	*/
+	/**
+	* Module dependencies.
+	*/
+	var relative = __require("path").relative;
+	/**
+	* Module exports.
+	*/
+	module.exports = depd;
+	/**
+	* Get the path to base files on.
+	*/
+	var basePath = process.cwd();
+	/**
+	* Determine if namespace is contained in the string.
+	*/
+	function containsNamespace(str, namespace) {
+		var vals = str.split(/[ ,]+/);
+		var ns = String(namespace).toLowerCase();
+		for (var i = 0; i < vals.length; i++) {
+			var val = vals[i];
+			if (val && (val === "*" || val.toLowerCase() === ns)) return true;
+		}
+		return false;
+	}
+	/**
+	* Convert a data descriptor to accessor descriptor.
+	*/
+	function convertDataDescriptorToAccessor(obj, prop, message) {
+		var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+		var value = descriptor.value;
+		descriptor.get = function getter() {
+			return value;
+		};
+		if (descriptor.writable) descriptor.set = function setter(val) {
+			return value = val;
+		};
+		delete descriptor.value;
+		delete descriptor.writable;
+		Object.defineProperty(obj, prop, descriptor);
+		return descriptor;
+	}
+	/**
+	* Create arguments string to keep arity.
+	*/
+	function createArgumentsString(arity) {
+		var str = "";
+		for (var i = 0; i < arity; i++) str += ", arg" + i;
+		return str.substr(2);
+	}
+	/**
+	* Create stack string from stack.
+	*/
+	function createStackString(stack) {
+		var str = this.name + ": " + this.namespace;
+		if (this.message) str += " deprecated " + this.message;
+		for (var i = 0; i < stack.length; i++) str += "\n    at " + stack[i].toString();
+		return str;
+	}
+	/**
+	* Create deprecate for namespace in caller.
+	*/
+	function depd(namespace) {
+		if (!namespace) throw new TypeError("argument namespace is required");
+		var file = callSiteLocation(getStack()[1])[0];
+		function deprecate(message) {
+			log.call(deprecate, message);
+		}
+		deprecate._file = file;
+		deprecate._ignored = isignored(namespace);
+		deprecate._namespace = namespace;
+		deprecate._traced = istraced(namespace);
+		deprecate._warned = Object.create(null);
+		deprecate.function = wrapfunction;
+		deprecate.property = wrapproperty;
+		return deprecate;
+	}
+	/**
+	* Determine if event emitter has listeners of a given type.
+	*
+	* The way to do this check is done three different ways in Node.js >= 0.8
+	* so this consolidates them into a minimal set using instance methods.
+	*
+	* @param {EventEmitter} emitter
+	* @param {string} type
+	* @returns {boolean}
+	* @private
+	*/
+	function eehaslisteners(emitter, type) {
+		return (typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type)) > 0;
+	}
+	/**
+	* Determine if namespace is ignored.
+	*/
+	function isignored(namespace) {
+		if (process.noDeprecation) return true;
+		return containsNamespace(process.env.NO_DEPRECATION || "", namespace);
+	}
+	/**
+	* Determine if namespace is traced.
+	*/
+	function istraced(namespace) {
+		if (process.traceDeprecation) return true;
+		return containsNamespace(process.env.TRACE_DEPRECATION || "", namespace);
+	}
+	/**
+	* Display deprecation message.
+	*/
+	function log(message, site) {
+		var haslisteners = eehaslisteners(process, "deprecation");
+		if (!haslisteners && this._ignored) return;
+		var caller;
+		var callFile;
+		var callSite;
+		var depSite;
+		var i = 0;
+		var seen = false;
+		var stack = getStack();
+		var file = this._file;
+		if (site) {
+			depSite = site;
+			callSite = callSiteLocation(stack[1]);
+			callSite.name = depSite.name;
+			file = callSite[0];
+		} else {
+			i = 2;
+			depSite = callSiteLocation(stack[i]);
+			callSite = depSite;
+		}
+		for (; i < stack.length; i++) {
+			caller = callSiteLocation(stack[i]);
+			callFile = caller[0];
+			if (callFile === file) seen = true;
+			else if (callFile === this._file) file = this._file;
+			else if (seen) break;
+		}
+		var key = caller ? depSite.join(":") + "__" + caller.join(":") : void 0;
+		if (key !== void 0 && key in this._warned) return;
+		this._warned[key] = true;
+		var msg = message;
+		if (!msg) msg = callSite === depSite || !callSite.name ? defaultMessage(depSite) : defaultMessage(callSite);
+		if (haslisteners) {
+			var err = DeprecationError(this._namespace, msg, stack.slice(i));
+			process.emit("deprecation", err);
+			return;
+		}
+		var output = (process.stderr.isTTY ? formatColor : formatPlain).call(this, msg, caller, stack.slice(i));
+		process.stderr.write(output + "\n", "utf8");
+	}
+	/**
+	* Get call site location as array.
+	*/
+	function callSiteLocation(callSite) {
+		var file = callSite.getFileName() || "<anonymous>";
+		var line = callSite.getLineNumber();
+		var colm = callSite.getColumnNumber();
+		if (callSite.isEval()) file = callSite.getEvalOrigin() + ", " + file;
+		var site = [
+			file,
+			line,
+			colm
+		];
+		site.callSite = callSite;
+		site.name = callSite.getFunctionName();
+		return site;
+	}
+	/**
+	* Generate a default message from the site.
+	*/
+	function defaultMessage(site) {
+		var callSite = site.callSite;
+		var funcName = site.name;
+		if (!funcName) funcName = "<anonymous@" + formatLocation(site) + ">";
+		var context = callSite.getThis();
+		var typeName = context && callSite.getTypeName();
+		if (typeName === "Object") typeName = void 0;
+		if (typeName === "Function") typeName = context.name || typeName;
+		return typeName && callSite.getMethodName() ? typeName + "." + funcName : funcName;
+	}
+	/**
+	* Format deprecation message without color.
+	*/
+	function formatPlain(msg, caller, stack) {
+		var formatted = (/* @__PURE__ */ new Date()).toUTCString() + " " + this._namespace + " deprecated " + msg;
+		if (this._traced) {
+			for (var i = 0; i < stack.length; i++) formatted += "\n    at " + stack[i].toString();
+			return formatted;
+		}
+		if (caller) formatted += " at " + formatLocation(caller);
+		return formatted;
+	}
+	/**
+	* Format deprecation message with color.
+	*/
+	function formatColor(msg, caller, stack) {
+		var formatted = "\x1B[36;1m" + this._namespace + "\x1B[22;39m \x1B[33;1mdeprecated\x1B[22;39m \x1B[0m" + msg + "\x1B[39m";
+		if (this._traced) {
+			for (var i = 0; i < stack.length; i++) formatted += "\n    \x1B[36mat " + stack[i].toString() + "\x1B[39m";
+			return formatted;
+		}
+		if (caller) formatted += " \x1B[36m" + formatLocation(caller) + "\x1B[39m";
+		return formatted;
+	}
+	/**
+	* Format call site location.
+	*/
+	function formatLocation(callSite) {
+		return relative(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
+	}
+	/**
+	* Get the stack as array of call sites.
+	*/
+	function getStack() {
+		var limit = Error.stackTraceLimit;
+		var obj = {};
+		var prep = Error.prepareStackTrace;
+		Error.prepareStackTrace = prepareObjectStackTrace;
+		Error.stackTraceLimit = Math.max(10, limit);
+		Error.captureStackTrace(obj);
+		var stack = obj.stack.slice(1);
+		Error.prepareStackTrace = prep;
+		Error.stackTraceLimit = limit;
+		return stack;
+	}
+	/**
+	* Capture call site stack from v8.
+	*/
+	function prepareObjectStackTrace(obj, stack) {
+		return stack;
+	}
+	/**
+	* Return a wrapped function in a deprecation message.
+	*/
+	function wrapfunction(fn, message) {
+		if (typeof fn !== "function") throw new TypeError("argument fn must be a function");
+		var args = createArgumentsString(fn.length);
+		var site = callSiteLocation(getStack()[1]);
+		site.name = fn.name;
+		return new Function("fn", "log", "deprecate", "message", "site", "\"use strict\"\nreturn function (" + args + ") {log.call(deprecate, message, site)\nreturn fn.apply(this, arguments)\n}")(fn, log, this, message, site);
+	}
+	/**
+	* Wrap property in a deprecation message.
+	*/
+	function wrapproperty(obj, prop, message) {
+		if (!obj || typeof obj !== "object" && typeof obj !== "function") throw new TypeError("argument obj must be object");
+		var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+		if (!descriptor) throw new TypeError("must call property on owner object");
+		if (!descriptor.configurable) throw new TypeError("property must be configurable");
+		var deprecate = this;
+		var site = callSiteLocation(getStack()[1]);
+		site.name = prop;
+		if ("value" in descriptor) descriptor = convertDataDescriptorToAccessor(obj, prop, message);
+		var get = descriptor.get;
+		var set = descriptor.set;
+		if (typeof get === "function") descriptor.get = function getter() {
+			log.call(deprecate, message, site);
+			return get.apply(this, arguments);
+		};
+		if (typeof set === "function") descriptor.set = function setter() {
+			log.call(deprecate, message, site);
+			return set.apply(this, arguments);
+		};
+		Object.defineProperty(obj, prop, descriptor);
+	}
+	/**
+	* Create DeprecationError for deprecation
+	*/
+	function DeprecationError(namespace, message, stack) {
+		var error = /* @__PURE__ */ new Error();
+		var stackString;
+		Object.defineProperty(error, "constructor", { value: DeprecationError });
+		Object.defineProperty(error, "message", {
+			configurable: true,
+			enumerable: false,
+			value: message,
+			writable: true
+		});
+		Object.defineProperty(error, "name", {
+			enumerable: false,
+			configurable: true,
+			value: "DeprecationError",
+			writable: true
+		});
+		Object.defineProperty(error, "namespace", {
+			configurable: true,
+			enumerable: false,
+			value: namespace,
+			writable: true
+		});
+		Object.defineProperty(error, "stack", {
+			configurable: true,
+			enumerable: false,
+			get: function() {
+				if (stackString !== void 0) return stackString;
+				return stackString = createStackString.call(this, stack);
+			},
+			set: function setter(val) {
+				stackString = val;
+			}
+		});
+		return error;
+	}
+}) });
+
+//#endregion
+export { require_depd as t };

package/dist/_libs/dot-prop.mjs

@@ -0,0 +1,138 @@
+//#region node_modules/.pnpm/dot-prop@10.1.0/node_modules/dot-prop/index.js
+const isObject = (value) => {
+	const type = typeof value;
+	return value !== null && (type === "object" || type === "function");
+};
+const disallowedKeys = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+const MAX_ARRAY_INDEX = 1e6;
+const isDigit = (character) => character >= "0" && character <= "9";
+function shouldCoerceToNumber(segment) {
+	if (segment === "0") return true;
+	if (/^[1-9]\d*$/.test(segment)) {
+		const parsedNumber = Number.parseInt(segment, 10);
+		return parsedNumber <= Number.MAX_SAFE_INTEGER && parsedNumber <= MAX_ARRAY_INDEX;
+	}
+	return false;
+}
+function processSegment(segment, parts) {
+	if (disallowedKeys.has(segment)) return false;
+	if (segment && shouldCoerceToNumber(segment)) parts.push(Number.parseInt(segment, 10));
+	else parts.push(segment);
+	return true;
+}
+function parsePath(path) {
+	if (typeof path !== "string") throw new TypeError(`Expected a string, got ${typeof path}`);
+	const parts = [];
+	let currentSegment = "";
+	let currentPart = "start";
+	let isEscaping = false;
+	let position = 0;
+	for (const character of path) {
+		position++;
+		if (isEscaping) {
+			currentSegment += character;
+			isEscaping = false;
+			continue;
+		}
+		if (character === "\\") {
+			if (currentPart === "index") throw new Error(`Invalid character '${character}' in an index at position ${position}`);
+			if (currentPart === "indexEnd") throw new Error(`Invalid character '${character}' after an index at position ${position}`);
+			isEscaping = true;
+			currentPart = currentPart === "start" ? "property" : currentPart;
+			continue;
+		}
+		switch (character) {
+			case ".":
+				if (currentPart === "index") throw new Error(`Invalid character '${character}' in an index at position ${position}`);
+				if (currentPart === "indexEnd") {
+					currentPart = "property";
+					break;
+				}
+				if (!processSegment(currentSegment, parts)) return [];
+				currentSegment = "";
+				currentPart = "property";
+				break;
+			case "[":
+				if (currentPart === "index") throw new Error(`Invalid character '${character}' in an index at position ${position}`);
+				if (currentPart === "indexEnd") {
+					currentPart = "index";
+					break;
+				}
+				if (currentPart === "property" || currentPart === "start") {
+					if ((currentSegment || currentPart === "property") && !processSegment(currentSegment, parts)) return [];
+					currentSegment = "";
+				}
+				currentPart = "index";
+				break;
+			case "]":
+				if (currentPart === "index") {
+					if (currentSegment === "") {
+						currentSegment = (parts.pop() || "") + "[]";
+						currentPart = "property";
+					} else {
+						const parsedNumber = Number.parseInt(currentSegment, 10);
+						if (!Number.isNaN(parsedNumber) && Number.isFinite(parsedNumber) && parsedNumber >= 0 && parsedNumber <= Number.MAX_SAFE_INTEGER && parsedNumber <= MAX_ARRAY_INDEX && currentSegment === String(parsedNumber)) parts.push(parsedNumber);
+						else parts.push(currentSegment);
+						currentSegment = "";
+						currentPart = "indexEnd";
+					}
+					break;
+				}
+				if (currentPart === "indexEnd") throw new Error(`Invalid character '${character}' after an index at position ${position}`);
+				currentSegment += character;
+				break;
+			default:
+				if (currentPart === "index" && !isDigit(character)) throw new Error(`Invalid character '${character}' in an index at position ${position}`);
+				if (currentPart === "indexEnd") throw new Error(`Invalid character '${character}' after an index at position ${position}`);
+				if (currentPart === "start") currentPart = "property";
+				currentSegment += character;
+		}
+	}
+	if (isEscaping) currentSegment += "\\";
+	switch (currentPart) {
+		case "property":
+			if (!processSegment(currentSegment, parts)) return [];
+			break;
+		case "index": throw new Error("Index was not closed");
+		case "start":
+			parts.push("");
+			break;
+	}
+	return parts;
+}
+function normalizePath(path) {
+	if (typeof path === "string") return parsePath(path);
+	if (Array.isArray(path)) {
+		const normalized = [];
+		for (const [index, segment] of path.entries()) {
+			if (typeof segment !== "string" && typeof segment !== "number") throw new TypeError(`Expected a string or number for path segment at index ${index}, got ${typeof segment}`);
+			if (typeof segment === "number" && !Number.isFinite(segment)) throw new TypeError(`Path segment at index ${index} must be a finite number, got ${segment}`);
+			if (disallowedKeys.has(segment)) return [];
+			if (typeof segment === "string" && shouldCoerceToNumber(segment)) normalized.push(Number.parseInt(segment, 10));
+			else normalized.push(segment);
+		}
+		return normalized;
+	}
+	return [];
+}
+function getProperty(object, path, value) {
+	if (!isObject(object) || typeof path !== "string" && !Array.isArray(path)) return value === void 0 ? object : value;
+	const pathArray = normalizePath(path);
+	if (pathArray.length === 0) return value;
+	for (let index = 0; index < pathArray.length; index++) {
+		const key = pathArray[index];
+		object = object[key];
+		if (object === void 0 || object === null) {
+			if (index !== pathArray.length - 1) return value;
+			break;
+		}
+	}
+	return object === void 0 ? value : object;
+}
+
+//#endregion
+export { getProperty as t };

package/dist/_libs/duplexer.mjs

@@ -0,0 +1,71 @@
+import { i as __require, t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/duplexer@0.1.2/node_modules/duplexer/index.js
+var require_duplexer = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/duplexer@0.1.2/node_modules/duplexer/index.js": ((exports, module) => {
+	var Stream = __require("stream");
+	var writeMethods = [
+		"write",
+		"end",
+		"destroy"
+	];
+	var readMethods = ["resume", "pause"];
+	var readEvents = ["data", "close"];
+	var slice = Array.prototype.slice;
+	module.exports = duplex;
+	function forEach(arr, fn) {
+		if (arr.forEach) return arr.forEach(fn);
+		for (var i = 0; i < arr.length; i++) fn(arr[i], i);
+	}
+	function duplex(writer, reader) {
+		var stream = new Stream();
+		var ended = false;
+		forEach(writeMethods, proxyWriter);
+		forEach(readMethods, proxyReader);
+		forEach(readEvents, proxyStream);
+		reader.on("end", handleEnd);
+		writer.on("drain", function() {
+			stream.emit("drain");
+		});
+		writer.on("error", reemit);
+		reader.on("error", reemit);
+		stream.writable = writer.writable;
+		stream.readable = reader.readable;
+		return stream;
+		function proxyWriter(methodName) {
+			stream[methodName] = method;
+			function method() {
+				return writer[methodName].apply(writer, arguments);
+			}
+		}
+		function proxyReader(methodName) {
+			stream[methodName] = method;
+			function method() {
+				stream.emit(methodName);
+				var func = reader[methodName];
+				if (func) return func.apply(reader, arguments);
+				reader.emit(methodName);
+			}
+		}
+		function proxyStream(methodName) {
+			reader.on(methodName, reemit$1);
+			function reemit$1() {
+				var args = slice.call(arguments);
+				args.unshift(methodName);
+				stream.emit.apply(stream, args);
+			}
+		}
+		function handleEnd() {
+			if (ended) return;
+			ended = true;
+			var args = slice.call(arguments);
+			args.unshift("end");
+			stream.emit.apply(stream, args);
+		}
+		function reemit(err) {
+			stream.emit("error", err);
+		}
+	}
+}) });
+
+//#endregion
+export { require_duplexer as t };

package/dist/_libs/ee-first.mjs

@@ -0,0 +1,68 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/ee-first@1.1.1/node_modules/ee-first/index.js
+var require_ee_first = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/ee-first@1.1.1/node_modules/ee-first/index.js": ((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = first;
+	/**
+	* Get the first event in a set of event emitters and event pairs.
+	*
+	* @param {array} stuff
+	* @param {function} done
+	* @public
+	*/
+	function first(stuff, done) {
+		if (!Array.isArray(stuff)) throw new TypeError("arg must be an array of [ee, events...] arrays");
+		var cleanups = [];
+		for (var i = 0; i < stuff.length; i++) {
+			var arr = stuff[i];
+			if (!Array.isArray(arr) || arr.length < 2) throw new TypeError("each array member must be [ee, events...]");
+			var ee = arr[0];
+			for (var j = 1; j < arr.length; j++) {
+				var event = arr[j];
+				var fn = listener(event, callback);
+				ee.on(event, fn);
+				cleanups.push({
+					ee,
+					event,
+					fn
+				});
+			}
+		}
+		function callback() {
+			cleanup();
+			done.apply(null, arguments);
+		}
+		function cleanup() {
+			var x;
+			for (var i$1 = 0; i$1 < cleanups.length; i$1++) {
+				x = cleanups[i$1];
+				x.ee.removeListener(x.event, x.fn);
+			}
+		}
+		function thunk(fn$1) {
+			done = fn$1;
+		}
+		thunk.cancel = cleanup;
+		return thunk;
+	}
+	/**
+	* Create the event listener.
+	* @private
+	*/
+	function listener(event, done) {
+		return function onevent(arg1) {
+			var args = new Array(arguments.length);
+			var ee = this;
+			var err = event === "error" ? arg1 : null;
+			for (var i = 0; i < args.length; i++) args[i] = arguments[i];
+			done(err, ee, event, args);
+		};
+	}
+}) });
+
+//#endregion
+export { require_ee_first as t };