@dualkit/convert 0.0.0-stage → 0.2.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,3368 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ConvertFailedError: () => ConvertFailedError,
+  OverlapError: () => OverlapError,
+  RefusedError: () => RefusedError,
+  UnsupportedError: () => UnsupportedError,
+  applyEdits: () => applyEdits,
+  branchFor: () => branchFor,
+  convert: () => convert,
+  detectProject: () => detectProject,
+  finish: () => finish,
+  problems: () => problems
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/edits.ts
+var OverlapError = class extends Error {
+  constructor(first, second) {
+    super(`edits overlap: [${first.start}, ${first.end}) and [${second.start}, ${second.end})`);
+    this.first = first;
+    this.second = second;
+    this.name = "OverlapError";
+  }
+  first;
+  second;
+};
+function checkBounds(text, edit) {
+  const span2 = `edit [${edit.start}, ${edit.end})`;
+  if (edit.end < edit.start) throw new RangeError(`${span2} ends before it starts`);
+  if (edit.start < 0 || edit.end > text.length) throw new RangeError(`${span2} is outside the text, which is ${text.length} characters long`);
+}
+function applyEdits(text, edits2) {
+  for (const edit of edits2) checkBounds(text, edit);
+  const ordered = edits2.map((edit, index) => ({ edit, index })).sort((a, b) => a.edit.start - b.edit.start || a.index - b.index).map((entry) => entry.edit);
+  for (let i = 1; i < ordered.length; i++) {
+    const prev = ordered[i - 1];
+    const next = ordered[i];
+    if (next.start < prev.end) throw new OverlapError(prev, next);
+  }
+  let out = "";
+  let cursor = 0;
+  for (const edit of ordered) {
+    out += text.slice(cursor, edit.start) + edit.text;
+    cursor = edit.end;
+  }
+  return out + text.slice(cursor);
+}
+
+// src/project.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_lint = require("@dualkit/lint");
+
+// src/guards.ts
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+
+// src/project.ts
+var UnsupportedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedError";
+  }
+};
+var SUPPORTED = "Next.js App Router and Vite React apps";
+var REFUSED = [
+  ["@remix-run/react", "Remix"],
+  ["@remix-run/dev", "Remix"],
+  ["react-scripts", "Create React App"],
+  ["vue", "Vue"],
+  ["svelte", "Svelte"],
+  ["@angular/core", "Angular"]
+];
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["package-lock.json", "npm"]
+];
+var ENTRY_NAMES = ["main", "index"];
+var EXTENSIONS = ["tsx", "jsx", "ts", "js"];
+var unsupported = (what) => new UnsupportedError(`Convert supports ${SUPPORTED}, not ${what}.`);
+function readDeps(root) {
+  const path = (0, import_node_path.join)(root, "package.json");
+  if (!(0, import_node_fs.existsSync)(path)) throw new UnsupportedError(`No package.json in ${root}. Convert supports ${SUPPORTED}.`);
+  let json2;
+  try {
+    json2 = JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+  } catch {
+    throw new UnsupportedError(`The package.json in ${root} is not valid JSON. Convert supports ${SUPPORTED}.`);
+  }
+  if (!isRecord(json2)) throw new UnsupportedError(`The package.json in ${root} must hold a JSON object. Convert supports ${SUPPORTED}.`);
+  const deps = {};
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    const list = json2[field];
+    if (isRecord(list)) Object.assign(deps, list);
+  }
+  return deps;
+}
+function withExtension(root, base) {
+  const ext = EXTENSIONS.find((e) => (0, import_node_fs.existsSync)((0, import_node_path.join)(root, `${base}.${e}`)));
+  return ext ? `${base}.${ext}` : null;
+}
+function nextLayout(root) {
+  for (const appDir of ["app", "src/app"]) {
+    const entry = withExtension(root, `${appDir}/[locale]/layout`) ?? withExtension(root, `${appDir}/layout`);
+    if (entry) return { appDir, entry };
+  }
+  const hasPages = ["pages", "src/pages"].some((d) => (0, import_node_fs.existsSync)((0, import_node_path.join)(root, d)));
+  throw new UnsupportedError(
+    hasPages ? `This Next.js app uses the Pages Router. Convert supports the App Router only, so there is no app/layout file to start from.` : `No root layout found in app or src/app. Convert supports the Next.js App Router and Vite React apps.`
+  );
+}
+function viteEntry(root) {
+  const candidates = ["src", "."].flatMap((dir) => ENTRY_NAMES.map((name) => dir === "." ? name : `${dir}/${name}`));
+  for (const base of candidates) {
+    const entry = withExtension(root, base);
+    if (entry && (0, import_node_fs.readFileSync)((0, import_node_path.join)(root, entry), "utf8").includes("createRoot")) return entry;
+  }
+  const src = (0, import_node_path.join)(root, "src");
+  const files = (0, import_node_fs.existsSync)(src) ? (0, import_node_fs.readdirSync)(src).filter((f) => /\.(tsx|jsx|ts|js)$/.test(f)) : [];
+  const found = files.find((f) => (0, import_node_fs.readFileSync)((0, import_node_path.join)(src, f), "utf8").includes("createRoot"));
+  if (found) return `src/${found}`;
+  throw new UnsupportedError(`No file calling createRoot found in this Vite app. Convert supports ${SUPPORTED}.`);
+}
+function detectPackageManager(root) {
+  for (let dir = root; ; dir = (0, import_node_path.dirname)(dir)) {
+    const hit = LOCKFILES.find(([file]) => (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, file)));
+    if (hit) return hit[1];
+    const top = (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, ".git")) || dir !== root && (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "package.json"));
+    if (top || (0, import_node_path.dirname)(dir) === dir) return "npm";
+  }
+}
+function detectI18n(deps) {
+  if ("next-intl" in deps) return "next-intl";
+  if ("react-i18next" in deps) return "react-i18next";
+  return null;
+}
+function detectProject(root) {
+  const deps = readDeps(root);
+  const refused = REFUSED.find(([name]) => name in deps);
+  if (refused) throw unsupported(refused[1]);
+  if (!("react" in deps)) throw new UnsupportedError(`This app does not use React. Convert supports ${SUPPORTED}.`);
+  const tailwind = (0, import_lint.createTailwindVersion)()((0, import_node_path.join)(root, "package.json"), root);
+  const common = { root, tailwind, i18n: detectI18n(deps), packageManager: detectPackageManager(root) };
+  if ("next" in deps) {
+    const { appDir, entry } = nextLayout(root);
+    return { ...common, framework: "next-app", appDir, entry };
+  }
+  if ("vite" in deps) return { ...common, framework: "vite-react", appDir: null, entry: viteEntry(root) };
+  throw new UnsupportedError(`This React app uses neither Next.js nor Vite. Convert supports ${SUPPORTED}.`);
+}
+
+// src/convert.ts
+var import_lint12 = require("@dualkit/lint");
+var import_node_path17 = require("path");
+
+// src/apply.ts
+var import_lint2 = require("@dualkit/lint");
+var import_node_fs6 = require("fs");
+var import_node_path7 = require("path");
+
+// src/generate/stylesheet.ts
+var import_rules = require("@dualkit/rules");
+var import_node_path2 = require("path");
+var FONT_URL = "https://fonts.googleapis.com/css2?family=IBM+Plex+Sans+Arabic:wght@400;500;600;700&display=swap";
+var SMALL_TEXT = [".text-xs", ".text-\\[10px\\]", ".text-\\[11px\\]", ".text-\\[12px\\]", ".text-\\[13px\\]"];
+function stylesheetPath(project) {
+  return project.appDir ? `${project.appDir}/dualkit.css` : "src/dualkit.css";
+}
+function dualkitCss(project) {
+  const blocks = [
+    `@import url('${FONT_URL}');`,
+    `:lang(ar) {
+  font-family: 'IBM Plex Sans Arabic', system-ui, sans-serif;
+  line-height: 1.7;
+}`,
+    ":lang(ar) * {\n  letter-spacing: 0;\n}"
+  ];
+  if (project.tailwind) {
+    const selectors = SMALL_TEXT.map((s) => `:lang(ar) ${s}`).join(", ");
+    blocks.push(`${selectors} {
+  font-size: ${import_rules.MIN_ARABIC_SIZE}px;
+}`);
+  }
+  blocks.push('[dir="rtl"] [data-dk-mirror] {\n  scale: -1 1;\n}');
+  blocks.push('[dir="rtl"] input[dir="ltr"]:placeholder-shown, [dir="rtl"] textarea[dir="ltr"]:placeholder-shown {\n  direction: rtl;\n}');
+  return blocks.join("\n\n") + "\n";
+}
+function specifier(entry, cssPath) {
+  const rel = import_node_path2.posix.relative(import_node_path2.posix.dirname(entry.path), cssPath);
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function importEdit(entry, cssPath) {
+  const block = entry.js[0];
+  if (!block) return null;
+  const spec = specifier(entry, cssPath);
+  const body = block.ast.program.body;
+  const imports = body.filter((node) => node.type === "ImportDeclaration");
+  if (imports.some((node) => node.source?.value === spec)) return null;
+  const statement = (at2) => `import '${spec}'${entry.text[at2 - 1] === ";" ? ";" : ""}`;
+  const after = imports.at(-1) ?? block.ast.program.directives.at(-1);
+  if (after) {
+    const at2 = block.offset + after.end;
+    return { start: at2, end: at2, text: `
+${statement(at2)}` };
+  }
+  return { start: block.offset, end: block.offset, text: `import '${spec}'
+` };
+}
+
+// src/git.ts
+var import_node_child_process = require("child_process");
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+
+// src/state.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+var STATE_DIR = ".dualkit";
+var STATE_FILE = `${STATE_DIR}/convert.json`;
+function isState(value) {
+  return isRecord(value) && ["mode", "base", "branch", "framework"].every((k) => typeof value[k] === "string") && typeof value.phase === "string" && Array.isArray(value.generated) && value.generated.every((p) => typeof p === "string");
+}
+function readState(root) {
+  const path = (0, import_node_path3.join)(root, STATE_FILE);
+  if (!(0, import_node_fs2.existsSync)(path)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs2.readFileSync)(path, "utf8"));
+  } catch (error) {
+    throw new Error(`${STATE_FILE} is not valid JSON: ${error.message}`);
+  }
+  if (!isState(parsed)) throw new Error(`${STATE_FILE} is missing its mode, base, branch, framework, phase or generated files.`);
+  return parsed;
+}
+var stateText = (state) => JSON.stringify(state, null, 2) + "\n";
+function saveState(root, state) {
+  (0, import_node_fs2.mkdirSync)((0, import_node_path3.join)(root, STATE_DIR), { recursive: true });
+  (0, import_node_fs2.writeFileSync)((0, import_node_path3.join)(root, STATE_FILE), stateText(state));
+}
+
+// src/git.ts
+var RefusedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RefusedError";
+  }
+};
+var NO_GIT = "git is not installed or not on PATH";
+function git(cwd, args) {
+  return new Promise((resolve3, reject) => {
+    (0, import_node_child_process.execFile)("git", ["--literal-pathspecs", ...args], { cwd, maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error && error.code === "ENOENT") return reject(new Error((0, import_node_fs3.existsSync)(cwd) ? NO_GIT : `The folder ${cwd} does not exist.`));
+      const code = error ? typeof error.code === "number" ? error.code : 1 : 0;
+      resolve3({ code, out: `${stdout}${stderr}`.trim(), stdout });
+    });
+  });
+}
+async function mustOut(cwd, args) {
+  const result = await git(cwd, args);
+  if (result.code !== 0) throw new Error(`git ${args[0]} failed${result.out ? `: ${result.out}` : ""}`);
+  return result.stdout.trim();
+}
+async function must(cwd, args) {
+  const result = await git(cwd, args);
+  if (result.code !== 0) throw new Error(`git ${args[0]} failed${result.out ? `: ${result.out}` : ""}`);
+  return result.out;
+}
+var isStatePath = (entry, prefix) => entry.slice(3).startsWith(`${prefix}${STATE_DIR}/`);
+async function assertCleanRepo(root) {
+  const inside = await git(root, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside.code !== 0 || inside.out !== "true") throw new RefusedError(`${root} is not inside a git repo. Convert works on a new branch, so run git init and commit first.`);
+  const prefix = await mustOut(root, ["rev-parse", "--show-prefix"]);
+  const status = await git(root, ["status", "--porcelain", "-z"]);
+  if (status.code !== 0) throw new Error(`git status failed: ${status.out}`);
+  const entries = status.stdout.split("\0").filter(Boolean);
+  if (entries.some((entry) => !isStatePath(entry, prefix))) throw new RefusedError("This repo has uncommitted changes. Commit or stash them, then run convert again.");
+}
+async function currentBranch(root) {
+  const name = await git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+  return name.code === 0 ? name.out : must(root, ["rev-parse", "--short", "HEAD"]);
+}
+async function branchExists(root, branch) {
+  return (await git(root, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])).code === 0;
+}
+async function createBranch(root, branch) {
+  await must(root, ["checkout", "-q", "-b", branch]);
+}
+async function moveFile(root, from, to) {
+  await must(root, ["mv", "--", from, to]);
+}
+async function resetHard(root) {
+  await must(root, ["reset", "-q", "--hard"]);
+}
+async function checkout(root, ref) {
+  await must(root, ["checkout", "-q", ref]);
+}
+async function deleteBranch(root, branch) {
+  await must(root, ["branch", "-q", "-D", branch]);
+}
+async function stage(root, paths) {
+  if (paths.length) await must(root, ["add", "-A", "--", ...paths]);
+}
+async function stagedFiles(root) {
+  const out = await must(root, ["diff", "--cached", "--name-only", "-z", "-M"]);
+  return out.split("\0").filter(Boolean);
+}
+async function commit(root, message) {
+  await must(root, ["commit", "-q", "-m", message]);
+}
+async function trackedFiles(root) {
+  const out = await must(root, ["ls-files", "-z"]);
+  return out.split("\0").filter(Boolean).sort();
+}
+async function cleanAtHead(root, paths) {
+  if (!paths.length) return [];
+  const inHead = new Set((await must(root, ["ls-tree", "-r", "--name-only", "-z", "HEAD", "--", ...paths])).split("\0").filter(Boolean));
+  const changed2 = new Set((await must(root, ["diff", "HEAD", "--relative", "--name-only", "-z", "--", ...paths])).split("\0").filter(Boolean));
+  return paths.filter((p) => inHead.has(p) && !changed2.has(p));
+}
+async function restoreFromHead(root, paths) {
+  if (paths.length) await must(root, ["checkout", "HEAD", "--", ...paths]);
+}
+async function unstage(root, paths) {
+  if (paths.length) await must(root, ["reset", "-q", "--", ...paths]);
+}
+async function excludeStateDir(root) {
+  const file = (0, import_node_path4.resolve)(root, await mustOut(root, ["rev-parse", "--git-path", "info/exclude"]));
+  const line = `/${await mustOut(root, ["rev-parse", "--show-prefix"])}${STATE_DIR}/*`;
+  const text = (0, import_node_fs3.existsSync)(file) ? (0, import_node_fs3.readFileSync)(file, "utf8") : "";
+  if (text.split(/\r?\n/).some((l) => l.trim() === line)) return;
+  (0, import_node_fs3.mkdirSync)((0, import_node_path4.dirname)(file), { recursive: true });
+  (0, import_node_fs3.writeFileSync)(file, `${text}${text === "" || text.endsWith("\n") ? "" : "\n"}${line}
+`);
+}
+
+// src/ledger.ts
+var import_node_fs4 = require("fs");
+var import_node_path5 = require("path");
+var LEDGER_FILE = "dualkit-strings.json";
+var STATUSES = /* @__PURE__ */ new Set(["pending", "drafted", "reviewed"]);
+function isEntry(value) {
+  return isRecord(value) && ["key", "en", "ar", "file"].every((k) => typeof value[k] === "string") && typeof value.line === "number" && STATUSES.has(value.status);
+}
+var byKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+function readLedger(root) {
+  const path = (0, import_node_path5.join)(root, LEDGER_FILE);
+  if (!(0, import_node_fs4.existsSync)(path)) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs4.readFileSync)(path, "utf8"));
+  } catch (error) {
+    throw new Error(`${LEDGER_FILE} is not valid JSON: ${error.message}`);
+  }
+  if (!Array.isArray(parsed)) throw new Error(`${LEDGER_FILE} should hold a list of strings.`);
+  const bad = parsed.findIndex((e) => !isEntry(e));
+  if (bad !== -1) throw new Error(`${LEDGER_FILE} entry ${bad + 1} is missing a key, en, ar, status, file or line.`);
+  return parsed;
+}
+function writeLedger(root, entries) {
+  const sorted = [...entries].sort(byKey);
+  (0, import_node_fs4.writeFileSync)((0, import_node_path5.join)(root, LEDGER_FILE), JSON.stringify(sorted, null, 2) + "\n");
+}
+function mergeLedger(existing, added) {
+  const keys = new Set(existing.map((e) => e.key));
+  const fresh = [];
+  for (const entry of added) {
+    if (keys.has(entry.key)) continue;
+    keys.add(entry.key);
+    fresh.push(entry);
+  }
+  return [...existing, ...fresh].sort(byKey);
+}
+var textFor = (entry, locale) => locale === "en" || entry.status === "pending" || entry.ar === "" ? entry.en : entry.ar;
+var group = () => /* @__PURE__ */ Object.create(null);
+function messagesFor(entries, locale) {
+  const root = group();
+  for (const entry of [...entries].sort(byKey)) {
+    const parts = entry.key.split(".");
+    let node = root;
+    for (const part of parts.slice(0, -1)) {
+      const next = Object.hasOwn(node, part) ? node[part] : group();
+      if (typeof next !== "object") throw new Error(`Key ${entry.key} sits under a key that is already a message.`);
+      node[part] = next;
+      node = next;
+    }
+    const leaf = parts[parts.length - 1];
+    if (Object.hasOwn(node, leaf)) throw new Error(`Key ${entry.key} is used twice or is also a group.`);
+    node[leaf] = textFor(entry, locale);
+  }
+  return root;
+}
+
+// src/summary.ts
+var import_node_fs5 = require("fs");
+var import_node_path6 = require("path");
+var SUMMARY_FILE = `${STATE_DIR}/summary.json`;
+function readSummary(root) {
+  const path = (0, import_node_path6.join)(root, SUMMARY_FILE);
+  if (!(0, import_node_fs5.existsSync)(path)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs5.readFileSync)(path, "utf8"));
+    return isRecord(parsed) && Array.isArray(parsed.flags) && Array.isArray(parsed.changed) && parsed.byKind ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var flagKey = (f) => `${f.file}\0${f.line}\0${f.kind}\0${f.message}`;
+function mergeSummary(earlier, next) {
+  if (!earlier) return next;
+  const seen = /* @__PURE__ */ new Set();
+  const flags = [...next.flags, ...earlier.flags].filter((f) => !seen.has(flagKey(f)) && Boolean(seen.add(flagKey(f))));
+  return { ...next, flags };
+}
+var summaryText = (summary) => JSON.stringify(summary, null, 2) + "\n";
+
+// src/apply.ts
+var MESSAGES_DIR = "messages";
+var messagesPath = (locale) => `${MESSAGES_DIR}/${locale}.json`;
+var readText = (root, rel) => (0, import_node_fs6.existsSync)((0, import_node_path7.join)(root, rel)) ? (0, import_node_fs6.readFileSync)((0, import_node_path7.join)(root, rel), "utf8") : null;
+function ensureDir(disk, dir) {
+  const made = (0, import_node_fs6.mkdirSync)((0, import_node_path7.join)(disk.root, dir), { recursive: true });
+  if (made) disk.created.push((0, import_node_path7.relative)(disk.root, made).split(import_node_path7.sep).join("/"));
+}
+function writeText(disk, rel, text) {
+  const before = readText(disk.root, rel);
+  if (before === text) return false;
+  ensureDir(disk, (0, import_node_path7.dirname)(rel));
+  (0, import_node_fs6.writeFileSync)((0, import_node_path7.join)(disk.root, rel), text);
+  if (before === null) disk.created.push(rel);
+  return true;
+}
+async function applyPlan(disk, plan) {
+  const touched = [];
+  for (const [from, to] of plan.moves) {
+    ensureDir(disk, (0, import_node_path7.dirname)(to));
+    await moveFile(disk.root, from, to);
+    disk.created.push(to);
+    touched.push(to);
+  }
+  let writes = 0;
+  for (const [path, text] of Object.entries(plan.writes)) {
+    if (!writeText(disk, path, text)) continue;
+    touched.push(path);
+    writes += 1;
+  }
+  let edits2 = 0;
+  const perFile = {};
+  for (const [path, list] of Object.entries(plan.edits)) {
+    const text = readText(disk.root, path);
+    if (text === null) throw new Error(`Convert planned edits to ${path}, but the file is not there.`);
+    if (!writeText(disk, path, applyEdits(text, list))) continue;
+    touched.push(path);
+    edits2 += list.length;
+    perFile[path] = list.length;
+  }
+  return { touched, edits: edits2, writes, perFile };
+}
+var json = (value) => JSON.stringify(value, null, 2) + "\n";
+var isMessages = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function keepHandAdded(existing, generated) {
+  const kept = Object.entries(existing).map(([key, value]) => {
+    const fresh = generated[key];
+    if (fresh === void 0) return [key, value];
+    return [key, isMessages(value) && isMessages(fresh) ? keepHandAdded(value, fresh) : fresh];
+  });
+  return { ...generated, ...Object.fromEntries(kept) };
+}
+var messagesFiles = (ledger) => ({
+  [messagesPath("en")]: json(messagesFor(ledger, "en")),
+  [messagesPath("ar")]: json(messagesFor(ledger, "ar"))
+});
+function ownFiles(project, ledger) {
+  return { [stylesheetPath(project)]: dualkitCss(project), ...messagesFiles(ledger) };
+}
+function addOwnFiles(disk, project, ledger, entry) {
+  const touched = Object.entries(ownFiles(project, ledger)).filter(([path, text2]) => writeText(disk, path, text2)).map(([path]) => path);
+  const text = readText(disk.root, entry);
+  if (text === null) throw new Error(`Convert could not read the entry file ${entry}.`);
+  const outcome = (0, import_lint2.parseSourceOutcome)(entry, text, (0, import_node_path7.join)(disk.root, entry));
+  if ("error" in outcome) throw new Error(`The entry file ${entry} does not parse after wiring: ${outcome.error}`);
+  const edit = importEdit(outcome.file, stylesheetPath(project));
+  if (!edit || !writeText(disk, entry, applyEdits(outcome.file.text, [edit]))) return { touched, edits: 0 };
+  return { touched: [...touched, entry], edits: 1 };
+}
+function saveLedger(disk, ledger) {
+  const before = readText(disk.root, LEDGER_FILE);
+  writeLedger(disk.root, ledger);
+  if (before === null) disk.created.push(LEDGER_FILE);
+  return readText(disk.root, LEDGER_FILE) !== before;
+}
+function addDependencies(disk, deps) {
+  const text = readText(disk.root, "package.json");
+  if (text === null) throw new Error("Convert could not read package.json.");
+  const pkg = JSON.parse(text);
+  const declared = { ...pkg.devDependencies, ...pkg.peerDependencies, ...pkg.dependencies };
+  const missing = Object.entries(deps).filter(([name]) => !(name in declared));
+  if (missing.length === 0) return false;
+  const dependencies = Object.fromEntries([...Object.entries(pkg.dependencies ?? {}), ...missing].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+  const indent = /^([ \t]+)"/m.exec(text)?.[1] ?? "  ";
+  return writeText(disk, "package.json", JSON.stringify({ ...pkg, dependencies }, null, indent) + "\n");
+}
+var STATE_IGNORE = [`${STATE_DIR}/*`, `!${STATE_FILE}`, `!${SUMMARY_FILE}`];
+var WHOLE_FOLDER = [STATE_DIR, `${STATE_DIR}/`, `/${STATE_DIR}`, `/${STATE_DIR}/`];
+function ignoreStateDir(disk) {
+  const text = readText(disk.root, ".gitignore") ?? "";
+  const lines = text.split(/\r?\n/);
+  const kept = lines.filter((l) => !WHOLE_FOLDER.includes(l.trim()));
+  const missing = STATE_IGNORE.filter((l) => !kept.some((k) => k.trim() === l));
+  if (missing.length === 0 && kept.length === lines.length) return false;
+  const body = kept.join("\n").replace(/\n*$/, "");
+  const out = body === "" ? missing : [body, ...missing];
+  return writeText(disk, ".gitignore", `${out.join("\n")}
+`);
+}
+
+// src/config-answers.ts
+var CONFIG_FILE = "dualkit.config.json";
+function mergedConfigText(before, answers2, file = CONFIG_FILE) {
+  let current = {};
+  if (before !== null) {
+    let parsed;
+    try {
+      parsed = JSON.parse(before);
+    } catch {
+      throw new RefusedError(`${file} is not valid JSON, so convert did not save your answers.`);
+    }
+    if (!isRecord(parsed)) throw new RefusedError(`${file} must hold a JSON object, so convert did not save your answers.`);
+    current = parsed;
+  }
+  const block = isRecord(current.convert) ? current.convert : {};
+  return `${JSON.stringify({ ...current, convert: { ...block, ...answers2 } }, null, 2)}
+`;
+}
+function checkConfigAnswers(root, file = CONFIG_FILE) {
+  mergedConfigText(readText(root, file), {}, file);
+}
+function writeConfigAnswers(disk, answers2, file = CONFIG_FILE) {
+  return writeText(disk, file, mergedConfigText(readText(disk.root, file), answers2, file));
+}
+
+// src/baseline.ts
+var import_node_fs8 = require("fs");
+var import_node_path9 = require("path");
+
+// src/routes.ts
+var import_node_fs7 = require("fs");
+var import_node_path8 = require("path");
+var NEEDS_PARAMS = "needs sample params in dualkit.config.json";
+var PAGE = /^page\.(tsx|jsx|ts|js)$/;
+var GROUP = /^\([^.)][^)]*\)$/;
+var INTERCEPTING = /^\(\.{1,3}\)/;
+var GENERATED_CATCH_ALL = "[...rest]";
+var DYNAMIC = /^\[.+\]$/;
+function pageFolders(dir, segments = []) {
+  const entries = (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true });
+  const here = entries.some((e) => e.isFile() && PAGE.test(e.name)) ? [segments] : [];
+  const nested = entries.filter((e) => e.isDirectory() && !e.name.startsWith("@") && !e.name.startsWith("_") && !INTERCEPTING.test(e.name) && e.name !== "node_modules").flatMap((e) => pageFolders((0, import_node_path8.join)(dir, e.name), [...segments, e.name]));
+  return [...here, ...nested];
+}
+function nextRoutes(project, config) {
+  const routes = [];
+  const unreachable = [];
+  const appPath = (0, import_node_path8.join)(project.root, project.appDir ?? "app");
+  if (!(0, import_node_fs7.existsSync)(appPath)) throw new Error(`The app folder ${appPath} does not exist, so there are no pages to list.`);
+  for (const folder of pageFolders(appPath)) {
+    const visible = folder.filter((s) => !GROUP.test(s));
+    if (visible.length === 2 && visible[0] === "[locale]" && visible[1] === GENERATED_CATCH_ALL) continue;
+    const first = visible[0];
+    const segments = first === "[locale]" ? visible.slice(1) : visible;
+    const route = `/${segments.join("/")}`;
+    if (!segments.some((s) => DYNAMIC.test(s))) {
+      routes.push(route);
+      continue;
+    }
+    const sample = config.params?.[route];
+    if (sample) routes.push(sample);
+    else unreachable.push({ route, reason: NEEDS_PARAMS });
+  }
+  return { routes: routes.sort(), unreachable: unreachable.sort((a, b) => a.route.localeCompare(b.route)) };
+}
+function listRoutes(project, config) {
+  if (project.framework === "vite-react") return { routes: config.routes ?? ["/"], unreachable: [] };
+  return nextRoutes(project, config);
+}
+
+// src/server.ts
+var import_node_child_process2 = require("child_process");
+var import_node_net = require("net");
+var ServerError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ServerError";
+  }
+};
+var OUTPUT_LINES = 20;
+var POLL_MS = 250;
+var KILL_GRACE_MS = 5e3;
+var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+function portTaken(port) {
+  return new Promise((resolve3) => {
+    const socket = (0, import_node_net.connect)({ port, host: "localhost" });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve3(true);
+    });
+    socket.once("error", () => resolve3(false));
+  });
+}
+async function answers(url) {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(2e3), redirect: "manual" });
+    return res.status < 500;
+  } catch {
+    return false;
+  }
+}
+function groupAlive(pid) {
+  try {
+    process.kill(-pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function signalGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+  }
+}
+async function startServer(cmd, port, cwd, timeoutMs = 12e4) {
+  if (await portTaken(port)) {
+    throw new ServerError(`Port ${port} is already in use. Stop whatever is running there or set another port in dualkit.config.json.`);
+  }
+  const child = (0, import_node_child_process2.spawn)(cmd, { cwd, shell: true, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+  let output = "";
+  let exited = false;
+  let spawnError = null;
+  child.on("error", (error) => {
+    spawnError = error;
+    output += `${error.message}
+`;
+  });
+  const pid = child.pid;
+  if (pid === void 0) {
+    await new Promise((resolve3) => setImmediate(resolve3));
+    throw new ServerError(`Could not start "${cmd}": ${spawnError?.message ?? "no process id"}`);
+  }
+  const collect = (chunk) => {
+    output += chunk.toString();
+  };
+  child.stdout?.on("data", collect);
+  child.stderr?.on("data", collect);
+  child.on("exit", () => {
+    exited = true;
+  });
+  const stop = async () => {
+    signalGroup(pid, "SIGTERM");
+    const deadline2 = Date.now() + KILL_GRACE_MS;
+    while ((!exited || groupAlive(pid)) && Date.now() < deadline2) await sleep(50);
+    if (!exited || groupAlive(pid)) {
+      signalGroup(pid, "SIGKILL");
+      while ((!exited || groupAlive(pid)) && Date.now() < deadline2 + KILL_GRACE_MS) await sleep(50);
+    }
+  };
+  const tail2 = () => output.trimEnd().split("\n").slice(-OUTPUT_LINES).join("\n");
+  const url = `http://localhost:${port}`;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (exited) {
+      await stop();
+      throw new ServerError(`The server command "${cmd}" exited before it answered.
+${tail2()}`);
+    }
+    if (await answers(`${url}/`)) return { url, stop };
+    await sleep(POLL_MS);
+  }
+  await stop();
+  throw new ServerError(`The server did not answer on port ${port} within ${Math.round(timeoutMs / 1e3)} seconds.
+${tail2()}`);
+}
+
+// src/baseline.ts
+var BASELINE_DIR = `${STATE_DIR}/baseline`;
+var WIDTHS = [390, 1280];
+var DEFAULT_PORTS = { "next-app": 3e3, "vite-react": 5173 };
+var routeSlug = (route) => route.replace(/^\/+|\/+$/g, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, "") || "home";
+var baselinePath = (route, width) => `${BASELINE_DIR}/${routeSlug(route)}-${width}.png`;
+async function shootBaseline(project, config, shoot, log) {
+  const { routes, unreachable } = listRoutes(project, config);
+  const port = config.port ?? DEFAULT_PORTS[project.framework];
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.join)(project.root, BASELINE_DIR), { recursive: true });
+  const server = await startServer(config.start, port, project.root);
+  const shots = [];
+  try {
+    for (const route of routes) {
+      for (const width of WIDTHS) {
+        const path = baselinePath(route, width);
+        (0, import_node_fs8.writeFileSync)((0, import_node_path9.join)(project.root, path), await shoot(`${server.url}${route}`, width));
+        shots.push(path);
+      }
+    }
+  } finally {
+    await server.stop();
+  }
+  log(`Took ${shots.length} English baseline screenshots.`);
+  return { shots, unreachable };
+}
+
+// src/generate/locale.ts
+var LOCALE_COOKIE = "dk-locale";
+var SWITCH_CHOICES = "[\n  { code: 'en', label: 'English' },\n  { code: 'ar', label: '\u0627\u0644\u0639\u0631\u0628\u064A\u0629' },\n] as const";
+var sourceBase = (project) => project.framework === "vite-react" || project.appDir?.startsWith("src/") ? "src/" : "";
+var localeHelperPath = (project) => `${sourceBase(project)}lib/dualkit-locale.ts`;
+var switchPath = (project) => `${sourceBase(project)}components/dualkit-language-switch.tsx`;
+var LOCALE_HELPER = `/** The Intl locale for an app locale: Arabic uses the UAE region with Latin digits, anything else is unchanged. */
+export function dkIntlLocale(locale: string): string {
+  return locale === 'ar' ? 'ar-AE-u-nu-latn' : locale
+}
+`;
+function guardWrites(writes, files, replaced) {
+  for (const [path, text] of Object.entries(writes)) {
+    const existing = files(path);
+    if (existing === null || existing === text || replaced.has(path)) continue;
+    throw new UnsupportedError(`This app already has ${path}. Convert cannot merge its own version into it, so move or remove that file and run convert again.`);
+  }
+}
+
+// src/generate/next-intl.ts
+var import_node_path13 = require("path");
+
+// src/transforms/imports.ts
+var import_node_path10 = require("path");
+var namedOf = (s) => (s.specifiers ?? []).filter((spec) => spec.type === "ImportSpecifier").map((spec) => spec.imported.name ?? spec.imported.value);
+var importsOf = (program) => (program.body ?? []).filter((s) => s.type === "ImportDeclaration" && s.importKind !== "type");
+function addImports(program, wanted, base, style) {
+  const imports = importsOf(program);
+  const bySource = /* @__PURE__ */ new Map();
+  for (const w of wanted) {
+    const known = imports.some((s) => s.source.value === w.source && namedOf(s).includes(w.name));
+    const list = bySource.get(w.source) ?? [];
+    if (!known && !list.includes(w.name)) bySource.set(w.source, [...list, w.name]);
+  }
+  const edits2 = [];
+  const lines = [];
+  for (const [source, names] of bySource) {
+    if (!names.length) continue;
+    const merge2 = imports.find((s) => s.source.value === source && namedOf(s).length);
+    if (merge2) {
+      const last = (merge2.specifiers ?? []).at(-1);
+      edits2.push({ start: base + last.end, end: base + last.end, text: names.map((n) => `, ${n}`).join("") });
+    } else lines.push(`import { ${names.join(", ")} } from ${style.quote}${source}${style.quote}${style.semi}`);
+  }
+  return lines.length ? [...edits2, linesEdit(program, lines, base)] : edits2;
+}
+function linesEdit(program, lines, base) {
+  const anchor = (program.body ?? []).filter((s) => s.type === "ImportDeclaration").at(-1) ?? (program.directives ?? []).at(-1);
+  if (!anchor) return { start: base, end: base, text: lines.map((l) => `${l}
+`).join("") };
+  const at2 = base + anchor.end;
+  return { start: at2, end: at2, text: lines.map((l) => `
+${l}`).join("") };
+}
+var sideEffectImport = (program, source, base, style) => linesEdit(program, [`import ${style.quote}${source}${style.quote}${style.semi}`], base);
+function specifierTo(from, to) {
+  const rel = import_node_path10.posix.relative(import_node_path10.posix.dirname(from), to).replace(/\.(tsx?|jsx?)$/, "");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+
+// src/generate/aliases.ts
+var import_node_path11 = require("path");
+var CONFIGS = ["tsconfig.json", "jsconfig.json"];
+var EXTENSIONS2 = ["", ".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs", ".mts", ".cts"];
+function stripJsonc(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === '"') {
+      const start2 = i;
+      for (i++; i < text.length && text[i] !== '"'; i++) if (text[i] === "\\") i++;
+      out += text.slice(start2, i + 1);
+    } else if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+    } else if (c === "/" && text[i + 1] === "*") {
+      i = text.indexOf("*/", i + 2);
+      if (i === -1) break;
+      i++;
+    } else out += c;
+  }
+  return out.replace(/,(\s*[}\]])/g, "$1");
+}
+var prefixLength = (key) => key.includes("*") ? key.indexOf("*") : Number.MAX_SAFE_INTEGER;
+function readAliases(files) {
+  for (const name of CONFIGS) {
+    const text = files(name);
+    if (text === null) continue;
+    let options;
+    try {
+      options = JSON.parse(stripJsonc(text)).compilerOptions ?? {};
+    } catch {
+      return [];
+    }
+    const base = typeof options.baseUrl === "string" ? options.baseUrl : ".";
+    const paths = options.paths && typeof options.paths === "object" ? options.paths : {};
+    return Object.entries(paths).filter((entry) => Array.isArray(entry[1]) && entry[1].every((t) => typeof t === "string")).map(([key, targets]) => ({ key, targets: targets.map((t) => import_node_path11.posix.join(base, t)) })).sort((a, b) => prefixLength(b.key) - prefixLength(a.key));
+  }
+  return [];
+}
+function capture(pattern, value) {
+  const star = pattern.indexOf("*");
+  if (star === -1) return pattern === value ? "" : null;
+  const [prefix, suffix] = [pattern.slice(0, star), pattern.slice(star + 1)];
+  const fits = value.startsWith(prefix) && value.endsWith(suffix) && value.length >= prefix.length + suffix.length;
+  return fits ? value.slice(prefix.length, value.length - suffix.length) : null;
+}
+function resolveFile(target, has) {
+  const stem = target.replace(/\.(js|jsx|mjs|cjs)$/, "");
+  const candidates = [target, ...EXTENSIONS2.map((e) => `${stem}${e}`), ...EXTENSIONS2.slice(1).map((e) => `${target}/index${e}`)];
+  return candidates.find(has) ?? null;
+}
+function resolveAlias(spec, aliases, has) {
+  const alias = aliases.find((a) => capture(a.key, spec) !== null);
+  if (!alias) return null;
+  const star = capture(alias.key, spec);
+  for (const target of alias.targets) {
+    const path = target.replace("*", () => star);
+    const file = resolveFile(path, has);
+    if (!file) continue;
+    const respell = (next) => {
+      const middle = target.includes("*") ? capture(target, next) : null;
+      return middle === null ? null : alias.key.replace("*", () => middle);
+    };
+    return { path, file, respell };
+  }
+  return null;
+}
+
+// src/generate/next-config.ts
+var import_lint3 = require("@dualkit/lint");
+
+// src/transforms/lines.ts
+function lineOf(text, offset) {
+  let line = 1;
+  for (let i = text.indexOf("\n"); i !== -1 && i < offset; i = text.indexOf("\n", i + 1)) line++;
+  return line;
+}
+
+// src/transforms/scope.ts
+var FUNCTIONS = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+var isPascal = (name) => typeof name === "string" && /^[A-Z]/.test(name);
+var idName = (node) => node?.type === "Identifier" ? node.name : void 0;
+var WRAPPERS = /* @__PURE__ */ new Set(["memo", "forwardRef"]);
+function isWrapper(call) {
+  const callee = call?.type === "CallExpression" ? call.callee : void 0;
+  if (callee?.type === "Identifier") return WRAPPERS.has(callee.name);
+  return callee?.type === "MemberExpression" && idName(callee.object) === "React" && WRAPPERS.has(idName(callee.property));
+}
+function isComponent(ancestors, at2) {
+  const fn = ancestors[at2];
+  if (isPascal(idName(fn.id))) return true;
+  let above = at2 - 1;
+  while (above >= 0 && isWrapper(ancestors[above])) above--;
+  const holder = ancestors[above];
+  if (holder?.type === "VariableDeclarator" && isPascal(idName(holder.id))) return true;
+  return holder?.type === "ExportDefaultDeclaration";
+}
+function componentOf(ancestors) {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    if (FUNCTIONS.has(ancestors[i].type) && isComponent(ancestors, i)) return ancestors[i];
+  }
+  return null;
+}
+function patternNames(pattern) {
+  if (!pattern) return [];
+  switch (pattern.type) {
+    case "Identifier":
+      return [pattern.name];
+    case "AssignmentPattern":
+      return patternNames(pattern.left);
+    case "RestElement":
+      return patternNames(pattern.argument);
+    case "TSParameterProperty":
+      return patternNames(pattern.parameter);
+    case "ArrayPattern":
+      return (pattern.elements ?? []).flatMap(patternNames);
+    case "ObjectPattern":
+      return (pattern.properties ?? []).flatMap((p) => patternNames(p.type === "RestElement" ? p : p.value));
+    default:
+      return [];
+  }
+}
+function isOwnHook(statement) {
+  const [d, extra] = statement.declarations ?? [];
+  if (statement.type !== "VariableDeclaration" || !d || extra) return false;
+  const init = d.init?.type === "AwaitExpression" ? d.init.argument : d.init;
+  if (init?.type !== "CallExpression" || (init.arguments ?? []).length) return false;
+  const callee = idName(init.callee);
+  const id = d.id;
+  if (id.type === "Identifier") return id.name === "t" && (callee === "useTranslations" || callee === "getTranslations");
+  return callee === "useTranslation" && patternNames(id).join() === "t";
+}
+function statementNames(statement) {
+  const s = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+  if (!s) return [];
+  if (s.type === "VariableDeclaration") return isOwnHook(s) ? [] : (s.declarations ?? []).flatMap((d) => patternNames(d.id));
+  if (s.type === "FunctionDeclaration" || s.type === "ClassDeclaration") return patternNames(s.id);
+  if (s.type === "ImportDeclaration") return (s.specifiers ?? []).map((spec) => spec.local.name);
+  return [];
+}
+function scopeNames(node) {
+  if (FUNCTIONS.has(node.type)) return [...(node.params ?? []).flatMap(patternNames), ...node.type === "FunctionExpression" ? patternNames(node.id) : []];
+  if (node.type === "BlockStatement" || node.type === "Program") return (node.body ?? []).flatMap(statementNames);
+  if (node.type === "CatchClause") return patternNames(node.param);
+  if (/^For(In|Of)?Statement$/.test(node.type)) {
+    const head = node.init ?? node.left;
+    return head?.type === "VariableDeclaration" ? statementNames(head) : [];
+  }
+  return [];
+}
+var tInScope = (ancestors) => ancestors.some((node) => scopeNames(node).includes("t"));
+
+// src/transforms/strings.ts
+var SKIP = /* @__PURE__ */ new Set(["loc", "leadingComments", "trailingComments", "innerComments", "extra"]);
+var TEXT_ATTRIBUTES = /* @__PURE__ */ new Set(["alt", "title", "placeholder", "aria-label", "label"]);
+var LETTER = /\p{L}/u;
+var PROSE = /^\p{Lu}\p{Ll}/u;
+var NOT_PROSE = /[/\\_=<>{}@#|]/;
+var ascii = (text) => text.normalize("NFKD").replace(/[̀-ͯ]/g, "");
+var ROUTE_STEMS = /* @__PURE__ */ new Set(["page", "layout", "index", "route", "default"]);
+var kebab = (text) => ascii(text).replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+function routeDirs(dirs) {
+  const app = dirs.lastIndexOf("app");
+  const route = app === -1 ? dirs.slice(-1) : dirs.slice(app + 1);
+  return route.filter((d) => !/^\(.*\)$/.test(d) && d !== "[locale]").map((d) => d.replace(/^\[+(\.\.\.)?|\]+$/g, ""));
+}
+function stemOf(path) {
+  const parts = path.split(/[\\/]/).filter(Boolean);
+  const stem = parts.pop().split(".")[0];
+  if (!ROUTE_STEMS.has(stem)) return kebab(stem) || "file";
+  return kebab(routeDirs(parts).join("-")) || "home";
+}
+var keyWords = (en) => ascii(en.replace(/\{[^}]*\}/g, " ")).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean).slice(0, 4).join("-") || "text";
+function flag(ctx, offset, kind, message, suggestion) {
+  ctx.flags.push({ file: ctx.file.path, line: lineOf(ctx.file.text, offset), kind, message, suggestion });
+}
+function keyFor(ctx, en) {
+  const known = ctx.byText.get(en);
+  if (known) return known;
+  const base = `${ctx.stem}.${keyWords(en)}`;
+  let key = base;
+  for (let n = 2; ctx.used.has(key); n++) key = `${base}-${n}`;
+  ctx.used.add(key);
+  ctx.byText.set(en, key);
+  return key;
+}
+function place(ctx, ancestors, start2, end, en, values) {
+  const component = componentOf(ancestors);
+  if (!component) {
+    flag(
+      ctx,
+      start2,
+      "outside-component",
+      `"${en}" sits outside a component, so convert cannot give it a translation hook.`,
+      "Move the text into a component, or translate it where it is used."
+    );
+    return;
+  }
+  if (ctx.lib === "react-i18next" && component.async) {
+    flag(
+      ctx,
+      start2,
+      "unsupported",
+      `"${en}" sits in an async component, where the react-i18next hook cannot run, so it was left as it is.`,
+      "Move the text into a component that is not async, or translate it there with i18n.t from the i18n setup convert added."
+    );
+    return;
+  }
+  if (tInScope(ancestors)) {
+    flag(
+      ctx,
+      start2,
+      "unsupported",
+      `"${en}" was left as it is: a variable named t is already in scope, so a translation hook would clash with it.`,
+      "Rename that variable, then run convert again, or translate this text by hand."
+    );
+    return;
+  }
+  const isNew = !ctx.byText.has(en);
+  const key = keyFor(ctx, en);
+  if (isNew) ctx.entries.push({ key, en, ar: "", status: "pending", file: ctx.file.path, line: lineOf(ctx.file.text, start2) });
+  ctx.edits.push({ start: start2, end, text: `{t('${key}'${values ? `, { ${values} }` : ""})}` });
+  ctx.components.add(component);
+}
+var TEXT_METHODS = /^(toLocale(Date|Time)?String|toFixed|toPrecision|toString|toUpperCase|toLowerCase|trim(Start|End)?|padStart|padEnd)$/;
+function textMethodTarget(expression) {
+  if (expression.type !== "CallExpression" && expression.type !== "OptionalCallExpression") return null;
+  const callee = expression.callee;
+  if (callee.type !== "MemberExpression" && callee.type !== "OptionalMemberExpression" || callee.computed) return null;
+  const method = callee.property;
+  return method.type === "Identifier" && TEXT_METHODS.test(method.name) ? callee.object : null;
+}
+function placeholderName(expression) {
+  const target = textMethodTarget(expression);
+  if (target) return placeholderName(target);
+  if (expression.type === "Identifier") return expression.name;
+  if ((expression.type === "MemberExpression" || expression.type === "OptionalMemberExpression") && !expression.computed) {
+    const property = expression.property;
+    return property.type === "Identifier" ? property.name : null;
+  }
+  return null;
+}
+function hasText(element) {
+  return (element.children ?? []).some((c) => c.type === "JSXText" ? /\S/.test(String(c.value)) : c.type === "JSXExpressionContainer" ? c.expression.type !== "JSXEmptyExpression" : c.type === "JSXSpreadChild" || hasText(c));
+}
+function pieceOf(child, ctx) {
+  const start2 = ctx.base + child.start;
+  const end = ctx.base + child.end;
+  if (child.type === "JSXText") {
+    const raw = ctx.file.text.slice(start2, end);
+    if (!/\S/.test(raw)) return { kind: "space", start: start2, end };
+    const lead = raw.length - raw.trimStart().length;
+    const trail = raw.length - raw.trimEnd().length;
+    return { kind: "text", value: String(child.value), start: start2 + lead, end: end - trail };
+  }
+  if (child.type === "JSXSpreadChild") return { kind: "other", start: start2, end };
+  if (child.type !== "JSXExpressionContainer") return { kind: "element", texty: hasText(child), start: start2, end };
+  const expression = child.expression;
+  if (expression.type === "JSXEmptyExpression") return { kind: "comment", start: start2, end };
+  if (expression.type === "StringLiteral") {
+    const value = String(expression.value);
+    return /\S/.test(value) ? { kind: "text", value, start: start2, end } : { kind: "space", start: start2, end };
+  }
+  const name = placeholderName(expression);
+  if (!name) return { kind: "other", start: start2, end };
+  const source = ctx.file.text.slice(ctx.base + expression.start, ctx.base + expression.end);
+  return { kind: "value", name, source, start: start2, end };
+}
+var mixed = (ctx, offset) => flag(
+  ctx,
+  offset,
+  "mixed-text",
+  "This text shares its element with other elements or expressions, so it was left as it is.",
+  "Translate the whole sentence with rich text or a plural message, by hand."
+);
+function valuesOf(pieces) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const p of pieces) {
+    if (p.kind !== "value") continue;
+    if (seen.has(p.name) && seen.get(p.name) !== p.source) return null;
+    seen.set(p.name, p.source);
+  }
+  return [...seen].map(([name, source]) => name === source ? name : `${name}: ${source}`).join(", ");
+}
+function unitsOf(pieces) {
+  const units = [];
+  let run2 = [];
+  let before;
+  for (const piece of [...pieces, void 0]) {
+    if (piece && piece.kind !== "element") {
+      run2.push(piece);
+      continue;
+    }
+    const texty = (p) => p?.kind === "element" && p.texty;
+    if (run2.length) units.push({ run: run2, touchesText: texty(before) || texty(piece) });
+    run2 = [];
+    before = piece;
+  }
+  return units;
+}
+function messageOf(pieces) {
+  if (pieces.some((p) => p.kind === "other")) return null;
+  const edge = (p) => p.kind !== "space" && p.kind !== "comment";
+  const first = pieces.findIndex(edge);
+  const last = pieces.length - 1 - [...pieces].reverse().findIndex(edge);
+  const run2 = pieces.slice(first, last + 1);
+  const values = valuesOf(run2);
+  if (values === null || run2.some((p) => p.kind === "comment")) return null;
+  const en = run2.map((p) => p.kind === "text" ? p.value : p.kind === "value" ? `{${p.name}}` : " ").join("").replace(/\s+/g, " ").trim();
+  return { start: run2[0].start, end: run2[run2.length - 1].end, en, values };
+}
+function visitChildren(element, ctx, ancestors) {
+  const pieces = (element.children ?? []).map((c) => pieceOf(c, ctx));
+  const messages = [];
+  for (const { run: run2, touchesText } of unitsOf(pieces)) {
+    const lettered = run2.find((p) => p.kind === "text" && LETTER.test(p.value));
+    if (!lettered) continue;
+    const message = touchesText ? null : messageOf(run2);
+    if (!message) {
+      mixed(ctx, lettered.start);
+      return false;
+    }
+    messages.push(message);
+  }
+  for (const m of messages) place(ctx, ancestors, m.start, m.end, m.en, m.values);
+  return true;
+}
+function visitAttribute(attribute, ctx, ancestors) {
+  const name = attribute.name;
+  if (name.type !== "JSXIdentifier" || !TEXT_ATTRIBUTES.has(name.name)) return;
+  const value = attribute.value;
+  const literal = value?.type === "JSXExpressionContainer" ? value.expression : value;
+  if (literal?.type !== "StringLiteral" || !LETTER.test(String(literal.value))) return;
+  const en = String(literal.value).replace(/\s+/g, " ").trim();
+  place(ctx, ancestors, ctx.base + value.start, ctx.base + value.end, en, "");
+}
+function walk(node, ctx, ancestors) {
+  if (Array.isArray(node)) return node.forEach((child) => walk(child, ctx, ancestors));
+  if (!node || typeof node !== "object") return;
+  const n = node;
+  if (n.type === "JSXElement" || n.type === "JSXFragment") {
+    ctx.sawJsx = true;
+    if (!visitChildren(n, ctx, ancestors)) return;
+  }
+  if (n.type === "JSXAttribute") visitAttribute(n, ctx, ancestors);
+  const next = typeof n.type === "string" ? [...ancestors, n] : ancestors;
+  for (const [key, child] of Object.entries(n)) if (!SKIP.has(key)) walk(child, ctx, next);
+}
+function proseLiteral(node) {
+  if (Array.isArray(node)) return node.map(proseLiteral).find(Boolean) ?? null;
+  if (!node || typeof node !== "object") return null;
+  const n = node;
+  if (FUNCTIONS.has(n.type) || n.type?.startsWith("JSX")) return null;
+  if (n.type === "StringLiteral") {
+    const value = String(n.value);
+    return PROSE.test(value) && !NOT_PROSE.test(value) ? n : null;
+  }
+  for (const [key, child] of Object.entries(n)) {
+    if (SKIP.has(key)) continue;
+    const found = proseLiteral(child);
+    if (found) return found;
+  }
+  return null;
+}
+function flagModuleStrings(program, ctx) {
+  for (const statement of program.body ?? []) {
+    const declaration = statement.type?.startsWith("Export") ? statement.declaration : statement;
+    if (declaration?.type !== "VariableDeclaration") continue;
+    for (const declarator of declaration.declarations ?? []) {
+      const literal = proseLiteral(declarator.init);
+      if (!literal) continue;
+      flag(
+        ctx,
+        ctx.base + literal.start,
+        "outside-component",
+        `"${String(literal.value)}" is set at module level, outside any component.`,
+        "Translate it where a component shows it, or move it into the component."
+      );
+    }
+  }
+}
+function styleOf(program, text, base) {
+  const first = (program.body ?? [])[0];
+  const semi = first && text[base + first.end - 1] === ";" ? ";" : "";
+  const source = (program.body ?? []).find((s) => s.type === "ImportDeclaration")?.source;
+  const quote = String(source?.extra?.raw ?? "'").startsWith('"') ? '"' : "'";
+  return { semi, quote };
+}
+var hookFor = (lib, async) => lib === "react-i18next" ? { statement: "const { t } = useTranslation()", import: { name: "useTranslation", source: "react-i18next" } } : async ? { statement: "const t = await getTranslations()", import: { name: "getTranslations", source: "next-intl/server" } } : { statement: "const t = useTranslations()", import: { name: "useTranslations", source: "next-intl" } };
+var indentAt = (text, offset) => /^[ \t]*/.exec(text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset))[0];
+function hookEdits(fn, lib, text, base, style) {
+  const hook = hookFor(lib, Boolean(fn.async));
+  const body = fn.body;
+  const statement = hook.statement + style.semi;
+  if (body.type === "BlockStatement") {
+    const statements = body.body ?? [];
+    if (statements.some(isOwnHook)) return { edits: [], imports: [hook.import] };
+    const at2 = base + (statements[0]?.start ?? body.start + 1);
+    const prefix = text.slice(text.lastIndexOf("\n", at2 - 1) + 1, at2);
+    const insert = /^\s*$/.test(prefix) ? `${statement}
+${prefix}` : `${hook.statement}; `;
+    return { edits: [{ start: at2, end: at2, text: insert }], imports: [hook.import] };
+  }
+  const extra = body.extra;
+  const open = base + (extra?.parenthesized ? extra.parenStart : body.start);
+  const indent = indentAt(text, base + fn.start);
+  return {
+    edits: [
+      { start: open, end: open, text: `{
+${indent}  ${statement}
+${indent}  return ` },
+      { start: base + fn.end, end: base + fn.end, text: `
+${indent}}` }
+    ],
+    imports: [hook.import]
+  };
+}
+var hasImport = (program, wanted) => (program.body ?? []).some((s) => s.type === "ImportDeclaration" && s.source.value === wanted.source && (s.specifiers ?? []).some((spec) => {
+  const imported = spec.imported;
+  return spec.type === "ImportSpecifier" && (imported?.name ?? imported?.value) === wanted.name;
+}));
+function importEdits(program, wanted, base, style) {
+  const unique = [...new Map(wanted.map((w) => [`${w.source}#${w.name}`, w])).values()].filter((w) => !hasImport(program, w));
+  if (!unique.length) return [];
+  const lines = unique.map((w) => `import { ${w.name} } from ${style.quote}${w.source}${style.quote}${style.semi}`);
+  const body = program.body ?? [];
+  const anchor = [...body].reverse().find((s) => s.type === "ImportDeclaration") ?? (program.directives ?? []).at(-1);
+  if (!anchor) return [{ start: base, end: base, text: lines.map((l) => `${l}
+`).join("") }];
+  const at2 = base + anchor.end;
+  return [{ start: at2, end: at2, text: lines.map((l) => `
+${l}`).join("") }];
+}
+var isServerFile = (program) => (program.directives ?? []).some((d) => d.value.value === "use server");
+function extractStrings(file, lib, taken) {
+  const entries = [];
+  const edits2 = [];
+  const flags = [];
+  const used = new Set(taken);
+  for (const block of file.js) {
+    const program = block.ast.program;
+    if (isServerFile(program)) continue;
+    const ctx = { file, base: block.offset, lib, stem: stemOf(file.path), used, byText: /* @__PURE__ */ new Map(), entries, edits: edits2, flags, components: /* @__PURE__ */ new Set(), sawJsx: false };
+    walk(program, ctx, []);
+    if (ctx.sawJsx) flagModuleStrings(program, ctx);
+    const style = styleOf(program, file.text, ctx.base);
+    const hooks = [...ctx.components].map((fn) => hookEdits(fn, lib, file.text, ctx.base, style));
+    edits2.push(...hooks.flatMap((h) => h.edits));
+    edits2.push(...importEdits(program, hooks.flatMap((h) => h.imports), ctx.base, style));
+  }
+  return { edits: edits2, flags, entries };
+}
+
+// src/generate/next-config.ts
+var CANDIDATES = ["next.config.ts", "next.config.mts", "next.config.mjs", "next.config.js", "next.config.cjs"];
+var FUNCTIONS2 = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+var PLUGIN = "createNextIntlPlugin";
+var NEW_CONFIG = `import ${PLUGIN} from 'next-intl/plugin'
+
+const withNextIntl = ${PLUGIN}()
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {}
+
+export default withNextIntl(nextConfig)
+`;
+var refuse = (path) => new UnsupportedError(`Convert could not find the config object ${path} exports, so it cannot add the next-intl plugin. Export the object directly, then run convert again.`);
+var isModuleExports = (left) => left.type === "MemberExpression" && left.object.name === "module" && left.property.name === "exports";
+function esmEdits(program, value, base, semi, quote) {
+  const lines = `import ${PLUGIN} from ${quote}next-intl/plugin${quote}${semi}
+
+const withNextIntl = ${PLUGIN}()${semi}`;
+  const last = (program.body ?? []).filter((s) => s.type === "ImportDeclaration").at(-1);
+  const head = last ? { start: base + last.end, end: base + last.end, text: `
+${lines}` } : { start: base, end: base, text: `${lines}
+
+` };
+  return [head, { start: base + value.start, end: base + value.start, text: "withNextIntl(" }, { start: base + value.end, end: base + value.end, text: ")" }];
+}
+function cjsEdits(program, value, base, semi, quote) {
+  const first = (program.body ?? [])[0];
+  const start2 = base + Math.min(first.start, ...(first.leadingComments ?? []).map((c) => c.start));
+  const lines = `const ${PLUGIN} = require(${quote}next-intl/plugin${quote})${semi}
+const withNextIntl = ${PLUGIN}()${semi}
+
+`;
+  return [{ start: start2, end: start2, text: lines }, { start: base + value.start, end: base + value.start, text: "withNextIntl(" }, { start: base + value.end, end: base + value.end, text: ")" }];
+}
+function configEdits(path, text) {
+  if (text.includes(PLUGIN)) return [];
+  const outcome = (0, import_lint3.parseSourceOutcome)(path, text);
+  const block = "file" in outcome ? outcome.file.js[0] : void 0;
+  if (!block) throw refuse(path);
+  const program = block.ast.program;
+  const { semi, quote } = styleOf(program, text, block.offset);
+  const body = program.body ?? [];
+  const esm = body.find((s) => s.type === "ExportDefaultDeclaration")?.declaration;
+  if (esm) {
+    if (FUNCTIONS2.has(esm.type) || esm.type === "ClassDeclaration") throw refuse(path);
+    return esmEdits(program, esm, block.offset, semi, quote);
+  }
+  const assign = body.map((s) => s.type === "ExpressionStatement" ? s.expression : null).find((e) => e?.type === "AssignmentExpression" && isModuleExports(e.left));
+  const value = assign?.right;
+  if (!value || FUNCTIONS2.has(value.type)) throw refuse(path);
+  return cjsEdits(program, value, block.offset, semi, quote);
+}
+function nextConfigPlan(files) {
+  const path = CANDIDATES.find((c) => files(c) !== null);
+  if (!path) return { writes: { "next.config.mjs": NEW_CONFIG }, edits: {} };
+  const edits2 = configEdits(path, files(path));
+  return { writes: {}, edits: edits2.length ? { [path]: edits2 } : {} };
+}
+
+// src/generate/next-layout.ts
+var import_lint4 = require("@dualkit/lint");
+var FUNCTIONS3 = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+var SKIP2 = /* @__PURE__ */ new Set(["loc", "leadingComments", "trailingComments", "innerComments", "extra"]);
+var LOOSE_TYPES = /* @__PURE__ */ new Set(["TSUnionType", "TSFunctionType", "TSConditionalType", "TSConstructorType"]);
+var PROVIDER = "NextIntlClientProvider";
+var at = (ctx, offset, text) => ({ start: ctx.base + offset, end: ctx.base + offset, text });
+function findElement(node, name) {
+  if (Array.isArray(node)) return node.map((n2) => findElement(n2, name)).find(Boolean) ?? null;
+  if (!node || typeof node !== "object") return null;
+  const n = node;
+  if (n.type === "JSXElement" && n.openingElement.name.name === name) return n;
+  for (const [key, child] of Object.entries(n)) {
+    if (SKIP2.has(key)) continue;
+    const found = findElement(child, name);
+    if (found) return found;
+  }
+  return null;
+}
+function htmlEdits(html, mode, ctx) {
+  const opening = html.openingElement;
+  const attrs = mode === "arabic" ? ' lang="ar" dir="rtl"' : " lang={locale} dir={locale === 'ar' ? 'rtl' : 'ltr'}";
+  const edits2 = [at(ctx, opening.name.end, attrs)];
+  for (const attr of opening.attributes ?? []) {
+    const name = attr.type === "JSXAttribute" ? attr.name.name : void 0;
+    if (name !== "lang" && name !== "dir") continue;
+    let start2 = ctx.base + attr.start;
+    while (/\s/.test(ctx.text[start2 - 1] ?? "")) start2--;
+    edits2.push({ start: start2, end: ctx.base + attr.end, text: "" });
+  }
+  return edits2;
+}
+function providerEdits(html, ctx) {
+  const body = findElement(html, "body");
+  const holder = body?.closingElement ? body : html;
+  const closing = holder.closingElement;
+  if (!closing) return [];
+  return [at(ctx, holder.openingElement.end, `<${PROVIDER}>`), at(ctx, closing.start, `</${PROVIDER}>`)];
+}
+function layoutFunction(program) {
+  const body = program.body ?? [];
+  const exported = body.find((s) => s.type === "ExportDefaultDeclaration")?.declaration;
+  if (!exported) return null;
+  if (FUNCTIONS3.has(exported.type)) return exported;
+  if (exported.type !== "Identifier") return null;
+  for (const s of body) {
+    const d = s.type === "ExportNamedDeclaration" ? s.declaration : s;
+    if (d?.type === "FunctionDeclaration" && d.id.name === exported.name) return d;
+    for (const v of d?.type === "VariableDeclaration" ? d.declarations ?? [] : []) {
+      const init = v.init;
+      if (v.id.name === exported.name && init && FUNCTIONS3.has(init.type)) return init;
+    }
+  }
+  return null;
+}
+var paramsType = (options) => options.promiseParams ? "{ params: Promise<{ locale: string }> }" : "{ params: { locale: string } }";
+function annotate(param, options, ctx) {
+  const annotation = param.typeAnnotation?.typeAnnotation;
+  if (!annotation) return [];
+  const extra = ` & ${paramsType(options)}`;
+  if (!LOOSE_TYPES.has(annotation.type)) return [at(ctx, annotation.end, extra)];
+  return [at(ctx, annotation.start, "("), at(ctx, annotation.end, `)${extra}`)];
+}
+function paramEdits(fn, options, ctx) {
+  const [param] = fn.params ?? [];
+  if (!param) {
+    const open = ctx.text.indexOf("(", ctx.base + (fn.id?.end ?? fn.start));
+    const type = ctx.typed ? `: ${paramsType(options)}` : "";
+    return { edits: [{ start: open + 1, end: open + 1, text: `{ params }${type}` }], source: "params" };
+  }
+  if (param.type === "Identifier") return { edits: annotate(param, options, ctx), source: `${param.name}.params` };
+  if (param.type !== "ObjectPattern") throw new UnsupportedError("The root layout takes its props in a form convert cannot add params to. Destructure them as { children }, then run convert again.");
+  const first = (param.properties ?? [])[0];
+  const insert = first ? at(ctx, first.start, "params, ") : at(ctx, param.start + 1, " params ");
+  return { edits: [insert, ...annotate(param, options, ctx)], source: "params" };
+}
+var indentAt2 = (text, offset) => /^[ \t]*/.exec(text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset))[0];
+function prepend(fn, lines, ctx) {
+  const body = fn.body;
+  if (body.type === "BlockStatement") {
+    const first = (body.body ?? [])[0];
+    if (first) {
+      const indent3 = indentAt2(ctx.text, ctx.base + first.start);
+      return [at(ctx, first.start, lines.map((l) => `${l}
+${indent3}`).join(""))];
+    }
+    const indent2 = `${indentAt2(ctx.text, ctx.base + fn.start)}  `;
+    return [at(ctx, body.start + 1, lines.map((l) => `
+${indent2}${l}`).join(""))];
+  }
+  const extra = body.extra;
+  const open = extra?.parenthesized ? extra.parenStart : body.start;
+  const indent = indentAt2(ctx.text, ctx.base + fn.start);
+  return [
+    at(ctx, open, `{
+${lines.map((l) => `${indent}  ${l}
+`).join("")}${indent}  return `),
+    at(ctx, fn.end, `
+${indent}}`)
+  ];
+}
+function hookEdits2(fn, ctx) {
+  const body = fn.body;
+  const statements = body.type === "BlockStatement" ? body.body ?? [] : [];
+  const hook = statements.find(isOwnHook);
+  const init = hook?.declarations?.[0]?.init;
+  if (!init || init.type === "AwaitExpression") return { edits: [], imports: [] };
+  return {
+    edits: [{ start: ctx.base + init.start, end: ctx.base + init.end, text: "await getTranslations()" }],
+    imports: [{ name: "getTranslations", source: "next-intl/server" }]
+  };
+}
+var exportsName = (program, name) => (program.body ?? []).some((s) => {
+  const d = s.type === "ExportNamedDeclaration" ? s.declaration : null;
+  if (d?.type === "FunctionDeclaration") return d.id.name === name;
+  if (d?.type === "VariableDeclaration") return (d.declarations ?? []).some((v) => v.id.name === name);
+  return s.type === "ExportNamedDeclaration" && (s.specifiers ?? []).some((spec) => spec.exported.name === name);
+});
+function localeEdits(program, options, ctx) {
+  const fn = layoutFunction(program);
+  if (!fn) throw new UnsupportedError("Convert could not find the default export of the root layout, so it cannot read the locale there.");
+  const { edits: edits2, source } = paramEdits(fn, options, ctx);
+  if (!fn.async) edits2.push(at(ctx, fn.start, "async "));
+  const semi = ctx.style.semi;
+  edits2.push(...prepend(fn, [
+    `const { locale } = await ${source}${semi}`,
+    `if (!hasLocale(routing.locales, locale)) notFound()${semi}`,
+    `setRequestLocale(locale)${semi}`
+  ], ctx));
+  const hook = hookEdits2(fn, ctx);
+  edits2.push(...hook.edits);
+  if (!exportsName(program, "generateStaticParams")) {
+    const end = program.end;
+    const lead = ctx.text.slice(0, ctx.base + end).endsWith("\n") ? "\n" : "\n\n";
+    edits2.push(at(ctx, end, `${lead}export function generateStaticParams() {
+  return routing.locales.map((locale) => ({ locale }))${semi}
+}
+`));
+  }
+  return {
+    edits: edits2,
+    imports: [
+      { name: "hasLocale", source: "next-intl" },
+      { name: "setRequestLocale", source: "next-intl/server" },
+      ...hook.imports,
+      { name: "notFound", source: "next/navigation" },
+      { name: "routing", source: options.routing }
+    ]
+  };
+}
+function layoutEdits(path, text, mode, options) {
+  if (text.includes(PROVIDER)) return [];
+  const outcome = (0, import_lint4.parseSourceOutcome)(path, text);
+  const block = "file" in outcome ? outcome.file.js[0] : void 0;
+  if (!block) throw new UnsupportedError(`Convert could not parse the root layout in ${path}.`);
+  const program = block.ast.program;
+  if ((program.directives ?? []).some((d) => d.value.value === "use client")) {
+    throw new UnsupportedError(`The root layout in ${path} is a client component. Convert needs it to be a server component to read the locale.`);
+  }
+  const html = findElement(program, "html");
+  if (!html) throw new UnsupportedError(`The root layout in ${path} has no <html> element, so convert cannot set the language and direction.`);
+  const ctx = { text, base: block.offset, style: styleOf(program, text, block.offset), typed: /\.tsx?$/.test(path) };
+  const edits2 = [...htmlEdits(html, mode, ctx), ...providerEdits(html, ctx)];
+  const imports = [{ name: PROVIDER, source: "next-intl" }];
+  if (mode === "bilingual") {
+    const locale = localeEdits(program, options, ctx);
+    edits2.push(...locale.edits);
+    imports.push(...locale.imports);
+  }
+  return [...edits2, ...addImports(program, imports, ctx.base, ctx.style)];
+}
+
+// src/generate/next-routes.ts
+var import_lint5 = require("@dualkit/lint");
+var import_node_path12 = require("path");
+var SKIP3 = /* @__PURE__ */ new Set(["loc", "leadingComments", "trailingComments", "innerComments", "extra"]);
+var CODE = /\.(tsx?|jsx?|mjs|cjs|mts|cts)$/;
+var MOVED = /\.(tsx?|jsx?|mjs|cjs|mts|cts|mdx?)$/;
+var PAGE2 = /^page\.(tsx?|jsx?|mdx?)$/;
+var ROOT_KEPT = /^(favicon\.ico|global-error\.[jt]sx?|(icon|apple-icon|opengraph-image|twitter-image)\d*(\.alt)?\.\w+|robots\.\w+|sitemap\.\w+|manifest\.\w+)$/;
+var SEGMENT_METADATA = /^(icon|apple-icon|opengraph-image|twitter-image)\d*(\.alt)?\.\w+$/;
+var UNMATCHED = /^(api|_next|_vercel)$/;
+var localePath = (appDir, path) => `${appDir}/[locale]/${path.slice(appDir.length + 1)}`;
+var urlSegments = (dirs) => dirs.filter((d) => !/^\(.*\)$/.test(d) && !d.startsWith("@"));
+function fateOf(appDir, path) {
+  if (!path.startsWith(`${appDir}/`)) return "stay";
+  const parts = path.slice(appDir.length + 1).split("/");
+  const name = parts.pop();
+  if (parts[0] === "[locale]") return "stay";
+  const url = urlSegments(parts);
+  if (url[0] && UNMATCHED.test(url[0]) || url.some((d) => d.includes(".") && !d.startsWith("["))) return "kept-route";
+  if (!parts.length && ROOT_KEPT.test(name)) return "stay";
+  return MOVED.test(name) || parts.length > 0 && SEGMENT_METADATA.test(name) ? "move" : "stay";
+}
+function routeMoves(appDir, paths) {
+  const moves = [];
+  const keptPages = [];
+  for (const p of paths) {
+    const fate = fateOf(appDir, p);
+    if (fate === "move") moves.push([p, localePath(appDir, p)]);
+    if (fate === "kept-route" && PAGE2.test(import_node_path12.posix.basename(p))) keptPages.push(p);
+  }
+  return { moves, keptPages };
+}
+function eachNode(node, visit) {
+  if (Array.isArray(node)) return node.forEach((child) => eachNode(child, visit));
+  if (!node || typeof node !== "object") return;
+  const n = node;
+  if (typeof n.type === "string") visit(n);
+  for (const [key, child] of Object.entries(n)) if (!SKIP3.has(key)) eachNode(child, visit);
+}
+var RELATIVE = /^\.\.?\//;
+var stringLiteral = (node) => node?.type === "StringLiteral" ? node : null;
+var localFontNames = (program) => new Set((program.body ?? []).filter((s) => s.type === "ImportDeclaration" && s.source.value === "next/font/local").flatMap((s) => (s.specifiers ?? []).filter((spec) => spec.type === "ImportDefaultSpecifier").map((spec) => spec.local.name)));
+function specifierLiterals(program) {
+  const fonts = localFontNames(program);
+  const found = [];
+  eachNode(program, (n) => {
+    if (/^(Import|ExportNamed|ExportAll)Declaration$/.test(n.type)) {
+      const hit = stringLiteral(n.source);
+      if (hit) found.push(hit);
+      return;
+    }
+    if (n.type !== "CallExpression") return;
+    const callee = n.callee;
+    const args = n.arguments ?? [];
+    if (callee.type === "Import" || callee.type === "Identifier" && callee.name === "require") {
+      const hit = stringLiteral(args[0]);
+      if (hit) found.push(hit);
+    } else if (callee.type === "Identifier" && fonts.has(callee.name)) {
+      eachNode(args[0], (inner) => {
+        const hit = stringLiteral(inner);
+        if (hit && RELATIVE.test(String(hit.value))) found.push(hit);
+      });
+    }
+  });
+  return found;
+}
+var newTarget = (scope, target) => resolveFile(target, (p) => scope.moved.has(p)) ? localePath(scope.appDir, target) : target;
+function relativeSpec(scope, from, to, spec) {
+  const target = import_node_path12.posix.join(import_node_path12.posix.dirname(from), spec);
+  let next = import_node_path12.posix.relative(import_node_path12.posix.dirname(to), newTarget(scope, target));
+  if (!next.startsWith(".")) next = `./${next}`;
+  if (spec.endsWith("/") && !next.endsWith("/")) next += "/";
+  return import_node_path12.posix.normalize(next) === import_node_path12.posix.normalize(spec) ? null : next;
+}
+function aliasSpec(scope, spec) {
+  const resolved = resolveAlias(spec, scope.aliases, scope.has);
+  if (!resolved || !scope.moved.has(resolved.file)) return null;
+  return resolved.respell(localePath(scope.appDir, resolved.path)) ?? "stuck";
+}
+var stuckFlag = (file, line, spec) => ({
+  file,
+  line,
+  kind: "unsupported",
+  message: `The import "${spec}" uses a path alias with no * that points at a file convert moved under [locale], so it still points at the old path.`,
+  suggestion: "Point that alias in tsconfig.json at the new path, or import the file by a relative path."
+});
+var ROUTE_TYPES = /* @__PURE__ */ new Set(["PageProps", "LayoutProps", "RouteContext"]);
+function routeTypeLiterals(program) {
+  const found = [];
+  eachNode(program, (n) => {
+    if (n.type !== "TSTypeReference") return;
+    const name = n.typeName;
+    const args = (n.typeParameters ?? n.typeArguments)?.params;
+    const literal = args?.[0]?.type === "TSLiteralType" ? args[0].literal : void 0;
+    if (name.type === "Identifier" && ROUTE_TYPES.has(name.name) && literal?.type === "StringLiteral" && String(literal.value).startsWith("/")) found.push(literal);
+  });
+  return found;
+}
+function routeTypeEdits(program, offset) {
+  return routeTypeLiterals(program).map((node) => {
+    const route = String(node.value);
+    return { start: offset + node.start + 1, end: offset + node.end - 1, text: route === "/" ? "/[locale]" : `/[locale]${route}` };
+  });
+}
+function fileRewrites(scope, from, to, text) {
+  const outcome = (0, import_lint5.parseSourceOutcome)(from, text);
+  const block = "file" in outcome ? outcome.file.js[0] : void 0;
+  if (!block) return { edits: [], flags: [] };
+  const edits2 = from === to ? [] : routeTypeEdits(block.ast.program, block.offset);
+  const flags = [];
+  for (const node of specifierLiterals(block.ast.program)) {
+    const spec = String(node.value);
+    const next = RELATIVE.test(spec) ? relativeSpec(scope, from, to, spec) : aliasSpec(scope, spec);
+    if (next === "stuck") flags.push(stuckFlag(to, lineOf(text, block.offset + node.start), spec));
+    else if (next !== null && next !== spec) edits2.push({ start: block.offset + node.start + 1, end: block.offset + node.end - 1, text: next });
+  }
+  return { edits: edits2, flags };
+}
+function importRewrites(appDir, moveList, paths, files, aliases) {
+  const known = new Set(paths);
+  const scope = { appDir, moved: new Map(moveList), has: (p) => known.has(p), aliases };
+  const edits2 = {};
+  const flags = [];
+  for (const path of paths) {
+    if (!CODE.test(path)) continue;
+    const text = files(path);
+    if (text === null) continue;
+    const to = scope.moved.get(path) ?? path;
+    const result = fileRewrites(scope, path, to, text);
+    if (result.edits.length) edits2[to] = result.edits;
+    flags.push(...result.flags);
+  }
+  return { edits: edits2, flags };
+}
+
+// src/generate/next-intl.ts
+var DEPS = { "next-intl": "4.14.9" };
+var LATEST_NEXT_MAJOR = 16;
+var LATEST_NEXT_MINOR = 4;
+function versionIn(text, read) {
+  try {
+    const value = read(JSON.parse(text ?? "{}"));
+    return typeof value === "string" ? value : "";
+  } catch {
+    return "";
+  }
+}
+function nextVersion(files) {
+  const deps = (json2, field) => json2[field]?.next;
+  const version = versionIn(files("node_modules/next/package.json"), (json2) => json2.version) || versionIn(files("package.json"), (json2) => deps(json2, "dependencies") ?? deps(json2, "devDependencies"));
+  const match = /(\d+)(?:\.(\d+))?/.exec(version);
+  return match ? { major: Number(match[1]), minor: Number(match[2] ?? 0) } : { major: LATEST_NEXT_MAJOR, minor: LATEST_NEXT_MINOR };
+}
+var nextMajor = (files) => nextVersion(files).major;
+function hasRootParams(files) {
+  const { major, minor } = nextVersion(files);
+  return major > 16 || major === 16 && minor >= 3;
+}
+var ROUTING = `import { defineRouting } from 'next-intl/routing'
+
+export const routing = defineRouting({
+  locales: ['en', 'ar'],
+  defaultLocale: 'en',
+  localePrefix: 'as-needed',
+})
+`;
+var NAVIGATION = `import { createNavigation } from 'next-intl/navigation'
+import { routing } from './routing'
+
+export const { Link, redirect, usePathname, useRouter, getPathname } = createNavigation(routing)
+`;
+function requestFile(mode, messages, rootParams) {
+  if (mode === "arabic") {
+    return `import { getRequestConfig } from 'next-intl/server'
+
+export default getRequestConfig(async () => ({
+  locale: 'ar',
+  messages: (await import('${messages}/ar.json')).default,
+}))
+`;
+  }
+  if (rootParams) {
+    return `import * as rootParams from 'next/root-params'
+import { hasLocale } from 'next-intl'
+import { getRequestConfig } from 'next-intl/server'
+import { routing } from './routing'
+
+export default getRequestConfig(async ({ locale: given }) => {
+  const requested = given ?? await rootParams.locale()
+  const locale = hasLocale(routing.locales, requested) ? requested : routing.defaultLocale
+  return {
+    locale,
+    messages: (await import(\`${messages}/\${locale}.json\`)).default,
+  }
+})
+`;
+  }
+  return `import { hasLocale } from 'next-intl'
+import { getRequestConfig } from 'next-intl/server'
+import { routing } from './routing'
+
+export default getRequestConfig(async ({ requestLocale }) => {
+  const requested = await requestLocale
+  const locale = hasLocale(routing.locales, requested) ? requested : routing.defaultLocale
+  return {
+    locale,
+    messages: (await import(\`${messages}/\${locale}.json\`)).default,
+  }
+})
+`;
+}
+var middlewareFile = (routing) => `import createMiddleware from 'next-intl/middleware'
+import { routing } from '${routing}'
+
+export default createMiddleware(routing)
+
+export const config = {
+  matcher: '/((?!(?:api|_next|_vercel)(?:/|$)|.*\\\\..*).*)',
+}
+`;
+var composedMiddlewareFile = (routing, matcher, own) => `import { NextRequest, NextResponse, type NextFetchEvent } from 'next/server'
+import createMiddleware from 'next-intl/middleware'
+import { routing } from '${routing}'
+import { matchesApp, type Matcher } from '${matcher}'
+import * as own from '${own}'
+
+const intl = createMiddleware(routing)
+type OwnHandler = (request: NextRequest, event: NextFetchEvent) => Response | null | undefined | Promise<Response | null | undefined>
+// A spread, so the bundler does not warn about the export names this app does not use.
+const exported: Record<string, unknown> = { ...own }
+const candidate = exported.default ?? exported.middleware ?? exported.proxy
+if (typeof candidate !== 'function') throw new Error('Dualkit could not find the middleware function exported by ${own}.')
+const ownHandler = candidate as OwnHandler
+const ownMatcher = (exported as { config?: { matcher?: Matcher } }).config?.matcher
+const OWN_ONLY = /^\\/(?:api|trpc)(?:\\/|$)/
+
+export default async function middleware(request: NextRequest, event: NextFetchEvent) {
+  const url = request.nextUrl.clone()
+  const [, first = '', ...rest] = url.pathname.split('/')
+  if ((routing.locales as readonly string[]).includes(first)) url.pathname = \`/\${rest.join('/')}\`
+  const result = matchesApp(url.pathname, ownMatcher) ? await ownHandler(new NextRequest(url, request), event) : null
+  // Anything but a plain "continue" is the app's answer: a redirect, a rewrite, a 401 or a page. Keep it as it is.
+  if (result && result.headers.get('x-middleware-next') !== '1') return result
+  if (OWN_ONLY.test(url.pathname)) return result ?? NextResponse.next()
+  const response = intl(request)
+  if (result) {
+    for (const cookie of result.headers.getSetCookie()) response.headers.append('set-cookie', cookie)
+    // Headers the app set for the browser, such as a content security policy.
+    result.headers.forEach((value, key) => { if (key !== 'set-cookie' && !key.startsWith('x-middleware-')) response.headers.set(key, value) })
+    const overridden = result.headers.get('x-middleware-override-headers')
+    if (overridden) {
+      const names = new Set([...(response.headers.get('x-middleware-override-headers') ?? '').split(','), ...overridden.split(',')].filter(Boolean))
+      response.headers.set('x-middleware-override-headers', [...names].join(','))
+      result.headers.forEach((value, key) => { if (key.startsWith('x-middleware-request-')) response.headers.set(key, value) })
+    }
+  }
+  return response
+}
+
+export const config = {
+  matcher: '/((?!(?:_next|_vercel)(?:/|$)|.*\\\\..*).*)',
+}
+`;
+var APP_MATCHER = String.raw`/** Whether a path is covered by an app's own middleware matcher. No matcher means every path. */
+export type Matcher = string | { source: string }  | (string | { source: string })[]
+
+/** An entry with has or missing conditions is treated as matching, so the app's middleware runs rather than being skipped. */
+export function matchesApp(pathname: string, matcher: Matcher | undefined): boolean {
+  if (matcher === undefined) return true
+  return (Array.isArray(matcher) ? matcher : [matcher]).some((entry) => toRegExp(typeof entry === 'string' ? entry : entry.source).test(pathname))
+}
+
+function toRegExp(pattern: string): RegExp {
+  let out = ''
+  let i = 0
+  while (i < pattern.length) {
+    const char = pattern[i]!
+    const param = char === '/' ? /^\/:[A-Za-z0-9_]+([*+?]?)/.exec(pattern.slice(i)) : null
+    if (param && pattern[i + param[0].length] === '(') {
+      out += '/'
+      i += param[0].length
+    } else if (param) {
+      out += { '*': '(?:/.*)?', '+': '/.+', '?': '(?:/[^/]+)?', '': '/[^/]+' }[param[1]!]
+      i += param[0].length
+    } else if (char === '(') {
+      let depth = 0
+      let j = i
+      for (; j < pattern.length; j++) {
+        if (pattern[j] === '\\') j++
+        else if (pattern[j] === '(') depth++
+        else if (pattern[j] === ')' && --depth === 0) break
+      }
+      out += pattern.slice(i, j + 1)
+      i = j + 1
+    } else {
+      out += char.replace(/[.*+?^$|{}[\]\\]/g, '\\$&')
+      i++
+    }
+  }
+  return new RegExp('^' + out + (out.endsWith('/') ? '' : '/?') + '$')
+}
+`;
+var switchFile = (navigation) => `'use client'
+
+import { useLocale } from 'next-intl'
+import { Link, usePathname } from '${navigation}'
+
+const CHOICES = ${SWITCH_CHOICES}
+
+/** Links to the current page in English and Arabic. Not placed by convert: add it where the app keeps its navigation. */
+export function DualkitLanguageSwitch() {
+  const pathname = usePathname()
+  const locale = useLocale()
+  return (
+    <nav aria-label="Language">
+      {CHOICES.map(({ code, label }) => (
+        <Link key={code} href={pathname} locale={code} lang={code} aria-current={locale === code ? 'true' : undefined}>
+          {label}
+        </Link>
+      ))}
+    </nav>
+  )
+}
+`;
+var CATCH_ALL = `import { notFound } from 'next/navigation'
+
+/** Every path no other route matches shows the not-found page, inside the [locale] layout. */
+export default function CatchAll() {
+  notFound()
+}
+`;
+var PAGE3 = /^page\.(tsx?|jsx?|mdx?)$/;
+var ROUTE = /^route\.(tsx?|jsx?)$/;
+var LAYOUT = /^layout\.(tsx?|jsx?)$/;
+var flagAt = (file, kind, message, suggestion) => ({ file, line: 1, kind, message, suggestion });
+function topCatchAll(appDir, moves, paths) {
+  const catches = (path) => {
+    const parts = path.slice(appDir.length + 1).split("/");
+    const name = parts.pop();
+    const url = urlSegments(parts);
+    return (PAGE3.test(name) || ROUTE.test(name)) && url.length === 1 && /^\[\[?\.\.\./.test(url[0]);
+  };
+  const moved = moves.find(([from]) => catches(from));
+  if (moved) return moved[1];
+  return paths.find((p) => p.startsWith(`${appDir}/`) && catches(p)) ?? null;
+}
+function alreadyWired(project, mode, appDir, files, paths) {
+  if (mode === "bilingual") {
+    const prefix = `${appDir}/[locale]/`;
+    return paths.find((p) => p.startsWith(prefix) && LAYOUT.test(p.slice(prefix.length))) ?? null;
+  }
+  const wired = (files(project.entry) ?? "").includes("NextIntlClientProvider") && files(`${sourceBase(project)}i18n/request.ts`) !== null;
+  return wired ? project.entry : null;
+}
+function findMiddleware(base, files) {
+  const found = [];
+  for (const name of ["middleware", "proxy"]) {
+    for (const ext of ["ts", "js", "mjs", "tsx", "jsx"]) {
+      const path = `${base}${name}.${ext}`;
+      const text = files(path);
+      if (text !== null) found.push({ path, text });
+    }
+  }
+  if (found.length > 1) throw new UnsupportedError(`This app has both ${found[0].path} and ${found[1].path}. Convert cannot tell which one to compose with next-intl, so it stopped before changing anything.`);
+  const only = found[0] ?? null;
+  if (only && !EXPORTS_HANDLER.test(only.text)) {
+    throw new UnsupportedError(`Convert could not find the middleware function exported from ${only.path}, so it stopped before changing anything.`);
+  }
+  return only;
+}
+var EXPORTS_HANDLER = /export\s+default\b|export\s+(?:async\s+)?function\s+(?:middleware|proxy)\b|export\s+(?:const|let|var)\s+(?:middleware|proxy)\b|export\s*\{[^}]*\b(?:middleware|proxy|default)\b[^}]*\}/;
+var movedMiddlewarePath = (base, existing) => `${base}app-middleware.${existing.split(".").pop()}`;
+var merge = (into, from) => {
+  const out = { ...into };
+  for (const [path, edits2] of Object.entries(from)) out[path] = [...out[path] ?? [], ...edits2];
+  return out;
+};
+function bilingualParts(project, appDir, files, paths) {
+  const base = sourceBase(project);
+  const { moves, keptPages } = routeMoves(appDir, paths);
+  const middlewarePath = `${base}${nextMajor(files) >= 16 ? "proxy" : "middleware"}.ts`;
+  const own = findMiddleware(base, files);
+  const routingSpec = specifierTo(middlewarePath, `${base}i18n/routing.ts`);
+  const ownMoved = own ? movedMiddlewarePath(base, own.path) : null;
+  if (ownMoved && files(ownMoved) !== null) {
+    throw new UnsupportedError(`This app already has ${ownMoved}. Convert needs that name for the app's own middleware, so move or remove that file and run convert again.`);
+  }
+  const middleware = ownMoved ? composedMiddlewareFile(routingSpec, specifierTo(middlewarePath, `${base}i18n/app-matcher.ts`), specifierTo(middlewarePath, ownMoved)) : middlewareFile(routingSpec);
+  const catchAll = topCatchAll(appDir, moves, paths);
+  const flags = keptPages.map((page) => flagAt(
+    page,
+    "unsupported",
+    `${page} stays outside [locale], because the middleware skips its path, so it has no Arabic version.`,
+    "Move the page to a path the middleware matches, or translate it by hand."
+  ));
+  if (own && ownMoved) {
+    flags.push(flagAt(
+      ownMoved,
+      "info",
+      `${own.path} moved to ${ownMoved}, and the new ${middlewarePath} runs it first on the path without its locale prefix, then next-intl.`,
+      "Check the app middleware still behaves as before and that its auth checks still hold under /ar. Any answer other than a plain continue (a redirect, rewrite or 401) is returned as it is. Paths under /api and /trpc skip next-intl. Config options other than matcher, such as runtime, are not carried over, and has or missing conditions on a matcher entry are ignored, so the middleware runs on those paths."
+    ));
+  }
+  if (catchAll) {
+    flags.push(flagAt(
+      catchAll,
+      "unsupported",
+      `${catchAll} already catches every path under [locale], so convert did not add its own catch-all.`,
+      "Call notFound() from next/navigation in that page for paths it does not know, so unknown URLs keep showing the not-found page."
+    ));
+  }
+  const writes = {
+    [`${base}i18n/routing.ts`]: ROUTING,
+    [`${base}i18n/navigation.ts`]: NAVIGATION,
+    [middlewarePath]: middleware,
+    ...own ? { [`${base}i18n/app-matcher.ts`]: APP_MATCHER } : {},
+    [switchPath(project)]: switchFile(specifierTo(switchPath(project), `${base}i18n/navigation.ts`)),
+    ...catchAll ? {} : { [`${appDir}/[locale]/[...rest]/page.tsx`]: CATCH_ALL }
+  };
+  const rewrites = importRewrites(appDir, moves, paths, files, readAliases(files));
+  const ownMove = own && ownMoved ? [[own.path, ownMoved]] : [];
+  return { moves: [...moves, ...ownMove], writes, flags: [...flags, ...rewrites.flags], edits: rewrites.edits };
+}
+function wireNextIntl(project, mode, files, paths) {
+  const appDir = project.appDir ?? "app";
+  const wired = alreadyWired(project, mode, appDir, files, paths);
+  if (wired) {
+    const flag3 = flagAt(wired, "info", "This app is already wired for next-intl, so convert left its locale setup as it is.", "Nothing to do.");
+    return { writes: {}, edits: {}, moves: [], deps: {}, flags: [flag3] };
+  }
+  const base = sourceBase(project);
+  const i18nDir = `${base}i18n`;
+  const messages = import_node_path13.posix.relative(i18nDir, "messages");
+  const config = nextConfigPlan(files);
+  const parts = mode === "bilingual" ? bilingualParts(project, appDir, files, paths) : { moves: [], writes: {}, edits: {}, flags: [] };
+  const writes = {
+    ...parts.writes,
+    [`${i18nDir}/request.ts`]: requestFile(mode, messages, hasRootParams(files)),
+    [localeHelperPath(project)]: LOCALE_HELPER,
+    ...config.writes
+  };
+  const moved = new Set(parts.moves.map(([from]) => from));
+  guardWrites(writes, files, moved);
+  const layoutPath = moved.has(project.entry) ? localePath(appDir, project.entry) : project.entry;
+  const layoutText = files(project.entry);
+  if (layoutText === null) throw new UnsupportedError(`Convert could not read the root layout at ${project.entry}.`);
+  const layout = layoutEdits(layoutPath, layoutText, mode, {
+    routing: specifierTo(layoutPath, `${i18nDir}/routing.ts`),
+    promiseParams: nextMajor(files) >= 15
+  });
+  const edits2 = merge(merge(parts.edits, config.edits), layout.length ? { [layoutPath]: layout } : {});
+  return { writes, edits: edits2, moves: parts.moves, deps: { ...DEPS }, flags: parts.flags };
+}
+
+// src/generate/react-i18next.ts
+var import_lint6 = require("@dualkit/lint");
+var import_node_path14 = require("path");
+var DEPS2 = { "react-i18next": "17.1.6", i18next: "26.5.8" };
+var INIT_PATH = "src/i18n.ts";
+var HTML_PATH = "index.html";
+var COOKIE_PATTERN = `/(?:^|; )${LOCALE_COOKIE}=([^;]*)/`;
+var messagesImport = (locale) => `import ${locale} from '${import_node_path14.posix.relative(import_node_path14.posix.dirname(INIT_PATH), `messages/${locale}.json`)}'`;
+function initFile(mode) {
+  const head = "import i18n from 'i18next'\nimport { initReactI18next } from 'react-i18next'\n";
+  const options = (resources, lng, fallback) => `void i18n.use(initReactI18next).init({
+  resources: ${resources},
+  lng: ${lng},
+  fallbackLng: '${fallback}',
+  initAsync: false,
+  interpolation: { prefix: '{', suffix: '}', escapeValue: false },
+})
+
+export default i18n
+`;
+  if (mode === "arabic") return `${head}${messagesImport("ar")}
+
+${options("{ ar: { translation: ar } }", "'ar'", "ar")}`;
+  return `${head}${messagesImport("en")}
+${messagesImport("ar")}
+
+/** The locale saved in the ${LOCALE_COOKIE} cookie, else English. */
+function savedLocale(): 'en' | 'ar' {
+  const match = ${COOKIE_PATTERN}.exec(document.cookie)
+  return match?.[1] === 'ar' ? 'ar' : 'en'
+}
+
+` + options("{ en: { translation: en }, ar: { translation: ar } }", "savedLocale()", "en");
+}
+var switchFile2 = () => `import { useTranslation } from 'react-i18next'
+
+const CHOICES = ${SWITCH_CHOICES}
+
+/** Buttons for English and Arabic. Not placed by convert: add it where the app keeps its navigation. */
+export function DualkitLanguageSwitch() {
+  const { i18n } = useTranslation()
+  const choose = (code: string): void => {
+    document.cookie = \`${LOCALE_COOKIE}=\${code}; path=/; max-age=31536000; samesite=lax\`
+    window.location.reload()
+  }
+  return (
+    <nav aria-label="Language">
+      {CHOICES.map(({ code, label }) => (
+        <button key={code} type="button" lang={code} aria-current={i18n.language === code ? 'true' : undefined} onClick={() => choose(code)}>
+          {label}
+        </button>
+      ))}
+    </nav>
+  )
+}
+`;
+var INLINE_SCRIPT = `<script>(function(){var m=document.cookie.match(${COOKIE_PATTERN});var l=m&&m[1]==='ar'?'ar':'en';var h=document.documentElement;h.lang=l;h.dir=l==='ar'?'rtl':'ltr'})()</script>`;
+function htmlEdits2(html, mode) {
+  if (mode === "bilingual") {
+    if (html.includes(LOCALE_COOKIE)) return [];
+    const head = /<head\b[^>]*>/i.exec(html);
+    if (!head) return [];
+    const at2 = head.index + head[0].length;
+    return [{ start: at2, end: at2, text: `
+    ${INLINE_SCRIPT}` }];
+  }
+  const open = /<html\b([^>]*)>/i.exec(html);
+  if (!open) return [];
+  const rest = open[1].replace(/\s(lang|dir)\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+  const text = `<html lang="ar" dir="rtl"${rest}>`;
+  return text === open[0] ? [] : [{ start: open.index, end: open.index + open[0].length, text }];
+}
+function titleFlags(html) {
+  const title = /<title\b[^>]*>([^<]*)<\/title>/i.exec(html);
+  const text = title?.[1].trim() ?? "";
+  if (!title || !/[A-Za-z]/.test(text) || /\{\{|%\w+%/.test(text)) return [];
+  return [{
+    file: HTML_PATH,
+    line: lineOf(html, title.index),
+    kind: "outside-component",
+    message: `The page title "${text}" in index.html stays in English.`,
+    suggestion: "Translate it in index.html for an Arabic-only app, or set document.title from a translated string in a component."
+  }];
+}
+function entryEdits(entry, text) {
+  const outcome = (0, import_lint6.parseSourceOutcome)(entry, text);
+  const block = "file" in outcome ? outcome.file.js[0] : void 0;
+  if (!block) return [];
+  const program = block.ast.program;
+  const spec = specifierTo(entry, INIT_PATH);
+  const has = (program.body ?? []).some((s) => s.type === "ImportDeclaration" && [spec, `${spec}.ts`].includes(String(s.source.value)));
+  if (has) return [];
+  return [sideEffectImport(program, spec, block.offset, styleOf(program, text, block.offset))];
+}
+function wireReactI18next(project, mode, files) {
+  const writes = {
+    [INIT_PATH]: initFile(mode),
+    [localeHelperPath(project)]: LOCALE_HELPER,
+    ...mode === "bilingual" ? { [switchPath(project)]: switchFile2() } : {}
+  };
+  guardWrites(writes, files, /* @__PURE__ */ new Set());
+  const edits2 = {};
+  const html = files(HTML_PATH);
+  const htmlChange = html === null ? [] : htmlEdits2(html, mode);
+  if (htmlChange.length) edits2[HTML_PATH] = htmlChange;
+  const entry = files(project.entry);
+  const entryChange = entry === null ? [] : entryEdits(project.entry, entry);
+  if (entryChange.length) edits2[project.entry] = entryChange;
+  return { writes, edits: edits2, moves: [], deps: { ...DEPS2 }, flags: html === null ? [] : titleFlags(html) };
+}
+
+// src/lint-context.ts
+var import_lint7 = require("@dualkit/lint");
+var import_node_path15 = require("path");
+var POSTCSS_LANGS = /* @__PURE__ */ new Set(["css", "scss", "vue", "svelte"]);
+function physicalContext(root) {
+  const cwd = (0, import_node_path15.resolve)(root);
+  const top = (0, import_lint7.repoTop)(cwd) ?? cwd;
+  const postcssOf = (0, import_lint7.createFlipperLookup)(top, import_lint7.POSTCSS_FLIPPERS);
+  const stylisOf = (0, import_lint7.createFlipperLookup)(top, import_lint7.STYLIS_FLIPPERS);
+  const blockFlipper = (file, block) => block.fromTemplate ? stylisOf(file.abs) : POSTCSS_LANGS.has(file.lang) ? postcssOf(file.abs) : null;
+  const reasons = /* @__PURE__ */ new Map();
+  const physicalQuiet = (file) => {
+    const known = reasons.get(file.path);
+    if (known !== void 0) return known;
+    const flipped = file.css.some((block) => blockFlipper(file, block) !== null);
+    const reason = (0, import_lint7.quietReason)(file.path, file.text) ?? (flipped ? "flipped" : null);
+    reasons.set(file.path, reason);
+    return reason;
+  };
+  return { blockFlipper, physicalQuiet };
+}
+
+// src/passes.ts
+var import_lint11 = require("@dualkit/lint");
+
+// src/transforms/css.ts
+var import_lint9 = require("@dualkit/lint");
+
+// src/transforms/css-values.ts
+function splitSpaces(value) {
+  const out = [];
+  let depth = 0;
+  let quote = "";
+  let from = -1;
+  for (let i = 0; i <= value.length; i++) {
+    const ch = value[i] ?? " ";
+    if (quote) {
+      if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === "(") depth++;
+    else if (ch === ")" && depth > 0) depth--;
+    const space = depth === 0 && /\s/.test(ch);
+    if (!space && from === -1) from = i;
+    if (space && from !== -1) {
+      out.push(value.slice(from, i));
+      from = -1;
+    }
+  }
+  return out;
+}
+function splitCommas(value) {
+  const out = [];
+  let depth = 0;
+  let from = 0;
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch === "(") depth++;
+    else if (ch === ")" && depth > 0) depth--;
+    else if (ch === "," && depth === 0) {
+      out.push(value.slice(from, i));
+      from = i + 1;
+    }
+  }
+  return [...out, value.slice(from)];
+}
+var BOX = /* @__PURE__ */ new Set(["margin", "padding"]);
+function splitShorthand(prop, value, normalised) {
+  if (!BOX.has(prop) || /[$@]|#\{/.test(value)) return null;
+  const raw = splitSpaces(value);
+  const norm = splitSpaces(normalised);
+  if (raw.length !== 4 || norm.length !== 4 || norm[1] === norm[3]) return null;
+  return { property: prop, block: `${raw[0]} ${raw[2]}`, inline: `${raw[3]} ${raw[1]}` };
+}
+var ZERO = /^[+-]?0*\.?0+[a-z%]*$/;
+var LENGTH = /^[+-]?(?:\d|\.\d)/;
+var CENTRE = /^[+-]?50%$/;
+var CENTRE_SIBLINGS = /* @__PURE__ */ new Set(["left", "right", "inset-inline-start", "inset-inline-end"]);
+var hasCentreOffset = (live) => (live.decl.parent?.nodes ?? []).some((n) => n.type === "decl" && CENTRE_SIBLINGS.has(n.prop.toLowerCase()) && n.value.trim() === "50%");
+function translateMoves(live) {
+  for (const m of live.value.matchAll(/translate(?:x|3d)?\(\s*([^,)]*)/g)) {
+    const x = m[1].trim();
+    if (ZERO.test(x)) continue;
+    if (CENTRE.test(x) && hasCentreOffset(live)) continue;
+    return true;
+  }
+  return false;
+}
+function shadowMoves(value) {
+  return splitCommas(value).some((shadow) => {
+    const x = splitSpaces(shadow).filter((t) => t !== "inset")[0];
+    return x !== void 0 && LENGTH.test(x) && !ZERO.test(x);
+  });
+}
+var SIDE_WORD = /(?:^|\s)(?:left|right)(?=$|\s)/;
+function corners(value) {
+  if (value.includes("/")) return null;
+  const t = splitSpaces(value);
+  const [a, b, c, d] = t;
+  if (t.length === 1) return [a, a, a, a];
+  if (t.length === 2) return [a, b, a, b];
+  if (t.length === 3) return [a, b, c, b];
+  return t.length === 4 ? [a, b, c, d] : null;
+}
+function sidesDiffer(prop, value) {
+  if (prop === "border-width") {
+    const t = splitSpaces(value);
+    return t.length === 4 && t[1] !== t[3];
+  }
+  const c = corners(value);
+  return c !== null && (c[0] !== c[1] || c[3] !== c[2]);
+}
+var MOVES = {
+  transform: "A horizontal translate moves the same way in Arabic. Use a logical offset, or flip the sign for Arabic with `:dir(rtl)`.",
+  "background-position": "A background placed left or right stays there in Arabic. Use `:dir(rtl)` with the opposite side.",
+  "box-shadow": "A shadow with a horizontal offset falls on the same side in Arabic. Use `:dir(rtl)` with the offset negated.",
+  "border-width": "A border width cannot be set per logical side in one shorthand. Use border-inline-start-width and border-inline-end-width.",
+  "border-radius": "Corner radii cannot be set per logical side in one shorthand. Use border-start-start-radius and its three siblings."
+};
+function noLogicalForm(live) {
+  const { prop, value } = live;
+  const hit = prop === "transform" ? translateMoves(live) : prop === "background-position" || prop === "background-position-x" ? SIDE_WORD.test(value) : prop === "box-shadow" ? shadowMoves(value) : prop === "border-width" || prop === "border-radius" ? sidesDiffer(prop, value) : false;
+  return hit ? MOVES[prop === "background-position-x" ? "background-position" : prop] ?? null : null;
+}
+
+// src/transforms/css-jsx.ts
+var import_lint8 = require("@dualkit/lint");
+var SKIP4 = /* @__PURE__ */ new Set(["loc", "leadingComments", "trailingComments", "innerComments", "extra"]);
+function* styleObjects(node) {
+  if (Array.isArray(node)) for (const child of node) yield* styleObjects(child);
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const n = node;
+  if (n.type === "JSXAttribute" && n.name?.name === "style") {
+    const expression = n.value?.type === "JSXExpressionContainer" ? n.value.expression : void 0;
+    if (expression?.type === "ObjectExpression") yield expression;
+    return;
+  }
+  for (const [key, child] of Object.entries(n)) if (!SKIP4.has(key)) yield* styleObjects(child);
+}
+var kebab2 = (name) => name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+var camel = (name) => name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+var span = (n, base) => ({ start: base + n.start, end: base + n.end });
+function keyOf(property, base) {
+  const key = property.key;
+  if (property.computed || key.type !== "Identifier" && key.type !== "StringLiteral") return null;
+  const name = key.type === "Identifier" ? key.name : String(key.value);
+  if (!/^[a-z][A-Za-z]*$/.test(name)) return null;
+  return { name, ...span(key, base), quote: key.type === "StringLiteral" ? "x" : "" };
+}
+function entryOf(property, base, text, dynamic) {
+  if (property.type !== "ObjectProperty") return null;
+  const key = keyOf(property, base);
+  if (!key) return null;
+  const value = property.value;
+  const at2 = span(value, base);
+  const quote = text[at2.start];
+  const literal = value.type === "StringLiteral" ? { ...at2, quote } : null;
+  const written = value.type === "StringLiteral" ? String(value.value) : value.type === "NumericLiteral" ? `${String(value.value)}px` : dynamic(text.slice(at2.start, at2.end));
+  return {
+    prop: kebab2(key.name),
+    value: written.replace(/\s+/g, " "),
+    key: { start: key.start, end: key.end, quote: key.quote ? text[key.start] : "" },
+    literal,
+    whole: span(property, base)
+  };
+}
+var requote = (quote, inner) => `${quote}${inner}${quote}`;
+function edits(entry, live, physical) {
+  const split = splitShorthand(live.prop, entry.value, live.value);
+  if (split && entry.literal) {
+    const q = entry.literal.quote;
+    const text = `${camel(split.property)}Block: ${requote(q, split.block)}, ${camel(split.property)}Inline: ${requote(q, split.inline)}`;
+    return [{ ...entry.whole, text }];
+  }
+  if (physical?.property) return [{ start: entry.key.start, end: entry.key.end, text: requote(entry.key.quote, camel(physical.property)) }];
+  if (physical?.word && entry.literal) return [{ start: entry.literal.start, end: entry.literal.end, text: requote(entry.literal.quote, physical.word) }];
+  return [];
+}
+function jsxStyleResult(file) {
+  const editsOut = [];
+  const flags = [];
+  for (const block of file.js) {
+    for (const object of styleObjects(block.ast.program)) {
+      const ids = /* @__PURE__ */ new Map();
+      const dynamic = (source) => {
+        if (!ids.has(source)) ids.set(source, `$${"x".repeat(ids.size + 1)}`);
+        return ids.get(source);
+      };
+      const entries = (object.properties ?? []).map((p) => entryOf(p, block.offset, file.text, dynamic)).filter((e) => e !== null);
+      const starts = [];
+      let css = "";
+      for (const e of entries) {
+        starts.push(css.length);
+        css += `${e.prop}: ${e.value};
+`;
+      }
+      const synthetic = (0, import_lint8.parseSource)("style-object.css", css);
+      if (!synthetic) continue;
+      const entryAt = (offset) => entries[starts.indexOf(offset)];
+      const physical = new Map((0, import_lint8.physicalDeclarations)(synthetic).map((d) => [d.offset, d]));
+      for (const live of (0, import_lint8.liveDeclarations)(synthetic)) {
+        const entry = entryAt(live.offset);
+        if (!entry) continue;
+        editsOut.push(...edits(entry, live, physical.get(live.offset) ?? null));
+        const suggestion = noLogicalForm(live);
+        if (suggestion) {
+          const message = `\`${entry.prop}: ${live.shown}\` has no logical form in CSS and stays physical in Arabic.`;
+          flags.push({ file: file.path, line: lineOf(file.text, entry.whole.start), kind: "no-logical-form", message, suggestion });
+        }
+      }
+    }
+  }
+  return { edits: editsOut, flags };
+}
+
+// src/transforms/css.ts
+function spans(file, d) {
+  const end = d.block.offset + (d.decl.source?.end?.offset ?? -1) + 1;
+  const name = d.offset + d.decl.prop.length;
+  const value = name + (d.decl.raws.between?.length ?? 0);
+  if (end <= value || file.text.slice(d.offset, name).toLowerCase() !== d.prop) return null;
+  return { start: d.offset, name, value, end };
+}
+function renameEdits(file, d) {
+  const at2 = spans(file, d);
+  if (!at2) return [];
+  if (d.property) return [{ start: at2.start, end: at2.name, text: d.property }];
+  if (!d.word || file.text.slice(at2.value, at2.value + d.decl.value.length) !== d.decl.value) return [];
+  return [{ start: at2.value, end: at2.value + d.decl.value.length, text: d.word }];
+}
+function shorthandEdits(file, d) {
+  const split = splitShorthand(d.prop, d.decl.value, d.value);
+  const at2 = spans(file, d);
+  if (!split || !at2 || d.decl.raws.value) return [];
+  const important = d.decl.important ? d.decl.raws.important ?? " !important" : "";
+  const text = `${split.property}-block: ${split.block}${important}; ${split.property}-inline: ${split.inline}${important}`;
+  const raw = file.text.slice(at2.start, at2.end);
+  return [{ start: at2.start, end: at2.start + raw.replace(/\s*;?\s*$/, "").length, text }];
+}
+function noFormFlag(file, d) {
+  const suggestion = noLogicalForm(d);
+  if (!suggestion) return [];
+  const message = `\`${d.prop}: ${d.shown}\` has no logical form in CSS and stays physical in Arabic.`;
+  return [{ file: file.path, line: lineOf(file.text, d.offset), kind: "no-logical-form", message, suggestion }];
+}
+function cssEdits(file, ctx = {}) {
+  const live = (0, import_lint9.liveDeclarations)(file, ctx);
+  const edits2 = [
+    ...(0, import_lint9.physicalDeclarations)(file, ctx).flatMap((d) => renameEdits(file, d)),
+    ...live.flatMap((d) => shorthandEdits(file, d))
+  ];
+  const flags = live.flatMap((d) => noFormFlag(file, d));
+  const quiet = ctx.physicalQuiet?.(file);
+  const jsx = quiet && quiet !== "flipped" ? { edits: [], flags: [] } : jsxStyleResult(file);
+  return { edits: [...edits2, ...jsx.edits], flags: [...flags, ...jsx.flags].sort((a, b) => a.line - b.line) };
+}
+
+// src/transforms/formats.ts
+var SKIP5 = /* @__PURE__ */ new Set(["loc", "leadingComments", "trailingComments", "innerComments", "extra"]);
+var INTL = /* @__PURE__ */ new Set(["NumberFormat", "DateTimeFormat"]);
+var TO_LOCALE = /* @__PURE__ */ new Set(["toLocaleString", "toLocaleDateString", "toLocaleTimeString"]);
+var ENGLISH = /^en(-[A-Za-z0-9]+)*$/i;
+var DATE_NAME = /Date|Calendar|Picker/;
+var PICKERS = [
+  [/^react-day-picker$/, null],
+  [/^react-datepicker$/, null],
+  [/^react-calendar$/, null],
+  [/^react-date-range$/, null],
+  [/^react-big-calendar$/, null],
+  [/^react-flatpickr$/, null],
+  [/^@fullcalendar\/react$/, null],
+  [/^primereact\/calendar$/, null],
+  [/^@mui\/x-date-pickers(-pro)?(\/.*)?$/, DATE_NAME],
+  [/^@mantine\/dates$/, DATE_NAME],
+  [/^@ark-ui\/react(\/.*)?$/, /DatePicker/],
+  [/^(@heroui|@nextui-org)\/(react|date-picker|calendar)$/, DATE_NAME],
+  [/^antd$/, /^(DatePicker|Calendar)$/]
+];
+var idName2 = (node) => node?.type === "Identifier" ? node.name : void 0;
+var statementsOf = (fn) => fn.body.type === "BlockStatement" ? fn.body.body ?? [] : [];
+var callOf = (d) => {
+  const init = d?.init;
+  return init?.type === "AwaitExpression" ? init.argument : init ?? void 0;
+};
+function isOwnLocale(statement, lib) {
+  const [d, extra] = statement.declarations ?? [];
+  const call = callOf(d);
+  if (statement.type !== "VariableDeclaration" || extra || call?.type !== "CallExpression" || (call.arguments ?? []).length) return false;
+  const callee = idName2(call.callee);
+  const id = d.id;
+  if (lib === "react-i18next") {
+    const props = id.type === "ObjectPattern" ? id.properties ?? [] : [];
+    return callee === "useTranslation" && props.length === 1 && idName2(props[0].value) === "i18n";
+  }
+  return idName2(id) === "locale" && (callee === "useLocale" || callee === "getLocale");
+}
+var bindingName = (lib) => lib === "react-i18next" ? "i18n" : "locale";
+var localeExpression = (lib) => lib === "react-i18next" ? "i18n.language" : "locale";
+function isFormatCall(call) {
+  const callee = call.callee;
+  if (callee.type !== "MemberExpression" && callee.type !== "OptionalMemberExpression") return false;
+  if (callee.computed) return false;
+  const property = idName2(callee.property);
+  const isIntl = idName2(callee.object) === "Intl" && INTL.has(property ?? "");
+  const isToLocale = call.type !== "NewExpression" && TO_LOCALE.has(property ?? "");
+  return isIntl || isToLocale;
+}
+function localeArgument(call) {
+  if (!isFormatCall(call)) return null;
+  const arg = (call.arguments ?? [])[0];
+  return arg?.type === "StringLiteral" && ENGLISH.test(String(arg.value)) ? arg : null;
+}
+function usesBrowserLocale(call) {
+  if (!isFormatCall(call)) return false;
+  const arg = (call.arguments ?? [])[0];
+  return !arg || idName2(arg) === "undefined";
+}
+function flag2(ctx, offset, message, suggestion) {
+  ctx.flags.push({ file: ctx.file.path, line: lineOf(ctx.file.text, offset), kind: "format", message, suggestion });
+}
+var helperName = (helper) => helper.replace(/\.(tsx?|jsx?)$/, "");
+function clashes(ctx, ancestors, fn) {
+  const name = bindingName(ctx.lib);
+  const from = ancestors.indexOf(fn);
+  return ancestors.slice(from).some((node) => {
+    if (node === fn.body && statementsOf(fn).some((s) => isOwnLocale(s, ctx.lib))) return false;
+    return scopeNames(node).includes(name);
+  });
+}
+function visitLocale(arg, ctx, ancestors) {
+  const start2 = ctx.base + arg.start;
+  const value = String(arg.value);
+  const fn = componentOf(ancestors);
+  const hook = fn ? statementsOf(fn).find(isOwnHook) : void 0;
+  if (!fn || !hook) {
+    flag2(
+      ctx,
+      start2,
+      `The locale '${value}' is fixed here, so Arabic pages show English number and date formats.`,
+      `Pass the active locale through dkIntlLocale from ${helperName(ctx.helper)}, or move this into a component that has the translation hook.`
+    );
+    return;
+  }
+  if (clashes(ctx, ancestors, fn)) {
+    flag2(
+      ctx,
+      start2,
+      `The locale '${value}' was left as it is: a variable named ${bindingName(ctx.lib)} is already in scope.`,
+      `Rename that variable, then run convert again, or pass dkIntlLocale(${localeExpression(ctx.lib)}) by hand.`
+    );
+    return;
+  }
+  ctx.edits.push({ start: start2, end: ctx.base + arg.end, text: `dkIntlLocale(${localeExpression(ctx.lib)})` });
+  if (!ctx.hooked.has(fn)) ctx.hooked.set(fn, { fn, hook, own: statementsOf(fn).find((s) => isOwnLocale(s, ctx.lib)) ?? null });
+}
+function visitCurrency(property, ctx) {
+  const key = property.key;
+  const name = key.type === "Identifier" && !property.computed ? key.name : key.type === "StringLiteral" ? key.value : void 0;
+  const value = property.value;
+  if (name !== "currency" || value.type !== "StringLiteral" || value.value !== "USD") return;
+  flag2(
+    ctx,
+    ctx.base + value.start,
+    "Prices are formatted in US dollars.",
+    "Offer AED for Gulf customers, with VAT shown on prices."
+  );
+}
+function visitImport(declaration, ctx) {
+  if (declaration.importKind === "type") return;
+  const source = String(declaration.source.value);
+  const match = PICKERS.find(([pattern]) => pattern.test(source));
+  if (!match) return;
+  const names = (declaration.specifiers ?? []).filter((s) => s.importKind !== "type").map((s) => s.local.name);
+  const picked = match[1] ? names.filter((n) => match[1].test(n)) : names;
+  if (!picked.length) return;
+  flag2(
+    ctx,
+    ctx.base + declaration.start,
+    `${picked.join(", ")} from ${source} is a date picker or calendar with its own week start and calendar system.`,
+    "Start weeks on Saturday for Gulf users and offer Hijri dates beside Gregorian ones where dates matter."
+  );
+}
+function walk2(node, ctx, ancestors) {
+  if (Array.isArray(node)) return node.forEach((child) => walk2(child, ctx, ancestors));
+  if (!node || typeof node !== "object") return;
+  const n = node;
+  if (n.type === "CallExpression" || n.type === "OptionalCallExpression" || n.type === "NewExpression") {
+    const arg = localeArgument(n);
+    if (arg) visitLocale(arg, ctx, ancestors);
+    else if (usesBrowserLocale(n)) {
+      flag2(
+        ctx,
+        ctx.base + n.start,
+        "This formats in the browser's own locale, so an Arabic page can show an English date or number, such as 11/1/2026 for 1 November.",
+        `Pass dkIntlLocale(${localeExpression(ctx.lib)}) from ${helperName(ctx.helper)} as the locale, so the format follows the page language.`
+      );
+    }
+  }
+  if (n.type === "ObjectProperty") visitCurrency(n, ctx);
+  if (n.type === "ImportDeclaration") visitImport(n, ctx);
+  const next = typeof n.type === "string" ? [...ancestors, n] : ancestors;
+  for (const [key, child] of Object.entries(n)) if (!SKIP5.has(key)) walk2(child, ctx, next);
+}
+var indentAt3 = (text, offset) => /^[ \t]*/.exec(text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset))[0];
+function localeStatement(lib, async) {
+  if (lib === "react-i18next") return { statement: "const { i18n } = useTranslation()", import: { name: "useTranslation", source: "react-i18next" } };
+  return async ? { statement: "const locale = await getLocale()", import: { name: "getLocale", source: "next-intl/server" } } : { statement: "const locale = useLocale()", import: { name: "useLocale", source: "next-intl" } };
+}
+function bindingEdits(ctx, style) {
+  const imports = [];
+  for (const { fn, hook, own } of ctx.hooked.values()) {
+    if (own) continue;
+    const binding = localeStatement(ctx.lib, Boolean(fn.async));
+    const end = ctx.base + hook.end;
+    const indent = indentAt3(ctx.file.text, ctx.base + hook.start);
+    ctx.edits.push({ start: end, end, text: `
+${indent}${binding.statement}${style.semi}` });
+    imports.push(binding.import);
+  }
+  return imports;
+}
+function formatEdits(file, lib, helper) {
+  const edits2 = [];
+  const flags = [];
+  for (const block of file.js) {
+    const program = block.ast.program;
+    const ctx = { file, base: block.offset, lib, helper, edits: edits2, flags, hooked: /* @__PURE__ */ new Map() };
+    const before = edits2.length;
+    walk2(program, ctx, []);
+    if (edits2.length === before) continue;
+    const style = styleOf(program, file.text, ctx.base);
+    const imports = bindingEdits(ctx, style);
+    const helperImport = { name: "dkIntlLocale", source: specifierTo(file.path, helper) };
+    edits2.push(...addImports(program, [...imports, helperImport], ctx.base, style));
+  }
+  return { edits: edits2, flags };
+}
+
+// src/transforms/markup.ts
+var SKIP6 = /* @__PURE__ */ new Set(["loc", "leadingComments", "trailingComments", "innerComments", "extra"]);
+var ICON_SOURCES = ["lucide-react", "@radix-ui/react-icons", "@tabler/icons-react", "@phosphor-icons/react"];
+var ICON_PREFIXES = ["@heroicons/react/", "react-icons/"];
+var MIRROR_ICON = /(Arrow|Chevron|Chevrons|Caret|Angle|Triangle)(Left|Right)|ArrowBack|ArrowForward|Undo|Redo|Reply|Forward|Send|LogIn|LogOut|SignIn|SignOut|Indent|Outdent/;
+var NEVER_MIRROR = /Play|Pause|FastForward|Rewind|Skip|Clock|Timer|Check|Music|Logo|Brand|Github|Twitter|X$/;
+var NUMBER_NAME = /(price|amount|total|subtotal|cost|fee|balance|phone|mobile|tel|qty|quantity|count)$/i;
+var NUMBER_CALL = /^(toLocaleString|toFixed|format.*)$/;
+var DIRECTION_LABEL = /\b(back|prev|previous|next|forward)\b/i;
+var LTR_TYPES = /* @__PURE__ */ new Set(["tel", "email", "url"]);
+var isIconSource = (source) => ICON_SOURCES.includes(source) || ICON_PREFIXES.some((p) => source.startsWith(p));
+function iconImports(program) {
+  const found = /* @__PURE__ */ new Map();
+  for (const statement of program.body ?? []) {
+    if (statement.type !== "ImportDeclaration" || !isIconSource(String(statement.source.value))) continue;
+    for (const spec of statement.specifiers ?? []) {
+      const local = spec.local.name;
+      const imported = spec.type === "ImportSpecifier" ? spec.imported.name ?? spec.imported.value : local;
+      found.set(local, String(imported));
+    }
+  }
+  return found;
+}
+var isMirrored = (imported) => MIRROR_ICON.test(imported) && !NEVER_MIRROR.test(imported);
+var tagName = (opening) => {
+  const name = opening.name;
+  return name.type === "JSXIdentifier" ? name.name : null;
+};
+var attributes = (opening) => (opening.attributes ?? []).filter((a) => a.type === "JSXAttribute");
+var attributeNamed = (opening, name) => attributes(opening).find((a) => a.name.name === name);
+function literalValue(attribute) {
+  const value = attribute?.value;
+  if (value?.type === "StringLiteral") return String(value.value);
+  const inner = value?.type === "JSXExpressionContainer" ? value.expression : void 0;
+  return inner?.type === "StringLiteral" ? String(inner.value) : null;
+}
+function lastName(expression) {
+  if (expression.type === "Identifier") return expression.name;
+  if (expression.type === "MemberExpression" || expression.type === "OptionalMemberExpression") {
+    const property = expression.property;
+    return !expression.computed && property.type === "Identifier" ? property.name : null;
+  }
+  return null;
+}
+function isNumberExpression(expression) {
+  if (expression.type === "CallExpression" || expression.type === "OptionalCallExpression") {
+    const name2 = lastName(expression.callee);
+    return name2 !== null && NUMBER_CALL.test(name2);
+  }
+  const name = lastName(expression);
+  return name !== null && NUMBER_NAME.test(name);
+}
+function labelOf(element) {
+  const opening = element.openingElement;
+  const own = [literalValue(attributeNamed(opening, "aria-label")), literalValue(attributeNamed(opening, "title"))];
+  const text = (element.children ?? []).filter((c) => c.type === "JSXText").map((c) => String(c.value));
+  return [...own, ...text].filter(Boolean).join(" ");
+}
+function alreadyMirrored(opening, ctx) {
+  if (attributeNamed(opening, "data-dk-mirror")) return true;
+  return ["className", "class"].some((name) => {
+    const attribute = attributeNamed(opening, name);
+    return attribute !== void 0 && /(?:^|[\s"'`{])rtl:/.test(ctx.file.text.slice(ctx.base + attribute.start, ctx.base + attribute.end));
+  });
+}
+function visitOpening(opening, ctx, ancestors) {
+  const name = tagName(opening);
+  if (!name) return;
+  const after = ctx.base + opening.name.end;
+  if (ctx.icons.has(name) && isMirrored(ctx.icons.get(name)) && !alreadyMirrored(opening, ctx)) {
+    ctx.edits.push({ start: after, end: after, text: ' data-dk-mirror=""' });
+  }
+  if (name === "input" && LTR_TYPES.has(literalValue(attributeNamed(opening, "type")) ?? "") && !attributeNamed(opening, "dir")) {
+    ctx.edits.push({ start: after, end: after, text: ' dir="ltr"' });
+  }
+  if (name === "svg") flagSvg(opening, ctx, ancestors);
+}
+function flagSvg(opening, ctx, ancestors) {
+  if (alreadyMirrored(opening, ctx)) return;
+  const control = [...ancestors].reverse().find((a) => a.type === "JSXElement" && ["button", "a"].includes(tagName(a.openingElement) ?? ""));
+  if (!control || !DIRECTION_LABEL.test(labelOf(control))) return;
+  ctx.flags.push({
+    file: ctx.file.path,
+    line: lineOf(ctx.file.text, ctx.base + opening.start),
+    kind: "inline-svg-icon",
+    message: "An inline svg sits in a back or next control and may point the wrong way in Arabic.",
+    suggestion: 'Add data-dk-mirror="" to the svg, or rtl:-scale-x-100 to its class.'
+  });
+}
+var isolates = (element) => {
+  const opening = element.openingElement;
+  return tagName(opening) === "bdi" || attributeNamed(opening, "dir") !== void 0;
+};
+function visitExpression(container, ancestors, ctx) {
+  const parent = ancestors[ancestors.length - 1];
+  if (parent.type !== "JSXElement" && parent.type !== "JSXFragment") return;
+  if (ancestors.some((a) => a.type === "JSXElement" && isolates(a))) return;
+  const expression = container.expression;
+  if (!isNumberExpression(expression)) return;
+  ctx.edits.push({ start: ctx.base + container.start, end: ctx.base + container.start, text: "<bdi>" });
+  ctx.edits.push({ start: ctx.base + container.end, end: ctx.base + container.end, text: "</bdi>" });
+}
+function walk3(node, ctx, ancestors) {
+  if (Array.isArray(node)) return node.forEach((child) => walk3(child, ctx, ancestors));
+  if (!node || typeof node !== "object") return;
+  const n = node;
+  if (n.type === "JSXOpeningElement") visitOpening(n, ctx, ancestors);
+  if (n.type === "JSXExpressionContainer" && ancestors.length) visitExpression(n, ancestors, ctx);
+  const next = typeof n.type === "string" ? [...ancestors, n] : ancestors;
+  for (const [key, child] of Object.entries(n)) if (!SKIP6.has(key)) walk3(child, ctx, next);
+}
+function markupEdits(file) {
+  const edits2 = [];
+  const flags = [];
+  for (const block of file.js) {
+    const program = block.ast.program;
+    walk3(program, { file, base: block.offset, icons: iconImports(program), edits: edits2, flags }, []);
+  }
+  return { edits: edits2, flags };
+}
+
+// src/transforms/tailwind.ts
+var import_lint10 = require("@dualkit/lint");
+var FLOOR = "3.3.0";
+function parseVersion(text) {
+  const match = text ? /(\d+)\.(\d+)\.(\d+)/.exec(text) : null;
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+var compareVersions = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+var tokensOf = (fragments) => fragments.flatMap((fragment) => [...fragment.text.matchAll(/\S+/g)].map((m) => ({ text: m[0], at: fragment.offset + m.index, parsed: (0, import_lint10.parseClass)(m[0]), fragment })));
+var rebuild = (p, core) => `${p.variants.map((v) => `${v}:`).join("")}${p.important[0]}${p.negative}${core}${p.important[1]}`;
+function pickEntry(matches, version) {
+  const usable = matches.map((entry) => ({ entry, since: parseVersion(entry.since) })).filter(({ since }) => compareVersions(since, version) <= 0).sort((a, b) => compareVersions(b.since, a.since));
+  return usable[0]?.entry ?? null;
+}
+function physicalEdits(fragments, version) {
+  return (0, import_lint10.physicalTokens)(fragments).flatMap(({ token, at: at2, parsed, matches }) => {
+    const replaced = pickEntry(matches, version)?.replace(parsed.core);
+    return replaced ? [{ start: at2, end: at2 + token.length, text: rebuild(parsed, replaced) }] : [];
+  });
+}
+var KEPT = (t) => t.fragment.deliberate !== true && t.fragment.sided !== true && !(0, import_lint10.sideScoped)(t.parsed.variants);
+var REVERSIBLE = /^(space|divide)-x(?:-|$)/;
+var REVERSE = /^(space|divide)-x-reverse$/;
+function reverseEdits(fragments) {
+  const tokens = tokensOf(fragments);
+  const reversed = new Set(tokens.filter((t) => REVERSE.test(t.parsed.core)).map((t) => REVERSE.exec(t.parsed.core)[1]));
+  const edits2 = [];
+  for (const t of tokens) {
+    const kind = REVERSIBLE.exec(t.parsed.core)?.[1];
+    if (!kind || REVERSE.test(t.parsed.core) || !KEPT(t) || reversed.has(kind)) continue;
+    reversed.add(kind);
+    const end = t.at + t.text.length;
+    edits2.push({ start: end, end, text: ` rtl:${kind}-x-reverse` });
+  }
+  return edits2;
+}
+var TRANSLATE_CENTRE = /^translate-x-(?:1\/2|\[-?50%\])$/;
+var CENTRE_OFFSET = /^(?:left|right|start|end)-(?:1\/2|\[50%\])$/;
+var CORNERS = "(?:left|right|(?:top|bottom)-(?:left|right)|(?:left|right)-(?:top|bottom))";
+var CORNER_SHORT = "(?:l|r|tl|tr|bl|br)";
+function adviceFor(core, negative, tokens) {
+  if (/^translate-x-/.test(core)) {
+    if (TRANSLATE_CENTRE.test(core) && tokens.some((t) => CENTRE_OFFSET.test(t.parsed.core))) return null;
+    return `Tailwind has no logical translate. Keep it for centring, or flip it for Arabic with an rtl: variant such as rtl:${negative ? "" : "-"}${core}.`;
+  }
+  if (new RegExp(`^bg-(?:gradient|linear)-to-${CORNER_SHORT}$`).test(core)) return "A gradient direction stays physical. Add an rtl: variant with the opposite side, such as rtl:bg-gradient-to-l.";
+  if (new RegExp(`^origin-${CORNERS}$`).test(core)) return "A transform origin stays physical. Add an rtl: variant with the opposite side.";
+  if (new RegExp(`^(?:bg|object)-${CORNERS}$`).test(core)) return "A background or object position stays physical. Add an rtl: variant with the opposite side.";
+  if (/^rotate-(?!x-|y-)/.test(core) && !/^rotate-(?:z-)?0$/.test(core)) return "A rotation turns the same way in Arabic. If it points an arrow or chevron, add an rtl: variant such as rtl:-rotate-45, or use rtl:scale-x-[-1] to mirror it.";
+  if (/^skew-x-/.test(core)) return "A horizontal skew leans the same way in Arabic. Add an rtl: variant with the opposite sign if it should mirror.";
+  return shadowAdvice(core);
+}
+var OFFSET = /^(-?\d*\.?\d+)(?:px|rem|em)?$/;
+function shadowAdvice(core) {
+  const inner = /^shadow-\[(.+)\]$/.exec(core)?.[1];
+  if (!inner) return null;
+  const parts = inner.split("_").filter((p) => p !== "inset");
+  const x = OFFSET.exec(parts[0] ?? "")?.[1];
+  return x !== void 0 && Number(x) !== 0 ? "A shadow with a horizontal offset falls on the same side in Arabic. Add an rtl: variant with the offset negated." : null;
+}
+function formFlags(file, fragments) {
+  const tokens = tokensOf(fragments);
+  return tokens.filter(KEPT).flatMap((t) => {
+    const suggestion = adviceFor(t.parsed.core, t.parsed.negative, tokens);
+    if (!suggestion) return [];
+    const message = `\`${t.text}\` has no logical form in Tailwind and stays physical in Arabic.`;
+    return [{ file: file.path, line: lineOf(file.text, t.at), kind: "no-logical-form", message, suggestion }];
+  });
+}
+var SKIP7 = /* @__PURE__ */ new Set(["loc", "leadingComments", "trailingComments", "innerComments", "extra"]);
+function* templatesIn(node) {
+  if (Array.isArray(node)) for (const child of node) yield* templatesIn(child);
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const n = node;
+  if (n.type === "TemplateLiteral" && Array.isArray(n.expressions) && n.expressions.length > 0) yield n;
+  for (const [key, child] of Object.entries(n)) if (!SKIP7.has(key)) yield* templatesIn(child);
+}
+function* classAttributes(node) {
+  if (Array.isArray(node)) for (const child of node) yield* classAttributes(child);
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const n = node;
+  if (n.type === "JSXAttribute" && (n.name?.name === "className" || n.name?.name === "class")) yield n;
+  else for (const [key, child] of Object.entries(n)) if (!SKIP7.has(key)) yield* classAttributes(child);
+}
+function fontNames(program) {
+  const body = program.body ?? [];
+  const loaders = new Set(body.filter((s) => s.type === "ImportDeclaration" && /^next\/font\//.test(String(s.source.value))).flatMap((s) => s.specifiers.map((spec) => String(spec.local.name))));
+  const names = /* @__PURE__ */ new Set();
+  for (const s of body) {
+    const declaration = s.type === "ExportNamedDeclaration" ? s.declaration : s;
+    if (declaration?.type !== "VariableDeclaration") continue;
+    for (const d of declaration.declarations) {
+      const init = d.init;
+      const callee = init?.type === "CallExpression" ? init.callee : null;
+      if (callee?.type === "Identifier" && loaders.has(String(callee.name)) && d.id.type === "Identifier") names.add(String(d.id.name));
+    }
+  }
+  return names;
+}
+var isFontClass = (fonts, e) => {
+  const object = e.object;
+  const property = e.property;
+  return e.type === "MemberExpression" && !e.computed && object?.type === "Identifier" && fonts.has(String(object.name)) && (property?.name === "variable" || property?.name === "className");
+};
+function computedFlags(file) {
+  const starts = /* @__PURE__ */ new Set();
+  for (const block of file.js) {
+    const fonts = fontNames(block.ast.program);
+    for (const attr of classAttributes(block.ast.program)) {
+      for (const template of templatesIn(attr.value)) {
+        if (template.expressions.every((e) => isFontClass(fonts, e))) continue;
+        if (template.start !== void 0) starts.add(block.offset + template.start);
+      }
+    }
+  }
+  return [...starts].sort((a, b) => a - b).map((at2) => ({
+    file: file.path,
+    line: lineOf(file.text, at2),
+    kind: "computed-class",
+    message: "This className is built at run time, so convert cannot see every class in it.",
+    suggestion: "Check it by hand for ml-, mr-, pl-, pr-, left-, right-, text-left and text-right, and use the logical classes."
+  }));
+}
+function groups(fragments) {
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const f of fragments) byGroup.set(f.group, [...byGroup.get(f.group) ?? [], f]);
+  return [...byGroup.values()];
+}
+function tailwindEdits(file, version) {
+  const parsed = parseVersion(version);
+  const fragments = (0, import_lint10.classStrings)(file);
+  if (!parsed) return { edits: [], flags: [] };
+  if (compareVersions(parsed, parseVersion(FLOOR)) < 0) {
+    const first = fragments[0];
+    if (!first) return { edits: [], flags: [] };
+    const message = `Tailwind ${version} has no logical classes such as ms-4 or text-start. Upgrade Tailwind to 3.3 or later.`;
+    const suggestion = "Upgrade Tailwind to 3.3 or later, then run convert again.";
+    return { edits: [], flags: [{ file: file.path, line: lineOf(file.text, first.offset), kind: "unsupported", message, suggestion }] };
+  }
+  const sources = groups(fragments);
+  const edits2 = sources.flatMap((g) => [...physicalEdits(g, parsed), ...parsed[0] < 4 ? reverseEdits(g) : []]);
+  const flags = [...sources.flatMap((g) => formFlags(file, g)), ...computedFlags(file)];
+  return { edits: edits2, flags: flags.sort((a, b) => a.line - b.line) };
+}
+
+// src/passes.ts
+var PASSES = [
+  { name: "tailwind", run: (file, ctx) => tailwindEdits(file, ctx.tailwind) },
+  { name: "css", run: (file, ctx) => cssEdits(file, ctx.css) },
+  { name: "markup", run: (file) => markupEdits(file) },
+  { name: "strings", run: (file, ctx) => extractStrings(file, ctx.lib, ctx.taken) },
+  { name: "formats", run: (file, ctx) => formatEdits(file, ctx.lib, ctx.helper) }
+];
+var parse = (path, text, abs) => {
+  const outcome = (0, import_lint11.parseSourceOutcome)(path, text, abs);
+  return "file" in outcome ? outcome.file : outcome.error;
+};
+function runPasses(path, text, abs, ctx) {
+  const first = parse(path, text, abs);
+  if (typeof first === "string") return { kind: "skipped", reason: `parse error: ${first}` };
+  let file = first;
+  let edits2 = 0;
+  const byKind = { tailwind: 0, css: 0, markup: 0, strings: 0, formats: 0 };
+  const flags = [];
+  const entries = [];
+  const taken = new Set(ctx.taken);
+  for (const pass of PASSES) {
+    const result = pass.run(file, { ...ctx, taken });
+    flags.push(...result.flags);
+    for (const entry of result.entries ?? []) {
+      entries.push(entry);
+      taken.add(entry.key);
+    }
+    if (result.edits.length === 0) continue;
+    let next;
+    try {
+      next = applyEdits(file.text, result.edits);
+    } catch (error) {
+      if (!(error instanceof OverlapError)) throw error;
+      return { kind: "skipped", reason: `the ${pass.name} pass made overlapping edits, so convert left the file as it was` };
+    }
+    const reparsed = parse(path, next, abs);
+    if (typeof reparsed === "string") return { kind: "skipped", reason: `the ${pass.name} pass made code that does not parse, so convert left the file as it was` };
+    file = reparsed;
+    edits2 += result.edits.length;
+    byKind[pass.name] += result.edits.length;
+  }
+  return { kind: "done", text: file.text, edits: edits2, byKind, flags, entries };
+}
+
+// src/rollback.ts
+var import_node_fs9 = require("fs");
+var import_node_path16 = require("path");
+var ConvertFailedError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ConvertFailedError";
+  }
+  cause;
+};
+var reasonOf = (error) => (error instanceof Error ? error.message : String(error)).replace(/\s*\n\s*/g, " ").trim().replace(/\.$/, "");
+function manualSteps(target) {
+  const commands = ["git reset --hard", ...target.madeBranch ? [`git checkout ${target.base}`, `git branch -D ${target.branch}`] : []];
+  const files = target.created.length ? `, then delete these new files: ${target.created.join(", ")}` : "";
+  return `${commands.join(", then ")}${files}`;
+}
+async function rollBack(target, step, error) {
+  const failed = `convert failed at ${step}: ${reasonOf(error)}.`;
+  try {
+    await resetHard(target.root);
+    for (const path of [...target.created].reverse()) (0, import_node_fs9.rmSync)((0, import_node_path16.join)(target.root, path), { recursive: true, force: true });
+    if (target.madeBranch) {
+      await checkout(target.root, target.base);
+      await deleteBranch(target.root, target.branch);
+    }
+  } catch (undo2) {
+    throw new ConvertFailedError(`${failed} Putting the repo back also failed (${reasonOf(undo2)}), so run these yourself: ${manualSteps(target)}.`, error);
+  }
+  const where = target.madeBranch ? target.base : target.branch;
+  throw new ConvertFailedError(`${failed} Your repo is back on ${where} as it was.`, error);
+}
+
+// src/write-all.ts
+var LOCKFILES2 = {
+  npm: ["package-lock.json"],
+  pnpm: ["pnpm-lock.yaml"],
+  yarn: ["yarn.lock"],
+  bun: ["bun.lock", "bun.lockb"]
+};
+async function install(project, io) {
+  const cmd = `${project.packageManager} install`;
+  io.log(`Running ${cmd}.`);
+  const result = await io.run(cmd, project.root);
+  if (result.code === 0) return [];
+  const message = `${cmd} exited with code ${result.code}, so the new packages may not be installed.`;
+  return [{ file: "package.json", line: 1, kind: "unsupported", message, suggestion: `Run ${cmd} yourself and fix what it reports.` }];
+}
+async function installed(disk, project, io) {
+  const lockfiles = LOCKFILES2[project.packageManager];
+  const before = new Set(lockfiles.filter((f) => readText(disk.root, f) !== null));
+  const flags = await install(project, io);
+  disk.created.push(...lockfiles.filter((f) => !before.has(f) && readText(disk.root, f) !== null));
+  if (io.signal?.aborted) throw new Error("the run was interrupted");
+  return flags;
+}
+async function writeAll(input) {
+  const { disk, project, options, io, plan, step } = input;
+  const moved = new Map(plan.moves);
+  const touched = [];
+  for (const [path, text] of input.texts) if (writeText(disk, path, text)) touched.push(moved.get(path) ?? path);
+  step.name = "wiring locales";
+  const wired = await applyPlan(disk, plan);
+  step.name = "adding the stylesheet and messages";
+  const own = addOwnFiles(disk, project, input.ledger, moved.get(project.entry) ?? project.entry);
+  step.name = "writing the strings ledger";
+  if (saveLedger(disk, input.ledger)) touched.push(LEDGER_FILE);
+  touched.push(...wired.touched, ...own.touched);
+  step.name = "saving your answers";
+  const configFile = options.configFile ?? CONFIG_FILE;
+  if (options.configAnswers && writeConfigAnswers(disk, options.configAnswers, configFile)) touched.push(configFile);
+  step.name = "updating package.json";
+  const added = addDependencies(disk, plan.deps);
+  if (added) touched.push("package.json");
+  step.name = "installing packages";
+  const flags = options.install && added ? await installed(disk, project, io) : [];
+  if (options.install && added) touched.push(...LOCKFILES2[project.packageManager].filter((f) => readText(disk.root, f) !== null));
+  step.name = "updating .gitignore";
+  if (ignoreStateDir(disk)) touched.push(".gitignore");
+  step.name = "committing";
+  await stage(disk.root, [...new Set(touched)]);
+  const changed2 = await stagedFiles(disk.root);
+  const edits2 = wired.edits + own.edits;
+  if (changed2.length) {
+    step.name = "saving the state";
+    const { state, summary } = input.record({ changed: changed2, edits: edits2, writes: wired.writes, wired: wired.perFile, flags });
+    writeText(disk, STATE_FILE, stateText(state));
+    writeText(disk, SUMMARY_FILE, summaryText(summary));
+    await stage(disk.root, [STATE_FILE, SUMMARY_FILE]);
+    step.name = "committing";
+    await commit(disk.root, `dualkit: convert to ${options.mode}`);
+  }
+  return { changed: changed2, edits: edits2, writes: wired.writes, wired: wired.perFile, flags };
+}
+
+// src/convert.ts
+var BOM = "\uFEFF";
+var branchFor = (mode) => `dualkit/${mode}`;
+var problems = (flags) => flags.filter((f) => f.kind !== "info");
+function transformAll(project, generated, taken) {
+  const { root } = project;
+  const walked = (0, import_lint12.walk)(["."], root);
+  const used = new Set(taken);
+  const ctx = {
+    tailwind: project.tailwind,
+    lib: project.framework === "next-app" ? "next-intl" : "react-i18next",
+    helper: localeHelperPath(project),
+    css: physicalContext(root)
+  };
+  const out = { texts: /* @__PURE__ */ new Map(), edits: 0, byKind: { tailwind: 0, css: 0, markup: 0, strings: 0, formats: 0 }, perFile: /* @__PURE__ */ new Map(), flags: [], entries: [], skipped: [...walked.skipped] };
+  for (const path of walked.files) {
+    if (generated.has(path)) continue;
+    const raw = readText(root, path);
+    if (raw === null) {
+      out.skipped.push({ file: path, reason: "unreadable" });
+      continue;
+    }
+    if ((0, import_lint12.isMinified)(raw)) {
+      out.skipped.push({ file: path, reason: "minified" });
+      continue;
+    }
+    const result = runPasses(path, raw, (0, import_node_path17.join)(root, path), { ...ctx, taken: used });
+    if (result.kind === "skipped") {
+      out.skipped.push({ file: path, reason: result.reason });
+      continue;
+    }
+    out.flags.push(...result.flags);
+    out.entries.push(...result.entries);
+    for (const entry of result.entries) used.add(entry.key);
+    if (result.edits === 0) continue;
+    out.edits += result.edits;
+    for (const kind of Object.keys(out.byKind)) out.byKind[kind] += result.byKind[kind];
+    out.perFile.set(path, result.edits);
+    out.texts.set(path, raw.startsWith(BOM) ? BOM + result.text : result.text);
+  }
+  return out;
+}
+function changedFiles(perFile, moved, wiring) {
+  const total = /* @__PURE__ */ new Map();
+  const add = (file, n) => {
+    if (n > 0) total.set(file, (total.get(file) ?? 0) + n);
+  };
+  for (const [path, n] of perFile) add(moved.get(path) ?? path, n);
+  for (const [path, n] of Object.entries(wiring)) add(path, n);
+  return [...total].map(([file, edits2]) => ({ file, edits: edits2 })).sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : 0);
+}
+async function planFor(project, mode, texts) {
+  const files = (rel) => texts.get(rel) ?? readText(project.root, rel);
+  if (project.framework === "vite-react") return wireReactI18next(project, mode, files);
+  return wireNextIntl(project, mode, files, await trackedFiles(project.root));
+}
+function finalFlags(flags, moved) {
+  const seen = /* @__PURE__ */ new Set();
+  return flags.map((f) => ({ ...f, file: moved.get(f.file) ?? f.file })).filter((f) => {
+    const key = `${f.file}\0${f.line}\0${f.kind}\0${f.message}`;
+    return !seen.has(key) && Boolean(seen.add(key));
+  });
+}
+function summarise({ branch, done, plan, moved, strings }, written) {
+  const byKind = { ...done.byKind, wiring: written.edits + written.writes };
+  const flags = finalFlags([...done.flags, ...plan.flags, ...written.flags], moved);
+  return { branch, filesChanged: written.changed.length, edits: done.edits + written.edits, byKind, changed: changedFiles(done.perFile, moved, written.wired), flags, strings, skipped: done.skipped };
+}
+async function start(options) {
+  await assertCleanRepo(options.root);
+  const branch = branchFor(options.mode);
+  const base = await currentBranch(options.root);
+  const state = base === branch ? readState(options.root) : null;
+  const rerun = base === branch && (state?.phase === "converted" || state?.phase === "finished") && state.mode === options.mode;
+  if (base === branch && !state) {
+    throw new RefusedError(`You are on ${branch}, but it has no convert state in ${STATE_FILE}. Switch back to the branch you started from, delete ${branch}, then run convert again.`);
+  }
+  if (!rerun && await branchExists(options.root, branch)) {
+    throw new RefusedError(`The branch ${branch} already exists. Delete it, or switch to it if convert made it, then run convert again.`);
+  }
+  return { state, rerun, base };
+}
+async function baseline(project, options, io) {
+  if (!options.baseline || options.mode === "arabic") return;
+  const { start: cmd } = io.config;
+  if (!cmd || !io.shoot) {
+    io.log("No start command is set, so no English baseline was taken.");
+    return;
+  }
+  const { unreachable } = await shootBaseline(project, { ...io.config, start: cmd }, io.shoot, io.log);
+  for (const page of unreachable) io.log(`No baseline for ${page.route}: ${page.reason}.`);
+}
+var committedLine = (files, branch) => `Committed ${files} changed ${files === 1 ? "file" : "files"} on ${branch}.`;
+var leftLine = (open, skipped) => `${open} ${open === 1 ? "thing is" : "things are"} left to finish. ${skipped} ${skipped === 1 ? "file was" : "files were"} skipped.`;
+async function convert(options, ioIn) {
+  const { root, mode } = options;
+  const { state, rerun, base } = await start(options);
+  if (options.configAnswers) checkConfigAnswers(root, options.configFile);
+  const io = options.configAnswers ? { ...ioIn, config: { ...ioIn.config, ...options.configAnswers } } : ioIn;
+  const project = detectProject(root);
+  const branch = branchFor(mode);
+  const generated = new Set(state?.generated ?? []);
+  const existing = readLedger(root);
+  const done = transformAll(project, generated, new Set(existing.map((e) => e.key)));
+  const plan = await planFor(project, mode, done.texts);
+  const moved = new Map(plan.moves);
+  const ledger = mergeLedger(existing, done.entries.map((e) => ({ ...e, file: moved.get(e.file) ?? e.file })));
+  guardWrites(ownFiles(project, ledger), (rel) => readText(root, rel), generated);
+  await excludeStateDir(root);
+  if (!rerun) {
+    await baseline(project, options, io);
+    await createBranch(root, branch);
+    io.log(`Created the branch ${branch}.`);
+  }
+  const ours = [...Object.keys(plan.writes), ...Object.keys(ownFiles(project, ledger)), LEDGER_FILE];
+  const nextState = { mode, base: state?.base ?? base, branch, framework: project.framework, phase: "converted", generated: [.../* @__PURE__ */ new Set([...generated, ...ours])].sort() };
+  const run2 = { branch, done, plan, moved, strings: ledger.length - existing.length };
+  const disk = { root, created: [] };
+  const step = { name: "writing the converted files" };
+  const record = (applied) => ({ state: nextState, summary: mergeSummary(readSummary(root), summarise(run2, applied)) });
+  const written = await writeAll({ disk, project, options, io, texts: done.texts, plan, ledger, step, record }).catch((error) => rollBack({ root, base: rerun ? branch : base, branch, madeBranch: !rerun, created: disk.created }, step.name, error));
+  io.log(written.changed.length ? committedLine(written.changed.length, branch) : "Nothing changed, so there is nothing to commit.");
+  const summary = summarise(run2, written);
+  io.log(leftLine(problems(summary.flags).length, done.skipped.length));
+  return summary;
+}
+
+// src/finish.ts
+var import_node_fs11 = require("fs");
+var import_node_path19 = require("path");
+
+// src/match.ts
+var import_pngjs = require("pngjs");
+var MAX_DIFF_RATIO = 1e-3;
+var CHANNEL_TOLERANCE = 8;
+var RED = [255, 0, 0, 255];
+function compare(a, b) {
+  const left = import_pngjs.PNG.sync.read(a);
+  const right = import_pngjs.PNG.sync.read(b);
+  if (left.width !== right.width || left.height !== right.height) {
+    const out2 = new import_pngjs.PNG({ width: Math.max(left.width, right.width), height: Math.max(left.height, right.height) });
+    for (let i = 0; i < out2.data.length; i += 4) out2.data.set(RED, i);
+    return { ratio: 1, diff: import_pngjs.PNG.sync.write(out2) };
+  }
+  const out = new import_pngjs.PNG({ width: left.width, height: left.height });
+  let differing = 0;
+  for (let i = 0; i < left.data.length; i += 4) {
+    const differs = [0, 1, 2, 3].some((c) => Math.abs((left.data[i + c] ?? 0) - (right.data[i + c] ?? 0)) > CHANNEL_TOLERANCE);
+    if (differs) {
+      differing++;
+      out.data.set(RED, i);
+    } else {
+      out.data.set([left.data[i] ?? 0, left.data[i + 1] ?? 0, left.data[i + 2] ?? 0, 64], i);
+    }
+  }
+  return { ratio: differing / (left.width * left.height), diff: import_pngjs.PNG.sync.write(out) };
+}
+
+// src/finish-undo.ts
+var import_node_fs10 = require("fs");
+var import_node_path18 = require("path");
+async function snapshot(root, paths) {
+  const clean = new Set(await cleanAtHead(root, paths));
+  return paths.map((path) => ({ path, clean: clean.has(path), text: clean.has(path) ? null : readText(root, path) }));
+}
+async function undo(root, saved, staged) {
+  await restoreFromHead(root, saved.filter((s) => s.clean).map((s) => s.path));
+  const dirty = saved.filter((s) => !s.clean);
+  for (const { path, text } of dirty) {
+    if (text === null) (0, import_node_fs10.rmSync)((0, import_node_path18.join)(root, path), { force: true });
+    else (0, import_node_fs10.writeFileSync)((0, import_node_path18.join)(root, path), text);
+  }
+  await unstage(root, [.../* @__PURE__ */ new Set([...dirty.map((s) => s.path), ...staged])]);
+}
+async function failFinish(root, saved, staged, step, error) {
+  const failed = `finish failed at ${step}: ${reasonOf(error)}.`;
+  try {
+    await undo(root, saved, staged);
+  } catch (cause) {
+    throw new ConvertFailedError(`${failed} Putting its files back also failed (${reasonOf(cause)}), so check git status. Nothing was committed.`, error);
+  }
+  throw new ConvertFailedError(`${failed} Nothing was committed.`, error);
+}
+
+// src/report.ts
+var NATIVE_SPEAKER_LINE = "Drafted by a model. A native speaker should check these before release.";
+function esc(text) {
+  return text.replace(/\s*\r?\n\s*/g, " ").replace(/([\\`*_[\]<>|#])/g, "\\$1").trim();
+}
+function link(file, line) {
+  const path = file.replace(/\\/g, "/").replace(/^\.\//, "");
+  const target = encodeURI(path).replace(/[()#]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+  return line === void 0 ? `[${esc(path)}](${target})` : `[${esc(`${path}:${line}`)}](${target}#L${line})`;
+}
+var KIND_LABELS = {
+  tailwind: "Tailwind classes",
+  css: "CSS rules",
+  markup: "Markup",
+  strings: "Strings",
+  formats: "Formats",
+  wiring: "Wiring"
+};
+var MAX_LISTED_FILES = 30;
+var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+var section = (title, lines, empty) => `## ${title}
+
+${(lines.length > 0 ? lines : [empty]).join("\n")}`;
+function flagLine(flag3) {
+  const where = link(flag3.file, flag3.line);
+  const message = esc(flag3.message);
+  if (!flag3.suggestion.trim()) return `- ${where}: ${message}`;
+  return `- ${where}: ${message.replace(/\.+$/, "")}. ${esc(flag3.suggestion)}`;
+}
+function kindLines(summary) {
+  const kinds = Object.keys(KIND_LABELS);
+  return kinds.filter((k) => summary.byKind[k] > 0).map((k) => `- ${KIND_LABELS[k]}: ${plural(summary.byKind[k], "edit", "edits")}`);
+}
+function fileLines(summary) {
+  if (summary.changed.length === 0) return [];
+  const shown = summary.changed.slice(0, MAX_LISTED_FILES);
+  const more = summary.changed.length - shown.length;
+  return [
+    "",
+    "Changed files:",
+    "",
+    ...shown.map((c) => `- ${link(c.file)} (${plural(c.edits, "edit", "edits")})`),
+    ...more > 0 ? [`- and ${more} more`] : []
+  ];
+}
+function changed(data) {
+  const { summary } = data;
+  const notes = summary.flags.filter((f) => f.kind === "info");
+  const lines = [
+    ...data.summaryMissing ? ["The phase 1 summary was not found, so the counts below are unknown.", ""] : [],
+    `Mode: ${data.mode}. Branch: ${esc(data.branch)}, made from ${esc(data.base)}.`,
+    "",
+    `- ${plural(summary.filesChanged, "file", "files")} changed with ${plural(summary.edits, "edit", "edits")}.`,
+    `- ${plural(summary.strings, "string", "strings")} moved into translation files.`,
+    `- ${plural(data.remainingLint, "lint issue", "lint issues")} left after conversion.`,
+    ...kindLines(summary),
+    ...fileLines(summary),
+    ...notes.map(flagLine)
+  ];
+  return section("What changed", lines, "");
+}
+function copy(data) {
+  const todo = data.ledger.filter((e) => e.status === "pending" || e.status === "drafted");
+  const lines = todo.length === 0 ? [] : [
+    NATIVE_SPEAKER_LINE,
+    "",
+    "| Key | English | Arabic | Status | Where |",
+    "| --- | --- | --- | --- | --- |",
+    ...todo.map((e) => `| ${esc(e.key)} | ${esc(e.en)} | ${esc(e.ar)} | ${e.status} | ${link(e.file, e.line)} |`)
+  ];
+  return section("Arabic copy to check", lines, "No Arabic copy needs checking.");
+}
+function suggestions(data) {
+  const lines = data.summary.flags.filter((f) => f.kind === "format").map(flagLine);
+  return section("Regional suggestions", lines, "No regional suggestions.");
+}
+function english(data) {
+  const lines = data.english.map((p) => {
+    const pass = p.ratio < MAX_DIFF_RATIO;
+    const share = `${(p.ratio * 100).toFixed(3)}% of pixels differ, limit ${(MAX_DIFF_RATIO * 100).toFixed(3)}%`;
+    const diff = !pass && p.diffPath ? `. Diff at ${esc(p.diffPath)}` : "";
+    return `- ${esc(p.route)} at ${p.width}px: ${pass ? "pass" : "fail"}: ${share}${diff}`;
+  });
+  const missing = (data.noBaseline ?? []).map((p) => `- ${esc(p.route)} at ${p.width}px: no English baseline was taken`);
+  const unproven = lines.length === 0 && missing.length > 0 ? ["", "Warning: No English pages were compared, so the English match is not proven."] : [];
+  return section("English pages", [...lines, ...missing, ...unproven], "No English pages were checked.");
+}
+function arabic(data) {
+  const lines = data.arabic.map(
+    (p) => !Number.isFinite(p.errors) ? `- ${esc(p.route)}: the check returned no result` : `- ${esc(p.route)}: score ${p.score}, ${plural(p.errors, "error", "errors")}, ${plural(p.warnings, "warning", "warnings")}`
+  );
+  return section("Arabic pages", lines, "No pages were checked.");
+}
+function notConverted(data) {
+  const flags = data.summary.flags.filter((f) => f.kind !== "info" && f.kind !== "format").map(flagLine);
+  const skipped = data.summary.skipped.map((s) => `- Skipped ${esc(s.file)}: ${esc(s.reason)}`);
+  const pages = data.unreachable.map((u) => `- Could not reach ${esc(u.route)}: ${esc(u.reason)}`);
+  return section("What Dualkit could not convert", [...flags, ...skipped, ...pages], "Nothing was left unconverted.");
+}
+function tests(data) {
+  if (!data.tests) return section("The app's tests", [], `The app's tests were not run, because dualkit.config.json has no test command. Add one under "convert", such as "test": "npm test".`);
+  const runs = Math.max(2, ...(data.tests.tail.match(/`+/g) ?? []).map((m) => m.length + 1));
+  const fence = "`".repeat(Math.max(3, runs));
+  const result = data.tests.code === 0 ? "The tests passed." : `The tests failed with exit code ${data.tests.code}.`;
+  return section("The app's tests", [result, "", fence, data.tests.tail.trimEnd(), fence], "");
+}
+function renderConvertReport(data) {
+  const parts = [
+    "# Dualkit convert report",
+    changed(data),
+    copy(data),
+    suggestions(data),
+    ...data.mode === "bilingual" ? [english(data)] : [],
+    arabic(data),
+    notConverted(data),
+    tests(data)
+  ];
+  return `${parts.join("\n\n")}
+`;
+}
+
+// src/finish.ts
+var REPORT_FILE = "dualkit-convert.md";
+var DIFF_DIR = `${STATE_DIR}/diff`;
+var TEST_TAIL_LINES = 40;
+var NEEDS_BROWSER = "Finish needs a start command in your Dualkit config file and a browser to take screenshots with.";
+var LOCALE_COOKIE2 = "dk-locale";
+function arabicTarget(project, state, route) {
+  if (state.mode === "arabic") return { path: route };
+  if (project.framework === "next-app") return { path: route === "/" ? "/ar" : `/ar${route}` };
+  return { path: route, options: { cookies: { [LOCALE_COOKIE2]: "ar" } } };
+}
+var ownFiles2 = (configFile) => [messagesPath("en"), messagesPath("ar"), REPORT_FILE, STATE_FILE, LEDGER_FILE, configFile];
+async function assertNothingElseStaged(root, own) {
+  const others = (await stagedFiles(root)).filter((f) => !own.includes(f));
+  if (others.length > 0) throw new RefusedError(`You have staged changes in ${others.join(", ")}. Commit or unstage them, then run finish again.`);
+}
+async function guard(root) {
+  const state = readState(root);
+  if (!state) throw new RefusedError("There is no saved convert state here. Run dualkit convert first, then fill in the Arabic and run this again.");
+  if (state.phase !== "converted" && state.phase !== "finished") {
+    throw new RefusedError("This conversion has not finished converting yet. Run dualkit convert until it completes, then run this again.");
+  }
+  const branch = await currentBranch(root);
+  if (branch !== state.branch) {
+    throw new RefusedError(`You are on ${branch}, but this conversion lives on ${state.branch}. Switch to that branch, then run dualkit convert --finish again.`);
+  }
+  return state;
+}
+function pendingCheck(ledger, force) {
+  const pending = ledger.filter((e) => e.status === "pending").length;
+  if (pending > 0 && !force) {
+    throw new RefusedError(`${pending} ${pending === 1 ? "string is" : "strings are"} still pending in ${LEDGER_FILE}. Fill in the Arabic and set each status to drafted, or run with --force to use English for those strings.`);
+  }
+}
+function writeMessages(root, ledger) {
+  const disk = { root, created: [] };
+  for (const [path, text] of Object.entries(messagesFiles(ledger))) writeText(disk, path, mergedMessages(root, path, text));
+}
+function mergedMessages(root, path, generated) {
+  const full = (0, import_node_path19.join)(root, path);
+  if (!(0, import_node_fs11.existsSync)(full)) return generated;
+  try {
+    const existing = JSON.parse((0, import_node_fs11.readFileSync)(full, "utf8"));
+    if (typeof existing !== "object" || existing === null) return generated;
+    return JSON.stringify(keepHandAdded(existing, JSON.parse(generated)), null, 2) + "\n";
+  } catch {
+    return generated;
+  }
+}
+async function englishChecks(root, base, routes, shoot) {
+  const english2 = [];
+  const noBaseline = [];
+  for (const route of routes) {
+    for (const width of WIDTHS) {
+      const file = (0, import_node_path19.join)(root, baselinePath(route, width));
+      if (!(0, import_node_fs11.existsSync)(file)) {
+        noBaseline.push({ route, width });
+        continue;
+      }
+      const shot = await shoot(`${base}${route}`, width);
+      const { ratio, diff } = compare((0, import_node_fs11.readFileSync)(file), shot);
+      let diffPath;
+      if (ratio >= MAX_DIFF_RATIO) {
+        diffPath = `${DIFF_DIR}/${routeSlug(route)}-${width}.png`;
+        (0, import_node_fs11.mkdirSync)((0, import_node_path19.join)(root, DIFF_DIR), { recursive: true });
+        (0, import_node_fs11.writeFileSync)((0, import_node_path19.join)(root, diffPath), diff);
+      }
+      english2.push({ route, width, ratio, ...diffPath ? { diffPath } : {} });
+    }
+  }
+  return { english: english2, noBaseline };
+}
+async function arabicChecks(project, state, base, routes, audit) {
+  const arabic2 = [];
+  for (const route of routes) {
+    const { path, options } = arabicTarget(project, state, route);
+    for (const width of WIDTHS) {
+      const result = await audit(`${base}${path}`, width, options);
+      const usable = result && Number.isFinite(result.errors);
+      const failed = { score: Number.NaN, errors: Number.NaN, warnings: Number.NaN };
+      arabic2.push({ route: `${path} at ${width}px`, ...usable ? result : failed });
+    }
+  }
+  return arabic2;
+}
+async function runChecks(project, state, routes, { config, shoot, audit }, step) {
+  const { start: cmd } = config;
+  if (!cmd || !shoot) throw new RefusedError(NEEDS_BROWSER);
+  const port = config.port ?? DEFAULT_PORTS[project.framework];
+  step.name = "starting the app";
+  const server = await startServer(cmd, port, project.root).catch((error) => {
+    throw new Error(`Could not start the app with "${cmd}". ${error.message}`, { cause: error });
+  });
+  try {
+    step.name = "checking the pages";
+    const english2 = state.mode === "bilingual" ? await englishChecks(project.root, server.url, routes, shoot) : { english: [], noBaseline: [] };
+    return { ...english2, arabic: await arabicChecks(project, state, server.url, routes, audit) };
+  } finally {
+    await server.stop();
+  }
+}
+var emptySummary = (state, strings) => ({ branch: state.branch, filesChanged: 0, edits: 0, byKind: { tailwind: 0, css: 0, markup: 0, strings: 0, formats: 0, wiring: 0 }, changed: [], flags: [], strings, skipped: [] });
+var tail = (out) => out.trimEnd().split("\n").slice(-TEST_TAIL_LINES).join("\n");
+async function prepare(options, ioIn) {
+  const { root } = options;
+  const configFile = options.configFile ?? CONFIG_FILE;
+  const io = options.configAnswers ? { ...ioIn, config: { ...ioIn.config, ...options.configAnswers } } : ioIn;
+  if (options.configAnswers) checkConfigAnswers(root, configFile);
+  const state = await guard(root);
+  const ledger = readLedger(root);
+  pendingCheck(ledger, options.force);
+  if (!io.config.start || !io.shoot) throw new RefusedError(NEEDS_BROWSER);
+  const own = ownFiles2(configFile);
+  await assertNothingElseStaged(root, own);
+  return { root, options, io, state, ledger, configFile, own };
+}
+async function run(ready, step) {
+  const { root, options, io, state, ledger, configFile, own } = ready;
+  const project = detectProject(root);
+  const { routes, unreachable } = listRoutes(project, io.config);
+  step.name = "writing the messages";
+  writeMessages(root, ledger);
+  const checks = await runChecks(project, state, routes, io, step);
+  step.name = "running the tests";
+  const tests2 = io.config.test ? await io.run(io.config.test, root) : void 0;
+  step.name = "counting lint findings";
+  const remainingLint = await io.lint(root);
+  step.name = "writing the report";
+  const earlier = readSummary(root);
+  const data = {
+    mode: state.mode,
+    base: state.base,
+    branch: state.branch,
+    summary: earlier ?? emptySummary(state, ledger.length),
+    ledger,
+    ...checks,
+    ...earlier ? {} : { summaryMissing: true },
+    unreachable,
+    remainingLint,
+    ...tests2 ? { tests: { code: tests2.code, tail: tail(tests2.out) } } : {}
+  };
+  (0, import_node_fs11.writeFileSync)((0, import_node_path19.join)(root, REPORT_FILE), renderConvertReport(data));
+  step.name = "saving the state";
+  saveState(root, { ...state, phase: "finished" });
+  step.name = "saving your answers";
+  if (options.configAnswers) writeConfigAnswers({ root, created: [] }, options.configAnswers, configFile);
+  step.name = "committing";
+  await stage(root, own.filter((p) => (p !== configFile || options.configAnswers) && (0, import_node_fs11.existsSync)((0, import_node_path19.join)(root, p))));
+  if ((await stagedFiles(root)).length) await commit(root, `dualkit: finish ${state.mode} conversion`);
+  const checked = checks.arabic.length > 0;
+  const passed = checked && checks.english.every((p) => p.ratio < MAX_DIFF_RATIO) && checks.arabic.every((p) => p.errors === 0) && (tests2?.code ?? 0) === 0;
+  return { reportPath: (0, import_node_path19.join)(root, REPORT_FILE), passed };
+}
+async function finish(options, ioIn) {
+  const ready = await prepare(options, ioIn);
+  const { root, configFile, own } = ready;
+  const written = [messagesPath("en"), messagesPath("ar"), REPORT_FILE, STATE_FILE, ...options.configAnswers ? [configFile] : []];
+  const saved = await snapshot(root, written);
+  const step = { name: "writing the messages" };
+  const result = await run(ready, step).catch((error) => failFinish(root, saved, own.filter((p) => !written.includes(p)), step.name, error));
+  ready.io.log(result.passed ? "All checks passed." : "Some checks failed. The report lists them.");
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConvertFailedError,
+  OverlapError,
+  RefusedError,
+  UnsupportedError,
+  applyEdits,
+  branchFor,
+  convert,
+  detectProject,
+  finish,
+  problems
+});