@faasjs/node-utils 8.0.0-beta.10

package/dist/index.mjs

@@ -0,0 +1,1065 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { loadEnvFile } from "node:process";
+
+//#region src/deep_merge.ts
+const shouldMerge = (item) => {
+	const type = Object.prototype.toString.call(item);
+	return type === "[object Object]" || type === "[object Array]";
+};
+/**
+* Deep merge two objects or arrays.
+*
+* Features:
+* * All objects will be cloned before merging.
+* * Merging order is from right to left.
+* * If an array include same objects, it will be unique to one.
+*
+* ```ts
+* deepMerge({ a: 1 }, { a: 2 }) // { a: 2 }
+* deepMerge([1, 2], [2, 3]) // [1, 2, 3]
+* ```
+*/
+function deepMerge(...sources) {
+	let acc = Object.create(null);
+	for (const source of sources) {
+		if (Array.isArray(source)) {
+			if (!Array.isArray(acc)) acc = [];
+			acc = [...new Set(source.concat(...acc))];
+			continue;
+		}
+		if (!shouldMerge(source)) continue;
+		for (const [key, value] of Object.entries(source)) acc = {
+			...acc,
+			[key]: shouldMerge(value) ? deepMerge(acc[key], value) : value
+		};
+	}
+	return acc;
+}
+
+//#endregion
+//#region src/color.ts
+const Color = {
+	DEFAULT: 39,
+	BLACK: 30,
+	RED: 31,
+	GREEN: 32,
+	ORANGE: 33,
+	BLUE: 34,
+	MAGENTA: 35,
+	CYAN: 36,
+	GRAY: 90
+};
+const LevelColor = {
+	debug: Color.GRAY,
+	info: Color.GREEN,
+	warn: Color.ORANGE,
+	error: Color.RED
+};
+/**
+* Apply ANSI color codes to a message based on the log level.
+*
+* @param level - The log level to determine the color.
+* @param message - The message to be colorized.
+* @returns The colorized message string.
+*/
+function colorfy(level, message) {
+	return `\u001b[0${LevelColor[level]}m${message}\u001b[39m`;
+}
+
+//#endregion
+//#region src/format.ts
+/**
+* Formats a string using placeholders and arguments.
+*
+* The function supports the following placeholders:
+* - `%o`: Formats the argument as a JSON string if it's an array, otherwise falls through to `%s`.
+* - `%s`: Converts the argument to a string.
+* - `%d`: Converts the argument to a number.
+* - `%j`: Formats the argument as a JSON string.
+*/
+function format(fmt, ...args) {
+	const re = /(%?)(%([ojds]))/g;
+	let fmtString;
+	if (typeof fmt !== "string") if (fmt instanceof Error) fmtString = `Error: ${fmt.message}\n${fmt.stack}`;
+	else if (fmt instanceof Object) fmtString = JSON.stringify(fmt);
+	else fmtString = String(fmt);
+	else fmtString = fmt;
+	if (args.length) fmtString = fmtString.replace(re, (match, escaped, _, flag) => {
+		let arg = args.shift();
+		switch (flag) {
+			case "o": if (Array.isArray(arg)) {
+				arg = JSON.stringify(arg);
+				break;
+			}
+			case "s":
+				arg = `${arg}`;
+				break;
+			case "d":
+				arg = Number(arg);
+				break;
+			case "j":
+				arg = JSON.stringify(arg);
+				break;
+		}
+		if (!escaped) return arg;
+		args.unshift(arg);
+		return match;
+	});
+	if (args.length) fmtString += ` ${args.join(" ")}`;
+	fmtString = fmtString.replace(/%{2,2}/g, "%");
+	return fmtString;
+}
+
+//#endregion
+//#region src/transport.ts
+/**
+* The transport class that manages the transport handlers and log messages.
+*
+* **Note: This class is not meant to be used directly. Use the {@link getTransport} instead.**
+*
+* @example
+* ```typescript
+* import { getTransport } from '@faasjs/node-utils'
+*
+* const transport = getTransport()
+*
+* transport.register('test', async (messages) => {
+*  for (const { level, message } of messages)
+*    console.log(level, message)
+* })
+*
+* transport.config({ label: 'test', debug: true })
+*
+* // If you using Logger, it will automatically insert messages to the transport.
+* // Otherwise, you can insert messages manually.
+* transport.insert({
+*   level: 'info',
+*   labels: ['server'],
+*   message: 'test message',
+*   timestamp: Date.now()
+* })
+*
+* process.on('SIGINT', async () => {
+*   await transport.stop()
+*   process.exit(0)
+* })
+* ```
+*/
+var Transport = class {
+	enabled = true;
+	handlers = /* @__PURE__ */ new Map();
+	logger;
+	messages = [];
+	flushing = false;
+	interval;
+	intervalTime = 5e3;
+	constructor() {
+		this.logger = new Logger("LoggerTransport");
+		this.logger.level = "info";
+		this.flush = this.flush.bind(this);
+		this.interval = setInterval(this.flush, this.intervalTime);
+	}
+	/**
+	* Registers a new transport handler.
+	*
+	* @param name - The name of the transport handler.
+	* @param handler - The transport handler function to be registered.
+	*/
+	register(name, handler) {
+		this.logger.info("register", name);
+		this.handlers.set(name, handler);
+		if (!this.enabled) this.enabled = true;
+	}
+	/**
+	* Unregister a handler by its name.
+	*
+	* This method logs the unregistration process, removes the handler from the internal collection,
+	* and disables the logger if no handlers remain.
+	*
+	* @param name - The name of the handler to unregister.
+	*/
+	unregister(name) {
+		this.logger.info("unregister", name);
+		this.handlers.delete(name);
+		if (this.handlers.size === 0) this.enabled = false;
+	}
+	/**
+	* Inserts a log message into the transport if it is enabled.
+	*
+	* @param message - The log message to be inserted.
+	*/
+	insert(message) {
+		if (!this.enabled) return;
+		this.messages.push(message);
+	}
+	/**
+	* Flushes the current messages by processing them with the registered handlers.
+	*
+	* If the transport is already flushing, it will wait until the current flush is complete.
+	* If the transport is disabled or there are no messages to flush, it will return immediately.
+	* If there are no handlers registered, it will log a warning, clear the messages, disable the transport, and stop the interval.
+	*
+	* The method processes all messages with each handler and logs any errors encountered during the process.
+	*
+	* @returns {Promise<void>} A promise that resolves when the flush operation is complete.
+	*/
+	async flush() {
+		if (this.flushing) return new Promise((resolve) => {
+			const interval = setInterval(() => {
+				if (!this.flushing) {
+					clearInterval(interval);
+					resolve();
+				}
+			}, 100);
+		});
+		if (!this.enabled || this.messages.length === 0) return;
+		if (this.handlers.size === 0) {
+			this.logger.warn("no handlers to flush, disable transport");
+			this.messages.splice(0, this.messages.length);
+			this.enabled = false;
+			clearInterval(this.interval);
+			return;
+		}
+		this.flushing = true;
+		const messages = this.messages.splice(0, this.messages.length);
+		this.logger.debug("flushing %d messages with %d handlers", messages.length, this.handlers.size);
+		for (const handler of this.handlers.values()) try {
+			await handler(messages);
+		} catch (error) {
+			this.logger.error(handler.name, error);
+		}
+		this.flushing = false;
+	}
+	/**
+	* Stops the logger transport.
+	*
+	* This method performs the following actions:
+	* 1. Logs a 'stopping' message.
+	* 2. Clears the interval if it is set.
+	* 3. Flushes any remaining logs.
+	* 4. Disables the transport.
+	*
+	* @returns {Promise<void>} A promise that resolves when the transport has been stopped.
+	*/
+	async stop() {
+		this.logger.info("stopping");
+		if (this.interval) {
+			clearInterval(this.interval);
+			this.interval = void 0;
+		}
+		await this.flush();
+		this.enabled = false;
+	}
+	/**
+	* Resets the transport by clearing handlers, emptying messages, and re-enabling the transport.
+	* If an interval is set, it will be cleared.
+	*/
+	reset() {
+		this.handlers.clear();
+		this.messages.splice(0, this.messages.length);
+		this.enabled = true;
+		if (this.interval) {
+			clearInterval(this.interval);
+			this.interval = void 0;
+		}
+	}
+	/**
+	* Configure the transport options for the logger.
+	*
+	* @param {TransportOptions} options - The configuration options for the transport.
+	* @param {string} [options.label] - The label to be used by the logger.
+	* @param {boolean} [options.debug] - If true, sets the logger level to 'debug', otherwise sets it to 'info'.
+	* @param {number} [options.interval] - The interval time in milliseconds for flushing the logs. If different from the current interval, it updates the interval and resets the timer.
+	*/
+	config(options) {
+		if (options.label) this.logger.label = options.label;
+		if (typeof options.debug === "boolean") this.logger.level = options.debug ? "debug" : "info";
+		if (options.interval && options.interval !== this.intervalTime) {
+			this.intervalTime = options.interval;
+			clearInterval(this.interval);
+			this.interval = setInterval(this.flush, this.intervalTime);
+		}
+		if (!this.enabled) this.enabled = true;
+	}
+};
+let current;
+function getTransport() {
+	current ||= new Transport();
+	return current;
+}
+
+//#endregion
+//#region src/logger.ts
+const LevelPriority = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+/**
+* Formats the provided arguments into a string, filtering out any objects
+* with a `__hidden__` property set to `true`. If formatting fails, it attempts
+* to stringify each argument individually.
+*
+* @param {...any[]} args - The arguments to format.
+* @returns {string} The formatted string.
+*/
+function formatLogger(fmt, ...args) {
+	try {
+		return format(fmt, ...args.filter((a) => !a || typeof a !== "object" || a.__hidden__ !== true));
+	} catch (e) {
+		return `[Unable to format] ${e?.message}`;
+	}
+}
+/**
+* Logger Class
+*
+* @example
+* ```ts
+* const logger = new Logger()
+*
+* logger.debug('debug message')
+* logger.info('info message')
+* logger.warn('warn message')
+* logger.error('error message')
+*
+* logger.time('timer name')
+* logger.timeEnd('timer name', 'message') // => 'message +1ms'
+* ```
+*/
+var Logger = class {
+	silent = false;
+	level = "debug";
+	colorfyOutput = true;
+	label;
+	size = 1e3;
+	disableTransport = false;
+	stdout = console.log;
+	stderr = console.error;
+	cachedTimers = {};
+	/**
+	* @param label {string} Prefix label
+	*/
+	constructor(label) {
+		if (label) this.label = label;
+		if (typeof process === "undefined") return;
+		if (!process.env.FaasLog && process.env.npm_config_argv && JSON.parse(process.env.npm_config_argv).original.includes("--silent")) this.silent = true;
+		if (process.env.FaasLogTransport !== "true" && (process.env.VITEST || process.env.FaasLogTransport === "false")) this.disableTransport = true;
+		switch (process.env.FaasLogMode) {
+			case "plain":
+				this.colorfyOutput = false;
+				break;
+			case "pretty":
+				this.colorfyOutput = true;
+				break;
+			default:
+				this.colorfyOutput = process.env.FaasMode !== "remote";
+				break;
+		}
+		if (process.env.FaasLog) this.level = process.env.FaasLog.toLowerCase();
+		if (process.env.FaasLogSize) this.size = Number(process.env.FaasLogSize);
+	}
+	/**
+	* @param message {string} message
+	* @param args {...any=} arguments
+	*/
+	debug(message, ...args) {
+		this.log("debug", message, ...args);
+		return this;
+	}
+	/**
+	* @param message {string} message
+	* @param args {...any=} arguments
+	*/
+	info(message, ...args) {
+		this.log("info", message, ...args);
+		return this;
+	}
+	/**
+	* @param message {string} message
+	* @param args {...any=} arguments
+	*/
+	warn(message, ...args) {
+		this.log("warn", message, ...args);
+		return this;
+	}
+	/**
+	* @param message {any} message or Error object
+	* @param args {...any=} arguments
+	*/
+	error(message, ...args) {
+		this.log("error", message, ...args);
+		return this;
+	}
+	/**
+	* Start a timer with a specific key and log level.
+	*
+	* @param key - The unique identifier for the timer.
+	* @param level - The log level for the timer. Defaults to 'debug'.
+	* @returns The Logger instance for chaining.
+	*/
+	time(key, level = "debug") {
+		this.cachedTimers[key] = {
+			level,
+			time: Date.now()
+		};
+		return this;
+	}
+	/**
+	* End a timer with a specific key and log the elapsed time.
+	*
+	* @param key - The unique identifier for the timer.
+	* @param message - The message to log with the elapsed time.
+	* @param args - Additional arguments to log with the message.
+	* @returns The Logger instance for chaining.
+	*/
+	timeEnd(key, message, ...args) {
+		if (this.cachedTimers[key]) {
+			const timer = this.cachedTimers[key];
+			const duration = Date.now() - timer.time;
+			message = `${message} +${duration}ms`;
+			args.push({
+				__hidden__: true,
+				performance: {
+					name: key,
+					startTime: timer.time,
+					duration
+				}
+			});
+			this[timer.level](message, ...args);
+			delete this.cachedTimers[key];
+		} else {
+			this.warn("timeEnd not found key %s", key);
+			this.debug(message);
+		}
+		return this;
+	}
+	/**
+	* @param message {string} message
+	* @param args {...any=} arguments
+	*/
+	raw(message, ...args) {
+		if (this.silent) return this;
+		this.stdout(formatLogger(message, ...args));
+		return this;
+	}
+	log(level, message, ...args) {
+		if (this.silent) return this;
+		if (LevelPriority[level] < LevelPriority[this.level]) return this;
+		const formattedMessage = formatLogger(message, ...args);
+		if (!formattedMessage && !args.length) return this;
+		if (!this.disableTransport) getTransport().insert({
+			level,
+			labels: this.label?.split(/\]\s*\[/) || [],
+			message: formattedMessage,
+			timestamp: Date.now(),
+			extra: args
+		});
+		let output = `${level.toUpperCase()} ${this.label ? `[${this.label}] ` : ""}${formattedMessage}`;
+		if (this.colorfyOutput) output = colorfy(level, output);
+		else if (!this.colorfyOutput) output = output.replace(/\n/g, "");
+		if (!output) return this;
+		if (this.size > 0 && output.length > this.size && !["error", "warn"].includes(level)) output = `${output.slice(0, this.size - 100)}...[truncated]...${output.slice(output.length - 100)}`;
+		if (level === "error") this.stderr(output);
+		else this.stdout(output);
+		return this;
+	}
+};
+
+//#endregion
+//#region src/parse_yaml.ts
+function createParseError(line, reason) {
+	return Error(`[parseYaml] ${reason} at line ${line}`);
+}
+function isSequenceLine(content) {
+	return /^-(\s|$)/.test(content);
+}
+function isMappingValue(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stripInlineComment(content) {
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	let escaped = false;
+	for (let i = 0; i < content.length; i++) {
+		const char = content[i];
+		if (inDoubleQuote) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === "\"") inDoubleQuote = false;
+			continue;
+		}
+		if (inSingleQuote) {
+			if (char === "'") {
+				if (content[i + 1] === "'") {
+					i++;
+					continue;
+				}
+				inSingleQuote = false;
+			}
+			continue;
+		}
+		if (char === "\"") {
+			inDoubleQuote = true;
+			continue;
+		}
+		if (char === "'") {
+			inSingleQuote = true;
+			continue;
+		}
+		if (char === "#" && (i === 0 || /\s/.test(content[i - 1]))) return content.slice(0, i).trimEnd();
+	}
+	return content.trimEnd();
+}
+function normalizeLines(content) {
+	const lines = content.replace(/\r\n?/g, "\n").split("\n");
+	const normalized = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const lineNumber = i + 1;
+		const leading = line.match(/^[ \t]*/)?.[0] || "";
+		if (leading.includes("	")) throw createParseError(lineNumber, "Tabs are not supported for indentation");
+		const indent = leading.length;
+		const contentWithoutComment = stripInlineComment(line.slice(indent));
+		if (!contentWithoutComment.trim()) continue;
+		if (contentWithoutComment === "---" || contentWithoutComment === "...") throw createParseError(lineNumber, "Multiple YAML documents are not supported");
+		normalized.push({
+			content: contentWithoutComment,
+			indent,
+			line: lineNumber
+		});
+	}
+	return normalized;
+}
+function findMappingSeparator(content) {
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	let escaped = false;
+	for (let i = 0; i < content.length; i++) {
+		const char = content[i];
+		if (inDoubleQuote) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === "\"") inDoubleQuote = false;
+			continue;
+		}
+		if (inSingleQuote) {
+			if (char === "'") {
+				if (content[i + 1] === "'") {
+					i++;
+					continue;
+				}
+				inSingleQuote = false;
+			}
+			continue;
+		}
+		if (char === "\"") {
+			inDoubleQuote = true;
+			continue;
+		}
+		if (char === "'") {
+			inSingleQuote = true;
+			continue;
+		}
+		if (char !== ":") continue;
+		const next = content[i + 1];
+		if (typeof next === "undefined" || /\s/.test(next)) return i;
+	}
+	return -1;
+}
+function parseDoubleQuotedScalar(value, line) {
+	let result = "";
+	for (let i = 1; i < value.length; i++) {
+		const char = value[i];
+		if (char === "\"") {
+			if (i !== value.length - 1) throw createParseError(line, "Invalid double quoted string");
+			return result;
+		}
+		if (char !== "\\") {
+			result += char;
+			continue;
+		}
+		const escaped = value[++i];
+		if (typeof escaped === "undefined") throw createParseError(line, "Invalid escape sequence");
+		switch (escaped) {
+			case "\"":
+			case "\\":
+			case "/":
+				result += escaped;
+				break;
+			case "b":
+				result += "\b";
+				break;
+			case "f":
+				result += "\f";
+				break;
+			case "n":
+				result += "\n";
+				break;
+			case "r":
+				result += "\r";
+				break;
+			case "t":
+				result += "	";
+				break;
+			case "u": {
+				const hex = value.slice(i + 1, i + 5);
+				if (!/^[0-9a-fA-F]{4}$/.test(hex)) throw createParseError(line, "Invalid unicode escape sequence");
+				result += String.fromCharCode(Number.parseInt(hex, 16));
+				i += 4;
+				break;
+			}
+			default: throw createParseError(line, `Unsupported escape sequence \\${escaped}`);
+		}
+	}
+	throw createParseError(line, "Unterminated double quoted string");
+}
+function parseSingleQuotedScalar(value, line) {
+	let result = "";
+	for (let i = 1; i < value.length; i++) {
+		const char = value[i];
+		if (char === "'") {
+			if (value[i + 1] === "'") {
+				result += "'";
+				i++;
+				continue;
+			}
+			if (i !== value.length - 1) throw createParseError(line, "Invalid single quoted string");
+			return result;
+		}
+		result += char;
+	}
+	throw createParseError(line, "Unterminated single quoted string");
+}
+function parseQuotedScalar(value, line) {
+	if (value.startsWith("\"")) return parseDoubleQuotedScalar(value, line);
+	if (value.startsWith("'")) return parseSingleQuotedScalar(value, line);
+	throw createParseError(line, "Invalid quoted string");
+}
+function parsePlainScalar(value) {
+	if (value === "~") return null;
+	const lower = value.toLowerCase();
+	if (lower === "null") return null;
+	if (lower === "true") return true;
+	if (lower === "false") return false;
+	if (/^[-+]?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][-+]?\d+)?$/.test(value)) return Number(value);
+	return value;
+}
+function parseInlineValue(value, line) {
+	if (value.startsWith("|") || value.startsWith(">")) throw createParseError(line, "Block scalar is not supported");
+	if (value.startsWith("!")) throw createParseError(line, "YAML tags are not supported");
+	if (value === "[]") return [];
+	if (value === "{}") return Object.create(null);
+	if (value.startsWith("[") || value.startsWith("{")) throw createParseError(line, "Flow collection is not supported");
+	if (value.startsWith("\"") || value.startsWith("'")) return parseQuotedScalar(value, line);
+	return parsePlainScalar(value);
+}
+function parseKey(rawKey, line) {
+	if (!rawKey.length) throw createParseError(line, "Missing mapping key");
+	if (rawKey.startsWith("\"") || rawKey.startsWith("'")) return parseQuotedScalar(rawKey, line);
+	if (rawKey.startsWith("[") || rawKey.startsWith("{")) throw createParseError(line, "Complex mapping key is not supported");
+	return rawKey;
+}
+function parseReferenceToken(value, line, marker) {
+	let index = 1;
+	while (index < value.length && !/\s/.test(value[index])) index++;
+	const name = value.slice(1, index);
+	if (!name.length) throw createParseError(line, marker === "&" ? "Missing anchor name" : "Missing alias name");
+	if (!/^[^\s\[\]\{\},]+$/.test(name)) throw createParseError(line, marker === "&" ? "Invalid anchor name" : "Invalid alias name");
+	return {
+		name,
+		rest: value.slice(index).trimStart()
+	};
+}
+function setAnchor(context, anchorName, value) {
+	if (!anchorName) return;
+	context.anchors.set(anchorName, value);
+}
+function parseValueToken(token, line, context) {
+	let anchorName;
+	let rest = token;
+	if (rest.startsWith("&")) {
+		const anchor = parseReferenceToken(rest, line, "&");
+		anchorName = anchor.name;
+		rest = anchor.rest;
+		if (!rest.length) return {
+			anchorName,
+			kind: "nested"
+		};
+	}
+	if (rest.startsWith("*")) {
+		const alias = parseReferenceToken(rest, line, "*");
+		if (alias.rest.length) throw createParseError(line, "Unexpected token after alias");
+		if (!context.anchors.has(alias.name)) throw createParseError(line, `Unknown alias "*${alias.name}"`);
+		return {
+			anchorName,
+			kind: "alias",
+			value: context.anchors.get(alias.name)
+		};
+	}
+	return {
+		anchorName,
+		kind: "inline",
+		raw: rest
+	};
+}
+function parseNode(lines, index, indent, context) {
+	const current = lines[index];
+	if (!current) return {
+		value: null,
+		nextIndex: index
+	};
+	if (current.indent !== indent) throw createParseError(current.line, `Unexpected indentation: expected ${indent} spaces but got ${current.indent}`);
+	if (isSequenceLine(current.content)) return parseSequence(lines, index, indent, context);
+	return parseMapping(lines, index, indent, context);
+}
+function parseNestedBlockOrNull(lines, index, parentIndent, context) {
+	const next = lines[index + 1];
+	if (!next || next.indent <= parentIndent) return {
+		value: null,
+		nextIndex: index + 1
+	};
+	return parseNode(lines, index + 1, next.indent, context);
+}
+function parseMappingEntry(lines, index, content, entryIndent, line, context) {
+	const separator = findMappingSeparator(content);
+	if (separator < 0) throw createParseError(line, "Invalid mapping entry, expected \"key: value\"");
+	const key = parseKey(content.slice(0, separator).trim(), line);
+	const valueToken = content.slice(separator + 1).trimStart();
+	if (!valueToken.length) {
+		const nested = parseNestedBlockOrNull(lines, index, entryIndent, context);
+		return {
+			key,
+			value: nested.value,
+			nextIndex: nested.nextIndex
+		};
+	}
+	const token = parseValueToken(valueToken, line, context);
+	if (token.kind === "alias") {
+		setAnchor(context, token.anchorName, token.value);
+		return {
+			key,
+			value: token.value,
+			nextIndex: index + 1
+		};
+	}
+	if (token.kind === "nested") {
+		const nested = parseNestedBlockOrNull(lines, index, entryIndent, context);
+		setAnchor(context, token.anchorName, nested.value);
+		return {
+			key,
+			value: nested.value,
+			nextIndex: nested.nextIndex
+		};
+	}
+	const inlineValue = parseInlineValue(token.raw, line);
+	setAnchor(context, token.anchorName, inlineValue);
+	return {
+		key,
+		value: inlineValue,
+		nextIndex: index + 1
+	};
+}
+function applyMergeKey(target, source, line) {
+	if (Array.isArray(source)) {
+		for (const value of source) applyMergeKey(target, value, line);
+		return;
+	}
+	if (!isMappingValue(source)) throw createParseError(line, "Merge key \"<<\" expects a mapping or sequence of mappings");
+	for (const key in source) {
+		if (Object.hasOwn(target, key)) continue;
+		target[key] = source[key];
+	}
+}
+function parseMapping(lines, index, indent, context) {
+	const value = Object.create(null);
+	let currentIndex = index;
+	while (currentIndex < lines.length) {
+		const line = lines[currentIndex];
+		if (line.indent < indent) break;
+		if (line.indent > indent) throw createParseError(line.line, `Unexpected indentation in mapping: expected ${indent} spaces but got ${line.indent}`);
+		if (isSequenceLine(line.content)) throw createParseError(line.line, "Cannot mix sequence item with mapping at the same indentation");
+		const entry = parseMappingEntry(lines, currentIndex, line.content, indent, line.line, context);
+		if (entry.key === "<<") applyMergeKey(value, entry.value, line.line);
+		else value[entry.key] = entry.value;
+		currentIndex = entry.nextIndex;
+	}
+	return {
+		value,
+		nextIndex: currentIndex
+	};
+}
+function parseSequenceItem(lines, index, indent, context) {
+	const line = lines[index];
+	const rest = line.content.slice(1);
+	if (rest.length && !/^\s/.test(rest)) throw createParseError(line.line, "Missing whitespace after sequence marker \"-\"");
+	const token = rest.trimStart();
+	if (!token.length) return parseNestedBlockOrNull(lines, index, indent, context);
+	const parsedToken = parseValueToken(token, line.line, context);
+	if (parsedToken.kind === "alias") {
+		setAnchor(context, parsedToken.anchorName, parsedToken.value);
+		return {
+			value: parsedToken.value,
+			nextIndex: index + 1
+		};
+	}
+	if (parsedToken.kind === "nested") {
+		const nested = parseNestedBlockOrNull(lines, index, indent, context);
+		setAnchor(context, parsedToken.anchorName, nested.value);
+		return nested;
+	}
+	if (findMappingSeparator(parsedToken.raw) < 0) {
+		const inlineValue = parseInlineValue(parsedToken.raw, line.line);
+		setAnchor(context, parsedToken.anchorName, inlineValue);
+		return {
+			value: inlineValue,
+			nextIndex: index + 1
+		};
+	}
+	const itemIndent = indent + 2;
+	const item = Object.create(null);
+	const firstEntry = parseMappingEntry(lines, index, parsedToken.raw, itemIndent, line.line, context);
+	if (firstEntry.key === "<<") applyMergeKey(item, firstEntry.value, line.line);
+	else item[firstEntry.key] = firstEntry.value;
+	let currentIndex = firstEntry.nextIndex;
+	while (currentIndex < lines.length) {
+		const next = lines[currentIndex];
+		if (next.indent < itemIndent) break;
+		if (next.indent > itemIndent) throw createParseError(next.line, `Unexpected indentation in sequence mapping: expected ${itemIndent} spaces but got ${next.indent}`);
+		if (isSequenceLine(next.content)) throw createParseError(next.line, "Cannot mix sequence item with mapping at the same indentation");
+		const entry = parseMappingEntry(lines, currentIndex, next.content, itemIndent, next.line, context);
+		if (entry.key === "<<") applyMergeKey(item, entry.value, next.line);
+		else item[entry.key] = entry.value;
+		currentIndex = entry.nextIndex;
+	}
+	setAnchor(context, parsedToken.anchorName, item);
+	return {
+		value: item,
+		nextIndex: currentIndex
+	};
+}
+function parseSequence(lines, index, indent, context) {
+	const value = [];
+	let currentIndex = index;
+	while (currentIndex < lines.length) {
+		const line = lines[currentIndex];
+		if (line.indent < indent) break;
+		if (line.indent > indent) throw createParseError(line.line, `Unexpected indentation in sequence: expected ${indent} spaces but got ${line.indent}`);
+		if (!isSequenceLine(line.content)) throw createParseError(line.line, "Cannot mix mapping entry with sequence at the same indentation");
+		const item = parseSequenceItem(lines, currentIndex, indent, context);
+		value.push(item.value);
+		currentIndex = item.nextIndex;
+	}
+	return {
+		value,
+		nextIndex: currentIndex
+	};
+}
+function parseYaml(content) {
+	const lines = normalizeLines(content);
+	if (!lines.length) return void 0;
+	const context = { anchors: /* @__PURE__ */ new Map() };
+	const parsed = parseNode(lines, 0, lines[0].indent, context);
+	if (parsed.nextIndex < lines.length) throw createParseError(lines[parsed.nextIndex].line, "Unexpected trailing content");
+	return parsed.value;
+}
+
+//#endregion
+//#region src/load_config.ts
+function isObject(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function createConfigError(filePath, keyPath, reason) {
+	return Error(`[loadConfig] Invalid faas.yaml ${filePath} at "${keyPath}": ${reason}`);
+}
+function validateServerConfig(filePath, staging, server) {
+	if (!isObject(server)) throw createConfigError(filePath, `${staging}.server`, "must be an object");
+	if (typeof server.root !== "undefined" && typeof server.root !== "string") throw createConfigError(filePath, `${staging}.server.root`, "must be a string");
+	if (typeof server.base !== "undefined" && typeof server.base !== "string") throw createConfigError(filePath, `${staging}.server.base`, "must be a string");
+}
+function validateFaasYaml(filePath, config) {
+	if (typeof config === "undefined" || config === null) return Object.create(null);
+	if (!isObject(config)) throw createConfigError(filePath, "<root>", "must be an object");
+	for (const staging in config) {
+		if (staging === "types") throw createConfigError(filePath, "types", "has been removed, move related settings out of faas.yaml");
+		const stageConfig = config[staging];
+		if (typeof stageConfig === "undefined" || stageConfig === null) continue;
+		if (!isObject(stageConfig)) throw createConfigError(filePath, staging, "must be an object");
+		if (Object.hasOwn(stageConfig, "types")) throw createConfigError(filePath, `${staging}.types`, "has been removed, move related settings out of faas.yaml");
+		if (Object.hasOwn(stageConfig, "server")) validateServerConfig(filePath, staging, stageConfig.server);
+	}
+	return config;
+}
+function assignPluginNames(config) {
+	if (!config.plugins) return;
+	for (const pluginKey in config.plugins) {
+		const plugin = config.plugins[pluginKey];
+		plugin.name = pluginKey;
+	}
+}
+/**
+* Load configuration from faas.yaml
+*/
+var Config = class {
+	root;
+	filename;
+	origin;
+	defaults;
+	logger;
+	constructor(root, filename, logger) {
+		this.logger = new Logger(logger?.label ? `${logger.label}] [config` : "config");
+		this.root = root;
+		if (!this.root.endsWith(sep)) this.root += sep;
+		this.filename = filename;
+		this.logger.debug("load %s in %s", filename, root);
+		const configs = [];
+		const paths = [this.root, "."].concat(dirname(filename.replace(root, "")).split(sep));
+		let base = paths[0];
+		for (const path of paths.slice(1)) {
+			const currentRoot = join(base, path);
+			if (currentRoot === base) continue;
+			const faas = join(currentRoot, "faas.yaml");
+			if (existsSync(faas)) configs.push(validateFaasYaml(faas, parseYaml(readFileSync(faas, "utf8"))));
+			base = currentRoot;
+		}
+		this.origin = deepMerge(...configs);
+		this.defaults = deepMerge(this.origin.defaults || {});
+		for (const key in this.origin) {
+			const data = key === "defaults" ? this.defaults : deepMerge(this.defaults, this.origin[key]);
+			if (key !== "defaults") this[key] = data;
+			assignPluginNames(data);
+		}
+	}
+	get(key) {
+		return this[key] || this.defaults || Object.create(null);
+	}
+};
+/**
+* Load configuration from faas.yaml
+*/
+function loadConfig(root, filename, staging, logger) {
+	return new Config(root, filename, logger).get(staging);
+}
+
+//#endregion
+//#region src/load_env.ts
+/**
+* Load a dotenv file if it exists.
+*
+* - Defaults to `${process.cwd()}/.env`.
+* - Existing environment variables are preserved (Node.js behavior).
+*/
+function loadEnvFileIfExists(options = {}) {
+	const filePath = resolve(options.cwd || process.cwd(), options.filename || ".env");
+	if (!existsSync(filePath)) return null;
+	loadEnvFile(filePath);
+	return filePath;
+}
+
+//#endregion
+//#region src/load_package.ts
+let _runtime = null;
+function resetRuntime() {
+	_runtime = null;
+}
+/**
+* Detect current JavaScript runtime environment.
+*
+* This function checks for presence of `require` first, then falls back to
+* Node.js ESM detection via `process.versions.node`.
+*
+* @returns {NodeRuntime} Returns `module` for ESM and `commonjs` for CJS.
+* @throws {Error} Throws an error if runtime cannot be determined.
+*/
+function detectNodeRuntime() {
+	if (_runtime) return _runtime;
+	if (typeof globalThis.require === "function" && typeof module !== "undefined") return _runtime = "commonjs";
+	if (typeof process !== "undefined" && process.versions?.node) return _runtime = "module";
+	throw Error("Unknown runtime");
+}
+/**
+* Asynchronously loads a package by its name, supporting both ESM and CJS.
+*
+* @template T The type of module to be loaded.
+* @param name The package name to load.
+* @param defaultNames Preferred export keys used to resolve default values.
+* @returns Loaded module or resolved default export.
+*/
+async function loadPackage(name, defaultNames = "default") {
+	const runtime = detectNodeRuntime();
+	let module;
+	if (runtime === "module") module = await import(name);
+	else if (runtime === "commonjs") module = globalThis.require(name);
+	else throw Error("Unknown runtime");
+	if (typeof defaultNames === "string") return defaultNames in module ? module[defaultNames] : module;
+	for (const key of defaultNames) if (key in module) return module[key];
+	return module;
+}
+
+//#endregion
+//#region src/load_func.ts
+/**
+* Load a FaasJS function and its configuration, returning the handler.
+*
+* @param root Project root directory used to resolve configuration.
+* @param filename Path to the packaged FaasJS function file to load.
+* @param staging Staging directory name (used when locating config).
+* @returns A promise that resolves to the function handler.
+*
+* @example
+* ```ts
+* import { loadFunc } from '@faasjs/node-utils'
+*
+* const handler = await loadFunc(
+*   process.cwd(),
+*   __dirname + '/example.func.ts',
+*   'development'
+* )
+*
+* const result = await handler(event, context)
+* console.log(result)
+* ```
+*/
+async function loadFunc(root, filename, staging) {
+	const func = await loadPackage(filename);
+	func.config = await loadConfig(root, filename, staging);
+	return func.export().handler;
+}
+
+//#endregion
+//#region src/stream.ts
+/**
+* Convert ReadableStream to text.
+*
+* @throws {TypeError} If stream is not a ReadableStream instance.
+*/
+async function streamToText(stream) {
+	if (!(stream instanceof ReadableStream)) throw new TypeError("stream must be a ReadableStream instance");
+	return new Response(stream).text();
+}
+/**
+* Convert ReadableStream to object.
+*
+* @throws {TypeError} If stream is not a ReadableStream instance.
+*/
+async function streamToObject(stream) {
+	if (!(stream instanceof ReadableStream)) throw new TypeError("stream must be a ReadableStream instance");
+	return new Response(stream).json();
+}
+const streamToString = streamToText;
+
+//#endregion
+export { Color, LevelColor, Logger, Transport, colorfy, deepMerge, detectNodeRuntime, formatLogger, getTransport, loadConfig, loadEnvFileIfExists, loadFunc, loadPackage, resetRuntime, streamToObject, streamToString, streamToText };