@ucdjs/cli 0.2.2 → 0.3.1-beta.1

package/dist/get-CHw5s5Ab.mjs

@@ -0,0 +1,63 @@
+import { _ as output, p as green, t as printHelp, v as red } from "./cli.mjs";
+import { writeFile } from "node:fs/promises";
+import { createUCDClient } from "@ucdjs/client";
+import { UCDJS_API_BASE_URL } from "@ucdjs/env";
+
+//#region src/cmd/files/get.ts
+async function runFilesGet({ path, flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Get a specific file from the UCD API",
+			commandName: "ucd files get",
+			usage: "<path> [...flags]",
+			description: "Download a specific file from the Unicode Character Database API. The file content will be written to stdout by default, or to a file if --output is specified.",
+			tables: { Flags: [
+				["--base-url", "Base URL for the UCD API (defaults to api.ucdjs.dev)."],
+				["--output (-o)", "Write file content to the specified file path instead of stdout."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	if (!path) {
+		output.error(red(`\n❌ Error: Path is required.`));
+		output.error(`  Usage: ucd files get <path>`);
+		output.error(`  Example: ucd files get 16.0.0/ucd/UnicodeData.txt`);
+		return;
+	}
+	const { baseUrl, output: outputFlag } = flags;
+	try {
+		const result = await (await createUCDClient(baseUrl || UCDJS_API_BASE_URL)).files.get(path);
+		if (result.error) {
+			output.error(red(`\n❌ Error fetching file:`));
+			output.error(`  ${result.error.message}`);
+			if (result.error.status === 404) output.error(`  File "${path}" not found.`);
+			return;
+		}
+		if (!result.data) {
+			output.error(red(`\n❌ Error: No data returned from API.`));
+			return;
+		}
+		if (Array.isArray(result.data)) {
+			output.error(red(`\n❌ Error: Path "${path}" is a directory, not a file.`));
+			output.error(`  Use "ucd files list" to view directory contents.`);
+			return;
+		}
+		const content = result.data;
+		if (outputFlag) {
+			await writeFile(outputFlag, content, "utf-8");
+			output.log(green(`\n✓ File written to: ${outputFlag}\n`));
+		} else output.log(content);
+	} catch (err) {
+		let message = "Unknown error";
+		if (err instanceof Error) message = err.message;
+		else if (typeof err === "string") message = err;
+		output.error(red(`\n❌ Error getting file:`));
+		output.error(`  ${message}`);
+		output.error("Please check the API configuration and try again.");
+		output.error("If you believe this is a bug, please report it at https://github.com/ucdjs/ucd/issues");
+	}
+}
+
+//#endregion
+export { runFilesGet };

package/dist/hash-BAViT6QD.mjs

@@ -0,0 +1,116 @@
+import { _ as output, c as bold, d as formatBytes, p as green, t as printHelp, u as dim, v as red, y as yellow } from "./cli.mjs";
+import process from "node:process";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { Buffer } from "node:buffer";
+import { computeFileHash, computeFileHashWithoutUCDHeader, stripUnicodeHeader } from "@ucdjs/lockfile";
+
+//#region src/cmd/lockfile/hash.ts
+async function runLockfileHash({ filePath, flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Compute content hash for a file",
+			commandName: "ucd lockfile hash",
+			usage: "<file-path> [...flags]",
+			description: "Compute the SHA-256 hash of a file, optionally stripping the Unicode header first. Useful for debugging and verifying file integrity.",
+			tables: { Flags: [
+				["--strip-header", "Strip the Unicode header before computing hash (default: false)."],
+				["--compare <hash>", "Compare computed hash with the provided hash."],
+				["--json", "Output hash information as JSON."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	if (!filePath) {
+		output.error(red(`\n❌ Error: File path is required.`));
+		output.error(`\n  Usage: ${green("ucd lockfile hash <file-path>")}`);
+		return;
+	}
+	const { json, stripHeader, compare } = flags;
+	const resolvedPath = resolve(process.cwd(), filePath);
+	try {
+		let content;
+		try {
+			content = await readFile(resolvedPath, "utf-8");
+		} catch {
+			if (json) output.json({
+				success: false,
+				filePath: resolvedPath,
+				error: "FILE_NOT_FOUND",
+				message: `File not found at "${resolvedPath}"`
+			});
+			else output.error(red(`\n❌ Error: File not found at "${resolvedPath}".`));
+			return;
+		}
+		const fileSize = Buffer.byteLength(content, "utf-8");
+		const fileHash = await computeFileHash(content);
+		const contentHash = await computeFileHashWithoutUCDHeader(content);
+		const primaryHash = stripHeader ? contentHash : fileHash;
+		const strippedContent = stripUnicodeHeader(content);
+		const hasUnicodeHeader = strippedContent !== content;
+		const headerLinesRemoved = hasUnicodeHeader ? content.split("\n").length - strippedContent.split("\n").length : 0;
+		let compareResult;
+		if (compare) {
+			const normalizedCompare = compare.startsWith("sha256:") ? compare : `sha256:${compare}`;
+			compareResult = {
+				matches: primaryHash === normalizedCompare,
+				providedHash: normalizedCompare
+			};
+		}
+		if (json) {
+			output.json({
+				success: true,
+				filePath: resolvedPath,
+				fileSize,
+				formattedSize: formatBytes(fileSize),
+				fileHash,
+				contentHash,
+				hasUnicodeHeader,
+				headerLinesRemoved,
+				usedHash: stripHeader ? "contentHash" : "fileHash",
+				primaryHash,
+				comparison: compareResult ? {
+					providedHash: compareResult.providedHash,
+					matches: compareResult.matches
+				} : void 0
+			});
+			return;
+		}
+		output.log(`\n  ${bold("File Hash Information")}`);
+		output.log(`  ${dim("─".repeat(50))}\n`);
+		output.log(`  ${bold("File:")}            ${green(resolvedPath)}`);
+		output.log(`  ${bold("Size:")}            ${formatBytes(fileSize)}`);
+		output.log(`  ${bold("Unicode Header:")}  ${hasUnicodeHeader ? yellow("Present") : dim("Not detected")}`);
+		if (hasUnicodeHeader) output.log(`  ${bold("Header Lines:")}    ${headerLinesRemoved}`);
+		output.log(`\n  ${bold("Hashes:")}`);
+		output.log(`  ${dim("─".repeat(50))}`);
+		output.log(`  ${bold("File Hash:")}       ${dim(fileHash)}`);
+		output.log(`                   ${dim("(hash of complete file content)")}`);
+		output.log(`  ${bold("Content Hash:")}    ${dim(contentHash)}`);
+		output.log(`                   ${dim("(hash with Unicode header stripped)")}`);
+		if (compareResult) {
+			output.log(`\n  ${bold("Comparison:")}`);
+			output.log(`  ${dim("─".repeat(50))}`);
+			output.log(`  ${bold("Provided Hash:")}   ${dim(compareResult.providedHash)}`);
+			output.log(`  ${bold("Computed Hash:")}   ${dim(primaryHash)}`);
+			if (compareResult.matches) output.log(`  ${bold("Result:")}          ${green("✅ Hashes match")}`);
+			else output.log(`  ${bold("Result:")}          ${red("❌ Hashes do not match")}`);
+		}
+		output.log("");
+	} catch (err) {
+		if (json) output.json({
+			success: false,
+			filePath: resolvedPath,
+			error: "HASH_COMPUTATION_FAILED",
+			message: err instanceof Error ? err.message : String(err)
+		});
+		else {
+			output.error(red(`\n❌ Error computing hash:`));
+			if (err instanceof Error) output.error(`  ${err.message}`);
+		}
+	}
+}
+
+//#endregion
+export { runLockfileHash };

package/dist/info-D2uPOmns.mjs

@@ -0,0 +1,100 @@
+import { _ as output, c as bold, d as formatBytes, p as green, t as printHelp, u as dim, v as red, y as yellow } from "./cli.mjs";
+import process from "node:process";
+import { resolve } from "node:path";
+import { getLockfilePath, readLockfile } from "@ucdjs/lockfile";
+import NodeFileSystemBridge from "@ucdjs/fs-bridge/bridges/node";
+
+//#region src/cmd/lockfile/info.ts
+async function runLockfileInfo({ flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Display lockfile information and summary",
+			commandName: "ucd lockfile info",
+			usage: "[...flags]",
+			description: "Read and display information from the UCD store lockfile including versions, file counts, and sizes.",
+			tables: { Flags: [
+				["--store-dir", "Directory where the UCD store is located (defaults to current directory)."],
+				["--json", "Output lockfile information as JSON."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	const { storeDir, json } = flags;
+	const storePath = storeDir ? resolve(storeDir) : process.cwd();
+	try {
+		const fs = NodeFileSystemBridge({ basePath: storePath });
+		const lockfilePath = getLockfilePath();
+		let lockfile;
+		try {
+			lockfile = await readLockfile(fs, lockfilePath);
+		} catch (err) {
+			output.error(red(`\n❌ Error: Could not read lockfile at "${lockfilePath}".`));
+			if (err instanceof Error) output.error(`  ${err.message}`);
+			output.error(`\n  Run ${green("ucd store init")} to create a new store.`);
+			return;
+		}
+		const versions = Object.keys(lockfile.versions);
+		const totalFiles = Object.values(lockfile.versions).reduce((sum, v) => sum + v.fileCount, 0);
+		const totalSize = Object.values(lockfile.versions).reduce((sum, v) => sum + v.totalSize, 0);
+		if (json) {
+			output.json({
+				storePath,
+				lockfilePath,
+				lockfileVersion: lockfile.lockfileVersion,
+				totalVersions: versions.length,
+				totalFiles,
+				totalSize,
+				formattedTotalSize: formatBytes(totalSize),
+				filters: lockfile.filters,
+				versions: Object.entries(lockfile.versions).map(([version, entry]) => ({
+					version,
+					...entry,
+					formattedSize: formatBytes(entry.totalSize)
+				}))
+			});
+			return;
+		}
+		output.log(`\n  ${bold("UCD Store Lockfile Information")}`);
+		output.log(`  ${dim("─".repeat(40))}\n`);
+		output.log(`  ${bold("Store Path:")}       ${green(storePath)}`);
+		output.log(`  ${bold("Lockfile Path:")}    ${dim(lockfilePath)}`);
+		output.log(`  ${bold("Lockfile Version:")} ${lockfile.lockfileVersion}`);
+		output.log(`  ${bold("Total Versions:")}   ${versions.length}`);
+		output.log(`  ${bold("Total Files:")}      ${totalFiles.toLocaleString()}`);
+		output.log(`  ${bold("Total Size:")}       ${formatBytes(totalSize)}`);
+		const includeFilters = lockfile.filters?.include ?? [];
+		const excludeFilters = lockfile.filters?.exclude ?? [];
+		const disableDefaultExclusions = lockfile.filters?.disableDefaultExclusions ?? false;
+		if (includeFilters.length > 0 || excludeFilters.length > 0 || disableDefaultExclusions) {
+			output.log(`\n  ${bold("Filters:")}`);
+			if (includeFilters.length > 0) output.log(`    ${bold("Include:")} ${includeFilters.join(", ")}`);
+			if (excludeFilters.length > 0) output.log(`    ${bold("Exclude:")} ${excludeFilters.join(", ")}`);
+			if (disableDefaultExclusions) output.log(`    ${yellow("Default exclusions disabled")}`);
+		}
+		output.log(`\n  ${bold("Versions:")}`);
+		output.log(`  ${dim("─".repeat(40))}`);
+		const sortedVersions = versions.sort((a, b) => {
+			const [aMajor = 0, aMinor = 0, aPatch = 0] = a.split(".").map(Number);
+			const [bMajor = 0, bMinor = 0, bPatch = 0] = b.split(".").map(Number);
+			if (bMajor !== aMajor) return bMajor - aMajor;
+			if (bMinor !== aMinor) return bMinor - aMinor;
+			return bPatch - aPatch;
+		});
+		for (const version of sortedVersions) {
+			const entry = lockfile.versions[version];
+			if (!entry) continue;
+			output.log(`\n    ${green(version)}`);
+			output.log(`      ${bold("Files:")}      ${entry.fileCount.toLocaleString()}`);
+			output.log(`      ${bold("Size:")}       ${formatBytes(entry.totalSize)}`);
+			output.log(`      ${bold("Snapshot:")}   ${dim(entry.path)}`);
+		}
+		output.log("");
+	} catch (err) {
+		output.error(red(`\n❌ Error reading lockfile:`));
+		if (err instanceof Error) output.error(`  ${err.message}`);
+	}
+}
+
+//#endregion
+export { runLockfileInfo };

package/dist/info-ZGysg0N_.mjs

@@ -0,0 +1,75 @@
+import { _ as output, c as bold, d as formatBytes, p as green, t as printHelp, u as dim, v as red } from "./cli.mjs";
+import { UCDJS_API_BASE_URL, UCD_STAT_TYPE_HEADER } from "@ucdjs/env";
+import { customFetch } from "@ucdjs-internal/shared";
+
+//#region src/cmd/files/info.ts
+function formatMetadata(metadata) {
+	const lines = [];
+	lines.push(`  ${bold("Path:")}          ${green(metadata.path || "(root)")}`);
+	lines.push(`  ${bold("Type:")}          ${metadata.type === "directory" ? green("directory") : dim("file")}`);
+	if (metadata.contentType) lines.push(`  ${bold("Content-Type:")} ${dim(metadata.contentType)}`);
+	if (metadata.lastModified) lines.push(`  ${bold("Last Modified:")} ${dim(metadata.lastModified)}`);
+	if (metadata.contentLength) {
+		const formatted = formatBytes(Number.parseInt(metadata.contentLength, 10));
+		lines.push(`  ${bold("Size:")}          ${dim(formatted)}`);
+	}
+	return lines.join("\n");
+}
+async function runFilesInfo({ path, flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Get metadata about a file or directory from the UCD API",
+			commandName: "ucd files info",
+			usage: "<path> [...flags]",
+			description: "Retrieve metadata (type, size, last modified date) about a file or directory without downloading its content.",
+			tables: { Flags: [
+				["--base-url", "Base URL for the UCD API (defaults to api.ucdjs.dev)."],
+				["--json", "Output metadata as raw JSON."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	const { baseUrl, json } = flags;
+	const apiBaseUrl = baseUrl || UCDJS_API_BASE_URL;
+	try {
+		const url = new URL(`/api/v1/files/${path || ""}`, apiBaseUrl);
+		const result = await customFetch.safe(url.toString(), { method: "HEAD" });
+		if (result.error) {
+			output.error(red(`\n❌ Error fetching file info:`));
+			output.error(`  ${result.error.message}`);
+			if (result.error.status === 404) output.error(`  Path "${path || "(root)"}" not found.`);
+			return;
+		}
+		if (!result.response) {
+			output.error(red(`\n❌ Error: No response from API.`));
+			return;
+		}
+		const headers = result.response.headers;
+		const metadata = {
+			path: path || "",
+			type: headers.get(UCD_STAT_TYPE_HEADER) || "file",
+			contentType: headers.get("Content-Type") || void 0,
+			lastModified: headers.get("Last-Modified") || void 0,
+			contentLength: headers.get("Content-Length") || void 0
+		};
+		if (json) {
+			output.json(metadata);
+			return;
+		}
+		output.log(`\nFile info: ${green(path || "(root)")}\n`);
+		output.log(formatMetadata(metadata));
+		output.log("");
+	} catch (err) {
+		let message = "Unknown error";
+		if (err instanceof Error) message = err.message;
+		else if (typeof err === "string") message = err;
+		output.error(red(`\n❌ Error getting file info:`));
+		output.error(`  ${message}`);
+		output.error("Please check the API configuration and try again.");
+		output.error("If you believe this is a bug, please report it at https://github.com/ucdjs/ucd/issues");
+	}
+}
+
+//#endregion
+export { runFilesInfo };

package/dist/init-DilsO33p.mjs

@@ -0,0 +1,126 @@
+import { _ as output, f as formatDuration, h as keyValue, l as cyan, m as header, p as green, s as blankLine, t as printHelp, v as red, y as yellow } from "./cli.mjs";
+import { i as assertLocalStore, o as createStoreFromFlags, r as SHARED_FLAGS, s as runVersionPrompt, t as LOCAL_STORE_FLAGS } from "./_shared-CgcKJJFf.mjs";
+import { tryOr } from "@ucdjs-internal/shared";
+
+//#region src/cmd/store/init.ts
+async function runInitStore({ flags, versions }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Initialize an UCD Store",
+			commandName: "ucd store init",
+			usage: "[...versions] [...flags]",
+			tables: { Flags: [
+				...LOCAL_STORE_FLAGS,
+				...SHARED_FLAGS,
+				["--json", "Output initialization results in JSON format."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	assertLocalStore(flags);
+	const { storeDir, baseUrl, include: patterns, exclude: excludePatterns, force, json } = flags;
+	let selectedVersions = versions;
+	if (!selectedVersions || selectedVersions.length === 0) {
+		const pickedVersions = await tryOr({
+			try: runVersionPrompt(),
+			err: () => {
+				if (json) output.errorJson({
+					type: "PROMPT_CANCELLED",
+					message: "Version selection cancelled"
+				});
+				else output.warning("Version selection cancelled.");
+				return [];
+			}
+		});
+		if (pickedVersions.length === 0) {
+			if (json) output.errorJson({
+				type: "NO_VERSIONS_SELECTED",
+				message: "No versions selected"
+			});
+			else output.warning("No versions selected. Operation cancelled.");
+			return;
+		}
+		selectedVersions = pickedVersions;
+	}
+	const store = await createStoreFromFlags({
+		baseUrl,
+		storeDir,
+		remote: false,
+		include: patterns,
+		exclude: excludePatterns,
+		versions: selectedVersions,
+		force,
+		requireExistingStore: false
+	});
+	if (!json) {
+		header("UCD Store Initialization");
+		keyValue("Store Path", storeDir, { valueColor: cyan });
+		keyValue("Versions", selectedVersions.map((v) => cyan(v)).join(", "));
+		blankLine();
+		output.success("Lockfile created");
+	}
+	const [mirrorResult, mirrorError] = await store.mirror({
+		versions: selectedVersions,
+		force,
+		filters: {
+			include: patterns,
+			exclude: excludePatterns
+		}
+	});
+	if (mirrorError) {
+		if (json) output.errorJson({
+			type: "MIRROR_FAILED",
+			message: "Mirror failed",
+			details: {
+				reason: mirrorError.message,
+				lockfileCreated: true
+			}
+		});
+		else output.fail("Mirror failed", { details: [mirrorError.message, "Lockfile was created, but files were not downloaded."] });
+		return;
+	}
+	if (!mirrorResult) {
+		if (json) output.errorJson({
+			type: "NO_MIRROR_RESULT",
+			message: "Mirror returned no result",
+			details: { lockfileCreated: true }
+		});
+		else output.fail("Mirror returned no result", { details: ["Lockfile was created, but files were not downloaded."] });
+		return;
+	}
+	if (json) {
+		const jsonOutput = {
+			success: true,
+			storeDir,
+			versions: selectedVersions,
+			summary: mirrorResult.summary ? {
+				versionsCount: mirrorResult.versions.size,
+				downloaded: mirrorResult.summary.counts.success,
+				skipped: mirrorResult.summary.counts.skipped,
+				failed: mirrorResult.summary.counts.failed,
+				totalSize: mirrorResult.summary.storage.totalSize,
+				duration: mirrorResult.summary.duration
+			} : void 0
+		};
+		output.json(jsonOutput);
+		return;
+	}
+	output.success("Files downloaded");
+	if (mirrorResult.summary) {
+		const { counts, duration, storage } = mirrorResult.summary;
+		header("Summary");
+		keyValue("Versions", String(mirrorResult.versions.size));
+		keyValue("Downloaded", `${green(String(counts.success))} files`);
+		if (counts.skipped > 0) keyValue("Skipped", `${yellow(String(counts.skipped))} files`);
+		if (counts.failed > 0) keyValue("Failed", `${red(String(counts.failed))} files`);
+		keyValue("Total Size", storage.totalSize);
+		keyValue("Duration", formatDuration(duration));
+	}
+	blankLine();
+	output.success("Store initialized successfully");
+	blankLine();
+}
+
+//#endregion
+export { runInitStore };

package/dist/list-C1bd3Vq4.mjs

@@ -0,0 +1,89 @@
+import { _ as output, p as green, t as printHelp, u as dim, v as red } from "./cli.mjs";
+import { createUCDClient } from "@ucdjs/client";
+import { UCDJS_API_BASE_URL } from "@ucdjs/env";
+import { createDebugger } from "@ucdjs-internal/shared";
+
+//#region src/cmd/files/list.ts
+const debug = createDebugger("ucdjs:cli:files:list");
+function formatDate(timestamp) {
+	return new Date(timestamp).toLocaleString();
+}
+function formatDirectoryListing(entries) {
+	if (entries.length === 0) return "  (empty directory)";
+	const sorted = [...entries].sort((a, b) => {
+		if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+		return a.name.localeCompare(b.name);
+	});
+	const lines = [];
+	const maxNameLength = Math.max(...sorted.map((e) => e.name.length), 20);
+	const padding = Math.min(maxNameLength + 2, 40);
+	for (const entry of sorted) {
+		const typeIcon = entry.type === "directory" ? green("▸") : "·";
+		const typeLabel = entry.type === "directory" ? green("dir") : dim("file");
+		const name = entry.name.padEnd(padding);
+		const date = entry.lastModified ? formatDate(entry.lastModified) : dim("no date");
+		lines.push(`  ${typeIcon} ${name} ${typeLabel}  ${date}`);
+	}
+	return lines.join("\n");
+}
+async function runFilesList({ path, flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "List files and directories from the UCD API",
+			commandName: "ucd files list",
+			usage: "[path] [...flags]",
+			description: "List files and directories from the Unicode Character Database API. If no path is provided, lists the root directory.",
+			tables: { Flags: [
+				["--base-url", "Base URL for the UCD API (defaults to api.ucdjs.dev)."],
+				["--json", "Output directory listing as raw JSON."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	const { baseUrl, json } = flags;
+	try {
+		const client = await createUCDClient(baseUrl || UCDJS_API_BASE_URL);
+		debug?.(`Fetching directory listing for path "${path || "(root)"}"`);
+		const result = await client.files.get(path || "");
+		if (result.error) {
+			output.error(red(`\n❌ Error fetching directory listing:`));
+			output.error(`  ${result.error.message}`);
+			if (result.error.status === 404) output.error(`  Path "${path || "(root)"}" not found.`);
+			return;
+		}
+		if (!result.data) {
+			output.error(red(`\n❌ Error: No data returned from API.`));
+			return;
+		}
+		if (typeof result.data === "string") {
+			output.error(red(`\n❌ Error: Path "${path || "(root)"}" is a file, not a directory.`));
+			output.error(`  Use "ucd files get" to retrieve file content.`);
+			return;
+		}
+		if (!Array.isArray(result.data)) {
+			output.error(red(`\n❌ Error: Unexpected response format from API.`));
+			return;
+		}
+		const entries = result.data;
+		if (json) {
+			output.json(entries);
+			return;
+		}
+		const pathDisplay = path || "(root)";
+		output.log(`\nDirectory listing: ${green(pathDisplay)}\n`);
+		output.log(formatDirectoryListing(entries));
+		output.log("");
+	} catch (err) {
+		let message = "Unknown error";
+		if (err instanceof Error) message = err.message;
+		else if (typeof err === "string") message = err;
+		output.error(red(`\n❌ Error listing files:`));
+		output.error(`  ${message}`);
+		output.error("Please check the API configuration and try again.");
+		output.error("If you believe this is a bug, please report it at https://github.com/ucdjs/ucd/issues");
+	}
+}
+
+//#endregion
+export { runFilesList };