@faasjs/node-utils 8.0.0-beta.7 → 8.0.0-beta.9

package/dist/index.mjs

@@ -1,7 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, sep } from "node:path";
-import { Logger } from "@faasjs/logger";
-import { load } from "js-yaml";
 
 //#region src/deep_merge.ts
 const shouldMerge = (item) => {
@@ -23,21 +21,861 @@ const shouldMerge = (item) => {
 */
 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))];
-	} else if (shouldMerge(source)) for (const [key, value] of Object.entries(source)) {
-		let val;
-		if (shouldMerge(value)) val = deepMerge(acc[key], value);
-		else val = value;
-		acc = {
+	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]: val
+			[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) {
@@ -64,6 +902,13 @@ function validateFaasYaml(filePath, config) {
 	}
 	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
 */
@@ -80,22 +925,21 @@ var Config = class {
 		this.filename = filename;
 		this.logger.debug("load %s in %s", filename, root);
 		const configs = [];
-		[this.root, "."].concat(dirname(filename.replace(root, "")).split(sep)).reduce((base, path) => {
-			const root = join(base, path);
-			if (root === base) return base;
-			const faas = join(root, "faas.yaml");
-			if (existsSync(faas)) configs.push(validateFaasYaml(faas, load(readFileSync(faas).toString())));
-			return root;
-		});
+		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) {
-			if (key !== "defaults") this[key] = deepMerge(this.defaults, this.origin[key]);
-			const data = this[key];
-			if (data.plugins) for (const pluginKey in data.plugins) {
-				const plugin = data.plugins[pluginKey];
-				plugin.name = pluginKey;
-			}
+			const data = key === "defaults" ? this.defaults : deepMerge(this.defaults, this.origin[key]);
+			if (key !== "defaults") this[key] = data;
+			assignPluginNames(data);
 		}
 	}
 	get(key) {
@@ -141,19 +985,12 @@ function detectNodeRuntime() {
 async function loadPackage(name, defaultNames = "default") {
 	const runtime = detectNodeRuntime();
 	let module;
-	if (runtime === "module") {
-		module = await import(name);
-		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;
-	}
-	if (runtime === "commonjs") {
-		module = globalThis.require(name);
-		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;
-	}
-	throw Error("Unknown runtime");
+	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
@@ -209,4 +1046,4 @@ async function streamToObject(stream) {
 const streamToString = streamToText;
 
 //#endregion
-export { deepMerge, detectNodeRuntime, loadConfig, loadFunc, loadPackage, resetRuntime, streamToObject, streamToString, streamToText };
+export { Color, LevelColor, Logger, Transport, colorfy, deepMerge, detectNodeRuntime, formatLogger, getTransport, loadConfig, loadFunc, loadPackage, resetRuntime, streamToObject, streamToString, streamToText };