@hot-updater/cli-tools 0.21.8

package/dist/createTarBr.js

@@ -0,0 +1,88 @@
+import fs from "fs/promises";
+import path from "path";
+import * as tar from "tar";
+import { brotliCompressSync, constants } from "zlib";
+
+//#region src/createTarBr.ts
+const createTarBrTargetFiles = async ({ outfile, targetFiles }) => {
+	await fs.rm(outfile, { force: true });
+	const tmpDir = path.join(path.dirname(outfile), `.tmp-tar-${Date.now()}`);
+	await fs.mkdir(tmpDir, { recursive: true });
+	try {
+		for (const target of targetFiles) {
+			const sourcePath = target.path;
+			const destPath = path.join(tmpDir, target.name);
+			await fs.mkdir(path.dirname(destPath), { recursive: true });
+			if ((await fs.stat(sourcePath)).isDirectory()) await copyDir(sourcePath, destPath);
+			else await fs.copyFile(sourcePath, destPath);
+		}
+		const tmpTarFile = outfile.replace(/\.tar\.br$/, ".tar");
+		await tar.create({
+			file: tmpTarFile,
+			cwd: tmpDir,
+			portable: true,
+			mtime: /* @__PURE__ */ new Date(0),
+			gzip: false
+		}, await fs.readdir(tmpDir));
+		const compressedData = brotliCompressSync(await fs.readFile(tmpTarFile), { params: {
+			[constants.BROTLI_PARAM_QUALITY]: 11,
+			[constants.BROTLI_PARAM_LGWIN]: 24
+		} });
+		await fs.mkdir(path.dirname(outfile), { recursive: true });
+		await fs.writeFile(outfile, compressedData);
+		await fs.rm(tmpTarFile, { force: true });
+		return outfile;
+	} finally {
+		await fs.rm(tmpDir, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+async function copyDir(src, dest) {
+	await fs.mkdir(dest, { recursive: true });
+	const entries = await fs.readdir(src, { withFileTypes: true });
+	for (const entry of entries) {
+		const srcPath = path.join(src, entry.name);
+		const destPath = path.join(dest, entry.name);
+		if (entry.isDirectory()) await copyDir(srcPath, destPath);
+		else await fs.copyFile(srcPath, destPath);
+	}
+}
+const createTarBr = async ({ outfile, targetDir, excludeExts = [] }) => {
+	await fs.rm(outfile, { force: true });
+	const tmpTarFile = outfile.replace(/\.tar\.br$/, ".tar");
+	async function getFiles(dir, baseDir = "") {
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		const files = [];
+		for (const entry of entries) {
+			if (excludeExts.some((pattern) => entry.name.includes(pattern))) continue;
+			const fullPath = path.join(dir, entry.name);
+			const relativePath = path.join(baseDir, entry.name);
+			if (entry.isDirectory()) {
+				const subFiles = await getFiles(fullPath, relativePath);
+				files.push(...subFiles);
+			} else files.push(relativePath);
+		}
+		return files;
+	}
+	const filesToInclude = await getFiles(targetDir);
+	filesToInclude.sort();
+	await tar.create({
+		file: tmpTarFile,
+		cwd: targetDir,
+		portable: true,
+		mtime: /* @__PURE__ */ new Date(0),
+		gzip: false
+	}, filesToInclude);
+	const compressedData = brotliCompressSync(await fs.readFile(tmpTarFile), { params: {
+		[constants.BROTLI_PARAM_QUALITY]: 11,
+		[constants.BROTLI_PARAM_LGWIN]: 24
+	} });
+	await fs.writeFile(outfile, compressedData);
+	await fs.rm(tmpTarFile, { force: true });
+	return outfile;
+};
+
+//#endregion
+export { createTarBr, createTarBrTargetFiles };

package/dist/createTarGz.cjs

@@ -0,0 +1,78 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let fs_promises = require("fs/promises");
+fs_promises = require_rolldown_runtime.__toESM(fs_promises);
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
+let tar = require("tar");
+tar = require_rolldown_runtime.__toESM(tar);
+
+//#region src/createTarGz.ts
+const createTarGzTargetFiles = async ({ outfile, targetFiles }) => {
+	await fs_promises.default.rm(outfile, { force: true });
+	const tmpDir = path.default.join(path.default.dirname(outfile), `.tmp-tar-${Date.now()}`);
+	await fs_promises.default.mkdir(tmpDir, { recursive: true });
+	try {
+		for (const target of targetFiles) {
+			const sourcePath = target.path;
+			const destPath = path.default.join(tmpDir, target.name);
+			await fs_promises.default.mkdir(path.default.dirname(destPath), { recursive: true });
+			if ((await fs_promises.default.stat(sourcePath)).isDirectory()) await copyDir(sourcePath, destPath);
+			else await fs_promises.default.copyFile(sourcePath, destPath);
+		}
+		await fs_promises.default.mkdir(path.default.dirname(outfile), { recursive: true });
+		await tar.create({
+			file: outfile,
+			cwd: tmpDir,
+			portable: true,
+			mtime: /* @__PURE__ */ new Date(0),
+			gzip: true
+		}, await fs_promises.default.readdir(tmpDir));
+		return outfile;
+	} finally {
+		await fs_promises.default.rm(tmpDir, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+async function copyDir(src, dest) {
+	await fs_promises.default.mkdir(dest, { recursive: true });
+	const entries = await fs_promises.default.readdir(src, { withFileTypes: true });
+	for (const entry of entries) {
+		const srcPath = path.default.join(src, entry.name);
+		const destPath = path.default.join(dest, entry.name);
+		if (entry.isDirectory()) await copyDir(srcPath, destPath);
+		else await fs_promises.default.copyFile(srcPath, destPath);
+	}
+}
+const createTarGz = async ({ outfile, targetDir, excludeExts = [] }) => {
+	await fs_promises.default.rm(outfile, { force: true });
+	async function getFiles(dir, baseDir = "") {
+		const entries = await fs_promises.default.readdir(dir, { withFileTypes: true });
+		const files = [];
+		for (const entry of entries) {
+			if (excludeExts.some((pattern) => entry.name.includes(pattern))) continue;
+			const fullPath = path.default.join(dir, entry.name);
+			const relativePath = path.default.join(baseDir, entry.name);
+			if (entry.isDirectory()) {
+				const subFiles = await getFiles(fullPath, relativePath);
+				files.push(...subFiles);
+			} else files.push(relativePath);
+		}
+		return files;
+	}
+	const filesToInclude = await getFiles(targetDir);
+	filesToInclude.sort();
+	await tar.create({
+		file: outfile,
+		cwd: targetDir,
+		portable: true,
+		mtime: /* @__PURE__ */ new Date(0),
+		gzip: true
+	}, filesToInclude);
+	return outfile;
+};
+
+//#endregion
+exports.createTarGz = createTarGz;
+exports.createTarGzTargetFiles = createTarGzTargetFiles;

package/dist/createTarGz.d.cts

@@ -0,0 +1,22 @@
+//#region src/createTarGz.d.ts
+declare const createTarGzTargetFiles: ({
+  outfile,
+  targetFiles
+}: {
+  targetFiles: {
+    path: string;
+    name: string;
+  }[];
+  outfile: string;
+}) => Promise<string>;
+declare const createTarGz: ({
+  outfile,
+  targetDir,
+  excludeExts
+}: {
+  targetDir: string;
+  outfile: string;
+  excludeExts?: string[];
+}) => Promise<string>;
+//#endregion
+export { createTarGz, createTarGzTargetFiles };

package/dist/createTarGz.d.ts

@@ -0,0 +1,22 @@
+//#region src/createTarGz.d.ts
+declare const createTarGzTargetFiles: ({
+  outfile,
+  targetFiles
+}: {
+  targetFiles: {
+    path: string;
+    name: string;
+  }[];
+  outfile: string;
+}) => Promise<string>;
+declare const createTarGz: ({
+  outfile,
+  targetDir,
+  excludeExts
+}: {
+  targetDir: string;
+  outfile: string;
+  excludeExts?: string[];
+}) => Promise<string>;
+//#endregion
+export { createTarGz, createTarGzTargetFiles };

package/dist/createTarGz.js

@@ -0,0 +1,73 @@
+import fs from "fs/promises";
+import path from "path";
+import * as tar from "tar";
+
+//#region src/createTarGz.ts
+const createTarGzTargetFiles = async ({ outfile, targetFiles }) => {
+	await fs.rm(outfile, { force: true });
+	const tmpDir = path.join(path.dirname(outfile), `.tmp-tar-${Date.now()}`);
+	await fs.mkdir(tmpDir, { recursive: true });
+	try {
+		for (const target of targetFiles) {
+			const sourcePath = target.path;
+			const destPath = path.join(tmpDir, target.name);
+			await fs.mkdir(path.dirname(destPath), { recursive: true });
+			if ((await fs.stat(sourcePath)).isDirectory()) await copyDir(sourcePath, destPath);
+			else await fs.copyFile(sourcePath, destPath);
+		}
+		await fs.mkdir(path.dirname(outfile), { recursive: true });
+		await tar.create({
+			file: outfile,
+			cwd: tmpDir,
+			portable: true,
+			mtime: /* @__PURE__ */ new Date(0),
+			gzip: true
+		}, await fs.readdir(tmpDir));
+		return outfile;
+	} finally {
+		await fs.rm(tmpDir, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+async function copyDir(src, dest) {
+	await fs.mkdir(dest, { recursive: true });
+	const entries = await fs.readdir(src, { withFileTypes: true });
+	for (const entry of entries) {
+		const srcPath = path.join(src, entry.name);
+		const destPath = path.join(dest, entry.name);
+		if (entry.isDirectory()) await copyDir(srcPath, destPath);
+		else await fs.copyFile(srcPath, destPath);
+	}
+}
+const createTarGz = async ({ outfile, targetDir, excludeExts = [] }) => {
+	await fs.rm(outfile, { force: true });
+	async function getFiles(dir, baseDir = "") {
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		const files = [];
+		for (const entry of entries) {
+			if (excludeExts.some((pattern) => entry.name.includes(pattern))) continue;
+			const fullPath = path.join(dir, entry.name);
+			const relativePath = path.join(baseDir, entry.name);
+			if (entry.isDirectory()) {
+				const subFiles = await getFiles(fullPath, relativePath);
+				files.push(...subFiles);
+			} else files.push(relativePath);
+		}
+		return files;
+	}
+	const filesToInclude = await getFiles(targetDir);
+	filesToInclude.sort();
+	await tar.create({
+		file: outfile,
+		cwd: targetDir,
+		portable: true,
+		mtime: /* @__PURE__ */ new Date(0),
+		gzip: true
+	}, filesToInclude);
+	return outfile;
+};
+
+//#endregion
+export { createTarGz, createTarGzTargetFiles };

package/dist/createZip.cjs

@@ -0,0 +1,80 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let fs_promises = require("fs/promises");
+fs_promises = require_rolldown_runtime.__toESM(fs_promises);
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
+let jszip = require("jszip");
+jszip = require_rolldown_runtime.__toESM(jszip);
+
+//#region src/createZip.ts
+const createZipTargetFiles = async ({ outfile, targetFiles }) => {
+	const zip = new jszip.default();
+	await fs_promises.default.rm(outfile, { force: true });
+	async function addFiles(dir, zipFolder) {
+		const files = await fs_promises.default.readdir(dir);
+		files.sort();
+		for (const file of files) {
+			const fullPath = path.default.join(dir, file);
+			if ((await fs_promises.default.stat(fullPath)).isDirectory()) {
+				const folder = zipFolder.folder(file);
+				if (!folder) continue;
+				await addFiles(fullPath, folder);
+			} else {
+				const data = await fs_promises.default.readFile(fullPath);
+				zipFolder.file(file, data);
+			}
+		}
+	}
+	for (const target of targetFiles) if ((await fs_promises.default.stat(target.path)).isDirectory()) {
+		const folder = zip.folder(target.name);
+		if (folder) await addFiles(target.path, folder);
+	} else {
+		const data = await fs_promises.default.readFile(target.path);
+		zip.file(target.name, data);
+	}
+	const content = await zip.generateAsync({
+		type: "nodebuffer",
+		compression: "DEFLATE",
+		compressionOptions: { level: 9 },
+		platform: "UNIX"
+	});
+	await fs_promises.default.mkdir(path.default.dirname(outfile), { recursive: true });
+	await fs_promises.default.writeFile(outfile, content);
+	return outfile;
+};
+const createZip = async ({ outfile, targetDir, excludeExts = [] }) => {
+	const zip = new jszip.default();
+	await fs_promises.default.rm(outfile, { force: true });
+	async function addFiles(dir, zipFolder) {
+		const files = await fs_promises.default.readdir(dir);
+		files.sort();
+		for (const file of files) {
+			if (excludeExts.some((pattern) => file.includes(pattern))) continue;
+			const fullPath = path.default.join(dir, file);
+			if ((await fs_promises.default.stat(fullPath)).isDirectory()) {
+				const folder = zipFolder.folder(file);
+				if (!folder) continue;
+				await addFiles(fullPath, folder);
+			} else {
+				const data = await fs_promises.default.readFile(fullPath);
+				zipFolder.file(file, data);
+			}
+		}
+	}
+	await addFiles(targetDir, zip);
+	zip.forEach((_, file) => {
+		file.date = /* @__PURE__ */ new Date(0);
+	});
+	const content = await zip.generateAsync({
+		type: "nodebuffer",
+		compression: "DEFLATE",
+		compressionOptions: { level: 9 },
+		platform: "UNIX"
+	});
+	await fs_promises.default.writeFile(outfile, content);
+	return outfile;
+};
+
+//#endregion
+exports.createZip = createZip;
+exports.createZipTargetFiles = createZipTargetFiles;

package/dist/createZip.d.cts

@@ -0,0 +1,22 @@
+//#region src/createZip.d.ts
+declare const createZipTargetFiles: ({
+  outfile,
+  targetFiles
+}: {
+  targetFiles: {
+    path: string;
+    name: string;
+  }[];
+  outfile: string;
+}) => Promise<string>;
+declare const createZip: ({
+  outfile,
+  targetDir,
+  excludeExts
+}: {
+  targetDir: string;
+  outfile: string;
+  excludeExts?: string[];
+}) => Promise<string>;
+//#endregion
+export { createZip, createZipTargetFiles };

package/dist/createZip.d.ts

@@ -0,0 +1,22 @@
+//#region src/createZip.d.ts
+declare const createZipTargetFiles: ({
+  outfile,
+  targetFiles
+}: {
+  targetFiles: {
+    path: string;
+    name: string;
+  }[];
+  outfile: string;
+}) => Promise<string>;
+declare const createZip: ({
+  outfile,
+  targetDir,
+  excludeExts
+}: {
+  targetDir: string;
+  outfile: string;
+  excludeExts?: string[];
+}) => Promise<string>;
+//#endregion
+export { createZip, createZipTargetFiles };

package/dist/createZip.js

@@ -0,0 +1,75 @@
+import fs from "fs/promises";
+import path from "path";
+import JSZip from "jszip";
+
+//#region src/createZip.ts
+const createZipTargetFiles = async ({ outfile, targetFiles }) => {
+	const zip = new JSZip();
+	await fs.rm(outfile, { force: true });
+	async function addFiles(dir, zipFolder) {
+		const files = await fs.readdir(dir);
+		files.sort();
+		for (const file of files) {
+			const fullPath = path.join(dir, file);
+			if ((await fs.stat(fullPath)).isDirectory()) {
+				const folder = zipFolder.folder(file);
+				if (!folder) continue;
+				await addFiles(fullPath, folder);
+			} else {
+				const data = await fs.readFile(fullPath);
+				zipFolder.file(file, data);
+			}
+		}
+	}
+	for (const target of targetFiles) if ((await fs.stat(target.path)).isDirectory()) {
+		const folder = zip.folder(target.name);
+		if (folder) await addFiles(target.path, folder);
+	} else {
+		const data = await fs.readFile(target.path);
+		zip.file(target.name, data);
+	}
+	const content = await zip.generateAsync({
+		type: "nodebuffer",
+		compression: "DEFLATE",
+		compressionOptions: { level: 9 },
+		platform: "UNIX"
+	});
+	await fs.mkdir(path.dirname(outfile), { recursive: true });
+	await fs.writeFile(outfile, content);
+	return outfile;
+};
+const createZip = async ({ outfile, targetDir, excludeExts = [] }) => {
+	const zip = new JSZip();
+	await fs.rm(outfile, { force: true });
+	async function addFiles(dir, zipFolder) {
+		const files = await fs.readdir(dir);
+		files.sort();
+		for (const file of files) {
+			if (excludeExts.some((pattern) => file.includes(pattern))) continue;
+			const fullPath = path.join(dir, file);
+			if ((await fs.stat(fullPath)).isDirectory()) {
+				const folder = zipFolder.folder(file);
+				if (!folder) continue;
+				await addFiles(fullPath, folder);
+			} else {
+				const data = await fs.readFile(fullPath);
+				zipFolder.file(file, data);
+			}
+		}
+	}
+	await addFiles(targetDir, zip);
+	zip.forEach((_, file) => {
+		file.date = /* @__PURE__ */ new Date(0);
+	});
+	const content = await zip.generateAsync({
+		type: "nodebuffer",
+		compression: "DEFLATE",
+		compressionOptions: { level: 9 },
+		platform: "UNIX"
+	});
+	await fs.writeFile(outfile, content);
+	return outfile;
+};
+
+//#endregion
+export { createZip, createZipTargetFiles };

package/dist/crypto.cjs

@@ -0,0 +1,27 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_isObject = require('./isObject.cjs');
+let crypto = require("crypto");
+crypto = require_rolldown_runtime.__toESM(crypto);
+
+//#region src/crypto.ts
+const encryptJson = (jsonData, secretKey) => {
+	if (require_isObject.isObject(jsonData) === false) throw new Error("jsonData must be an object");
+	const iv = crypto.default.randomBytes(16);
+	const cipher = crypto.default.createCipheriv("aes-256-cbc", Buffer.from(secretKey, "hex"), iv);
+	let encrypted = cipher.update(JSON.stringify(jsonData));
+	encrypted = Buffer.concat([encrypted, cipher.final()]);
+	return [iv.toString("hex"), encrypted.toString("hex")].join(":");
+};
+const decryptJson = (encryptedData, secretKey) => {
+	const parts = encryptedData.split(":");
+	const iv = Buffer.from(parts[0], "hex");
+	const encryptedText = Buffer.from(parts[1], "hex");
+	const decipher = crypto.default.createDecipheriv("aes-256-cbc", Buffer.from(secretKey, "hex"), iv);
+	let decrypted = decipher.update(encryptedText);
+	decrypted = Buffer.concat([decrypted, decipher.final()]);
+	return JSON.parse(decrypted.toString());
+};
+
+//#endregion
+exports.decryptJson = decryptJson;
+exports.encryptJson = encryptJson;

package/dist/crypto.d.cts

@@ -0,0 +1,5 @@
+//#region src/crypto.d.ts
+declare const encryptJson: (jsonData: Record<string, any>, secretKey: string) => string;
+declare const decryptJson: <T>(encryptedData: string, secretKey: string) => T;
+//#endregion
+export { decryptJson, encryptJson };

package/dist/crypto.d.ts

@@ -0,0 +1,5 @@
+//#region src/crypto.d.ts
+declare const encryptJson: (jsonData: Record<string, any>, secretKey: string) => string;
+declare const decryptJson: <T>(encryptedData: string, secretKey: string) => T;
+//#endregion
+export { decryptJson, encryptJson };

package/dist/crypto.js

@@ -0,0 +1,24 @@
+import { isObject } from "./isObject.js";
+import crypto from "crypto";
+
+//#region src/crypto.ts
+const encryptJson = (jsonData, secretKey) => {
+	if (isObject(jsonData) === false) throw new Error("jsonData must be an object");
+	const iv = crypto.randomBytes(16);
+	const cipher = crypto.createCipheriv("aes-256-cbc", Buffer.from(secretKey, "hex"), iv);
+	let encrypted = cipher.update(JSON.stringify(jsonData));
+	encrypted = Buffer.concat([encrypted, cipher.final()]);
+	return [iv.toString("hex"), encrypted.toString("hex")].join(":");
+};
+const decryptJson = (encryptedData, secretKey) => {
+	const parts = encryptedData.split(":");
+	const iv = Buffer.from(parts[0], "hex");
+	const encryptedText = Buffer.from(parts[1], "hex");
+	const decipher = crypto.createDecipheriv("aes-256-cbc", Buffer.from(secretKey, "hex"), iv);
+	let decrypted = decipher.update(encryptedText);
+	decrypted = Buffer.concat([decrypted, decipher.final()]);
+	return JSON.parse(decrypted.toString());
+};
+
+//#endregion
+export { decryptJson, encryptJson };

package/dist/cwd.cjs

@@ -0,0 +1,9 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let workspace_tools = require("workspace-tools");
+workspace_tools = require_rolldown_runtime.__toESM(workspace_tools);
+
+//#region src/cwd.ts
+const getCwd = () => (0, workspace_tools.findPackageRoot)(process.cwd());
+
+//#endregion
+exports.getCwd = getCwd;

package/dist/cwd.d.cts

@@ -0,0 +1,4 @@
+//#region src/cwd.d.ts
+declare const getCwd: () => string;
+//#endregion
+export { getCwd };

package/dist/cwd.d.ts

@@ -0,0 +1,4 @@
+//#region src/cwd.d.ts
+declare const getCwd: () => string;
+//#endregion
+export { getCwd };

package/dist/cwd.js

@@ -0,0 +1,7 @@
+import { findPackageRoot } from "workspace-tools";
+
+//#region src/cwd.ts
+const getCwd = () => findPackageRoot(process.cwd());
+
+//#endregion
+export { getCwd };

package/dist/getAndroidSdkPath.cjs

@@ -0,0 +1,10 @@
+
+//#region src/getAndroidSdkPath.ts
+function getAndroidSdkPath() {
+	const sdkRoot = process.env["ANDROID_HOME"] || process.env["ANDROID_SDK_ROOT"];
+	if (!sdkRoot) throw new Error("ANDROID_HOME or ANDROID_SDK_ROOT environment variable is not set. Please follow instructions at: https://reactnative.dev/docs/set-up-your-environment?platform=android");
+	return sdkRoot;
+}
+
+//#endregion
+exports.getAndroidSdkPath = getAndroidSdkPath;

package/dist/getAndroidSdkPath.d.cts

@@ -0,0 +1,4 @@
+//#region src/getAndroidSdkPath.d.ts
+declare function getAndroidSdkPath(): string;
+//#endregion
+export { getAndroidSdkPath };

package/dist/getAndroidSdkPath.d.ts

@@ -0,0 +1,4 @@
+//#region src/getAndroidSdkPath.d.ts
+declare function getAndroidSdkPath(): string;
+//#endregion
+export { getAndroidSdkPath };

package/dist/getAndroidSdkPath.js

@@ -0,0 +1,9 @@
+//#region src/getAndroidSdkPath.ts
+function getAndroidSdkPath() {
+	const sdkRoot = process.env["ANDROID_HOME"] || process.env["ANDROID_SDK_ROOT"];
+	if (!sdkRoot) throw new Error("ANDROID_HOME or ANDROID_SDK_ROOT environment variable is not set. Please follow instructions at: https://reactnative.dev/docs/set-up-your-environment?platform=android");
+	return sdkRoot;
+}
+
+//#endregion
+export { getAndroidSdkPath };

package/dist/index.cjs

@@ -0,0 +1,48 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_banner = require('./banner.cjs');
+const require_ConfigBuilder = require('./ConfigBuilder.cjs');
+const require_cwd = require('./cwd.cjs');
+const require_copyDirToTmp = require('./copyDirToTmp.cjs');
+const require_createTarBr = require('./createTarBr.cjs');
+const require_createTarGz = require('./createTarGz.cjs');
+const require_createZip = require('./createZip.cjs');
+const require_crypto = require('./crypto.cjs');
+const require_getAndroidSdkPath = require('./getAndroidSdkPath.cjs');
+const require_loadConfig = require('./loadConfig.cjs');
+const require_log = require('./log.cjs');
+const require_makeEnv = require('./makeEnv.cjs');
+const require_transformEnv = require('./transformEnv.cjs');
+const require_transformTemplate = require('./transformTemplate.cjs');
+let picocolors = require("picocolors");
+picocolors = require_rolldown_runtime.__toESM(picocolors);
+let __clack_prompts = require("@clack/prompts");
+__clack_prompts = require_rolldown_runtime.__toESM(__clack_prompts);
+
+exports.ConfigBuilder = require_ConfigBuilder.ConfigBuilder;
+exports.banner = require_banner.banner;
+exports.colors = picocolors.default;
+exports.copyDirToTmp = require_copyDirToTmp.copyDirToTmp;
+exports.createTarBr = require_createTarBr.createTarBr;
+exports.createTarBrTargetFiles = require_createTarBr.createTarBrTargetFiles;
+exports.createTarGz = require_createTarGz.createTarGz;
+exports.createTarGzTargetFiles = require_createTarGz.createTarGzTargetFiles;
+exports.createZip = require_createZip.createZip;
+exports.createZipTargetFiles = require_createZip.createZipTargetFiles;
+exports.decryptJson = require_crypto.decryptJson;
+exports.encryptJson = require_crypto.encryptJson;
+exports.getAndroidSdkPath = require_getAndroidSdkPath.getAndroidSdkPath;
+exports.getCwd = require_cwd.getCwd;
+exports.link = require_banner.link;
+exports.loadConfig = require_loadConfig.loadConfig;
+exports.loadConfigSync = require_loadConfig.loadConfigSync;
+exports.log = require_log.log;
+exports.makeEnv = require_makeEnv.makeEnv;
+Object.defineProperty(exports, 'p', {
+  enumerable: true,
+  get: function () {
+    return __clack_prompts;
+  }
+});
+exports.printBanner = require_banner.printBanner;
+exports.transformEnv = require_transformEnv.transformEnv;
+exports.transformTemplate = require_transformTemplate.transformTemplate;