@yorozu/build 0.1.0

package/chunks/CYSd7-PF.js

@@ -0,0 +1,623 @@
+import { __toESM, asNonNull, asyncPool, collectPackageJsons, collectVersions, directoryExists, fileExists, filterPackageJsonsForPublish, findRootPackage, glob, info, loadBuildConfig, normalizeFilePath, object, processPackageJson, record, require_picomatch, string, tryCopy, unknown } from "./21EFCjEU.js";
+import { determinePublishOrder, exec, require_semver } from "./Cr5v7tI0.js";
+import { existsSync } from "node:fs";
+import process from "node:process";
+import { dirname, join, relative, resolve } from "node:path";
+import * as fsp from "node:fs/promises";
+import ts, { parseConfigFileTextToJson } from "typescript";
+//#region src/jsr/utils/jsr-api.ts
+var USER_AGENT$1 = "@yorozu/build";
+var REQUEST_TIMEOUT_MS$1 = 15e3;
+var MAX_RETRIES = 3;
+function joinRegistryUrl$1(registry, path) {
+	return `${registry.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+}
+async function readErrorBody(res) {
+	try {
+		return await res.text();
+	} catch {
+		return "";
+	}
+}
+async function jsrFetch$1(url, init = {}) {
+	let lastError;
+	for (let attempt = 0; attempt < MAX_RETRIES; attempt++) try {
+		return await fetch(url, {
+			...init,
+			headers: {
+				"User-Agent": USER_AGENT$1,
+				...init.headers
+			},
+			signal: init.signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS$1)
+		});
+	} catch (err) {
+		lastError = err;
+	}
+	throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function jsonInit(token, body) {
+	return {
+		headers: {
+			Cookie: `token=${token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(body)
+	};
+}
+async function jsrGetScopeInfo(params) {
+	let { scope, registry } = params;
+	let res = await jsrFetch$1(joinRegistryUrl$1(registry, `/api/scopes/${scope}`));
+	if (res.status === 404) {
+		if (res.body) res.body.cancel();
+		return null;
+	}
+	if (res.status !== 200) throw new Error(`Failed to get scope info: ${res.status} ${await readErrorBody(res)}`);
+	return res.json();
+}
+async function jsrCreateScope(params) {
+	let { name, registry, token, quiet } = params;
+	let create = await jsrFetch$1(joinRegistryUrl$1(registry, "/api/scopes"), {
+		method: "POST",
+		...jsonInit(token, { scope: name })
+	});
+	if (create.status !== 200) throw new Error(`Failed to create scope: ${create.status} ${await create.text()}`);
+	if (create.body) create.body.cancel();
+	if (!quiet) info(`Created scope @${name}`);
+}
+async function jsrMaybeCreatePackage(params) {
+	let { name, registry, token, quiet } = params;
+	let [scopeWithAt, packageName] = name.split("/");
+	if (!packageName || !scopeWithAt || !scopeWithAt.startsWith("@")) throw new Error("Invalid package name");
+	let scope = scopeWithAt.slice(1);
+	let packageMeta = await jsrFetch$1(joinRegistryUrl$1(registry, `/api/scopes/${scope}/packages/${packageName}`));
+	if (packageMeta.status === 200) {
+		if (packageMeta.body) packageMeta.body.cancel();
+		return;
+	}
+	if (packageMeta.status !== 404) throw new Error(`Failed to check package: ${packageMeta.status} ${await packageMeta.text()}`);
+	if (packageMeta.body) packageMeta.body.cancel();
+	if (!quiet) info(`${name} does not exist, creating..`);
+	let create = await jsrFetch$1(joinRegistryUrl$1(registry, `/api/scopes/${scope}/packages`), {
+		method: "POST",
+		...jsonInit(token, { package: packageName })
+	});
+	if (create.status !== 200) {
+		let text = await create.text();
+		if (create.status === 403) try {
+			if (JSON.parse(text).code === "actorNotScopeMember") {
+				if (await jsrGetScopeInfo({
+					scope,
+					registry
+				}) === null) {
+					await jsrCreateScope({
+						name: scope,
+						registry,
+						token,
+						quiet
+					});
+					return jsrMaybeCreatePackage({
+						...params,
+						quiet: true
+					});
+				}
+			}
+		} catch (err) {
+			if (err instanceof Error && err.message.startsWith("Failed to")) throw err;
+		}
+		throw new Error(`Failed to create package: ${create.status} ${text}`);
+	}
+	if (create.body) create.body.cancel();
+}
+async function jsrSetGithubRepo(params) {
+	let { registry, name, token, owner, repo } = params;
+	let [scopeWithAt, packageName] = name.split("/");
+	if (!packageName || !scopeWithAt || !scopeWithAt.startsWith("@")) throw new Error("Invalid package name");
+	let res = await jsrFetch$1(joinRegistryUrl$1(registry, `/api/scopes/${scopeWithAt.slice(1)}/packages/${packageName}`), {
+		method: "PATCH",
+		...jsonInit(token, { githubRepository: {
+			owner,
+			name: repo
+		} })
+	});
+	if (res.status !== 200) throw new Error(`Failed to set github repo: ${await res.text()}`);
+	if (res.body) res.body.cancel();
+}
+//#endregion
+//#region src/jsr/utils/external-libs.ts
+var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
+var _cacheDir;
+function getModuleCacheDirectory() {
+	if (process.env.JSR_CACHE_DIR != null) return process.env.JSR_CACHE_DIR;
+	if (_cacheDir != null) return _cacheDir;
+	switch (process.platform) {
+		case "win32": return _cacheDir = join(process.env.LOCALAPPDATA ?? process.env.APPDATA ?? "C:", "jsr-cache");
+		case "darwin": return _cacheDir = join(process.env.HOME ?? "/tmp", "Library", "Caches", "jsr");
+		default: return _cacheDir = join(process.env.XDG_CACHE_HOME ?? process.env.HOME ?? "/tmp", ".cache", "jsr");
+	}
+}
+function parseImportSpecifier(importSpecifier) {
+	let [registry, specifier] = importSpecifier.split(":");
+	if (registry !== "npm" && registry !== "jsr") throw new Error(`Invalid import specifier: ${importSpecifier}`);
+	if (registry === "jsr" && specifier[0] === "/") specifier = specifier.slice(1);
+	if (specifier.startsWith("@")) {
+		let [pkg, version] = specifier.slice(1).split("@");
+		return {
+			registry,
+			packageName: `@${pkg}`,
+			version: version.split("/")[0]
+		};
+	}
+	let [pkg, version] = specifier.split("@");
+	return {
+		registry,
+		packageName: pkg,
+		version: version.split("/")[0]
+	};
+}
+function splitImportRequest(request) {
+	if (request.startsWith("jsr:/")) request = `jsr:${request.slice(5)}`;
+	let parts = request.split("/");
+	if (parts[0].match(/^(?:npm:|jsr:)?@/)) return [parts.slice(0, 2).join("/"), parts.slice(2).join("/")];
+	return [parts[0], parts.slice(1).join("/")];
+}
+//#endregion
+//#region src/jsr/utils/jsr.ts
+var USER_AGENT = "@yorozu/build";
+var REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_REGISTRY = process.env.JSR_URL ?? "https://jsr.io";
+function joinRegistryUrl(registry, path) {
+	return `${registry.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+}
+async function jsrFetch(url, init = {}) {
+	return fetch(url, {
+		...init,
+		headers: {
+			"User-Agent": USER_AGENT,
+			...init.headers
+		},
+		signal: init.signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+	});
+}
+async function jsrCheckVersion(params) {
+	let { registry = DEFAULT_REGISTRY, package: packageName, version } = params;
+	let res = await jsrFetch(joinRegistryUrl(registry, `/${packageName}/meta${version != null ? `_${version}` : ""}.json`));
+	if (res.body) res.body.cancel();
+	return res.status === 200;
+}
+var MetaSchema = object({ versions: record(string(), unknown()) });
+var VersionMetaSchema = object({ manifest: record(string(), unknown()) });
+async function downloadJsrPackage(specifier, params) {
+	if (specifier.registry !== "jsr") throw new Error("Invalid registry");
+	let registry = params?.registry ?? DEFAULT_REGISTRY;
+	let targetDir = `${specifier.packageName.replace(/\//g, "+")}@${specifier.version}`;
+	let registryHost = new URL(registry).host;
+	let cacheDir = join(getModuleCacheDirectory(), "jsr", registryHost, targetDir);
+	if (await directoryExists(cacheDir)) if (params?.force) await fsp.rm(cacheDir, { recursive: true });
+	else return cacheDir;
+	let metaRes = await jsrFetch(joinRegistryUrl(registry, `${specifier.packageName}/meta.json`));
+	if (!metaRes.ok) throw new Error(`Failed to fetch jsr meta for ${specifier.packageName}: ${metaRes.status}`);
+	let meta = MetaSchema.parse(await metaRes.json());
+	let availableVersions = Object.keys(meta.versions);
+	let version = import_semver.default.maxSatisfying(availableVersions, specifier.version);
+	if (version == null) throw new Error(`No matching version for ${specifier.packageName}@${specifier.version}`);
+	await fsp.mkdir(cacheDir, { recursive: true });
+	let versionMetaRes = await jsrFetch(joinRegistryUrl(registry, `${specifier.packageName}/${version}_meta.json`));
+	if (!versionMetaRes.ok) throw new Error(`Failed to fetch jsr version meta for ${specifier.packageName}@${version}: ${versionMetaRes.status}`);
+	let versionMeta = VersionMetaSchema.parse(await versionMetaRes.json());
+	await asyncPool(Object.keys(versionMeta.manifest), async (file) => {
+		let relative = file.replace(/^\//, "");
+		let filePath = join(cacheDir, relative);
+		await fsp.mkdir(join(filePath, ".."), { recursive: true });
+		let res = await jsrFetch(joinRegistryUrl(registry, `${specifier.packageName}/${version}/${relative}`));
+		if (!res.ok) throw new Error(`Failed to download ${specifier.packageName}@${version}/${relative}: ${res.status}`);
+		await fsp.writeFile(filePath, Buffer.from(await res.arrayBuffer()));
+	});
+	return cacheDir;
+}
+//#endregion
+//#region src/jsr/create-packages.ts
+async function jsrCreatePackages(params) {
+	let { workspaceRoot, registry = process.env.JSR_URL ?? "https://jsr.io", token, githubRepo } = params;
+	let workspace = filterPackageJsonsForPublish(params.workspacePackages ?? await collectPackageJsons(workspaceRoot, false), "jsr");
+	let hasFailed = false;
+	for (let pkg of workspace) {
+		if (pkg.json.name == null) continue;
+		if (await jsrCheckVersion({
+			registry,
+			package: pkg.json.name
+		})) continue;
+		let [scope_, packageName] = pkg.json.name.split("/");
+		let scope = scope_.startsWith("@") ? scope_.slice(1) : scope_;
+		if (token == null) {
+			info(`to create ${pkg.json.name} follow this link: ${new URL(`/create?scope=${scope}&package=${packageName}`, registry).href}`);
+			hasFailed = true;
+			continue;
+		}
+		await jsrMaybeCreatePackage({
+			name: pkg.json.name,
+			registry,
+			token
+		});
+		if (githubRepo != null) {
+			let [owner, repo] = githubRepo.split("/");
+			await jsrSetGithubRepo({
+				registry,
+				name: pkg.json.name,
+				token,
+				owner,
+				repo
+			});
+		}
+	}
+	return hasFailed;
+}
+//#endregion
+//#region src/jsr/deno-json.ts
+var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
+function packageJsonToDeno({ packageJson, packageJsonOrig, workspaceVersions, exclude, buildDirName, baseDir }) {
+	let importMap = {};
+	let exports = {};
+	for (let field of [
+		"dependencies",
+		"peerDependencies",
+		"optionalDependencies"
+	]) {
+		let deps = packageJson[field];
+		if (deps == null) continue;
+		for (let [name, version] of Object.entries(deps)) {
+			if (typeof version !== "string") continue;
+			if (workspaceVersions.has(name)) continue;
+			else if (version.startsWith("npm:@jsr/")) {
+				let rest = version.slice(9);
+				importMap[name] = `jsr:@${rest.split("@")[0].replace("__", "/")}@${rest.split("@")[1]}`;
+			} else if (version.startsWith("jsr:")) importMap[name] = version;
+			else if (name) {
+				let packageName = name;
+				let packageVersion = version;
+				if (version.startsWith("npm:")) {
+					let npmValue = version.slice(4);
+					let idx = npmValue.lastIndexOf("@");
+					if (idx <= 0) throw new Error(`Invalid npm dependency: ${name}@${version}`);
+					packageName = npmValue.slice(0, idx);
+					packageVersion = npmValue.slice(idx + 1);
+				} else if (version.match(/\|\||&&|:/)) throw new Error(`Invalid npm dependency (not supported by JSR): ${name}@${version}`);
+				importMap[name] = `npm:${packageName}@${packageVersion}`;
+			}
+		}
+	}
+	if (packageJsonOrig.exports != null) {
+		let tmpExports;
+		if (typeof packageJsonOrig.exports === "string") tmpExports = { ".": packageJsonOrig.exports };
+		else if (typeof packageJsonOrig.exports !== "object") throw new TypeError("package.json exports must be an object");
+		else tmpExports = packageJsonOrig.exports;
+		for (let [name, value] of Object.entries(tmpExports)) {
+			if (typeof value !== "string") throw new TypeError(`package.json exports value must be a string: ${name}`);
+			if (value.endsWith(".wasm")) continue;
+			if (baseDir != null && baseDir !== ".") {
+				if (!value.startsWith(`./${baseDir}`)) throw new Error(`Invalid export value: ${value} (must be inside ./${baseDir})`);
+				exports[name] = `./${value.slice(baseDir.length + 3)}`;
+			} else exports[name] = value;
+		}
+	}
+	return {
+		name: asNonNull(packageJson.name),
+		version: asNonNull(packageJson.version),
+		exports,
+		exclude,
+		imports: importMap,
+		publish: { exclude: [`!../${buildDirName}`] },
+		...packageJson.denoJson != null && typeof packageJson.denoJson === "object" ? packageJson.denoJson : {}
+	};
+}
+//#endregion
+//#region src/jsr/_deno-directives.ts
+function applyDenoDirectives(code) {
+	if (!code.match("<deno-(insert|remove|tsignore)>")) return code;
+	let insertContent = code.match(/\/\/\s*<deno-insert>(.*?)<\/deno-insert>/s);
+	while (insertContent) {
+		code = code.slice(0, insertContent.index) + insertContent[1].replace(/\/\/\s*/g, "") + code.slice(asNonNull(insertContent.index) + insertContent[0].length);
+		insertContent = code.match(/\/\/\s*<deno-insert>(.*?)<\/deno-insert>/s);
+	}
+	let removeContent = code.match(/\/\/\s*<deno-remove>(.*?)<\/deno-remove>/s);
+	while (removeContent) {
+		code = code.slice(0, removeContent.index) + code.slice(asNonNull(removeContent.index) + removeContent[0].length);
+		removeContent = code.match(/\/\/\s*<deno-remove>(.*?)<\/deno-remove>/s);
+	}
+	let tsIgnoreContent = code.match(/\/\/\s*<deno-tsignore>/);
+	while (tsIgnoreContent) {
+		code = `${code.slice(0, tsIgnoreContent.index)}/* @ts-ignore */${code.slice(asNonNull(tsIgnoreContent.index) + tsIgnoreContent[0].length)}`;
+		tsIgnoreContent = code.match(/\/\/\s*<deno-tsignore>/);
+	}
+	return code;
+}
+//#endregion
+//#region src/jsr/generate-workspace.ts
+function mergeArrays(a, b, defaultValue = []) {
+	if (!a) return b ?? defaultValue;
+	if (!b) return a;
+	return [...a, ...b];
+}
+function shouldCopySource(source, srcDir, excludeFilesPico) {
+	let rel = relative(srcDir, source);
+	if (rel === "") return true;
+	if (rel.split(/[\\/]/).some((part) => part === "node_modules" || part === ".git" || part === "dist")) return false;
+	if (excludeFilesPico(rel)) return false;
+	return true;
+}
+async function generateDenoWorkspace(params) {
+	let { workspaceRoot: workspaceRoot_, workspacePackages = await collectPackageJsons(workspaceRoot_, true), rootConfig, withDryRun = false, fixedVersion } = params;
+	let workspaceRoot = normalizeFilePath(workspaceRoot_);
+	let rootPackage = findRootPackage(workspacePackages);
+	let outDir = join(workspaceRoot, rootConfig?.outputDir ?? "dist/jsr");
+	await fsp.rm(outDir, {
+		recursive: true,
+		force: true
+	});
+	await fsp.mkdir(outDir, { recursive: true });
+	let rootDenoJson = { workspace: [] };
+	for (let pkg of filterPackageJsonsForPublish(workspacePackages, "jsr")) {
+		if (pkg.json.name == null) continue;
+		if (rootConfig?.includePackage != null && !rootConfig.includePackage(pkg)) continue;
+		let packageRoot = pkg.path;
+		let packageDirName = pkg.json.name.replace(/\//g, "__");
+		let packageOutRoot = join(outDir, packageDirName);
+		rootDenoJson.workspace.push(`./${packageDirName}`);
+		await fsp.mkdir(packageOutRoot, { recursive: true });
+		if (pkg.json.scripts?.["build:jsr"] != null) {
+			await exec([
+				"npm",
+				"run",
+				"build:jsr"
+			], {
+				env: {
+					...process.env,
+					YOROZU_BUILD_SRC: packageRoot,
+					YOROZU_BUILD_OUT: packageOutRoot
+				},
+				cwd: packageRoot,
+				stdio: "inherit",
+				throwOnError: true
+			});
+			continue;
+		}
+		let packageConfig = await loadBuildConfig(pkg.path);
+		let packageConfigJsr = packageConfig?.jsr;
+		let srcDir = join(packageRoot, normalizeFilePath(packageConfigJsr?.sourceDir ?? rootConfig?.sourceDir ?? ""));
+		let excludeFiles = mergeArrays(rootConfig?.exclude, packageConfigJsr?.exclude);
+		let excludeFilesPico = (0, import_picomatch.default)(excludeFiles);
+		await fsp.cp(srcDir, packageOutRoot, {
+			recursive: true,
+			filter(source) {
+				return shouldCopySource(source, srcDir, excludeFilesPico);
+			}
+		});
+		let printer = ts.createPrinter();
+		await asyncPool(await glob("**/*.ts", { cwd: packageOutRoot }), async (filename) => {
+			let fullFilePath = join(packageOutRoot, filename);
+			let fileContent = await fsp.readFile(fullFilePath, "utf8");
+			let changed = false;
+			let file = ts.createSourceFile(filename, fileContent, ts.ScriptTarget.ESNext, true);
+			let changedTs = false;
+			for (let imp of file.statements) {
+				if (!ts.isImportDeclaration(imp) && !ts.isExportDeclaration(imp)) continue;
+				if (!imp.moduleSpecifier || !ts.isStringLiteral(imp.moduleSpecifier)) continue;
+				let mod = imp.moduleSpecifier.text;
+				if (mod[0] !== ".") continue;
+				if (mod.endsWith(".js") || mod.endsWith(".jsx")) {
+					let newMod = mod.replace(/\.js(x?)$/, ".ts$1");
+					let fullPathOld = join(dirname(fullFilePath), mod);
+					let fullPathNew = join(dirname(fullFilePath), newMod);
+					if (!await fileExists(fullPathOld) && await fileExists(fullPathNew)) {
+						changedTs = true;
+						imp.moduleSpecifier = ts.factory.createStringLiteral(newMod);
+					}
+				} else throw new Error(`Invalid import specifier: ${mod} at ${join(srcDir, filename)}`);
+			}
+			if (rootConfig?.transformAst?.(file)) changedTs = true;
+			if (packageConfigJsr?.transformAst?.(file)) changedTs = true;
+			if (changedTs) {
+				fileContent = printer.printFile(file);
+				changed = true;
+			}
+			if (rootConfig?.enableDenoDirectives) fileContent = applyDenoDirectives(fileContent);
+			if (rootConfig?.transformCode || packageConfigJsr?.transformCode) {
+				let origFileContent = fileContent;
+				if (rootConfig?.transformCode) fileContent = rootConfig.transformCode(filename, fileContent);
+				if (packageConfigJsr?.transformCode) fileContent = packageConfigJsr.transformCode(filename, fileContent);
+				if (fileContent !== origFileContent) changed = true;
+			}
+			if (changed) await fsp.writeFile(fullFilePath, fileContent);
+		});
+		let hookContext = {
+			outDir: packageOutRoot,
+			packageDir: packageOutRoot,
+			packageName: pkg.json.name,
+			packageJson: pkg.json,
+			jsr: true,
+			typedoc: false
+		};
+		packageConfig?.preparePackageJson?.(hookContext);
+		let workspaceVersions = collectVersions(workspacePackages);
+		let { packageJson, packageJsonOriginal } = processPackageJson({
+			packageJson: pkg.json,
+			rootPackageJson: rootPackage.json,
+			workspaceVersions,
+			bundledWorkspaceDeps: [],
+			rootFieldsToCopy: new Set(["license"])
+		});
+		if (fixedVersion != null) {
+			packageJson.version = fixedVersion;
+			packageJsonOriginal.version = fixedVersion;
+		}
+		hookContext.packageJson = packageJson;
+		await packageConfig?.finalizePackageJson?.(hookContext);
+		let denoJson = packageJsonToDeno({
+			packageJson,
+			packageJsonOrig: packageJsonOriginal,
+			workspaceVersions,
+			buildDirName: relative(packageOutRoot, outDir),
+			baseDir: relative(packageRoot, srcDir),
+			exclude: excludeFiles
+		});
+		packageConfig?.jsr?.finalizeDenoJson?.(hookContext, denoJson);
+		rootConfig?.finalizeDenoJson?.(hookContext, denoJson);
+		await fsp.writeFile(join(packageOutRoot, "deno.json"), JSON.stringify(denoJson, null, 4));
+		for (let file of mergeArrays(rootConfig?.copyRootFiles, packageConfig?.jsr?.copyRootFiles, ["LICENSE"])) await tryCopy(join(workspaceRoot, file), join(packageOutRoot, file), { recursive: true });
+		for (let file of mergeArrays(rootConfig?.copyPackageFiles, packageConfig?.jsr?.copyPackageFiles, ["README.md"])) await tryCopy(join(packageRoot, file), join(packageOutRoot, file), { recursive: true });
+		await packageConfig?.jsr?.finalize?.(hookContext);
+	}
+	await fsp.writeFile(join(outDir, "deno.json"), JSON.stringify(rootDenoJson, null, 4));
+	await rootConfig?.finalize?.({
+		outDir,
+		packageDir: outDir,
+		packageName: "<jsr-root>",
+		packageJson: {},
+		jsr: true,
+		typedoc: false
+	});
+	if (rootConfig?.dryRun === true || withDryRun) await exec([
+		"deno",
+		"publish",
+		"--dry-run",
+		"-q",
+		"--allow-dirty"
+	], {
+		cwd: outDir,
+		stdio: "inherit",
+		throwOnError: true
+	});
+	return outDir;
+}
+//#endregion
+//#region src/jsr/utils/jsr-json.ts
+function parseJsrJson(json) {
+	let res = parseConfigFileTextToJson("jsr.json", json);
+	if (res.error) throw new Error(res.error.messageText.toString());
+	let obj = res.config;
+	if (typeof obj !== "object" || obj === null) throw new Error("Expected object");
+	if (typeof obj.name !== "string") throw new TypeError("Expected \"name\" to be a string");
+	if (typeof obj.version !== "string") throw new TypeError("Expected \"version\" to be a string");
+	if (typeof obj.exports !== "string" && (typeof obj.exports !== "object" || obj.exports === null)) throw new TypeError("Expected \"exports\" to be a string or an object");
+	if (typeof obj.exports !== "string") for (let key in obj.exports) {
+		if (typeof key !== "string") throw new TypeError("exports: Expected key to be a string");
+		if (typeof obj.exports[key] !== "string") throw new TypeError("exports: Expected value to be a string");
+	}
+	if (obj.imports !== void 0) {
+		if (typeof obj.imports !== "object" || obj.imports === null) throw new TypeError("Expected \"imports\" to be an object");
+		let imports = obj.imports;
+		for (let key in imports) {
+			if (typeof key !== "string") throw new TypeError("imports: Expected key to be a string");
+			if (typeof imports[key] !== "string") throw new TypeError("imports: Expected value to be a string");
+			imports[key] = parseImportSpecifier(imports[key]);
+		}
+	}
+	if (obj.compilerOptions !== void 0) {
+		if (typeof obj.compilerOptions !== "object" || obj.compilerOptions === null) throw new TypeError("Expected \"compilerOptions\" to be an object");
+	}
+	return obj;
+}
+var _findClosestJsrJsonCache = /* @__PURE__ */ new Map();
+function findClosestJsrJson(path) {
+	while (true) {
+		if (_findClosestJsrJsonCache.has(path)) return _findClosestJsrJsonCache.get(path) ?? null;
+		for (let file of [
+			"jsr.json",
+			"deno.json",
+			"jsr.jsonc",
+			"deno.jsonc"
+		]) if (existsSync(join(path, file))) {
+			_findClosestJsrJsonCache.set(path, join(path, file));
+			return join(path, file);
+		}
+		if (existsSync(join(path, "package.json"))) {
+			_findClosestJsrJsonCache.set(path, null);
+			return null;
+		}
+		let parent = join(path, "..");
+		if (parent === path) return null;
+		path = parent;
+	}
+}
+//#endregion
+//#region src/jsr/populate.ts
+async function findPackageDependencies(packagePath) {
+	let jsrJsonPath = findClosestJsrJson(packagePath);
+	if (jsrJsonPath == null) throw new Error(`Could not find jsr.json for package at ${packagePath}`);
+	let jsrJson = parseJsrJson(await fsp.readFile(jsrJsonPath, "utf8"));
+	let entrypoints = typeof jsrJson.exports === "string" ? [jsrJson.exports] : Object.values(jsrJson.exports);
+	let visited = /* @__PURE__ */ new Set();
+	let dependencies = /* @__PURE__ */ new Set();
+	let queue = [...entrypoints];
+	while (queue.length > 0) {
+		let file = queue.shift();
+		if (file == null || visited.has(file)) continue;
+		visited.add(file);
+		const handleSpecifier = (specifier) => {
+			if (specifier.startsWith("jsr:")) {
+				let parsed = parseImportSpecifier(specifier);
+				dependencies.add(`${parsed.packageName}@${parsed.version}`);
+			} else if (specifier.startsWith(".")) {
+				let relative = resolve(dirname(join(packagePath, file)), specifier).slice(packagePath.length + 1);
+				if (!relative.startsWith(".")) relative = `./${relative}`;
+				queue.push(relative);
+			}
+		};
+		let content = await fsp.readFile(join(packagePath, file), "utf8");
+		let source = ts.createSourceFile(file, content, ts.ScriptTarget.ESNext, true);
+		for (let node of source.statements) if (ts.isImportDeclaration(node)) handleSpecifier(node.moduleSpecifier.getText().slice(1, -1));
+		else if (ts.isExportDeclaration(node) && node.moduleSpecifier) handleSpecifier(node.moduleSpecifier.getText().slice(1, -1));
+	}
+	return Array.from(dependencies);
+}
+async function populateFromUpstream(params) {
+	let { upstream = "https://jsr.io", downstream, packages, token, createViaApi = false, deno = "deno", quiet = false, publishArgs: _publishArgs } = params;
+	let publishArgs = typeof _publishArgs === "function" ? _publishArgs : () => _publishArgs || [];
+	if (createViaApi && token == null) throw new Error("createViaApi requires a token");
+	let depsMap = /* @__PURE__ */ new Map();
+	let nameToPath = /* @__PURE__ */ new Map();
+	let pending = [...packages];
+	let seen = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		let batch = pending.splice(0, pending.length).filter((pkg) => !seen.has(pkg));
+		for (let pkg of batch) seen.add(pkg);
+		if (batch.length === 0) break;
+		await asyncPool(batch, async (pkg) => {
+			if (!quiet) info(`Downloading ${pkg}...`);
+			let path = await downloadJsrPackage(parseImportSpecifier(`jsr:${pkg}`), { registry: upstream });
+			nameToPath.set(pkg, path);
+			let deps = await findPackageDependencies(path);
+			depsMap.set(pkg, deps);
+			for (let dep of deps) if (!seen.has(dep)) pending.push(dep);
+		});
+	}
+	let order = determinePublishOrder(Object.fromEntries(depsMap));
+	for (let item of order) {
+		let spec = parseImportSpecifier(`jsr:${item}`);
+		let path = nameToPath.get(item);
+		if (path == null) throw new Error(`Missing downloaded package path for ${item}`);
+		if (createViaApi) await jsrMaybeCreatePackage({
+			name: spec.packageName,
+			registry: downstream,
+			token,
+			quiet
+		});
+		if (!quiet) info(`Publishing ${item}...`);
+		await exec([
+			deno,
+			"publish",
+			"--quiet",
+			...token != null ? ["--token", token] : [],
+			...publishArgs(item)
+		], {
+			env: {
+				...process.env,
+				JSR_URL: downstream
+			},
+			cwd: path,
+			stdio: "inherit",
+			throwOnError: true
+		});
+	}
+}
+//#endregion
+export { downloadJsrPackage, findClosestJsrJson, generateDenoWorkspace, getModuleCacheDirectory, jsrCheckVersion, jsrCreatePackages, jsrCreateScope, jsrGetScopeInfo, jsrMaybeCreatePackage, jsrSetGithubRepo, packageJsonToDeno, parseImportSpecifier, parseJsrJson, populateFromUpstream, splitImportRequest };