@untestutils/core 0.5.0

package/dist/paths.mjs

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, normalize, resolve } from "pathe";
+import { fileURLToPath } from "node:url";
+
+export const LOOPBACK_HOST = "127.0.0.1";
+
+export function resolveBindHost() {
+	const raw = process.env.UNTESTUTILS_BIND_HOST?.trim();
+	if (!raw) return LOOPBACK_HOST;
+	if (raw === "localhost" || raw === "::1" || raw === "[::1]") return LOOPBACK_HOST;
+	return raw;
+}
+
+export function resolveProbeHost(bindHost = resolveBindHost()) {
+	const h = bindHost.replace(/^\[|\]$/g, "").toLowerCase();
+	if (h === "0.0.0.0" || h === "*" || h === "::" || h === "::0") return LOOPBACK_HOST;
+	return bindHost;
+}
+export function loopbackUrl(port, path = "/", host = resolveBindHost()) {
+	const probe = resolveProbeHost(host);
+	const p = path.startsWith("/") ? path : `/${path}`;
+	return `http://${probe}:${port}${p}`;
+}
+export function normalizeBaseUrl(url) {
+	try {
+		const u = new URL(url);
+		const host = u.hostname.replace(/^\[|\]$/g, "");
+		if (host === "localhost" || host === "::1") {
+			u.hostname = LOOPBACK_HOST;
+		}
+		let href = u.toString();
+		if (u.pathname === "/" && !href.endsWith("/")) href += "/";
+		return href;
+	} catch {
+		return url.replace("localhost", LOOPBACK_HOST).replace("[::1]", LOOPBACK_HOST);
+	}
+}
+export function resolveArtifactsRoot(cwd = process.cwd()) {
+	if (process.env.UNTESTUTILS_ARTIFACTS_DIR) {
+		return resolve(cwd, process.env.UNTESTUTILS_ARTIFACTS_DIR);
+	}
+	const repoRoot = findRepoRoot(cwd);
+	return join(repoRoot, ".untestutils");
+}
+export function findRepoRoot(start = process.cwd()) {
+	let dir = resolve(start);
+	for (;;) {
+		if (existsSync(join(dir, "pnpm-workspace.yaml")) || existsSync(join(dir, ".git"))) {
+			return dir;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) return start;
+		dir = parent;
+	}
+}
+export function assertNotInsideWorkspacePackage(artifactsRoot, workspaceRoots) {
+	const normalized = normalize(resolve(artifactsRoot));
+	for (const root of workspaceRoots) {
+		const pkgRoot = normalize(resolve(root));
+		if (normalized === pkgRoot || normalized.startsWith(pkgRoot + "/")) {
+			
+			const pkgJson = join(pkgRoot, "package.json");
+			if (!existsSync(pkgJson)) continue;
+			try {
+				const name = JSON.parse(readFileSync(pkgJson, "utf8")).name;
+				
+				if (name && name !== "untestutils" && !normalized.includes("/.untestutils")) {
+					throw new Error(`[untestutils] artifactsDir must not live inside workspace package "${name}" (${pkgRoot}). Use <repo>/.untestutils instead.`);
+				}
+			} catch (e) {
+				
+				if (e instanceof Error && e.message.startsWith("[untestutils]")) throw e;
+			}
+		}
+	}
+}
+
+export function refuseArtifactsInsidePackage(outDir) {
+	const target = normalize(resolve(outDir));
+	if (/(^|\/|\\)\.untestutils(\/|\\|$)/.test(target)) return;
+	let dir = target;
+	for (let i = 0; i < 12; i++) {
+		const pkgPath = join(dir, "package.json");
+		if (existsSync(pkgPath)) {
+			let name;
+			try {
+				name = JSON.parse(readFileSync(pkgPath, "utf8")).name;
+			} catch {
+				name = undefined;
+			}
+			if (name && name !== "untestutils") {
+				let walk = dir;
+				for (let j = 0; j < 12; j++) {
+					if (existsSync(join(walk, "pnpm-workspace.yaml"))) {
+						throw new Error(`[untestutils] refusing to write artifacts inside workspace package "${name}" (${dir}). Use <repo>/.untestutils/builds.`);
+					}
+					const parent = dirname(walk);
+					
+					if (parent === walk) break;
+					walk = parent;
+				}
+			}
+			break;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+}
+export function isWorkspacePackageDir(dir) {
+	return existsSync(join(dir, "package.json"));
+}
+export function toFilePath(urlOrPath) {
+	if (typeof urlOrPath === "string") {
+		if (urlOrPath.startsWith("file:")) return fileURLToPath(urlOrPath);
+		return isAbsolute(urlOrPath) ? urlOrPath : resolve(urlOrPath);
+	}
+	return fileURLToPath(urlOrPath);
+}
+export function expandHome(path) {
+	if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+	return path;
+}

package/dist/ports.d.mts

@@ -0,0 +1,2 @@
+export declare function getFreePort(host?: string): Promise<number>;
+export declare function waitForPort(port: number, host?: string, timeoutMs?: number): Promise<void>;

package/dist/ports.d.ts

@@ -0,0 +1,8 @@
+import net from 'node:net';
+/** @internal injectable for port allocation edge cases */
+export declare const portNet: {
+    createServer: (options?: net.ServerOpts | undefined, connectionListener?: ((socket: net.Socket) => void) | undefined) => net.Server;
+};
+export declare function getFreePort(host?: string): Promise<number>;
+export declare function waitForPort(port: number, host?: string, timeoutMs?: number): Promise<void>;
+//# sourceMappingURL=ports.d.ts.map

package/dist/ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../src/ports.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,UAAU,CAAC;AAG3B,0DAA0D;AAC1D,eAAO,MAAM,OAAO;;CAEnB,CAAC;AAEF,wBAAgB,WAAW,CAAC,IAAI,GAAE,MAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,CAezE;AAED,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAsB,EAC5B,SAAS,GAAE,MAAe,GACzB,OAAO,CAAC,IAAI,CAAC,CAiBf"}

package/dist/ports.mjs

@@ -0,0 +1,38 @@
+import net from "node:net";
+import { LOOPBACK_HOST } from "./paths.mjs";
+
+export const portNet = { createServer: (...args) => net.createServer(...args) };
+export function getFreePort(host = LOOPBACK_HOST) {
+	return new Promise((resolve, reject) => {
+		const server = portNet.createServer();
+		server.once("error", reject);
+		server.listen(0, host, () => {
+			const addr = server.address();
+			if (!addr || typeof addr === "string") {
+				server.close();
+				reject(new Error("failed to allocate port"));
+				return;
+			}
+			const { port } = addr;
+			server.close((err) => err ? reject(err) : resolve(port));
+		});
+	});
+}
+export function waitForPort(port, host = LOOPBACK_HOST, timeoutMs = 3e4) {
+	const deadline = Date.now() + timeoutMs;
+	return new Promise((resolve, reject) => {
+		const attempt = () => {
+			const socket = net.connect(port, host);
+			socket.once("connect", () => {
+				socket.destroy();
+				resolve();
+			});
+			socket.once("error", () => {
+				socket.destroy();
+				if (Date.now() > deadline) reject(new Error(`port ${port} not ready after ${timeoutMs}ms`));
+				else setTimeout(attempt, 150);
+			});
+		};
+		attempt();
+	});
+}

package/dist/process.d.mts

@@ -0,0 +1,31 @@
+import { type ChildProcess, spawn } from "node:child_process";
+export declare function scrubTestEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export interface SpawnOpts {
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	captureLogs?: boolean;
+}
+export interface ManagedProcess {
+	child: ChildProcess;
+	pid?: number;
+	stop: () => Promise<void>;
+	logs: () => string;
+}
+export declare const processIo: {
+	spawn: typeof spawn;
+	kill: typeof process.kill;
+};
+export declare function currentPlatform(): NodeJS.Platform;
+export declare function spawnManaged(command: string, args: string[], opts?: SpawnOpts): ManagedProcess;
+/** True when `pid` refers to a live process (signal 0). */
+export declare function isPidAlive(pid: number): boolean;
+/** Kill a process group by pid (detached spawn) without needing the ChildProcess handle. */
+export declare function killPidTree(pid: number): Promise<void>;
+export declare function killProcessTree(child: ChildProcess): Promise<void>;
+export declare function runCommand(command: string, args: string[], opts?: SpawnOpts & {
+	timeoutMs?: number;
+}): Promise<{
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+}>;

package/dist/process.d.ts

@@ -0,0 +1,36 @@
+import { type ChildProcess, spawn } from 'node:child_process';
+export declare function scrubTestEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export interface SpawnOpts {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    captureLogs?: boolean;
+}
+export interface ManagedProcess {
+    child: ChildProcess;
+    pid?: number;
+    stop: () => Promise<void>;
+    logs: () => string;
+}
+/** @internal mutable seams — tests replace these; never call real kill/spawn from unit tests */
+export declare const processPlatform: {
+    current: () => NodeJS.Platform;
+};
+export declare const processIo: {
+    spawn: typeof spawn;
+    kill: typeof process.kill;
+};
+export declare function currentPlatform(): NodeJS.Platform;
+export declare function spawnManaged(command: string, args: string[], opts?: SpawnOpts): ManagedProcess;
+/** True when `pid` refers to a live process (signal 0). */
+export declare function isPidAlive(pid: number): boolean;
+/** Kill a process group by pid (detached spawn) without needing the ChildProcess handle. */
+export declare function killPidTree(pid: number): Promise<void>;
+export declare function killProcessTree(child: ChildProcess): Promise<void>;
+export declare function runCommand(command: string, args: string[], opts?: SpawnOpts & {
+    timeoutMs?: number;
+}): Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+//# sourceMappingURL=process.d.ts.map

package/dist/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../src/process.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAa9D,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAAC,UAAU,CAIpF;AAED,MAAM,WAAW,SAAS;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,YAAY,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,gGAAgG;AAChG,eAAO,MAAM,eAAe;mBACb,MAAM,CAAC,QAAQ;CAC7B,CAAC;AAEF,eAAO,MAAM,SAAS;WAC8C,OAAO,KAAK;UAE9C,OAAO,OAAO,CAAC,IAAI;CACpD,CAAC;AAEF,wBAAgB,eAAe,IAAI,MAAM,CAAC,QAAQ,CAEjD;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,GAAE,SAAc,GACnB,cAAc,CAmChB;AAMD,2DAA2D;AAC3D,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAQ/C;AAED,4FAA4F;AAC5F,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgD5D;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAqCxE;AAED,wBAAsB,UAAU,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,GAAE,SAAS,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5C,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAgC/D"}

package/dist/process.mjs

@@ -0,0 +1,191 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { debug } from "./debug.mjs";
+const STRIP_ENV = [
+	"VITEST",
+	"VITEST_WORKER_ID",
+	"VITEST_POOL_ID",
+	"TEST",
+	"JEST_WORKER_ID",
+	"JEST"
+];
+export function scrubTestEnv(env = process.env) {
+	const next = { ...env };
+	for (const key of STRIP_ENV) delete next[key];
+	return next;
+}
+
+export const processPlatform = { current: () => platform() };
+export const processIo = {
+	spawn: ((...args) => spawn(...args)),
+	kill: ((pid, signal) => process.kill(pid, signal))
+};
+export function currentPlatform() {
+	return processPlatform.current();
+}
+export function spawnManaged(command, args, opts = {}) {
+	const env = scrubTestEnv(opts.env ?? process.env);
+	const capture = opts.captureLogs ?? envFlagCapture();
+	let output = "";
+	debug("spawn", `${command} ${args.join(" ")}`, { cwd: opts.cwd });
+	const child = processIo.spawn(command, args, {
+		cwd: opts.cwd,
+		env,
+		stdio: capture ? [
+			"ignore",
+			"pipe",
+			"pipe"
+		] : "inherit",
+		detached: currentPlatform() !== "win32"
+	});
+	if (capture) {
+		child.stdout?.on("data", (c) => {
+			output += c.toString();
+		});
+		child.stderr?.on("data", (c) => {
+			output += c.toString();
+		});
+	}
+	const stop = async () => {
+		
+		if (!child.pid) return;
+		await killProcessTree(child);
+	};
+	return {
+		child,
+		pid: child.pid,
+		stop,
+		logs: () => output
+	};
+}
+function envFlagCapture() {
+	return process.env.UNTESTUTILS_CAPTURE_LOGS === "1";
+}
+
+export function isPidAlive(pid) {
+	if (!pid || pid <= 1) return false;
+	try {
+		processIo.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function killPidTree(pid) {
+	
+	if (!pid || pid <= 1 || pid === process.pid) return;
+	if (currentPlatform() === "win32") {
+		await new Promise((resolve) => {
+			const killer = processIo.spawn("taskkill", [
+				"/T",
+				"/F",
+				"/PID",
+				String(pid)
+			], { stdio: "ignore" });
+			killer.on("exit", () => resolve());
+			killer.on("error", () => resolve());
+			setTimeout(resolve, 5e3).unref();
+		});
+		return;
+	}
+	await new Promise((resolve) => {
+		try {
+			processIo.kill(-pid, "SIGTERM");
+		} catch {
+			try {
+				processIo.kill(pid, "SIGTERM");
+			} catch {}
+		}
+		const t = setTimeout(() => {
+			try {
+				processIo.kill(-pid, "SIGKILL");
+			} catch {
+				try {
+					processIo.kill(pid, "SIGKILL");
+				} catch {}
+			}
+			resolve();
+		}, 2e3);
+		t.unref();
+		const poll = setInterval(() => {
+			if (!isPidAlive(pid)) {
+				clearInterval(poll);
+				clearTimeout(t);
+				resolve();
+			}
+		}, 50);
+		poll.unref();
+	});
+}
+export async function killProcessTree(child) {
+	const pid = child.pid;
+	if (!pid || pid <= 1 || pid === process.pid) return;
+	if (currentPlatform() === "win32") {
+		await killPidTree(pid);
+		return;
+	}
+	await new Promise((resolve) => {
+		try {
+			processIo.kill(-pid, "SIGTERM");
+		} catch {
+			try {
+				child.kill("SIGTERM");
+			} catch {}
+		}
+		const t = setTimeout(() => {
+			try {
+				processIo.kill(-pid, "SIGKILL");
+			} catch {
+				try {
+					child.kill("SIGKILL");
+				} catch {}
+			}
+			resolve();
+		}, 5e3);
+		t.unref();
+		child.once("exit", () => {
+			clearTimeout(t);
+			resolve();
+		});
+	});
+}
+export async function runCommand(command, args, opts = {}) {
+	const env = scrubTestEnv(opts.env ?? process.env);
+	return new Promise((resolve, reject) => {
+		const child = processIo.spawn(command, args, {
+			cwd: opts.cwd,
+			env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.on("data", (c) => {
+			stdout += c.toString();
+			if (process.env.UNTESTUTILS_DEBUG === "1") process.stderr.write(c);
+		});
+		child.stderr?.on("data", (c) => {
+			stderr += c.toString();
+			if (process.env.UNTESTUTILS_DEBUG === "1") process.stderr.write(c);
+		});
+		const timer = opts.timeoutMs ? setTimeout(() => {
+			void killProcessTree(child);
+			reject(new Error(`[untestutils] command timed out: ${command} ${args.join(" ")}`));
+		}, opts.timeoutMs) : undefined;
+		child.on("error", (err) => {
+			reject(new Error(`[untestutils] failed to spawn ${command}: ${err.message}`, { cause: err }));
+		});
+		child.on("exit", (code) => {
+			if (timer) clearTimeout(timer);
+			resolve({
+				exitCode: code ?? 1,
+				stdout,
+				stderr
+			});
+		});
+	});
+}

package/dist/progress.d.mts

@@ -0,0 +1,45 @@
+/** Common CI / non-interactive runners (GitHub, GitLab, Jenkins, …). */
+export declare function isCi(): boolean;
+/**
+* Compact harness progress (prepare wave + mass-run banner).
+* Off when: `UNTESTUTILS_QUIET=1`, `UNTESTUTILS_PROGRESS=0`, or CI (unless `UNTESTUTILS_PROGRESS=1`).
+*/
+export declare function isProgressEnabled(): boolean;
+/** @deprecated prefer isProgressEnabled — QUIET alone */
+export declare function isQuiet(): boolean;
+/**
+* Harness console UX — mirrors the README demo:
+* prepare once → shared hosts → mass run on live URLs.
+*/
+export declare const progress: {
+	/**
+	* Start a prepare wave (typically `prewarm` in globalSetup).
+	* Groups many recipe prepares under one banner.
+	*/
+	waveStart(ids: string[]): void;
+	/** @deprecated use waveStart — kept for older call sites */
+	prewarm(ids: string[]): void;
+	prepareStart(id: string): void;
+	prepareDone(id: string, ms: number): void;
+	prepareCache(id: string): void;
+	/**
+	* Close the prepare wave and announce shared hosts are warm.
+	* Call after all prewarm `ensurePrepared` calls finish.
+	*/
+	waveReady(): void;
+	/**
+	* Banner before specs hit live URLs (after prepare wave).
+	* Safe to call multiple times — only prints once per process.
+	*/
+	massRun(): void;
+	start(id: string, url: string): void;
+	teardown(): void;
+	/** Always surfaces failures — never swallowed by quiet/CI. */
+	fail(id: string, err: unknown): void;
+};
+/**
+* While pretty progress is on, mute noisy info/success from Nuxt/Vite/Nitro.
+* Errors (consola level ≥ error) stay visible. Never mutes in CI / quiet / debug.
+* Always restores level and rethrows — does not swallow.
+*/
+export declare function withQuietLogger<T>(fn: () => Promise<T>): Promise<T>;

package/dist/progress.d.ts

@@ -0,0 +1,66 @@
+/** Common CI / non-interactive runners (GitHub, GitLab, Jenkins, …). */
+export declare function isCi(): boolean;
+/**
+ * Compact harness progress (prepare wave + mass-run banner).
+ * Off when: `UNTESTUTILS_QUIET=1`, `UNTESTUTILS_PROGRESS=0`, or CI (unless `UNTESTUTILS_PROGRESS=1`).
+ */
+export declare function isProgressEnabled(): boolean;
+/** @deprecated prefer isProgressEnabled — QUIET alone */
+export declare function isQuiet(): boolean;
+type WaveState = {
+    total: number;
+    ready: number;
+    building: Set<string>;
+    /** Suppress per-id `→ start` noise while the prepare wave is active. */
+    active: boolean;
+    startedAt: number;
+    massRunShown: boolean;
+};
+/** @internal mutable seam for unit tests */
+export declare const progressIo: {
+    lines: string[];
+    capture: boolean;
+    bannerShown: boolean;
+    wave: WaveState | null;
+    write(line: string): void;
+    writeErr(line: string): void;
+    reset(): void;
+};
+/**
+ * Harness console UX — mirrors the README demo:
+ * prepare once → shared hosts → mass run on live URLs.
+ */
+export declare const progress: {
+    /**
+     * Start a prepare wave (typically `prewarm` in globalSetup).
+     * Groups many recipe prepares under one banner.
+     */
+    waveStart(ids: string[]): void;
+    /** @deprecated use waveStart — kept for older call sites */
+    prewarm(ids: string[]): void;
+    prepareStart(id: string): void;
+    prepareDone(id: string, ms: number): void;
+    prepareCache(id: string): void;
+    /**
+     * Close the prepare wave and announce shared hosts are warm.
+     * Call after all prewarm `ensurePrepared` calls finish.
+     */
+    waveReady(): void;
+    /**
+     * Banner before specs hit live URLs (after prepare wave).
+     * Safe to call multiple times — only prints once per process.
+     */
+    massRun(): void;
+    start(id: string, url: string): void;
+    teardown(): void;
+    /** Always surfaces failures — never swallowed by quiet/CI. */
+    fail(id: string, err: unknown): void;
+};
+/**
+ * While pretty progress is on, mute noisy info/success from Nuxt/Vite/Nitro.
+ * Errors (consola level ≥ error) stay visible. Never mutes in CI / quiet / debug.
+ * Always restores level and rethrows — does not swallow.
+ */
+export declare function withQuietLogger<T>(fn: () => Promise<T>): Promise<T>;
+export {};
+//# sourceMappingURL=progress.d.ts.map

package/dist/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../src/progress.ts"],"names":[],"mappings":"AAIA,wEAAwE;AACxE,wBAAgB,IAAI,IAAI,OAAO,CAe9B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAO3C;AAED,yDAAyD;AACzD,wBAAgB,OAAO,IAAI,OAAO,CAEjC;AAQD,KAAK,SAAS,GAAG;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,wEAAwE;IACxE,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,4CAA4C;AAC5C,eAAO,MAAM,UAAU;WACR,MAAM,EAAE;;;UAGP,SAAS,GAAG,IAAI;gBAClB,MAAM;mBAGH,MAAM;;CAStB,CAAC;AA8CF;;;GAGG;AACH,eAAO,MAAM,QAAQ;IACnB;;;OAGG;mBACY,MAAM,EAAE,GAAG,IAAI;IAuB9B,4DAA4D;iBAC/C,MAAM,EAAE,GAAG,IAAI;qBAIX,MAAM,GAAG,IAAI;oBAUd,MAAM,MAAM,MAAM,GAAG,IAAI;qBAWxB,MAAM,GAAG,IAAI;IAW9B;;;OAGG;iBACU,IAAI;IAYjB;;;OAGG;eACQ,IAAI;cAaL,MAAM,OAAO,MAAM,GAAG,IAAI;gBAWxB,IAAI;IAehB,8DAA8D;aACrD,MAAM,OAAO,OAAO,GAAG,IAAI;CAWrC,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAUzE"}