@kubb/agent 5.0.0-alpha.35 → 5.0.0-alpha.36

package/.output/server/node_modules/@kubb/fabric-core/dist/onProcessExit-Cput7j2c.js

@@ -0,0 +1,742 @@
+import "./chunk-O_arW02_.js";
+import { r as trimExtName } from "./getRelativePath-NAm_Y-vp.js";
+import { t as defaultParser } from "./defaultParser-iCpMSYCp.js";
+import { sortBy, uniqueBy } from "remeda";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import pLimit from "p-limit";
+import { EventEmitter } from "node:events";
+//#region src/context.ts
+/**
+* Context stack for tracking the current context values
+*
+* Note: This uses a global Map for simplicity in code generation scenarios.
+* For concurrent runtime execution, consider using AsyncLocalStorage or
+* instance-based context management.
+*/
+const contextStack = /* @__PURE__ */ new Map();
+const contextDefaults = /* @__PURE__ */ new Map();
+/**
+* Provides a value to descendant components (Vue 3 style)
+*
+* @example
+* ```ts
+* const ThemeKey = Symbol('theme')
+* provide(ThemeKey, { color: 'blue' })
+* ```
+*/
+function provide(key, value) {
+	if (!contextStack.has(key)) contextStack.set(key, []);
+	contextStack.get(key).push(value);
+}
+/**
+* Injects a value provided by an ancestor component (Vue 3 style)
+*
+* @example
+* ```ts
+* const theme = inject(ThemeKey, { color: 'default' })
+* ```
+*/
+function inject(key, defaultValue) {
+	const stack = contextStack.get(key);
+	if (!stack || stack.length === 0) {
+		if (defaultValue !== void 0) return defaultValue;
+		const storedDefault = contextDefaults.get(key);
+		if (storedDefault !== void 0) return storedDefault;
+		throw new Error(`No value provided for key: ${key.toString()}`);
+	}
+	return stack[stack.length - 1];
+}
+/**
+* Unprovides a value (for cleanup)
+* @internal
+*/
+function unprovide(key) {
+	const stack = contextStack.get(key);
+	if (stack && stack.length > 0) stack.pop();
+}
+/**
+* Creates a context key with a default value (React-style compatibility)
+*
+* @example
+* ```ts
+* const ThemeContext = createContext({ color: 'blue' })
+* // ThemeContext is now typed as Context<{ color: string }>
+* const theme = useContext(ThemeContext) // theme is { color: string }
+* ```
+*/
+function createContext(defaultValue) {
+	const key = Symbol("context");
+	contextDefaults.set(key, defaultValue);
+	return key;
+}
+//#endregion
+//#region src/contexts/RenderContext.ts
+/**
+* Provides a context for tracking rendering state such as indentation and line length.
+*/
+const RenderContext = createContext({
+	indentLevel: 0,
+	indentSize: 2,
+	currentLineLength: 0,
+	shouldBreak: false
+});
+//#endregion
+//#region src/intrinsic.ts
+function isFabricElement(value) {
+	return typeof value === "function" && "type" in value && "component" in value;
+}
+/**
+* Type guard to check if a value is an intrinsic element
+*/
+function isIntrinsic(value) {
+	return value && typeof value === "object" && value.__intrinsic === true;
+}
+/**
+* Render a single intrinsic node
+*/
+function renderIntrinsicNode(node, renderContext) {
+	switch (node.type) {
+		case "br":
+			renderContext.currentLineLength = 0;
+			return "\n";
+		case "indent":
+			renderContext.indentLevel++;
+			return "";
+		case "dedent":
+			renderContext.indentLevel = Math.max(0, renderContext.indentLevel - 1);
+			return "";
+		default: return "";
+	}
+}
+/**
+* Helper: render a plain string while applying current indentation at the
+* start of each logical line. This ensures `${indent}` intrinsics affect
+* subsequent string content.
+*/
+function renderIndent(content, renderContext) {
+	if (content.length === 0) return "";
+	const indentStr = " ".repeat(renderContext.indentLevel * renderContext.indentSize);
+	const lines = content.split("\n");
+	let out = "";
+	for (const [i, line] of lines.entries()) {
+		if (renderContext.currentLineLength === 0 && line.length > 0) {
+			out += indentStr + line;
+			renderContext.currentLineLength = indentStr.length + line.length;
+		} else {
+			out += line;
+			renderContext.currentLineLength += line.length;
+		}
+		if (i !== lines.length - 1) {
+			out += "\n";
+			renderContext.currentLineLength = 0;
+		}
+	}
+	return out;
+}
+function renderIntrinsic(children, context) {
+	const renderContext = context || inject(RenderContext);
+	provide(RenderContext, renderContext);
+	if (!children) return "";
+	if (isFabricElement(children)) try {
+		return renderIntrinsic(children());
+	} catch {
+		return "";
+	}
+	if (Array.isArray(children)) return children.map((child) => renderIntrinsic(child)).join("");
+	if (isIntrinsic(children)) return renderIntrinsicNode(children, renderContext);
+	if (typeof children === "function") return renderIntrinsic(children());
+	if (typeof children === "string") return renderIndent(children, renderContext);
+	if (typeof children === "number") return renderIndent(String(children), renderContext);
+	if (typeof children === "boolean") return renderIndent(children ? "true" : "false", renderContext);
+	try {
+		return renderIndent(children, renderContext);
+	} catch {
+		return "";
+	}
+}
+/**
+* Create an intrinsic element
+*/
+function createIntrinsic(type) {
+	return {
+		type,
+		__intrinsic: true
+	};
+}
+//#endregion
+//#region src/createComponent.ts
+function createComponent(type, Component) {
+	return (...args) => {
+		const fn = (() => renderIntrinsic(Component(args[0])));
+		fn.component = Component;
+		fn.props = args[0];
+		fn.type = type;
+		fn.children = (...children) => {
+			const propsWithChildren = {
+				...args[0] ?? {},
+				children() {
+					return renderIntrinsic(children);
+				}
+			};
+			const fnChild = (() => renderIntrinsic(Component(propsWithChildren)));
+			fnChild.component = Component;
+			fnChild.props = args[0];
+			fnChild.type = type;
+			return fnChild;
+		};
+		return fn;
+	};
+}
+//#endregion
+//#region src/contexts/NodeTreeContext.ts
+/**
+* Context for having the current NodeTree
+*/
+const NodeTreeContext = createContext(null);
+//#endregion
+//#region src/createFile.ts
+function combineSources(sources) {
+	return uniqueBy(sources, (obj) => {
+		return `${obj.name ?? obj.value ?? ""}:${obj.isExportable ?? false}:${obj.isTypeOnly ?? false}`;
+	});
+}
+function combineExports(exports) {
+	const sorted = sortBy(exports, (v) => !!Array.isArray(v.name), (v) => !v.isTypeOnly, (v) => v.path, (v) => !!v.name, (v) => Array.isArray(v.name) ? [...v.name].sort().join("\0") : v.name ?? "");
+	const prev = [];
+	const pathMap = /* @__PURE__ */ new Map();
+	const uniqueMap = /* @__PURE__ */ new Map();
+	for (const curr of sorted) {
+		const name = curr.name;
+		const pathKey = curr.path;
+		const prevByPath = pathMap.get(pathKey);
+		const uniqueKey = `${`${pathKey}:${Array.isArray(name) ? JSON.stringify(name) : name || ""}:${curr.isTypeOnly}`}:${curr.asAlias || ""}`;
+		if (uniqueMap.get(uniqueKey) || Array.isArray(name) && !name.length || prevByPath?.asAlias && !curr.asAlias) continue;
+		if (!prevByPath) {
+			const newItem = {
+				...curr,
+				name: Array.isArray(name) ? [...new Set(name)] : name
+			};
+			prev.push(newItem);
+			pathMap.set(pathKey, newItem);
+			uniqueMap.set(uniqueKey, newItem);
+			continue;
+		}
+		if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+			prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])];
+			continue;
+		}
+		prev.push(curr);
+		uniqueMap.set(uniqueKey, curr);
+	}
+	return prev;
+}
+function combineImports(imports, exports, source) {
+	const exportedNameLookup = /* @__PURE__ */ new Set();
+	for (const item of exports) {
+		const { name } = item;
+		if (!name) continue;
+		if (Array.isArray(name)) {
+			for (const value of name) if (value) exportedNameLookup.add(value);
+			continue;
+		}
+		exportedNameLookup.add(name);
+	}
+	const usageCache = /* @__PURE__ */ new Map();
+	const hasImportInSource = (importName) => {
+		if (!source) return true;
+		const cached = usageCache.get(importName);
+		if (cached !== void 0) return cached;
+		const isUsed = source.includes(importName) || exportedNameLookup.has(importName);
+		usageCache.set(importName, isUsed);
+		return isUsed;
+	};
+	const sorted = sortBy(imports, (v) => Array.isArray(v.name), (v) => !v.isTypeOnly, (v) => v.path, (v) => !!v.name, (v) => Array.isArray(v.name) ? [...v.name].sort().join("\0") : v.name ?? "");
+	const prev = [];
+	const pathTypeMap = /* @__PURE__ */ new Map();
+	const uniqueMap = /* @__PURE__ */ new Map();
+	for (const curr of sorted) {
+		let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name;
+		if (curr.path === curr.root) continue;
+		if (Array.isArray(name)) name = name.filter((item) => typeof item === "string" ? hasImportInSource(item) : hasImportInSource(item.propertyName));
+		const pathTypeKey = `${curr.path}:${curr.isTypeOnly}`;
+		const prevByPath = pathTypeMap.get(pathTypeKey);
+		const nameKey = Array.isArray(name) ? JSON.stringify(name) : name || "";
+		const pathNameTypeKey = `${curr.path}:${nameKey}:${curr.isTypeOnly}`;
+		if (uniqueMap.get(pathNameTypeKey) || Array.isArray(name) && !name.length) continue;
+		if (!prevByPath) {
+			const newItem = {
+				...curr,
+				name
+			};
+			prev.push(newItem);
+			pathTypeMap.set(pathTypeKey, newItem);
+			uniqueMap.set(pathNameTypeKey, newItem);
+			continue;
+		}
+		if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+			prevByPath.name = [...new Set([...prevByPath.name, ...name])];
+			continue;
+		}
+		if (!Array.isArray(name) && name && !hasImportInSource(name)) continue;
+		prev.push(curr);
+		uniqueMap.set(pathNameTypeKey, curr);
+	}
+	return prev;
+}
+/**
+* Helper to create a file with name and id set
+*/
+function createFile(file) {
+	const extname = path.extname(file.baseName);
+	if (!extname) throw new Error(`No extname found for ${file.baseName}`);
+	const source = file.sources.map((item) => item.value).join("\n\n");
+	const exports = file.exports?.length ? combineExports(file.exports) : [];
+	const imports = file.imports?.length && source ? combineImports(file.imports, exports, source) : [];
+	const sources = file.sources?.length ? combineSources(file.sources) : [];
+	return {
+		...file,
+		id: createHash("sha256").update(file.path).digest("hex"),
+		name: trimExtName(file.baseName),
+		extname,
+		imports,
+		exports,
+		sources,
+		meta: file.meta || {}
+	};
+}
+//#endregion
+//#region src/utils/AsyncEventEmitter.ts
+var AsyncEventEmitter = class {
+	constructor({ maxListener = 100, mode = "sequential" } = {}) {
+		this.#emitter.setMaxListeners(maxListener);
+		this.#mode = mode;
+	}
+	#emitter = new EventEmitter();
+	#mode;
+	async emit(eventName, ...eventArgs) {
+		const listeners = this.#emitter.listeners(eventName);
+		if (listeners.length === 0) return;
+		const errors = [];
+		if (this.#mode === "sequential") for (const listener of listeners) try {
+			await listener(...eventArgs);
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			errors.push(error);
+		}
+		else {
+			const promises = listeners.map(async (listener) => {
+				try {
+					await listener(...eventArgs);
+				} catch (err) {
+					const error = err instanceof Error ? err : new Error(String(err));
+					errors.push(error);
+				}
+			});
+			await Promise.all(promises);
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, `Errors in async listeners for "${eventName}"`);
+	}
+	on(eventName, handler) {
+		this.#emitter.on(eventName, handler);
+	}
+	onOnce(eventName, handler) {
+		const wrapper = (...args) => {
+			this.off(eventName, wrapper);
+			handler(...args);
+		};
+		this.on(eventName, wrapper);
+	}
+	off(eventName, handler) {
+		this.#emitter.off(eventName, handler);
+	}
+	removeAll() {
+		this.#emitter.removeAllListeners();
+	}
+};
+//#endregion
+//#region src/FileProcessor.ts
+var FileProcessor = class {
+	#limit = pLimit(100);
+	events;
+	constructor({ events = new AsyncEventEmitter() } = {}) {
+		this.events = events;
+		return this;
+	}
+	async parse(file, { parsers, extension } = {}) {
+		const parseExtName = extension?.[file.extname] || void 0;
+		if (!parsers) {
+			console.warn("No parsers provided, using default parser. If you want to use a specific parser, please provide it in the options.");
+			return defaultParser.parse(file, { extname: parseExtName });
+		}
+		if (!file.extname) return defaultParser.parse(file, { extname: parseExtName });
+		const parser = parsers.get(file.extname);
+		if (!parser) return defaultParser.parse(file, { extname: parseExtName });
+		return parser.parse(file, { extname: parseExtName });
+	}
+	async run(files, { parsers, mode = "sequential", dryRun, extension } = {}) {
+		await this.events.emit("files:processing:start", files);
+		const total = files.length;
+		let processed = 0;
+		const processOne = async (resolvedFile, index) => {
+			await this.events.emit("file:processing:start", resolvedFile, index, total);
+			const source = dryRun ? void 0 : await this.parse(resolvedFile, {
+				extension,
+				parsers
+			});
+			const currentProcessed = ++processed;
+			const percentage = currentProcessed / total * 100;
+			await this.events.emit("file:processing:update", {
+				file: resolvedFile,
+				source,
+				processed: currentProcessed,
+				percentage,
+				total
+			});
+			await this.events.emit("file:processing:end", resolvedFile, index, total);
+		};
+		if (mode === "sequential") {
+			async function* asyncFiles() {
+				for (let index = 0; index < files.length; index++) yield [files[index], index];
+			}
+			for await (const [file, index] of asyncFiles()) if (file) await processOne(file, index);
+		} else {
+			const promises = files.map((resolvedFile, index) => this.#limit(() => processOne(resolvedFile, index)));
+			await Promise.all(promises);
+		}
+		await this.events.emit("files:processing:end", files);
+		return files;
+	}
+};
+//#endregion
+//#region src/utils/Cache.ts
+var Cache = class {
+	#buffer = /* @__PURE__ */ new Map();
+	get(key) {
+		return this.#buffer.get(key) ?? null;
+	}
+	set(key, value) {
+		this.#buffer.set(key, value);
+	}
+	delete(key) {
+		this.#buffer.delete(key);
+	}
+	clear() {
+		this.#buffer.clear();
+	}
+	keys() {
+		return [...this.#buffer.keys()];
+	}
+	values() {
+		return [...this.#buffer.values()];
+	}
+	flush() {}
+};
+//#endregion
+//#region src/FileManager.ts
+function mergeFile(a, b) {
+	return {
+		...a,
+		sources: [...a.sources || [], ...b.sources || []],
+		imports: [...a.imports || [], ...b.imports || []],
+		exports: [...a.exports || [], ...b.exports || []]
+	};
+}
+var FileManager = class {
+	#cache = new Cache();
+	#filesCache = null;
+	events;
+	processor;
+	constructor({ events = new AsyncEventEmitter() } = {}) {
+		this.processor = new FileProcessor({ events });
+		this.events = events;
+		return this;
+	}
+	#resolvePath(file) {
+		this.events.emit("file:resolve:path", file);
+		return file;
+	}
+	#resolveName(file) {
+		this.events.emit("file:resolve:name", file);
+		return file;
+	}
+	add(...files) {
+		const resolvedFiles = [];
+		const mergedFiles = /* @__PURE__ */ new Map();
+		files.forEach((file) => {
+			const existing = mergedFiles.get(file.path);
+			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
+			else mergedFiles.set(file.path, file);
+		});
+		for (let file of mergedFiles.values()) {
+			file = this.#resolveName(file);
+			file = this.#resolvePath(file);
+			const resolvedFile = createFile(file);
+			this.#cache.set(resolvedFile.path, resolvedFile);
+			this.flush();
+			resolvedFiles.push(resolvedFile);
+		}
+		this.events.emit("files:added", resolvedFiles);
+		return resolvedFiles;
+	}
+	upsert(...files) {
+		const resolvedFiles = [];
+		const mergedFiles = /* @__PURE__ */ new Map();
+		files.forEach((file) => {
+			const existing = mergedFiles.get(file.path);
+			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
+			else mergedFiles.set(file.path, file);
+		});
+		for (let file of mergedFiles.values()) {
+			const existing = this.#cache.get(file.path);
+			file = this.#resolveName(file);
+			file = this.#resolvePath(file);
+			const resolvedFile = createFile(existing ? mergeFile(existing, file) : file);
+			this.#cache.set(resolvedFile.path, resolvedFile);
+			this.flush();
+			resolvedFiles.push(resolvedFile);
+		}
+		this.events.emit("files:added", resolvedFiles);
+		return resolvedFiles;
+	}
+	flush() {
+		this.#filesCache = null;
+		this.#cache.flush();
+	}
+	getByPath(path) {
+		return this.#cache.get(path);
+	}
+	deleteByPath(path) {
+		this.#cache.delete(path);
+		this.#filesCache = null;
+	}
+	clear() {
+		this.#cache.clear();
+		this.#filesCache = null;
+	}
+	get files() {
+		if (this.#filesCache) return this.#filesCache;
+		const keys = sortBy(this.#cache.keys(), (v) => v.length, (v) => trimExtName(v).endsWith("index"));
+		const files = [];
+		for (const key of keys) {
+			const file = this.#cache.get(key);
+			if (file) files.push(file);
+		}
+		this.#filesCache = files;
+		return files;
+	}
+	async write(options) {
+		await this.events.emit("files:writing:start", this.files);
+		const resolvedFiles = await this.processor.run(this.files, options);
+		this.clear();
+		await this.events.emit("files:writing:end", resolvedFiles);
+		return resolvedFiles;
+	}
+};
+//#endregion
+//#region src/utils/TreeNode.ts
+var TreeNode = class TreeNode {
+	data;
+	parent;
+	children = [];
+	#childrenMap = /* @__PURE__ */ new Map();
+	#cachedLeaves;
+	constructor(data, parent) {
+		this.data = data;
+		this.parent = parent;
+	}
+	addChild(data) {
+		const child = new TreeNode(data, this);
+		this.children.push(child);
+		if (typeof data === "object" && data !== null && "name" in data) this.#childrenMap.set(data.name, child);
+		this.#cachedLeaves = void 0;
+		return child;
+	}
+	getChildByName(name) {
+		return this.#childrenMap.get(name);
+	}
+	get leaves() {
+		if (this.#cachedLeaves) return this.#cachedLeaves;
+		if (this.children.length === 0) return [this];
+		const result = [];
+		const stack = [...this.children];
+		const visited = /* @__PURE__ */ new Set();
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (visited.has(node)) continue;
+			visited.add(node);
+			if (node.children.length > 0) stack.push(...node.children);
+			else result.push(node);
+		}
+		this.#cachedLeaves = result;
+		return result;
+	}
+	forEach(callback) {
+		const stack = [this];
+		for (let i = 0; i < stack.length; i++) {
+			const node = stack[i];
+			callback(node);
+			if (node.children.length > 0) stack.push(...node.children);
+		}
+		return this;
+	}
+	findDeep(predicate) {
+		for (const leaf of this.leaves) if (predicate(leaf)) return leaf;
+	}
+	static toGraph(root) {
+		const nodes = [];
+		const edges = [];
+		const stack = [root];
+		for (let i = 0; i < stack.length; i++) {
+			const node = stack[i];
+			nodes.push({
+				id: node.data.path,
+				label: node.data.name
+			});
+			const children = node.children;
+			if (children.length > 0) for (let j = 0, len = children.length; j < len; j++) {
+				const child = children[j];
+				edges.push({
+					from: node.data.path,
+					to: child.data.path
+				});
+				stack.push(child);
+			}
+		}
+		return {
+			nodes,
+			edges
+		};
+	}
+	static fromFiles(files, rootFolder = "") {
+		const normalizePath = (p) => p.replace(/\\/g, "/");
+		const normalizedRoot = normalizePath(rootFolder);
+		const rootPrefix = normalizedRoot.endsWith("/") ? normalizedRoot : `${normalizedRoot}/`;
+		const normalizedPaths = /* @__PURE__ */ new Map();
+		const filteredFiles = [];
+		for (const file of files) {
+			const filePath = normalizedPaths.get(file) ?? normalizePath(file.path);
+			normalizedPaths.set(file, filePath);
+			if (!filePath.endsWith(".json") && (!rootFolder || filePath.startsWith(rootPrefix))) filteredFiles.push(file);
+		}
+		if (filteredFiles.length === 0) return null;
+		const treeNode = new TreeNode({
+			name: rootFolder || "",
+			path: rootFolder || "",
+			file: void 0
+		});
+		for (const file of filteredFiles) {
+			const parts = normalizedPaths.get(file).slice(rootPrefix.length).split("/");
+			let current = treeNode;
+			let currentPath = rootFolder;
+			for (const [index, part] of parts.entries()) {
+				const isLast = index === parts.length - 1;
+				currentPath += (currentPath.endsWith("/") ? "" : "/") + part;
+				let next = current.getChildByName(part);
+				if (!next) next = current.addChild({
+					name: part,
+					path: currentPath,
+					file: isLast ? file : void 0
+				});
+				current = next;
+			}
+		}
+		return treeNode;
+	}
+};
+//#endregion
+//#region src/contexts/RootContext.ts
+/**
+* Context providing root-level functionalities such as exit hook, tree node structure, and file management.
+* Define in the `render` helper of the runtime.
+*/
+const RootContext = createContext({
+	exit: () => {},
+	treeNode: new TreeNode({
+		type: "Root",
+		props: {}
+	}),
+	fileManager: new FileManager()
+});
+//#endregion
+//#region src/components/Root.ts
+/**
+* Root component providing core Fabric runtime context.
+*
+* This component is typically used internally by the Fabric renderer.
+* It provides the root context including FileManager, error handling,
+* and lifecycle management.
+*
+* @example
+* ```tsx
+* <Root
+*   onExit={(error) => process.exit(error ? 1 : 0)}
+*   onError={(error) => console.error(error)}
+*   treeNode={treeNode}
+*   fileManager={fileManager}
+* >
+*   <App>
+*     Your components here
+*   </App>
+* </Root>
+* ```
+*/
+const Root = createComponent("Root", ({ onError, onExit, treeNode, fileManager, children }) => {
+	provide(RootContext, {
+		exit: onExit,
+		treeNode,
+		fileManager
+	});
+	provide(NodeTreeContext, treeNode);
+	try {
+		return children;
+	} catch (e) {
+		if (e instanceof Error) onError?.(e);
+		return "";
+	}
+});
+Root.displayName = "Root";
+//#endregion
+//#region src/utils/onProcessExit.ts
+const SIGNALS = [
+	"SIGINT",
+	"SIGTERM",
+	"SIGHUP"
+];
+/**
+* Register a callback to run when the process exits (via exit event or common signals).
+* Returns an unsubscribe function.
+*
+* Dynamically adjusts `process.maxListeners` to avoid MaxListenersExceededWarning
+* when multiple instances are created (e.g. in tests).
+*/
+function onProcessExit(callback) {
+	const exitHandler = (code) => callback(code);
+	const signalHandlers = /* @__PURE__ */ new Map();
+	const count = SIGNALS.length + 1;
+	process.setMaxListeners(process.getMaxListeners() + count);
+	for (const signal of SIGNALS) {
+		const handler = () => {
+			unsubscribe();
+			try {
+				callback(null);
+			} finally {
+				process.kill(process.pid, signal);
+			}
+		};
+		signalHandlers.set(signal, handler);
+		process.on(signal, handler);
+	}
+	process.on("exit", exitHandler);
+	function unsubscribe() {
+		process.removeListener("exit", exitHandler);
+		for (const [signal, handler] of signalHandlers) process.removeListener(signal, handler);
+		process.setMaxListeners(Math.max(process.getMaxListeners() - count, 0));
+	}
+	return unsubscribe;
+}
+//#endregion
+export { provide as _, FileManager as a, createFile as c, createIntrinsic as d, renderIndent as f, inject as g, createContext as h, TreeNode as i, NodeTreeContext as l, RenderContext as m, Root as n, FileProcessor as o, renderIntrinsic as p, RootContext as r, AsyncEventEmitter as s, onProcessExit as t, createComponent as u, unprovide as v };
+
+//# sourceMappingURL=onProcessExit-Cput7j2c.js.map