@code-plate/iran-cities 1.1.0 → 2.0.0

package/dist/changes-B-wz9-Gy.cjs

@@ -0,0 +1,841 @@
+// src/keyboard.ts
+const LATIN_TO_PERSIAN = {
+	q: "ض",
+	w: "ص",
+	e: "ث",
+	r: "ق",
+	t: "ف",
+	y: "غ",
+	u: "ع",
+	i: "ه",
+	o: "خ",
+	p: "ح",
+	"[": "ج",
+	"]": "چ",
+	a: "ش",
+	s: "س",
+	d: "ی",
+	f: "ب",
+	g: "ل",
+	h: "ا",
+	j: "ت",
+	k: "ن",
+	l: "م",
+	";": "ک",
+	"'": "گ",
+	z: "ظ",
+	x: "ط",
+	c: "ز",
+	v: "ر",
+	b: "ذ",
+	n: "د",
+	m: "پ",
+	",": "و",
+	"\\": "پ",
+	"`": "پ",
+	C: "ژ",
+	H: "آ"
+};
+const PERSIAN_TO_LATIN = (() => {
+	const map = {};
+	for (const [latin, persian] of Object.entries(LATIN_TO_PERSIAN)) if (!(persian in map)) map[persian] = latin.toLowerCase();
+	map["ي"] = "d";
+	map["ك"] = ";";
+	map["ئ"] = "m";
+	return map;
+})();
+const HAS_LATIN_LETTER = /[a-z]/i;
+const HAS_PERSIAN_LETTER = /[؀-ۿ]/;
+function convertKeyboardLayout(text, to) {
+	const input = typeof text === "string" ? text : "";
+	let out = "";
+	for (const ch of input) if (to === "fa") {
+		var _ref, _LATIN_TO_PERSIAN$ch;
+		out += (_ref = (_LATIN_TO_PERSIAN$ch = LATIN_TO_PERSIAN[ch]) !== null && _LATIN_TO_PERSIAN$ch !== void 0 ? _LATIN_TO_PERSIAN$ch : LATIN_TO_PERSIAN[ch.toLowerCase()]) !== null && _ref !== void 0 ? _ref : ch;
+	} else {
+		var _PERSIAN_TO_LATIN$ch;
+		out += (_PERSIAN_TO_LATIN$ch = PERSIAN_TO_LATIN[ch]) !== null && _PERSIAN_TO_LATIN$ch !== void 0 ? _PERSIAN_TO_LATIN$ch : ch;
+	}
+	return out;
+}
+function guessKeyboardTarget(text) {
+	if (typeof text !== "string") return void 0;
+	const latin = HAS_LATIN_LETTER.test(text);
+	const persian = HAS_PERSIAN_LETTER.test(text);
+	if (latin && !persian) return "fa";
+	if (persian && !latin) return "en";
+}
+// src/normalize.ts
+const CHAR_MAP = {
+	"ي": "ی",
+	"ى": "ی",
+	"ئ": "ی",
+	"ك": "ک",
+	"ة": "ه",
+	"ۀ": "ه",
+	"ؤ": "و",
+	"أ": "ا",
+	"إ": "ا",
+	"آ": "ا",
+	"ٱ": "ا"
+};
+function normalize(input) {
+	return input.trim().toLowerCase().replace(/[۰-۹]/g, (d) => String(d.charCodeAt(0) - 1776)).replace(/[٠-٩]/g, (d) => String(d.charCodeAt(0) - 1632)).replace(/[ً-ٰٟـ]/g, "").replace(/[يىئكةۀؤأإآٱ]/g, (ch) => {
+		var _CHAR_MAP$ch;
+		return (_CHAR_MAP$ch = CHAR_MAP[ch]) !== null && _CHAR_MAP$ch !== void 0 ? _CHAR_MAP$ch : ch;
+	}).replace(/[‌‍\s\-_'’`]+/g, "");
+}
+// src/core.ts
+const LATIN = /[a-z]/;
+const LOWERCASE_WORDS = /* @__PURE__ */ new Set([
+	"va",
+	"and",
+	"o"
+]);
+function displayNameFromSlug(slug) {
+	const parts = slug.split("-").filter(Boolean);
+	let out = "";
+	for (const part of parts) {
+		if ((part === "e" || part === "ye") && out) {
+			out += `-${part}`;
+			continue;
+		}
+		const word = LOWERCASE_WORDS.has(part) && out ? part : part.charAt(0).toUpperCase() + part.slice(1);
+		out += out ? ` ${word}` : word;
+	}
+	return out;
+}
+function toText(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	return "";
+}
+function isPresent(value) {
+	return value !== void 0 && value !== null && toText(value).trim() !== "";
+}
+function boundedLevenshtein(a, b, max) {
+	if (a === b) return 0;
+	if (Math.abs(a.length - b.length) > max) return max + 1;
+	if (a.length === 0) return b.length;
+	if (b.length === 0) return a.length;
+	let prev = [];
+	for (let j = 0; j <= b.length; j++) prev.push(j);
+	for (let i = 1; i <= a.length; i++) {
+		const curr = [i];
+		let rowMin = i;
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+			const value = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+			curr.push(value);
+			if (value < rowMin) rowMin = value;
+		}
+		if (rowMin > max) return max + 1;
+		prev = curr;
+	}
+	return prev[b.length];
+}
+function matchScore(query, target, fuzzy, maxDistance) {
+	if (!target) return 1e400;
+	if (target === query) return 0;
+	if (target.startsWith(query)) return 1;
+	if (target.includes(query)) return 2;
+	if (!fuzzy) return 1e400;
+	let best = 1e400;
+	const full = boundedLevenshtein(query, target, maxDistance);
+	if (full <= maxDistance) best = 3 + full;
+	if (query.length >= 3 && target.length > query.length) for (const len of [
+		query.length - 1,
+		query.length,
+		query.length + 1
+	]) {
+		if (len < 1 || len >= target.length) continue;
+		const prefix = boundedLevenshtein(query, target.slice(0, len), maxDistance);
+		if (prefix <= maxDistance) best = Math.min(best, 3.5 + prefix);
+	}
+	return best;
+}
+function deepFreeze(value) {
+	if (value && typeof value === "object" && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const key of Object.keys(value)) deepFreeze(value[key]);
+	}
+	return value;
+}
+function createCollator() {
+	try {
+		return new Intl.Collator("fa").compare;
+	} catch {
+		return (a, b) => a < b ? -1 : a > b ? 1 : 0;
+	}
+}
+function pickPreferred(list, primaryIds) {
+	var _ref, _list$find;
+	return (_ref = (_list$find = list.find((c) => c.isCapital)) !== null && _list$find !== void 0 ? _list$find : list.find((c) => primaryIds.has(c.id))) !== null && _ref !== void 0 ? _ref : list.reduce((a, b) => b.id < a.id ? b : a);
+}
+function pushTo(map, key, value) {
+	const list = map.get(key);
+	if (!list) map.set(key, [value]);
+	else if (!list.includes(value)) list.push(value);
+}
+function cityKeys(city) {
+	const keys = [{
+		value: normalize(city.en),
+		locale: "en"
+	}, {
+		value: normalize(city.fa),
+		locale: "fa"
+	}];
+	for (const alias of city.aliases) keys.push({
+		value: normalize(alias),
+		locale: LATIN.test(alias.toLowerCase()) ? "en" : "fa"
+	});
+	return keys;
+}
+function createApi(rawData) {
+	const compare = createCollator();
+	const primaryIds = /* @__PURE__ */ new Set();
+	const legacySlugs = [];
+	const provinces = rawData.map((p) => {
+		const provinceEn = p["province-en"];
+		return {
+			id: p["province-id"],
+			en: provinceEn,
+			fa: p["province-fa"],
+			nameEn: p["name-en"],
+			phoneCode: p["phone-code"],
+			capitalId: p["capital-city-id"],
+			neighborIds: [...p.neighbors],
+			cities: p.cities.map((c) => {
+				var _c$legacySlugs, _c$nameEn;
+				if (c.primary) primaryIds.add(c["city-id"]);
+				for (const slug of (_c$legacySlugs = c["legacy-slugs"]) !== null && _c$legacySlugs !== void 0 ? _c$legacySlugs : []) legacySlugs.push([slug, c["city-id"]]);
+				const city = {
+					id: c["city-id"],
+					isCapital: c["city-id"] === p["capital-city-id"],
+					en: c["city-en"],
+					fa: c["city-fa"],
+					nameEn: (_c$nameEn = c["name-en"]) !== null && _c$nameEn !== void 0 ? _c$nameEn : displayNameFromSlug(c["city-en"]),
+					slug: `${provinceEn}/${c["city-en"]}`,
+					aliases: c.aliases ? [...c.aliases] : []
+				};
+				if (typeof c.lat === "number" && typeof c.lng === "number") {
+					var _c$coordConfidence;
+					city.coordinates = {
+						lat: c.lat,
+						lng: c.lng,
+						confidence: (_c$coordConfidence = c["coord-confidence"]) !== null && _c$coordConfidence !== void 0 ? _c$coordConfidence : "high"
+					};
+				}
+				return city;
+			})
+		};
+	});
+	const flatCities = [];
+	const cityBySlug = /* @__PURE__ */ new Map();
+	const cityById = /* @__PURE__ */ new Map();
+	const provinceById = /* @__PURE__ */ new Map();
+	const provinceByPhoneCode = /* @__PURE__ */ new Map();
+	const provinceByNormKey = /* @__PURE__ */ new Map();
+	const citiesByNormKey = /* @__PURE__ */ new Map();
+	const searchableCities = [];
+	const searchableProvinces = [];
+	for (const p of provinces) {
+		provinceById.set(p.id, p);
+		provinceByPhoneCode.set(p.phoneCode, p);
+		const pKeys = [{
+			value: normalize(p.en),
+			locale: "en"
+		}, {
+			value: normalize(p.fa),
+			locale: "fa"
+		}];
+		for (const k of pKeys) if (!provinceByNormKey.has(k.value)) provinceByNormKey.set(k.value, p);
+		searchableProvinces.push({
+			item: p,
+			keys: pKeys,
+			isCapital: false,
+			rank: 0
+		});
+		for (const c of p.cities) {
+			const flat = {
+				...c,
+				provinceId: p.id,
+				provinceEn: p.en,
+				provinceFa: p.fa,
+				provinceNameEn: p.nameEn,
+				phoneCode: p.phoneCode
+			};
+			flatCities.push(flat);
+			cityBySlug.set(flat.slug, flat);
+			cityById.set(flat.id, flat);
+			const keys = cityKeys(flat);
+			for (const k of keys) pushTo(citiesByNormKey, k.value, flat);
+			searchableCities.push({
+				item: flat,
+				keys,
+				isCapital: flat.isCapital,
+				rank: 0
+			});
+		}
+	}
+	for (const [slug, id] of legacySlugs) {
+		const flat = cityById.get(id);
+		if (flat && !cityBySlug.has(slug)) cityBySlug.set(slug, flat);
+	}
+	const cityByNormKey = /* @__PURE__ */ new Map();
+	for (const [key, list] of citiesByNormKey) {
+		list.sort((a, b) => a.id - b.id);
+		cityByNormKey.set(key, pickPreferred(list, primaryIds));
+	}
+	[...searchableCities].sort((a, b) => compare(a.item.fa, b.item.fa) || a.item.id - b.item.id).forEach((entry, index) => {
+		entry.rank = index;
+	});
+	[...searchableProvinces].sort((a, b) => compare(a.item.fa, b.item.fa) || a.item.id - b.item.id).forEach((entry, index) => {
+		entry.rank = index;
+	});
+	const capitals = provinces.map((p) => cityById.get(p.capitalId));
+	const stats = {
+		provinceCount: provinces.length,
+		cityCount: flatCities.length
+	};
+	deepFreeze(provinces);
+	deepFreeze(flatCities);
+	deepFreeze(capitals);
+	deepFreeze(stats);
+	for (const list of citiesByNormKey.values()) Object.freeze(list);
+	const emptyCities = Object.freeze([]);
+	const emptyCityList = Object.freeze([]);
+	function rankedSearch(pool, query, options) {
+		const opts = options !== null && options !== void 0 ? options : {};
+		const text = toText(query);
+		const q = normalize(text);
+		const target = opts.keyboardFix === false || !q ? void 0 : guessKeyboardTarget(text);
+		const converted = target ? normalize(convertKeyboardLayout(text, target)) : "";
+		if (!converted || converted === q) return rankedSearchOnce(pool, q, opts);
+		const convertedOptions = {
+			...opts,
+			locale: target,
+			emptyQuery: "none"
+		};
+		if (rankedSearchOnce(pool, q, {
+			...opts,
+			fuzzy: false,
+			limit: 1
+		}).length > 0) return rankedSearchOnce(pool, q, opts);
+		if (rankedSearchOnce(pool, converted, {
+			...convertedOptions,
+			fuzzy: false,
+			limit: 1
+		}).length > 0) return rankedSearchOnce(pool, converted, convertedOptions);
+		const fuzzyResults = rankedSearchOnce(pool, q, opts);
+		return fuzzyResults.length > 0 ? fuzzyResults : rankedSearchOnce(pool, converted, convertedOptions);
+	}
+	function rankedSearchOnce(pool, q, opts) {
+		var _opts$locale, _opts$fuzzy;
+		const limit = typeof opts.limit === "number" && opts.limit > 0 ? Math.floor(opts.limit) : void 0;
+		if (!q) {
+			if (opts.emptyQuery === "none") return [];
+			const all = pool.map((e) => e.item);
+			return limit ? all.slice(0, limit) : all;
+		}
+		const locale = (_opts$locale = opts.locale) !== null && _opts$locale !== void 0 ? _opts$locale : "both";
+		const fuzzy = (_opts$fuzzy = opts.fuzzy) !== null && _opts$fuzzy !== void 0 ? _opts$fuzzy : false;
+		const requested = typeof opts.maxDistance === "number" && opts.maxDistance >= 0 ? Math.floor(opts.maxDistance) : 2;
+		const maxDistance = Math.min(requested, Math.floor(q.length / 3));
+		const scored = [];
+		for (const entry of pool) {
+			let score = 1e400;
+			for (const key of entry.keys) {
+				if (locale !== "both" && key.locale !== locale) continue;
+				score = Math.min(score, matchScore(q, key.value, fuzzy, maxDistance));
+				if (score === 0) break;
+			}
+			if (score !== 1e400) scored.push({
+				entry,
+				score
+			});
+		}
+		scored.sort((a, b) => a.score - b.score || Number(b.entry.isCapital) - Number(a.entry.isCapital) || a.entry.rank - b.entry.rank);
+		const results = scored.map((s) => s.entry.item);
+		return limit ? results.slice(0, limit) : results;
+	}
+	function asId(query) {
+		if (typeof query === "number") return Number.isInteger(query) ? query : void 0;
+		const t = normalize(toText(query));
+		return /^\d+$/.test(t) ? Number(t) : void 0;
+	}
+	function cityMatches(city, key) {
+		return normalize(city.en) === key || normalize(city.fa) === key || city.aliases.some((a) => normalize(a) === key);
+	}
+	function getProvinces() {
+		return provinces;
+	}
+	function getProvincesList() {
+		return provinces.map((p) => ({
+			id: p.id,
+			en: p.en,
+			fa: p.fa,
+			nameEn: p.nameEn,
+			phoneCode: p.phoneCode,
+			capitalId: p.capitalId
+		}));
+	}
+	function getProvinceById(id) {
+		return provinceById.get(Number(id));
+	}
+	function getProvince(query) {
+		if (!isPresent(query)) return void 0;
+		const id = asId(query);
+		if (id !== void 0) return provinceById.get(id);
+		return provinceByNormKey.get(normalize(toText(query)));
+	}
+	function getCities(provinceQuery) {
+		var _getProvince$cities, _getProvince;
+		return (_getProvince$cities = (_getProvince = getProvince(provinceQuery)) === null || _getProvince === void 0 ? void 0 : _getProvince.cities) !== null && _getProvince$cities !== void 0 ? _getProvince$cities : emptyCityList;
+	}
+	function getAllCities() {
+		return flatCities;
+	}
+	function getCityById(id) {
+		return cityById.get(Number(id));
+	}
+	function getCityBySlug(slug) {
+		return cityBySlug.get(toText(slug).trim());
+	}
+	function getCity(cityQuery, provinceQuery) {
+		if (!isPresent(cityQuery)) return void 0;
+		const cityId = asId(cityQuery);
+		if (isPresent(provinceQuery)) {
+			const province = getProvince(provinceQuery);
+			if (!province) return void 0;
+			const key = cityId === void 0 ? normalize(toText(cityQuery)) : "";
+			const city = province.cities.find((c) => cityId !== void 0 ? c.id === cityId : cityMatches(c, key));
+			return city ? cityById.get(city.id) : void 0;
+		}
+		if (cityId !== void 0) return cityById.get(cityId);
+		return cityByNormKey.get(normalize(toText(cityQuery)));
+	}
+	function getCitiesByName(cityQuery) {
+		const key = normalize(toText(cityQuery));
+		return key && citiesByNormKey.get(key) || emptyCities;
+	}
+	function isAmbiguousCityName(cityQuery) {
+		return getCitiesByName(cityQuery).length > 1;
+	}
+	function getProvinceOfCity(cityQuery) {
+		const city = getCity(cityQuery);
+		return city ? provinceById.get(city.provinceId) : void 0;
+	}
+	function getCapital(provinceQuery) {
+		const p = getProvince(provinceQuery);
+		return p ? cityById.get(p.capitalId) : void 0;
+	}
+	function getCapitals() {
+		return capitals.slice();
+	}
+	function getProvinceByPhoneCode(code) {
+		let digits = normalize(toText(code)).replace(/^\+/, "").replace(/^0+/, "");
+		if (digits.length > 2 && digits.startsWith("98")) digits = digits.slice(2).replace(/^0+/, "");
+		if (!/^\d+$/.test(digits)) return void 0;
+		return provinceByPhoneCode.get(`0${digits}`);
+	}
+	function searchProvinces(query, options) {
+		return rankedSearch(searchableProvinces, query, options);
+	}
+	function searchCities(query, options) {
+		return rankedSearch(searchableCities, query, options);
+	}
+	function getNeighborProvinces(provinceQuery) {
+		const province = getProvince(provinceQuery);
+		if (!province) return [];
+		return province.neighborIds.map((id) => provinceById.get(id));
+	}
+	function areNeighborProvinces(a, b) {
+		const first = getProvince(a);
+		const second = getProvince(b);
+		return !!first && !!second && first.neighborIds.includes(second.id);
+	}
+	function getStats() {
+		return stats;
+	}
+	return {
+		getProvinces,
+		getProvincesList,
+		getProvinceById,
+		getProvince,
+		getCities,
+		getAllCities,
+		getCityById,
+		getCityBySlug,
+		getCity,
+		getCitiesByName,
+		isAmbiguousCityName,
+		getProvinceOfCity,
+		getCapital,
+		getCapitals,
+		getProvinceByPhoneCode,
+		searchProvinces,
+		searchCities,
+		getNeighborProvinces,
+		areNeighborProvinces,
+		getStats
+	};
+}
+// src/packed.ts
+const SCALE = 1e7;
+const CONFIDENCE = {
+	"1": "high",
+	"2": "medium",
+	"3": "low"
+};
+function unpack(packed) {
+	if (packed.format !== 1) throw new Error(`Unsupported data format ${packed.format}`);
+	const en = packed.en.split("|");
+	const fa = packed.fa.split("|");
+	const extras = /* @__PURE__ */ new Map();
+	for (const extra of packed.extras) extras.set(extra[0], extra);
+	let id = 0;
+	let lat = 0;
+	let lng = 0;
+	let coordIndex = 0;
+	let cityIndex = 0;
+	return packed.provinces.map(([provinceId, provinceEn, provinceFa, phoneCode, capitalId, nameEn, neighbors, count]) => {
+		const cities = [];
+		for (let n = 0; n < count; n++, cityIndex++) {
+			var _packed$confidence;
+			id += packed.ids[cityIndex];
+			const city = {
+				"city-id": id,
+				"city-en": en[cityIndex],
+				"city-fa": fa[cityIndex]
+			};
+			const code = (_packed$confidence = packed.confidence) === null || _packed$confidence === void 0 ? void 0 : _packed$confidence.charAt(cityIndex);
+			if (code && code !== "0" && packed.lat && packed.lng) {
+				lat += packed.lat[coordIndex];
+				lng += packed.lng[coordIndex];
+				coordIndex++;
+				city.lat = lat / SCALE;
+				city.lng = lng / SCALE;
+				const confidence = CONFIDENCE[code];
+				if (confidence && confidence !== "high") city["coord-confidence"] = confidence;
+			}
+			const extra = extras.get(cityIndex);
+			if (extra) {
+				if (extra[1]) city["name-en"] = extra[1];
+				if (extra[2]) city.aliases = extra[2];
+				if (extra[3]) city.primary = true;
+				if (extra[4]) city["legacy-slugs"] = extra[4];
+			}
+			cities.push(city);
+		}
+		return {
+			"province-id": provinceId,
+			"province-en": provinceEn,
+			"province-fa": provinceFa,
+			"phone-code": phoneCode,
+			"capital-city-id": capitalId,
+			"name-en": nameEn,
+			neighbors,
+			cities
+		};
+	});
+}
+// src/changes.ts
+const DATA_VERSION = "2.0.0";
+const DATA_CHANGES = Object.freeze([
+	Object.freeze({
+		version: "1.2.0",
+		type: "removed",
+		provinceId: 20,
+		before: Object.freeze({ fa: "گلوگاه" }),
+		note: "Duplicate entry of Galugah in Mazandaran removed; the remaining entry keeps the city."
+	}),
+	Object.freeze({
+		version: "1.2.0",
+		type: "renamed",
+		cityId: 402,
+		before: Object.freeze({
+			en: "sowme'eh-sara",
+			slug: "gilan/sowme'eh-sara"
+		}),
+		after: Object.freeze({
+			en: "sowmeeh-sara",
+			fa: "صومعه سرا",
+			slug: "gilan/sowmeeh-sara"
+		}),
+		note: "English id normalized to kebab-case; the old id still resolves."
+	}),
+	Object.freeze({
+		version: "1.2.0",
+		type: "renamed",
+		cityId: 672,
+		before: Object.freeze({
+			en: "هلشی",
+			slug: "kermanshah/هلشی"
+		}),
+		after: Object.freeze({
+			en: "halashi",
+			fa: "هلشی",
+			slug: "kermanshah/halashi"
+		}),
+		note: "English id was a Persian string; the old id still resolves."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 145,
+		before: Object.freeze({ fa: "كليبر" }),
+		after: Object.freeze({ fa: "کلیبر" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 147,
+		before: Object.freeze({ fa: "صوفيان" }),
+		after: Object.freeze({ fa: "صوفیان" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 152,
+		before: Object.freeze({ fa: "كلوانق" }),
+		after: Object.freeze({ fa: "کلوانق" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 418,
+		before: Object.freeze({ fa: "لوندويل" }),
+		after: Object.freeze({ fa: "لوندویل" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 438,
+		before: Object.freeze({ fa: "ليسار" }),
+		after: Object.freeze({ fa: "لیسار" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 487,
+		before: Object.freeze({ fa: "مريانج" }),
+		after: Object.freeze({ fa: "مریانج" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 529,
+		before: Object.freeze({ fa: "تازيان پايين" }),
+		after: Object.freeze({ fa: "تازیان پایین" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 545,
+		before: Object.freeze({ fa: "كوخرد" }),
+		after: Object.freeze({ fa: "کوخرد" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 551,
+		before: Object.freeze({ fa: "اركواز" }),
+		after: Object.freeze({ fa: "ارکواز" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 564,
+		before: Object.freeze({ fa: "موسيان" }),
+		after: Object.freeze({ fa: "موسیان" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 714,
+		before: Object.freeze({ fa: "چويبده" }),
+		after: Object.freeze({ fa: "چویبده" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 716,
+		before: Object.freeze({ fa: "صيدون" }),
+		after: Object.freeze({ fa: "صیدون" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 749,
+		before: Object.freeze({ fa: "گلگير" }),
+		after: Object.freeze({ fa: "گلگیر" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 910,
+		before: Object.freeze({ fa: "پايين هولار" }),
+		after: Object.freeze({ fa: "پایین هولار" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 947,
+		before: Object.freeze({ fa: "اسفرورين" }),
+		after: Object.freeze({ fa: "اسفرورین" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1025,
+		before: Object.freeze({ fa: "كدكن" }),
+		after: Object.freeze({ fa: "کدکن" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1077,
+		before: Object.freeze({ fa: "گلمورتي" }),
+		after: Object.freeze({ fa: "گلمورتی" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1107,
+		before: Object.freeze({ fa: "آيسک" }),
+		after: Object.freeze({ fa: "آیسک" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1114,
+		before: Object.freeze({ fa: "طبس مسينا" }),
+		after: Object.freeze({ fa: "طبس مسینا" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1199,
+		before: Object.freeze({ fa: "ايواوغلی" }),
+		after: Object.freeze({ fa: "ایواوغلی" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1209,
+		before: Object.freeze({ fa: "خليفان" }),
+		after: Object.freeze({ fa: "خلیفان" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1225,
+		before: Object.freeze({ fa: "بفروييه" }),
+		after: Object.freeze({ fa: "بفروییه" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1235,
+		before: Object.freeze({ fa: "قيدار" }),
+		after: Object.freeze({ fa: "قیدار" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1236,
+		before: Object.freeze({ fa: "هيدج" }),
+		after: Object.freeze({ fa: "هیدج" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	}),
+	Object.freeze({
+		version: "2.0.0",
+		type: "spelling",
+		cityId: 1237,
+		before: Object.freeze({ fa: "صائين قلعه" }),
+		after: Object.freeze({ fa: "صائین قلعه" }),
+		note: "Arabic letters replaced with Persian ی/ک."
+	})
+]);
+function compareVersions(a, b) {
+	const pa = a.split(".").map(Number);
+	const pb = b.split(".").map(Number);
+	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+		var _pa$i, _pb$i;
+		const diff = ((_pa$i = pa[i]) !== null && _pa$i !== void 0 ? _pa$i : 0) - ((_pb$i = pb[i]) !== null && _pb$i !== void 0 ? _pb$i : 0);
+		if (diff !== 0) return diff;
+	}
+	return 0;
+}
+function getDataChanges(sinceVersion) {
+	if (!sinceVersion) return DATA_CHANGES.slice();
+	return DATA_CHANGES.filter((change) => compareVersions(change.version, sinceVersion) > 0);
+}
+Object.defineProperty(exports, "DATA_CHANGES", {
+	enumerable: true,
+	get: function() {
+		return DATA_CHANGES;
+	}
+});
+Object.defineProperty(exports, "DATA_VERSION", {
+	enumerable: true,
+	get: function() {
+		return DATA_VERSION;
+	}
+});
+Object.defineProperty(exports, "convertKeyboardLayout", {
+	enumerable: true,
+	get: function() {
+		return convertKeyboardLayout;
+	}
+});
+Object.defineProperty(exports, "createApi", {
+	enumerable: true,
+	get: function() {
+		return createApi;
+	}
+});
+Object.defineProperty(exports, "getDataChanges", {
+	enumerable: true,
+	get: function() {
+		return getDataChanges;
+	}
+});
+Object.defineProperty(exports, "normalize", {
+	enumerable: true,
+	get: function() {
+		return normalize;
+	}
+});
+Object.defineProperty(exports, "unpack", {
+	enumerable: true,
+	get: function() {
+		return unpack;
+	}
+});
+
+//# sourceMappingURL=changes-B-wz9-Gy.cjs.map