@kubb/cli 5.11.4 → 5.11.6

package/dist/utils-DpKrXR2t.cjs

@@ -0,0 +1,727 @@
+const require_rolldown_runtime = require("./rolldown-runtime-CPE0t6oh.cjs");
+const require_Telemetry = require("./Telemetry-Be3hIy6_.cjs");
+const require_text = require("./text-CknhKMvM.cjs");
+let node_util = require("node:util");
+let node_process = require("node:process");
+node_process = require_rolldown_runtime.__toESM(node_process, 1);
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+require("node:fs");
+//#region ../../internals/utils/src/fs.ts
+/**
+* Resolves to `true` when the file or directory at `path` exists.
+* Uses `Bun.file().exists()` when running under Bun, `fs.access` otherwise.
+*
+* @example
+* ```ts
+* if (await exists('./kubb.config.ts')) {
+*   const content = await read('./kubb.config.ts')
+* }
+* ```
+*/
+async function exists(path) {
+	if (require_Telemetry.runtime.isBun) return Bun.file(path).exists();
+	return (0, node_fs_promises.access)(path).then(() => true, () => false);
+}
+/**
+* Reads the file at `path` as a UTF-8 string.
+* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
+*
+* @example
+* ```ts
+* const source = await read('./src/Pet.ts')
+* ```
+*/
+async function read(path) {
+	if (require_Telemetry.runtime.isBun) return Bun.file(path).text();
+	return (0, node_fs_promises.readFile)(path, { encoding: "utf8" });
+}
+/**
+* Whether `stored` already holds `source`, comparing on the trimmed text rather than the exact
+* bytes. Surrounding whitespace is what a formatter adds and what editors strip, and neither is a
+* reason to rewrite the file.
+*
+* Both sides are trimmed, so a storage that keeps bytes verbatim settles on the same answer as one
+* that normalizes what it stores. Trimming only `stored` would leave a source with leading
+* whitespace rewritten on every build, since the stored copy keeps the whitespace the comparison
+* has already dropped.
+*/
+function matchesStored({ stored, source }) {
+	return stored.trim() === source.trim();
+}
+/**
+* Writes `data` to `path`, trimming surrounding whitespace and ending the file with a single newline
+* the way prettier, biome, and oxfmt all do.
+* Skips the write when the trimmed content is empty, or when the file already holds that content.
+* Creates any missing parent directories automatically.
+* When `sanity` is `true`, re-reads the file after writing and throws if the content does not match.
+*
+* @example
+* ```ts
+* await write('./src/Pet.ts', source)         // writes and returns the trimmed content plus a newline
+* await write('./src/Pet.ts', source)         // null — file unchanged
+* await write('./src/Pet.ts', '  ')           // null — empty content skipped
+* ```
+*/
+async function write(path, data, options = {}) {
+	const trimmed = data.trim();
+	if (trimmed === "") return null;
+	const content = `${trimmed}\n`;
+	const resolved = (0, node_path.resolve)(path);
+	let stored = options.stored;
+	if (stored === void 0) {
+		if (require_Telemetry.runtime.isBun) {
+			const file = Bun.file(resolved);
+			stored = await file.exists() ? await file.text() : null;
+		} else try {
+			stored = await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" });
+		} catch {
+			stored = null;
+		}
+	}
+	if (matchesStored({
+		stored: stored ?? "",
+		source: trimmed
+	})) return null;
+	await writeRaw(resolved, content);
+	if (options.sanity) {
+		const savedData = await read(resolved);
+		if (savedData !== content) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
+		return savedData;
+	}
+	return content;
+}
+/**
+* Writes UTF-8 content verbatim, including empty files and surrounding whitespace.
+* Uses Bun.write under Bun and creates missing parent directories under either runtime.
+*
+* @example
+* await writeRaw('./cache/output.ts', '  // keep these bytes\n\n')
+*/
+async function writeRaw(path, content) {
+	const resolved = (0, node_path.resolve)(path);
+	if (require_Telemetry.runtime.isBun) {
+		await Bun.write(resolved, content);
+		return;
+	}
+	try {
+		await (0, node_fs_promises.writeFile)(resolved, content, { encoding: "utf-8" });
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(resolved), { recursive: true });
+		await (0, node_fs_promises.writeFile)(resolved, content, { encoding: "utf-8" });
+	}
+}
+/**
+* Resolves to `true` when `path` is `parent` itself or nested inside it. Both sides are resolved
+* to absolute paths first, so relative and `..`-containing inputs compare correctly.
+*
+* Guards a destructive or an out-of-tree operation: before wiping an output directory, check that
+* it does not contain the project root, and before loading a path a caller supplied, check that it
+* did not escape the directory it is allowed to read from.
+*
+* @example
+* isPathInside('./src/gen', '.')   // true  — nested inside the root
+* isPathInside('.', '.')           // true  — the same directory counts as inside
+* isPathInside('.', './src/gen')   // false — the root is not inside its own output
+* isPathInside('../other', '.')    // false — escapes the root
+*/
+function isPathInside(path, parent) {
+	const resolvedPath = (0, node_path.resolve)(path);
+	const resolvedParent = (0, node_path.resolve)(parent);
+	if (resolvedPath === resolvedParent) return true;
+	const rel = (0, node_path.relative)(resolvedParent, resolvedPath);
+	return rel !== "" && !rel.startsWith("..") && !(0, node_path.isAbsolute)(rel);
+}
+//#endregion
+//#region ../../internals/utils/src/promise.ts
+/**
+* Runs `run` over every item with at most `limit` in flight. Workers share one iterator, so each
+* takes the next item the moment it frees up instead of waiting for a batch to drain.
+*
+* @example
+* ```ts
+* await inParallel({ items: files, limit: 50, run: (file) => storage.writeItem(file.path, file.source) })
+* ```
+*/
+async function inParallel({ items, limit, run }) {
+	const queue = items.entries();
+	const worker = async () => {
+		for (const [index, item] of queue) await run(item, index);
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+}
+//#endregion
+//#region src/loggers/banner.ts
+/**
+* xterm-256 color for each pixel letter of the mascot. Fixed codes rather than named colors, so a
+* terminal theme cannot repaint it.
+*/
+const colors = {
+	/** Hoodie. */
+	O: 208,
+	/** Shadow where the hood meets the face. */
+	R: 166,
+	/** Face. */
+	F: 223,
+	/** Eyes. */
+	K: 16,
+	/** Blush. */
+	B: 217,
+	/** Mouth. */
+	M: 131
+};
+/**
+* The two pixel rows of the face around the eyes, for each expression.
+*/
+const eyes = {
+	open: ["FFFFFFFFFF", "FFKFFFFKFF"],
+	left: ["FFFFFFFFFF", "FKFFFFKFFF"],
+	right: ["FFFFFFFFFF", "FFFKFFFFKF"],
+	blink: ["FFFFFFFFFF", "FKKFFFFKKF"],
+	happy: ["FFKFFFFKFF", "FKFKFFKFKF"]
+};
+/**
+* The frames the mascot plays when the CLI starts, each with how long it stays on screen. It ends on
+* open eyes, which stay.
+*/
+const wakeUp = [
+	["blink", 100],
+	["open", 180],
+	["left", 140],
+	["right", 140],
+	["open", 80],
+	["happy", 220],
+	["open", 0]
+];
+/**
+* The kid in the orange hoodie from the Kubb logo, one letter per pixel and `.` for none. Each
+* 2 × 2 block becomes one terminal cell, so a block holds at most two colors.
+*/
+function pixels(expression) {
+	const [top, bottom] = eyes[expression];
+	return [
+		"....OOOOOOOOOO....",
+		"..OORRRRRRRRRROO..",
+		`..OO${top}OO..`,
+		`OOFF${bottom}FFOO`,
+		"OOFFBBFFMMFFBBFFOO",
+		"..OOOOFFFFFFOOOO.."
+	];
+}
+/**
+* Quadrant glyphs indexed by which quarters are filled: top left 1, top right 2, bottom left 4,
+* bottom right 8.
+*/
+const quadrants = " ▘▝▀▖▌▞▛▗▚▐▜▄▙▟█";
+/**
+* Draws each 2 × 2 block of pixels as one quadrant glyph. The glyph's filled quarters take the first
+* color in the block and the rest take the other.
+*/
+function drawHead(expression) {
+	const rows = pixels(expression);
+	const lines = [];
+	for (let y = 0; y < rows.length; y += 2) {
+		let line = "";
+		for (let x = 0; x < rows[y].length; x += 2) {
+			const block = [
+				rows[y][x],
+				rows[y][x + 1],
+				rows[y + 1][x],
+				rows[y + 1][x + 1]
+			];
+			const fg = block.find((pixel) => pixel in colors);
+			if (!fg) {
+				line += " ";
+				continue;
+			}
+			const bg = colors[block.find((pixel) => pixel !== fg) ?? "."];
+			const mask = block.reduce((bits, pixel, index) => pixel === fg ? bits | 1 << index : bits, 0);
+			line += `\x1b[38;5;${colors[fg]}${bg === void 0 ? "" : `;48;5;${bg}`}m${quadrants[mask]}\x1b[0m`;
+		}
+		lines.push(line);
+	}
+	return lines;
+}
+/**
+* Generates the Kubb mascot welcome banner as an ANSI-colored string: the head with the version,
+* title, and description beside it.
+*
+* @example
+* ```ts
+* console.log(getIntro({ title: 'kubb.config.ts', description: 'generating…', version: '5.0.0', expression: 'open' }))
+* ```
+*/
+function getIntro({ title, description, version, expression }) {
+	const brand = (value, bold = false) => `\x1b[${bold ? "1;" : ""}38;5;${colors.O}m${value}\x1b[0m`;
+	const text = [
+		brand(`KUBB v${version}`, true),
+		(0, node_util.styleText)("gray", title),
+		`${brand("➜")} ${(0, node_util.styleText)("white", description)}`
+	];
+	return drawHead(expression).map((line, index) => `  ${line}  ${text[index]}`).join("\n");
+}
+/**
+* Formats a millisecond duration with a threshold-based ANSI color.
+* `≤ 500 ms` → green · `≤ 1 000 ms` → yellow · `> 1 000 ms` → red.
+*
+* @example
+* ```ts
+* formatMsWithColor(200)  // '\x1b[32m200ms\x1b[39m'
+* formatMsWithColor(800)  // '\x1b[33m800ms\x1b[39m'
+* formatMsWithColor(1500) // '\x1b[31m1.50s\x1b[39m'
+* ```
+*/
+function formatMsWithColor(ms) {
+	const formatted = require_Telemetry.formatMs(ms);
+	if (ms <= 500) return (0, node_util.styleText)("green", formatted);
+	if (ms <= 1e3) return (0, node_util.styleText)("yellow", formatted);
+	return (0, node_util.styleText)("red", formatted);
+}
+/**
+* A `size`-cell progress bar: `done` of `total` as filled cells, the rest light. Any progress shows
+* at least one cell, and only a finished bar fills the last one.
+*/
+function formatBar(done, total, size = 20) {
+	const filled = !done ? 0 : done >= total ? size : Math.min(size - 1, Math.max(1, Math.round(done / total * size)));
+	return (0, node_util.styleText)("magenta", "█".repeat(filled)) + (0, node_util.styleText)("dim", "░".repeat(size - filled));
+}
+//#endregion
+//#region src/ui/spinner.ts
+/**
+* A progress spinner, or a writer that prints each message it is given when the terminal cannot
+* animate one. Callers drive both the same way, including the failure state.
+*/
+function createSpinner() {
+	return require_text.writer().spinner();
+}
+/** How long a wait may run before a spinner shows, so a fast answer draws nothing. */
+const SPINNER_DELAY_MS = 150;
+/**
+* Awaits `promise`, showing a spinner with `message` only when it takes longer than 150 ms.
+*/
+async function withSpinner({ promise, message }) {
+	let spinner;
+	const timer = setTimeout(() => {
+		spinner = createSpinner();
+		spinner.start(message);
+	}, SPINNER_DELAY_MS);
+	try {
+		return await promise;
+	} finally {
+		clearTimeout(timer);
+		spinner?.clear();
+	}
+}
+//#endregion
+//#region src/runners/generate/utils.ts
+/** Glob pattern for paths the file watcher ignores. */
+const WATCHER_IGNORED_PATHS = "**/{.git,node_modules}/**";
+/**
+* Quiet window in milliseconds that collapses a burst of watcher events (an editor save emits several) into one rebuild.
+* It outlasts chokidar's 100 ms atomic-save window, which holds back the event of a write-then-rename save.
+*/
+const WATCHER_DEBOUNCE_MS = 250;
+/** Interval in milliseconds between polls of a remote `input` URL in watch mode, which emits no filesystem events. */
+const URL_WATCHER_INTERVAL_MS = 2e3;
+/** Upper bound in milliseconds for one URL watcher request, headers and body read, so a hung server never stalls polling. */
+const URL_WATCHER_TIMEOUT_MS = 1e4;
+/** `14:02:11  petStore.yaml changed`, the line a watcher prints when its input changes. */
+function formatChange({ target, removed = false, now = /* @__PURE__ */ new Date() }) {
+	return `${(0, node_util.styleText)("dim", now.toTimeString().slice(0, 8))}  ${(0, node_util.styleText)("bold", target)} ${removed ? "removed" : "changed"}`;
+}
+/**
+* Starts a file watcher on the given paths and calls `cb` on any change.
+* Ignores `.git` and `node_modules` directories. Event bursts (an editor save emits several)
+* are debounced into one call. `cb` must never reject: its result is not awaited, so the caller
+* serializes and reports its own builds. Resolves to a function that stops watching.
+*/
+async function startWatcher(path, cb, log = {
+	info: console.log,
+	error: console.log
+}) {
+	const { watch } = await import("chokidar");
+	const watcher = watch(path, {
+		ignorePermissionErrors: true,
+		ignored: WATCHER_IGNORED_PATHS,
+		ignoreInitial: true
+	});
+	for (const signal of ["SIGINT", "SIGTERM"]) node_process.default.once(signal, () => void watcher.close());
+	let debounceTimer = null;
+	watcher.on("all", (type, file) => {
+		log.info(formatChange({
+			target: (0, node_path.relative)(node_process.default.cwd(), file),
+			removed: type === "unlink"
+		}));
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			debounceTimer = null;
+			cb(path);
+		}, WATCHER_DEBOUNCE_MS);
+	});
+	return async () => {
+		if (debounceTimer) clearTimeout(debounceTimer);
+		await watcher.close();
+	};
+}
+/**
+* Fetches the body of a remote spec URL, `undefined` when the server does not answer with a
+* readable 2xx body before `signal` aborts. The caller seeds `startUrlWatcher` with the result, so
+* the watcher compares polls against the content the initial build ran on.
+*/
+async function fetchUrlBody(url, signal = AbortSignal.timeout(URL_WATCHER_TIMEOUT_MS)) {
+	try {
+		const response = await fetch(url, { signal });
+		if (!response.ok) return void 0;
+		return await response.text();
+	} catch {
+		return;
+	}
+}
+/**
+* Polls a remote spec URL and calls `cb` whenever the response body changes. A remote document
+* emits no filesystem events, so this is the URL counterpart of `startWatcher`.
+*
+* `initialBody` seeds the change detection, so an edit landing between the initial build and the
+* first poll still rebuilds. An unreachable server (the API restarting between saves) is reported
+* once per outage and polling continues; after it recovers, a rebuild happens only when the body
+* actually differs from the last one seen, so a plain restart with an unchanged spec stays quiet.
+* Each request is aborted after `timeoutMs`, so a hung response delays at most one poll.
+* `cb` must never reject: its result is not awaited.
+*
+* Returns a function that stops polling and aborts the in-flight request, so callers (and tests)
+* can shut the watcher down without signaling the process.
+*/
+function startUrlWatcher(url, cb, options = {}) {
+	const { log = {
+		info: console.log,
+		error: console.log
+	}, intervalMs = URL_WATCHER_INTERVAL_MS, timeoutMs = URL_WATCHER_TIMEOUT_MS, initialBody } = options;
+	let lastBody = initialBody;
+	let offline = false;
+	let timer = null;
+	let controller = null;
+	let stopped = false;
+	const stop = () => {
+		stopped = true;
+		if (timer) clearTimeout(timer);
+		controller?.abort();
+	};
+	node_process.default.once("SIGINT", stop);
+	node_process.default.once("SIGTERM", stop);
+	const schedule = () => {
+		if (!stopped) timer = setTimeout(() => void poll(), intervalMs);
+	};
+	const poll = async () => {
+		controller = new AbortController();
+		const body = await fetchUrlBody(url, AbortSignal.any([controller.signal, AbortSignal.timeout(timeoutMs)]));
+		if (body === void 0) {
+			if (!offline && !stopped) {
+				offline = true;
+				log.error((0, node_util.styleText)("red", `Cannot reach ${url}, polling until it responds again`));
+			}
+			schedule();
+			return;
+		}
+		if (offline) {
+			offline = false;
+			log.info((0, node_util.styleText)("yellow", `${url} is reachable again`));
+		}
+		const changed = lastBody !== void 0 && body !== lastBody;
+		if (changed) log.info(formatChange({ target: url }));
+		if (changed || lastBody === void 0) cb([url]);
+		lastBody = body;
+		schedule();
+	};
+	poll();
+	return stop;
+}
+function createSnapshot() {
+	return {
+		schemas: /* @__PURE__ */ new Set(),
+		operations: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* Collects a {@link BuildSnapshot} from the hooks while a build runs. `take` hands back the finished
+* build's snapshot and starts the next one.
+*/
+function trackBuild(hooks) {
+	let current = createSnapshot();
+	hooks.hook("kubb:generate:schema", (node) => {
+		if (node.name) current.schemas.add(node.name);
+	});
+	hooks.hook("kubb:generate:operation", (node) => {
+		current.operations.add(node.operationId);
+	});
+	return { take() {
+		const snapshot = current;
+		current = createSnapshot();
+		return snapshot;
+	} };
+}
+function diffNames(previous, next) {
+	return {
+		added: [...next].filter((name) => !previous.has(name)).length,
+		removed: [...previous].filter((name) => !next.has(name)).length
+	};
+}
+/**
+* Compares two {@link BuildSnapshot}s by name.
+*/
+function diffBuilds(previous, next) {
+	return {
+		schemas: diffNames(previous.schemas, next.schemas),
+		operations: diffNames(previous.operations, next.operations)
+	};
+}
+/**
+* Compares file contents or fingerprints by path.
+*/
+function diffFiles(previous, next) {
+	const files = [];
+	let unchanged = 0;
+	for (const [path, fingerprint] of next) {
+		const before = previous.get(path);
+		if (before === fingerprint) unchanged++;
+		else files.push({
+			status: before === void 0 ? "A" : "M",
+			path
+		});
+	}
+	for (const path of previous.keys()) if (!next.has(path)) files.push({
+		status: "D",
+		path
+	});
+	return {
+		files,
+		unchanged
+	};
+}
+function countLineChanges(before, after) {
+	const remaining = /* @__PURE__ */ new Map();
+	for (const line of before ? before.split("\n") : []) remaining.set(line, (remaining.get(line) ?? 0) + 1);
+	let added = 0;
+	for (const line of after ? after.split("\n") : []) {
+		const count = remaining.get(line) ?? 0;
+		if (count > 0) remaining.set(line, count - 1);
+		else added++;
+	}
+	const removed = [...remaining.values()].reduce((sum, count) => sum + count, 0);
+	return {
+		added,
+		removed
+	};
+}
+/**
+* Reads the output before generation, so cleaning the directory cannot erase the diff baseline.
+* A missing directory or an unreadable file is skipped.
+*/
+async function readOutputFiles(outputPath) {
+	const entries = await (0, node_fs_promises.readdir)(outputPath, {
+		recursive: true,
+		withFileTypes: true
+	}).catch(() => []);
+	const files = /* @__PURE__ */ new Map();
+	await inParallel({
+		items: entries.filter((entry) => entry.isFile()).map((entry) => (0, node_path.join)(entry.parentPath, entry.name)),
+		limit: 50,
+		run: async (filePath) => {
+			const source = await read(filePath).catch(() => null);
+			if (source !== null) files.set(filePath, source);
+		}
+	});
+	return files;
+}
+/**
+* Compares generated output with the files captured before generation. The manifest recognizes
+* output rewritten by a formatter, and `clean` includes files the run would delete.
+*/
+async function diffOutput({ storage, paths, clean, manifest, previousFiles }) {
+	const generated = new Set(paths);
+	const changes = [];
+	let unchanged = 0;
+	await inParallel({
+		items: paths,
+		limit: 50,
+		run: async (filePath, index) => {
+			const next = await storage.readItem(filePath);
+			if (next === null) return;
+			const previous = previousFiles.get(filePath) ?? null;
+			if (previous !== null && (matchesStored({
+				stored: previous,
+				source: next
+			}) || manifest?.isUpToDate({
+				key: filePath,
+				source: next,
+				disk: previous
+			}))) {
+				unchanged++;
+				return;
+			}
+			changes[index] = {
+				status: previous === null ? "A" : "M",
+				path: filePath,
+				...countLineChanges(previous?.trim() ?? "", previous === null ? next.trimEnd() : next.trim())
+			};
+		}
+	});
+	const files = changes.filter((file) => file !== void 0);
+	if (clean) {
+		for (const [filePath, source] of previousFiles) if (!generated.has(filePath)) files.push({
+			status: "D",
+			path: filePath,
+			...countLineChanges(source.trimEnd(), "")
+		});
+	}
+	return {
+		files,
+		unchanged
+	};
+}
+/**
+* Reads `r` (rebuild) and `q` (quit) from an interactive stdin in raw mode, and keeps ctrl+c
+* working. Returns `undefined` when stdin is not a TTY. Otherwise returns `arm`, which turns raw
+* mode back on: a spinner restores the terminal when it stops, so call it after each build. Raw mode
+* is restored on exit.
+*/
+function listenForKeys({ rebuild, quit, input = node_process.default.stdin }) {
+	if (!input.isTTY) return void 0;
+	const arm = () => {
+		input.setRawMode(true);
+		input.resume();
+	};
+	input.setEncoding("utf8");
+	input.on("data", (data) => {
+		const key = data.trim();
+		if (key === "r") {
+			rebuild();
+			return;
+		}
+		if (key === "q" || data === "") {
+			input.setRawMode(false);
+			input.pause();
+			quit(key === "q" ? 0 : 130);
+		}
+	});
+	node_process.default.once("exit", () => input.setRawMode(false));
+	arm();
+	return arm;
+}
+//#endregion
+Object.defineProperty(exports, "createSpinner", {
+	enumerable: true,
+	get: function() {
+		return createSpinner;
+	}
+});
+Object.defineProperty(exports, "diffBuilds", {
+	enumerable: true,
+	get: function() {
+		return diffBuilds;
+	}
+});
+Object.defineProperty(exports, "diffFiles", {
+	enumerable: true,
+	get: function() {
+		return diffFiles;
+	}
+});
+Object.defineProperty(exports, "diffOutput", {
+	enumerable: true,
+	get: function() {
+		return diffOutput;
+	}
+});
+Object.defineProperty(exports, "exists", {
+	enumerable: true,
+	get: function() {
+		return exists;
+	}
+});
+Object.defineProperty(exports, "fetchUrlBody", {
+	enumerable: true,
+	get: function() {
+		return fetchUrlBody;
+	}
+});
+Object.defineProperty(exports, "formatBar", {
+	enumerable: true,
+	get: function() {
+		return formatBar;
+	}
+});
+Object.defineProperty(exports, "formatMsWithColor", {
+	enumerable: true,
+	get: function() {
+		return formatMsWithColor;
+	}
+});
+Object.defineProperty(exports, "getIntro", {
+	enumerable: true,
+	get: function() {
+		return getIntro;
+	}
+});
+Object.defineProperty(exports, "isPathInside", {
+	enumerable: true,
+	get: function() {
+		return isPathInside;
+	}
+});
+Object.defineProperty(exports, "listenForKeys", {
+	enumerable: true,
+	get: function() {
+		return listenForKeys;
+	}
+});
+Object.defineProperty(exports, "read", {
+	enumerable: true,
+	get: function() {
+		return read;
+	}
+});
+Object.defineProperty(exports, "readOutputFiles", {
+	enumerable: true,
+	get: function() {
+		return readOutputFiles;
+	}
+});
+Object.defineProperty(exports, "startUrlWatcher", {
+	enumerable: true,
+	get: function() {
+		return startUrlWatcher;
+	}
+});
+Object.defineProperty(exports, "startWatcher", {
+	enumerable: true,
+	get: function() {
+		return startWatcher;
+	}
+});
+Object.defineProperty(exports, "trackBuild", {
+	enumerable: true,
+	get: function() {
+		return trackBuild;
+	}
+});
+Object.defineProperty(exports, "wakeUp", {
+	enumerable: true,
+	get: function() {
+		return wakeUp;
+	}
+});
+Object.defineProperty(exports, "withSpinner", {
+	enumerable: true,
+	get: function() {
+		return withSpinner;
+	}
+});
+Object.defineProperty(exports, "write", {
+	enumerable: true,
+	get: function() {
+		return write;
+	}
+});
+
+//# sourceMappingURL=utils-DpKrXR2t.cjs.map