flag-resizer 0.0.1

package/dist/generator.js

@@ -0,0 +1,950 @@
+import path from "node:path";
+import { loadConfig } from "c12";
+import { z } from "zod";
+import { access, copyFile, mkdir, mkdtemp, readFile, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import os, { availableParallelism } from "node:os";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import sharp from "sharp";
+//#region src/data/flags.ts
+const FLAGS = {
+	ac: "Ascension Island",
+	ad: "Andorra",
+	ae: "United Arab Emirates",
+	af: "Afghanistan",
+	ag: "Antigua and Barbuda",
+	ai: "Anguilla",
+	al: "Albania",
+	am: "Armenia",
+	ao: "Angola",
+	aq: "Antarctica",
+	ar: "Argentina",
+	as: "American Samoa",
+	at: "Austria",
+	au: "Australia",
+	"au-act": "Australian Capital Territory",
+	"au-nsw": "New South Wales",
+	"au-nt": "Northern Territory",
+	"au-qld": "Queensland",
+	"au-sa": "South Australia",
+	"au-tas": "Tasmania",
+	"au-vic": "Victoria",
+	"au-wa": "Western Australia",
+	aw: "Aruba",
+	ax: "Åland Islands",
+	az: "Azerbaijan",
+	ba: "Bosnia and Herzegovina",
+	bb: "Barbados",
+	bd: "Bangladesh",
+	be: "Belgium",
+	bf: "Burkina Faso",
+	bg: "Bulgaria",
+	bh: "Bahrain",
+	bi: "Burundi",
+	bj: "Benin",
+	bl: "Saint Barthélemy",
+	bm: "Bermuda",
+	bn: "Brunei",
+	bo: "Bolivia",
+	bq: "Caribbean Netherlands",
+	br: "Brazil",
+	bs: "Bahamas",
+	bt: "Bhutan",
+	bv: "Bouvet Island",
+	bw: "Botswana",
+	by: "Belarus",
+	bz: "Belize",
+	ca: "Canada",
+	"ca-ab": "Alberta",
+	"ca-bc": "British Columbia",
+	"ca-mb": "Manitoba",
+	"ca-nb": "New Brunswick",
+	"ca-nl": "Newfoundland and Labrador",
+	"ca-ns": "Nova Scotia",
+	"ca-nt": "Northwest Territories",
+	"ca-nu": "Nunavut",
+	"ca-on": "Ontario",
+	"ca-pe": "Prince Edward Island",
+	"ca-qc": "Quebec",
+	"ca-sk": "Saskatchewan",
+	"ca-yt": "Yukon",
+	cc: "Cocos (Keeling) Islands",
+	cd: "DR Congo",
+	cf: "Central African Republic",
+	cg: "Republic of the Congo",
+	ch: "Switzerland",
+	ci: "Côte d'Ivoire (Ivory Coast)",
+	ck: "Cook Islands",
+	cl: "Chile",
+	cm: "Cameroon",
+	cn: "China",
+	co: "Colombia",
+	cp: "Clipperton Island",
+	cq: "Sark",
+	cr: "Costa Rica",
+	cu: "Cuba",
+	cv: "Cape Verde",
+	cw: "Curaçao",
+	cx: "Christmas Island",
+	cy: "Cyprus",
+	cz: "Czechia",
+	de: "Germany",
+	"de-bb": "Brandenburg",
+	"de-be": "Berlin",
+	"de-bw": "Baden-Württemberg",
+	"de-by": "Bavaria",
+	"de-hb": "Bremen",
+	"de-he": "Hesse",
+	"de-hh": "Hamburg",
+	"de-mv": "Mecklenburg-Western Pomerania",
+	"de-ni": "Lower Saxony",
+	"de-nw": "North Rhine-Westphalia",
+	"de-rp": "Rhineland-Palatinate",
+	"de-sh": "Schleswig-Holstein",
+	"de-sl": "Saarland",
+	"de-sn": "Saxony",
+	"de-st": "Saxony-Anhalt",
+	"de-th": "Thuringia",
+	dg: "Diego Garcia",
+	dj: "Djibouti",
+	dk: "Denmark",
+	dm: "Dominica",
+	do: "Dominican Republic",
+	dz: "Algeria",
+	ea: "Ceuta & Melilla",
+	ec: "Ecuador",
+	ee: "Estonia",
+	eg: "Egypt",
+	eh: "Western Sahara",
+	er: "Eritrea",
+	es: "Spain",
+	"es-an": "Andalusia",
+	"es-ar": "Aragon",
+	"es-as": "Asturias",
+	"es-cb": "Cantabria",
+	"es-ce": "Ceuta",
+	"es-cl": "Castile and León",
+	"es-cm": "Castilla-La Mancha",
+	"es-cn": "Canary Islands",
+	"es-ct": "Catalonia",
+	"es-ex": "Extremadura",
+	"es-ga": "Galicia",
+	"es-ib": "Balearic Islands",
+	"es-mc": "Region of Murcia",
+	"es-md": "Community of Madrid",
+	"es-ml": "Melilla",
+	"es-nc": "Navarre",
+	"es-pv": "Basque Country",
+	"es-ri": "La Rioja",
+	"es-vc": "Valencian Community",
+	et: "Ethiopia",
+	eu: "European Union",
+	fi: "Finland",
+	fj: "Fiji",
+	fk: "Falkland Islands",
+	fm: "Micronesia",
+	fo: "Faroe Islands",
+	fr: "France",
+	ga: "Gabon",
+	gb: "United Kingdom",
+	"gb-eng": "England",
+	"gb-nir": "Northern Ireland",
+	"gb-sct": "Scotland",
+	"gb-wls": "Wales",
+	gd: "Grenada",
+	ge: "Georgia",
+	gf: "French Guiana",
+	gg: "Guernsey",
+	gh: "Ghana",
+	gi: "Gibraltar",
+	gl: "Greenland",
+	gm: "Gambia",
+	gn: "Guinea",
+	gp: "Guadeloupe",
+	gq: "Equatorial Guinea",
+	gr: "Greece",
+	gs: "South Georgia",
+	gt: "Guatemala",
+	gu: "Guam",
+	gw: "Guinea-Bissau",
+	gy: "Guyana",
+	hk: "Hong Kong",
+	hm: "Heard Island and McDonald Islands",
+	hn: "Honduras",
+	hr: "Croatia",
+	ht: "Haiti",
+	hu: "Hungary",
+	ic: "Canary Islands",
+	id: "Indonesia",
+	ie: "Ireland",
+	il: "Israel",
+	im: "Isle of Man",
+	in: "India",
+	io: "British Indian Ocean Territory",
+	iq: "Iraq",
+	ir: "Iran",
+	is: "Iceland",
+	it: "Italy",
+	je: "Jersey",
+	jm: "Jamaica",
+	jo: "Jordan",
+	jp: "Japan",
+	ke: "Kenya",
+	kg: "Kyrgyzstan",
+	kh: "Cambodia",
+	ki: "Kiribati",
+	km: "Comoros",
+	kn: "Saint Kitts and Nevis",
+	kp: "North Korea",
+	kr: "South Korea",
+	kw: "Kuwait",
+	ky: "Cayman Islands",
+	kz: "Kazakhstan",
+	la: "Laos",
+	lb: "Lebanon",
+	lc: "Saint Lucia",
+	li: "Liechtenstein",
+	lk: "Sri Lanka",
+	lr: "Liberia",
+	ls: "Lesotho",
+	lt: "Lithuania",
+	lu: "Luxembourg",
+	lv: "Latvia",
+	ly: "Libya",
+	ma: "Morocco",
+	mc: "Monaco",
+	md: "Moldova",
+	me: "Montenegro",
+	mf: "Saint Martin",
+	mg: "Madagascar",
+	mh: "Marshall Islands",
+	mk: "North Macedonia",
+	ml: "Mali",
+	mm: "Myanmar",
+	mn: "Mongolia",
+	mo: "Macau",
+	mp: "Northern Mariana Islands",
+	mq: "Martinique",
+	mr: "Mauritania",
+	ms: "Montserrat",
+	mt: "Malta",
+	mu: "Mauritius",
+	mv: "Maldives",
+	mw: "Malawi",
+	mx: "Mexico",
+	my: "Malaysia",
+	mz: "Mozambique",
+	na: "Namibia",
+	nc: "New Caledonia",
+	ne: "Niger",
+	nf: "Norfolk Island",
+	ng: "Nigeria",
+	ni: "Nicaragua",
+	nl: "Netherlands",
+	no: "Norway",
+	np: "Nepal",
+	nr: "Nauru",
+	nu: "Niue",
+	nz: "New Zealand",
+	om: "Oman",
+	pa: "Panama",
+	pe: "Peru",
+	pf: "French Polynesia",
+	pg: "Papua New Guinea",
+	ph: "Philippines",
+	pk: "Pakistan",
+	pl: "Poland",
+	pm: "Saint Pierre and Miquelon",
+	pn: "Pitcairn Islands",
+	pr: "Puerto Rico",
+	ps: "Palestine",
+	pt: "Portugal",
+	pw: "Palau",
+	py: "Paraguay",
+	qa: "Qatar",
+	re: "Réunion",
+	ro: "Romania",
+	rs: "Serbia",
+	ru: "Russia",
+	rw: "Rwanda",
+	sa: "Saudi Arabia",
+	sb: "Solomon Islands",
+	sc: "Seychelles",
+	sd: "Sudan",
+	se: "Sweden",
+	sg: "Singapore",
+	sh: "Saint Helena, Ascension and Tristan da Cunha",
+	si: "Slovenia",
+	sj: "Svalbard and Jan Mayen",
+	sk: "Slovakia",
+	sl: "Sierra Leone",
+	sm: "San Marino",
+	sn: "Senegal",
+	so: "Somalia",
+	sr: "Suriname",
+	ss: "South Sudan",
+	st: "São Tomé and Príncipe",
+	sv: "El Salvador",
+	sx: "Sint Maarten",
+	sy: "Syria",
+	sz: "Eswatini (Swaziland)",
+	ta: "Tristan da Cunha",
+	tc: "Turks and Caicos Islands",
+	td: "Chad",
+	tf: "French Southern and Antarctic Lands",
+	tg: "Togo",
+	th: "Thailand",
+	tj: "Tajikistan",
+	tk: "Tokelau",
+	tl: "Timor-Leste",
+	tm: "Turkmenistan",
+	tn: "Tunisia",
+	to: "Tonga",
+	tr: "Turkey",
+	tt: "Trinidad and Tobago",
+	tv: "Tuvalu",
+	tw: "Taiwan",
+	tz: "Tanzania",
+	ua: "Ukraine",
+	ug: "Uganda",
+	um: "United States Minor Outlying Islands",
+	un: "United Nations",
+	us: "United States",
+	"us-ak": "Alaska",
+	"us-al": "Alabama",
+	"us-ar": "Arkansas",
+	"us-az": "Arizona",
+	"us-ca": "California",
+	"us-co": "Colorado",
+	"us-ct": "Connecticut",
+	"us-de": "Delaware",
+	"us-fl": "Florida",
+	"us-ga": "Georgia",
+	"us-hi": "Hawaii",
+	"us-ia": "Iowa",
+	"us-id": "Idaho",
+	"us-il": "Illinois",
+	"us-in": "Indiana",
+	"us-ks": "Kansas",
+	"us-ky": "Kentucky",
+	"us-la": "Louisiana",
+	"us-ma": "Massachusetts",
+	"us-md": "Maryland",
+	"us-me": "Maine",
+	"us-mi": "Michigan",
+	"us-mn": "Minnesota",
+	"us-mo": "Missouri",
+	"us-ms": "Mississippi",
+	"us-mt": "Montana",
+	"us-nc": "North Carolina",
+	"us-nd": "North Dakota",
+	"us-ne": "Nebraska",
+	"us-nh": "New Hampshire",
+	"us-nj": "New Jersey",
+	"us-nm": "New Mexico",
+	"us-nv": "Nevada",
+	"us-ny": "New York",
+	"us-oh": "Ohio",
+	"us-ok": "Oklahoma",
+	"us-or": "Oregon",
+	"us-pa": "Pennsylvania",
+	"us-ri": "Rhode Island",
+	"us-sc": "South Carolina",
+	"us-sd": "South Dakota",
+	"us-tn": "Tennessee",
+	"us-tx": "Texas",
+	"us-ut": "Utah",
+	"us-va": "Virginia",
+	"us-vt": "Vermont",
+	"us-wa": "Washington",
+	"us-wi": "Wisconsin",
+	"us-wv": "West Virginia",
+	"us-wy": "Wyoming",
+	uy: "Uruguay",
+	uz: "Uzbekistan",
+	va: "Vatican City (Holy See)",
+	vc: "Saint Vincent and the Grenadines",
+	ve: "Venezuela",
+	vg: "British Virgin Islands",
+	vi: "United States Virgin Islands",
+	vn: "Vietnam",
+	vu: "Vanuatu",
+	wf: "Wallis and Futuna",
+	ws: "Samoa",
+	xk: "Kosovo",
+	ye: "Yemen",
+	yt: "Mayotte",
+	za: "South Africa",
+	zm: "Zambia",
+	zw: "Zimbabwe"
+};
+const COUNTRY_CODES = Object.keys(FLAGS);
+//#endregion
+//#region src/errors.ts
+var FlagResizerError = class extends Error {
+	name = "FlagResizerError";
+	constructor(message, options) {
+		super(message, options);
+	}
+};
+//#endregion
+//#region src/config.ts
+const countryCodeSchema = z.enum(COUNTRY_CODES);
+const filterPatternSchema = z.string().regex(/^(?=.*\*)[a-z*]+(?:-[a-z*]+)*$/u, "must be a lowercase flag code or a pattern using \"*\"");
+const filterValueSchema = z.union([countryCodeSchema, filterPatternSchema]);
+const formatSchema = z.enum(["png", "webp"]);
+const sizeSchema = z.tuple([z.number().int().positive("width must be a positive integer"), z.number().int().positive("height must be a positive integer")]);
+const formatOutputSchema = z.object({
+	dir: z.string().trim().min(1),
+	publicPath: z.string().trim().min(1)
+}).strict();
+const profileSchema = z.object({
+	filter: z.object({
+		type: z.enum(["whitelist", "blacklist"]),
+		values: z.array(filterValueSchema)
+	}).strict(),
+	sizes: z.array(sizeSchema).min(1),
+	quality: z.number().int().min(1).max(100),
+	formats: z.array(formatSchema).min(1),
+	output: z.object({
+		png: formatOutputSchema.optional(),
+		webp: formatOutputSchema.optional(),
+		ts: z.string().trim().min(1)
+	}).strict()
+}).strict();
+const configSchema = z.record(z.string().trim().min(1), profileSchema);
+function defineConfig(config) {
+	return config;
+}
+function formatValidationError(error) {
+	return error.issues.map((issue) => {
+		const location = issue.path.length > 0 ? issue.path.join(".") : "config";
+		const received = issue.code === "invalid_value" ? ` (${String(issue.input)})` : "";
+		return `${location}: ${issue.message}${received}`;
+	}).join("\n");
+}
+function preflightFormatTypos(raw) {
+	if (typeof raw !== "object" || raw === null) return;
+	for (const [profileName, value] of Object.entries(raw)) {
+		if (typeof value !== "object" || value === null) continue;
+		const formats = Reflect.get(value, "formats");
+		if (Array.isArray(formats) && formats.includes("wepb")) throw new FlagResizerError(`Profile "${profileName}" contains format "wepb". Did you mean "webp"?`);
+	}
+}
+function normalizePublicPath(publicPath) {
+	const normalized = publicPath.replace(/\/+$/u, "");
+	return normalized === "" ? "/" : normalized;
+}
+function assertUniqueValues(profileName, profile) {
+	if (new Set(profile.formats).size !== profile.formats.length) throw new FlagResizerError(`Profile "${profileName}" contains duplicate formats.`);
+	if (new Set(profile.sizes.map(([width, height]) => `${width}x${height}`)).size !== profile.sizes.length) throw new FlagResizerError(`Profile "${profileName}" contains duplicate sizes.`);
+	if (new Set(profile.filter.values).size !== profile.filter.values.length) throw new FlagResizerError(`Profile "${profileName}" contains duplicate filter values.`);
+}
+function assertConsistentRatio(profileName, profile) {
+	const first = profile.sizes[0];
+	if (!first) return;
+	const [baseWidth, baseHeight] = first;
+	for (const [width, height] of profile.sizes.slice(1)) if (width * baseHeight !== height * baseWidth) throw new FlagResizerError(`Profile "${profileName}" mixes aspect ratios: ${baseWidth}x${baseHeight} and ${width}x${height}.`);
+}
+function matchesFilterValue(code, value) {
+	if (!value.includes("*")) return code === value;
+	return new RegExp(`^${value.split("*").join(".*")}$`, "u").test(code);
+}
+function assertFilterValuesMatch(profileName, profile) {
+	for (const value of profile.filter.values) if (!COUNTRY_CODES.some((code) => matchesFilterValue(code, value))) throw new FlagResizerError(`Profile "${profileName}" contains filter pattern "${value}" that matches no bundled flags.`);
+}
+function selectCountries(profile) {
+	return COUNTRY_CODES.filter((code) => {
+		const matches = profile.filter.values.some((value) => matchesFilterValue(code, value));
+		return profile.filter.type === "whitelist" ? matches : !matches;
+	});
+}
+function resolveProfile(name, profile, baseDir) {
+	assertUniqueValues(name, profile);
+	assertConsistentRatio(name, profile);
+	assertFilterValuesMatch(name, profile);
+	for (const format of profile.formats) if (!profile.output[format]) throw new FlagResizerError(`Profile "${name}" enables "${format}" but output.${format} is missing.`);
+	return {
+		...profile,
+		name,
+		countries: selectCountries(profile),
+		output: {
+			...profile.output.png ? { png: {
+				dir: path.resolve(baseDir, profile.output.png.dir),
+				publicPath: normalizePublicPath(profile.output.png.publicPath)
+			} } : {},
+			...profile.output.webp ? { webp: {
+				dir: path.resolve(baseDir, profile.output.webp.dir),
+				publicPath: normalizePublicPath(profile.output.webp.publicPath)
+			} } : {},
+			ts: path.resolve(baseDir, profile.output.ts)
+		}
+	};
+}
+function profileTargets(profile) {
+	const targets = [profile.output.ts];
+	for (const format of profile.formats) {
+		const output = profile.output[format];
+		if (!output) continue;
+		for (const [width, height] of profile.sizes) for (const code of profile.countries) targets.push(path.join(output.dir, `${width}x${height}`, `${code}.${format}`));
+	}
+	return targets;
+}
+function assertNoTargetCollisions(profiles) {
+	const owners = /* @__PURE__ */ new Map();
+	for (const profile of profiles) for (const target of profileTargets(profile)) {
+		const owner = owners.get(target);
+		if (owner) throw new FlagResizerError(`Profiles "${owner}" and "${profile.name}" both generate ${target}.`);
+		owners.set(target, profile.name);
+	}
+}
+async function loadRawConfiguration(options) {
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	if ("config" in options) return {
+		raw: options.config,
+		baseDir: cwd
+	};
+	const requestedFile = options.configFile ? path.resolve(cwd, options.configFile) : void 0;
+	try {
+		const result = await loadConfig({
+			name: "flag-resizer",
+			cwd,
+			...requestedFile ? { configFile: requestedFile } : {},
+			configFileRequired: true,
+			rcFile: false,
+			globalRc: false,
+			packageJson: false,
+			dotenv: false,
+			envName: false,
+			extend: false
+		});
+		const discoveredFile = typeof result.configFile === "string" ? path.resolve(result.configFile) : requestedFile;
+		return {
+			raw: result.config,
+			baseDir: discoveredFile ? path.dirname(discoveredFile) : cwd,
+			...discoveredFile ? { configFile: discoveredFile } : {}
+		};
+	} catch (error) {
+		throw new FlagResizerError(`Unable to load flag-resizer configuration from ${requestedFile ?? path.join(cwd, "flag-resizer.config.*")}.`, { cause: error });
+	}
+}
+async function resolveConfiguration(options) {
+	const loaded = await loadRawConfiguration(options);
+	preflightFormatTypos(loaded.raw);
+	const parsed = configSchema.safeParse(loaded.raw);
+	if (!parsed.success) throw new FlagResizerError(`Invalid flag-resizer configuration:\n${formatValidationError(parsed.error)}`);
+	const entries = Object.entries(parsed.data);
+	if (entries.length === 0) throw new FlagResizerError("The configuration must contain at least one profile.");
+	const allProfiles = entries.map(([name, profile]) => resolveProfile(name, profile, loaded.baseDir));
+	assertNoTargetCollisions(allProfiles);
+	const requested = options.profiles;
+	const selected = requested && requested.length > 0 ? requested.map((name) => {
+		const profile = allProfiles.find((candidate) => candidate.name === name);
+		if (!profile) throw new FlagResizerError(`Unknown profile "${name}". Available profiles: ${allProfiles.map((candidate) => candidate.name).join(", ")}.`);
+		return profile;
+	}) : allProfiles;
+	if (new Set(selected.map((profile) => profile.name)).size !== selected.length) throw new FlagResizerError("A profile was selected more than once.");
+	return {
+		baseDir: loaded.baseDir,
+		profiles: selected,
+		...loaded.configFile ? { configFile: loaded.configFile } : {}
+	};
+}
+//#endregion
+//#region src/generated-typescript.ts
+function quote(value) {
+	return JSON.stringify(value);
+}
+function propertyKey(value) {
+	return /^[A-Za-z_$][\w$]*$/u.test(value) ? value : quote(value);
+}
+function createTypeScriptManifest(profile) {
+	return `/**
+ * Generated by script 🍺
+ * Do not edit manually.
+ */
+
+export const FLAGS = {
+${profile.countries.map((code) => `  ${propertyKey(code)}: ${quote(FLAGS[code])},`).join("\n")}
+} as const;
+
+export type CountryCode = keyof typeof FLAGS;
+
+export const FLAG_SIZES = [
+${profile.sizes.map(([width, height]) => `${width}x${height}`).map((size) => `  ${quote(size)},`).join("\n")}
+] as const;
+
+export type FlagSize = (typeof FLAG_SIZES)[number];
+
+export const FLAG_DIMENSIONS = {
+${profile.sizes.map(([width, height]) => `  ${quote(`${width}x${height}`)}: { width: ${width}, height: ${height} },`).join("\n")}
+} as const satisfies Record<FlagSize, { width: number; height: number }>;
+
+export const FLAG_FORMATS = [
+${profile.formats.map((format) => `  ${quote(format)},`).join("\n")}
+] as const;
+
+export type FlagFormat = (typeof FLAG_FORMATS)[number];
+
+export const FLAG_PUBLIC_PATHS = {
+${profile.formats.map((format) => {
+		const output = profile.output[format];
+		if (!output) throw new Error(`Missing resolved output for ${format}.`);
+		return `  ${format}: ${quote(output.publicPath)},`;
+	}).join("\n")}
+} as const satisfies Record<FlagFormat, string>;
+
+export function getFlagPath(
+  code: CountryCode,
+  size: FlagSize,
+  format: FlagFormat,
+): string {
+  const publicPath = FLAG_PUBLIC_PATHS[format];
+  const basePath = publicPath === '/' ? '' : publicPath;
+  return \`\${basePath}/\${size}/\${code}.\${format}\`;
+}
+`;
+}
+//#endregion
+//#region src/generator.ts
+const PACKAGE_ROOT = fileURLToPath(new URL("../", import.meta.url));
+const FLAGS_DIRECTORY = path.join(PACKAGE_ROOT, "flags");
+const ATTRIBUTION_FILE = path.join(PACKAGE_ROOT, "ATTRIBUTION.txt");
+const GRAPHICS_LICENSE_FILE = path.join(PACKAGE_ROOT, "LICENSE-GRAPHICS");
+const MANIFEST_VERSION = 1;
+function emptyManifest() {
+	return {
+		version: MANIFEST_VERSION,
+		profiles: {}
+	};
+}
+function entryTarget(entry) {
+	return path.resolve(entry.root, entry.relativePath);
+}
+function entryKey(entry) {
+	return entryTarget(entry);
+}
+function assertSafeManagedFile(entry) {
+	if (!path.isAbsolute(entry.root)) throw new FlagResizerError("The managed manifest contains a non-absolute output root.");
+	if (path.isAbsolute(entry.relativePath) || entry.relativePath.includes("\0")) throw new FlagResizerError("The managed manifest contains an unsafe file path.");
+	const target = entryTarget(entry);
+	const relative = path.relative(entry.root, target);
+	if (relative === "" || relative === ".." || relative.startsWith(`..${path.sep}`)) throw new FlagResizerError("The managed manifest contains a path outside its output root.");
+	const portable = entry.relativePath.split(path.sep).join("/");
+	if (!(entry.kind === "attribution" && portable === "ATTRIBUTION.txt" || entry.kind === "license" && portable === "LICENSE-GRAPHICS" || entry.kind === "typescript" && /^[^/]+\.ts$/u.test(portable) || entry.kind === "image" && /^[1-9]\d*x[1-9]\d*\/(?:[a-z]{2}|au-(?:act|nsw|nt|qld|sa|tas|vic|wa)|ca-(?:ab|bc|mb|nb|nl|ns|nt|nu|on|pe|qc|sk|yt)|de-(?:bb|be|bw|by|hb|he|hh|mv|ni|nw|rp|sh|sl|sn|st|th)|es-(?:an|ar|as|cb|ce|cl|cm|cn|ct|ex|ga|ib|mc|md|ml|nc|pv|ri|vc)|gb-(?:eng|nir|sct|wls)|us-(?:ak|al|ar|az|ca|co|ct|de|fl|ga|hi|ia|id|il|in|ks|ky|la|ma|md|me|mi|mn|mo|ms|mt|nc|nd|ne|nh|nj|nm|nv|ny|oh|ok|or|pa|ri|sc|sd|tn|tx|ut|va|vt|wa|wi|wv|wy))\.(?:png|webp)$/u.test(portable))) throw new FlagResizerError(`The managed manifest contains an invalid ${entry.kind} path: ${entry.relativePath}.`);
+}
+function managedFile(target, root, kind) {
+	const entry = {
+		root: path.resolve(root),
+		relativePath: path.relative(path.resolve(root), path.resolve(target)),
+		kind
+	};
+	assertSafeManagedFile(entry);
+	return entry;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseManifest(value) {
+	if (!isRecord(value) || value["version"] !== MANIFEST_VERSION || !isRecord(value["profiles"])) throw new FlagResizerError("The managed manifest has an unsupported or invalid structure.");
+	const profiles = {};
+	for (const [profileName, profileValue] of Object.entries(value["profiles"])) {
+		if (!isRecord(profileValue) || !Array.isArray(profileValue["files"])) throw new FlagResizerError(`The manifest entry for profile "${profileName}" is invalid.`);
+		profiles[profileName] = { files: profileValue["files"].map((file) => {
+			if (!isRecord(file) || typeof file["root"] !== "string" || typeof file["relativePath"] !== "string" || ![
+				"attribution",
+				"image",
+				"license",
+				"typescript"
+			].includes(String(file["kind"]))) throw new FlagResizerError(`The manifest contains an invalid file owned by profile "${profileName}".`);
+			const entry = {
+				root: file["root"],
+				relativePath: file["relativePath"],
+				kind: file["kind"]
+			};
+			assertSafeManagedFile(entry);
+			return entry;
+		}) };
+	}
+	return {
+		version: MANIFEST_VERSION,
+		profiles
+	};
+}
+async function pathExists(file) {
+	try {
+		await access(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function readManifest(file) {
+	try {
+		return parseManifest(JSON.parse(await readFile(file, "utf8")));
+	} catch (error) {
+		if (isRecord(error) && error["code"] === "ENOENT") return emptyManifest();
+		if (error instanceof FlagResizerError) throw error;
+		throw new FlagResizerError(`Unable to read managed manifest ${file}.`, { cause: error });
+	}
+}
+function resolveConcurrency(value) {
+	if (value !== void 0 && (!Number.isInteger(value) || value < 1)) throw new FlagResizerError("concurrency must be a positive integer.");
+	return value ?? Math.max(1, Math.min(8, availableParallelism()));
+}
+async function runBounded(items, concurrency, worker) {
+	let nextIndex = 0;
+	async function runWorker() {
+		while (nextIndex < items.length) {
+			const index = nextIndex;
+			nextIndex += 1;
+			const item = items[index];
+			if (item) await worker(item, index);
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(concurrency, Math.max(1, items.length)) }, runWorker));
+}
+function svgDensity(width, height) {
+	const scale = Math.max(width, height) / 36;
+	return Math.max(72, Math.ceil(scale * 72));
+}
+async function createImage(svg, width, height, format, quality) {
+	const pipeline = sharp(svg, { density: svgDensity(width, height) }).resize(width, height, {
+		fit: "cover",
+		position: "centre"
+	}).ensureAlpha();
+	if (format === "png") return pipeline.png({
+		quality,
+		compressionLevel: 9,
+		adaptiveFiltering: true,
+		effort: 7
+	}).toBuffer();
+	return pipeline.webp({
+		quality,
+		effort: 4
+	}).toBuffer();
+}
+function addProfileFile(filesByProfile, profileName, entry) {
+	const entries = filesByProfile.get(profileName) ?? [];
+	entries.push(entry);
+	filesByProfile.set(profileName, entries);
+}
+function createGenerationPlan(profiles) {
+	const taskByTarget = /* @__PURE__ */ new Map();
+	const filesByProfile = /* @__PURE__ */ new Map();
+	const imageCountByProfile = /* @__PURE__ */ new Map();
+	const svgCache = /* @__PURE__ */ new Map();
+	let attributionContent;
+	let licenseContent;
+	const readSvg = (code) => {
+		let content = svgCache.get(code);
+		if (!content) {
+			content = readFile(path.join(FLAGS_DIRECTORY, `${code}.svg`));
+			svgCache.set(code, content);
+		}
+		return content;
+	};
+	const register = (profileName, entry, image, createContent) => {
+		const target = entryTarget(entry);
+		if (!taskByTarget.has(target)) taskByTarget.set(target, {
+			entry,
+			target,
+			image,
+			createContent
+		});
+		addProfileFile(filesByProfile, profileName, entry);
+	};
+	for (const profile of profiles) {
+		const typeScriptEntry = managedFile(profile.output.ts, path.dirname(profile.output.ts), "typescript");
+		register(profile.name, typeScriptEntry, false, () => Promise.resolve(Buffer.from(createTypeScriptManifest(profile))));
+		let imageCount = 0;
+		for (const format of profile.formats) {
+			const output = profile.output[format];
+			if (!output) throw new FlagResizerError(`Profile "${profile.name}" has no resolved output for ${format}.`);
+			const attributionEntry = managedFile(path.join(output.dir, "ATTRIBUTION.txt"), output.dir, "attribution");
+			register(profile.name, attributionEntry, false, () => {
+				attributionContent ??= readFile(ATTRIBUTION_FILE);
+				return attributionContent;
+			});
+			const licenseEntry = managedFile(path.join(output.dir, "LICENSE-GRAPHICS"), output.dir, "license");
+			register(profile.name, licenseEntry, false, () => {
+				licenseContent ??= readFile(GRAPHICS_LICENSE_FILE);
+				return licenseContent;
+			});
+			for (const [width, height] of profile.sizes) for (const code of profile.countries) {
+				const entry = managedFile(path.join(output.dir, `${width}x${height}`, `${code}.${format}`), output.dir, "image");
+				register(profile.name, entry, true, async () => createImage(await readSvg(code), width, height, format, profile.quality));
+				imageCount += 1;
+			}
+		}
+		imageCountByProfile.set(profile.name, imageCount);
+	}
+	return {
+		tasks: [...taskByTarget.values()].sort((left, right) => left.target.localeCompare(right.target)),
+		filesByProfile,
+		imageCountByProfile
+	};
+}
+async function buffersEqual(file, expected) {
+	try {
+		if ((await stat(file)).size !== expected.byteLength) return false;
+		return (await readFile(file)).equals(expected);
+	} catch (error) {
+		if (isRecord(error) && error["code"] === "ENOENT") return false;
+		throw error;
+	}
+}
+async function writeStagedFile(target, staged) {
+	await mkdir(path.dirname(target), { recursive: true });
+	const temporaryTarget = path.join(path.dirname(target), `.${path.basename(target)}.${process.pid}.${randomUUID()}.tmp`);
+	try {
+		await copyFile(staged, temporaryTarget);
+		await rename(temporaryTarget, target);
+	} finally {
+		await rm(temporaryTarget, { force: true });
+	}
+}
+async function writeAtomic(target, content) {
+	await mkdir(path.dirname(target), { recursive: true });
+	const temporaryTarget = path.join(path.dirname(target), `.${path.basename(target)}.${process.pid}.${randomUUID()}.tmp`);
+	try {
+		await writeFile(temporaryTarget, content);
+		await rename(temporaryTarget, target);
+	} finally {
+		await rm(temporaryTarget, { force: true });
+	}
+}
+async function removeEmptyParents(start, root) {
+	let directory = path.resolve(start);
+	const resolvedRoot = path.resolve(root);
+	while (directory !== resolvedRoot) {
+		const relative = path.relative(resolvedRoot, directory);
+		if (relative === ".." || relative.startsWith(`..${path.sep}`)) return;
+		try {
+			await rmdir(directory);
+		} catch {
+			return;
+		}
+		directory = path.dirname(directory);
+	}
+}
+async function pruneFile(entry) {
+	assertSafeManagedFile(entry);
+	const target = entryTarget(entry);
+	try {
+		await unlink(target);
+		await removeEmptyParents(path.dirname(target), entry.root);
+		return true;
+	} catch (error) {
+		if (isRecord(error) && error["code"] === "ENOENT") return false;
+		throw new FlagResizerError(`Unable to remove stale generated file ${target}.`, { cause: error });
+	}
+}
+function sortedManifest(manifest) {
+	return {
+		version: MANIFEST_VERSION,
+		profiles: Object.fromEntries(Object.entries(manifest.profiles).sort(([left], [right]) => left.localeCompare(right)).map(([profileName, profile]) => [profileName, { files: [...profile.files].sort((left, right) => entryTarget(left).localeCompare(entryTarget(right))) }]))
+	};
+}
+function nextManifest(previous, plan, selectedProfiles, fullRun) {
+	const profiles = fullRun ? {} : { ...previous.profiles };
+	for (const profile of selectedProfiles) profiles[profile.name] = { files: plan.filesByProfile.get(profile.name) ?? [] };
+	return sortedManifest({
+		version: MANIFEST_VERSION,
+		profiles
+	});
+}
+function staleEntries(previous, next) {
+	const retainedTargets = new Set(Object.values(next.profiles).flatMap((profile) => profile.files.map(entryKey)));
+	const stale = /* @__PURE__ */ new Map();
+	for (const profile of Object.values(previous.profiles)) for (const entry of profile.files) {
+		const target = entryKey(entry);
+		if (!retainedTargets.has(target)) stale.set(target, entry);
+	}
+	return [...stale.values()];
+}
+function removedOwnershipCount(previous, next, profileName) {
+	const nextFiles = new Set((next.profiles[profileName]?.files ?? []).map(entryKey));
+	return (previous.profiles[profileName]?.files ?? []).filter((entry) => !nextFiles.has(entryKey(entry))).length;
+}
+async function generate(options = {}) {
+	const started = performance.now();
+	const concurrency = resolveConcurrency(options.concurrency);
+	const resolved = await resolveConfiguration(options);
+	const manifestFile = path.join(resolved.baseDir, ".flag-resizer", "manifest.json");
+	const previousManifest = await readManifest(manifestFile);
+	const plan = createGenerationPlan(resolved.profiles);
+	const fullRun = !options.profiles || options.profiles.length === 0;
+	const manifest = nextManifest(previousManifest, plan, resolved.profiles, fullRun);
+	const stale = staleEntries(previousManifest, manifest);
+	const statuses = /* @__PURE__ */ new Map();
+	const dryRun = options.dryRun ?? false;
+	if (dryRun) await runBounded(plan.tasks, concurrency, async (task) => {
+		statuses.set(task.target, await pathExists(task.target) ? "updated" : "created");
+	});
+	else {
+		const stagingDirectory = await mkdtemp(path.join(os.tmpdir(), "flag-resizer-"));
+		const stagedFiles = /* @__PURE__ */ new Map();
+		try {
+			await runBounded(plan.tasks, concurrency, async (task, index) => {
+				const content = await task.createContent();
+				const exists = await pathExists(task.target);
+				if (exists && await buffersEqual(task.target, content)) {
+					statuses.set(task.target, "unchanged");
+					return;
+				}
+				statuses.set(task.target, exists ? "updated" : "created");
+				const staged = path.join(stagingDirectory, String(index));
+				await writeFile(staged, content);
+				stagedFiles.set(task.target, staged);
+			});
+			for (const task of plan.tasks) {
+				const staged = stagedFiles.get(task.target);
+				if (staged) await writeStagedFile(task.target, staged);
+			}
+			for (const entry of stale) await pruneFile(entry);
+			await writeAtomic(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`);
+		} catch (error) {
+			throw new FlagResizerError("Flag generation failed before the manifest was committed.", { cause: error });
+		} finally {
+			await rm(stagingDirectory, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	const profiles = resolved.profiles.map((profile) => {
+		const entries = plan.filesByProfile.get(profile.name) ?? [];
+		const counts = {
+			created: 0,
+			updated: 0,
+			unchanged: 0
+		};
+		for (const entry of entries) {
+			const status = statuses.get(entryTarget(entry));
+			if (status) counts[status] += 1;
+		}
+		return {
+			name: profile.name,
+			countries: profile.countries.length,
+			images: plan.imageCountByProfile.get(profile.name) ?? 0,
+			sizes: profile.sizes,
+			formats: profile.formats,
+			outputDirectories: Object.fromEntries(profile.formats.map((format) => [format, profile.output[format]?.dir])),
+			...counts,
+			removed: removedOwnershipCount(previousManifest, manifest, profile.name),
+			typeScriptFile: profile.output.ts
+		};
+	});
+	return {
+		dryRun,
+		durationMs: Math.round(performance.now() - started),
+		...resolved.configFile ? { configFile: resolved.configFile } : {},
+		manifestFile,
+		profiles
+	};
+}
+//#endregion
+export { FLAGS as a, COUNTRY_CODES as i, defineConfig as n, FlagResizerError as r, generate as t };
+
+//# sourceMappingURL=generator.js.map