@nanoflags/cli 0.0.0-stage → 0.1.0

package/dist/chunk-KGDBDK5S.js

@@ -0,0 +1,174 @@
+// src/util.ts
+import { lstatSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+var EXIT = { ok: 0, failed: 1, usage: 2, unavailable: 3 };
+var CliError = class extends Error {
+  constructor(message, exitCode = EXIT.usage) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+  exitCode;
+};
+function table(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+  const line = (cells) => cells.map((c, i) => i === cells.length - 1 ? c : c.padEnd(widths[i])).join("  ").trimEnd();
+  return [line(headers), line(widths.map((w) => "-".repeat(w))), ...rows.map(line)].join("\n");
+}
+function show(v) {
+  return typeof v === "string" ? v : v === void 0 ? "" : JSON.stringify(v);
+}
+function clip(s, max) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var SKIP_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".next", ".git"]);
+var DEFAULT_MAX_FILE_BYTES = 1e6;
+function walk(root, maxBytes = DEFAULT_MAX_FILE_BYTES) {
+  const out = { files: [], tooLarge: [] };
+  const visit = (dir, rel) => {
+    let names;
+    try {
+      names = readdirSync(dir).sort();
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const full = join(dir, name);
+      const relPath = rel ? `${rel}/${name}` : name;
+      let st;
+      try {
+        st = lstatSync(full);
+      } catch {
+        continue;
+      }
+      if (st.isSymbolicLink()) continue;
+      if (st.isDirectory()) {
+        if (!SKIP_DIRECTORIES.has(name)) visit(full, relPath);
+      } else if (st.isFile() && SOURCE_EXTENSIONS.some((e) => name.endsWith(e)) && !name.endsWith(".d.ts")) {
+        if (st.size > maxBytes) out.tooLarge.push(relPath);
+        else out.files.push(relPath);
+      }
+    }
+  };
+  visit(root, "");
+  return out;
+}
+function diffLines(a, b) {
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const x = a.slice(start, endA);
+  const y = b.slice(start, endB);
+  const n = x.length;
+  const m = y.length;
+  const max = n + m;
+  const trace = [];
+  let v = /* @__PURE__ */ new Map([[1, 0]]);
+  let found = max === 0;
+  for (let d = 0; d <= max && !found; d++) {
+    const next = /* @__PURE__ */ new Map();
+    for (let k = -d; k <= d; k += 2) {
+      let i2 = k === -d || k !== d && (v.get(k - 1) ?? -1) < (v.get(k + 1) ?? -1) ? v.get(k + 1) ?? 0 : (v.get(k - 1) ?? 0) + 1;
+      let j2 = i2 - k;
+      while (i2 < n && j2 < m && x[i2] === y[j2]) {
+        i2++;
+        j2++;
+      }
+      next.set(k, i2);
+      if (i2 >= n && j2 >= m) {
+        found = true;
+        break;
+      }
+    }
+    trace.push(next);
+    v = next;
+  }
+  const middle = [];
+  let i = n;
+  let j = m;
+  for (let d = trace.length - 1; d > 0; d--) {
+    const prev = trace[d - 1];
+    const k = i - j;
+    const down = k === -d || k !== d && (prev.get(k - 1) ?? -1) < (prev.get(k + 1) ?? -1);
+    const prevK = down ? k + 1 : k - 1;
+    const prevI = prev.get(prevK) ?? 0;
+    const prevJ = prevI - prevK;
+    while (i > prevI && j > prevJ) {
+      middle.push({ kind: " ", line: x[--i] });
+      j--;
+    }
+    if (down) middle.push({ kind: "+", line: y[--j] });
+    else middle.push({ kind: "-", line: x[--i] });
+  }
+  while (i > 0 && j > 0) {
+    middle.push({ kind: " ", line: x[--i] });
+    j--;
+  }
+  middle.reverse();
+  return [...a.slice(0, start).map((line) => ({ kind: " ", line })), ...middle, ...a.slice(endA).map((line) => ({ kind: " ", line }))];
+}
+function unifiedDiff(path, before, after, context = 3) {
+  if (before === after) return "";
+  const split = (s) => {
+    const lines = s.split("\n");
+    if (lines.at(-1) === "") lines.pop();
+    return lines;
+  };
+  const ops = diffLines(split(before), split(after));
+  const out = [`--- a/${path}`, `+++ b/${path}`];
+  let i = 0;
+  let lineA = 1;
+  let lineB = 1;
+  while (i < ops.length) {
+    if (ops[i].kind === " ") {
+      i++;
+      lineA++;
+      lineB++;
+      continue;
+    }
+    const from = Math.max(0, i - context);
+    const startA = lineA - (i - from);
+    const startB = lineB - (i - from);
+    let end = i;
+    let quiet = 0;
+    let k = i;
+    while (k < ops.length && quiet <= context * 2) {
+      if (ops[k].kind === " ") quiet++;
+      else {
+        quiet = 0;
+        end = k;
+      }
+      k++;
+    }
+    const to = Math.min(ops.length, end + 1 + context);
+    const hunk = ops.slice(from, to);
+    const countA = hunk.filter((o) => o.kind !== "+").length;
+    const countB = hunk.filter((o) => o.kind !== "-").length;
+    out.push(`@@ -${countA === 0 ? startA - 1 : startA},${countA} +${countB === 0 ? startB - 1 : startB},${countB} @@`);
+    for (const o of hunk) out.push(`${o.kind}${o.line}`);
+    for (let q = i; q < to; q++) {
+      if (ops[q].kind !== "+") lineA++;
+      if (ops[q].kind !== "-") lineB++;
+    }
+    i = to;
+  }
+  return `${out.join("\n")}
+`;
+}
+
+export {
+  EXIT,
+  CliError,
+  table,
+  show,
+  clip,
+  DEFAULT_MAX_FILE_BYTES,
+  walk,
+  unifiedDiff
+};

package/dist/chunk-TJEVOUI3.js

@@ -0,0 +1,74 @@
+import {
+  clip
+} from "./chunk-KGDBDK5S.js";
+
+// src/refs.ts
+import ts from "typescript";
+var VALUE_NAMES = ["boolean", "string", "number", "json", "evaluate", "useFlag", "getBooleanValue", "getStringValue", "getNumberValue", "getObjectValue"];
+var DETAILS_NAMES = ["getBooleanDetails", "getStringDetails", "getNumberDetails", "getObjectDetails", "booleanDetails", "stringDetails", "numberDetails", "jsonDetails", "evaluateDetails", "useFlagDetails"];
+var CALLEE_NAMES = /* @__PURE__ */ new Set([...VALUE_NAMES, ...DETAILS_NAMES]);
+function scriptKind(path) {
+  if (path.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (path.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  if (path.endsWith(".ts") || path.endsWith(".mts") || path.endsWith(".cts")) return ts.ScriptKind.TS;
+  return ts.ScriptKind.JS;
+}
+function parse(path, text) {
+  return ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, scriptKind(path));
+}
+function calleeName(callee) {
+  let e = callee;
+  while (ts.isParenthesizedExpression(e) || ts.isNonNullExpression(e)) e = e.expression;
+  if (ts.isIdentifier(e)) return e.text;
+  if (ts.isPropertyAccessExpression(e)) return e.name.text;
+  return null;
+}
+function findCallSites(source, keys) {
+  const out = [];
+  const visit = (node) => {
+    if (ts.isCallExpression(node)) {
+      const name = calleeName(node.expression);
+      const first = node.arguments[0];
+      if (name !== null && CALLEE_NAMES.has(name) && first && (ts.isStringLiteral(first) || ts.isNoSubstitutionTemplateLiteral(first)) && keys.has(first.text)) {
+        out.push({ call: node, name, flag: first.text });
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return out;
+}
+function lineOf(source, pos) {
+  return source.getLineAndCharacterOfPosition(pos).line + 1;
+}
+function snippetAt(text, source, pos) {
+  const line = source.getLineAndCharacterOfPosition(pos).line;
+  const starts = source.getLineStarts();
+  const end = line + 1 < starts.length ? starts[line + 1] : text.length;
+  return clip(text.slice(starts[line], end).trim(), 240);
+}
+function scanText(path, text, keys) {
+  let mentions = false;
+  for (const k of keys) {
+    if (text.includes(k)) {
+      mentions = true;
+      break;
+    }
+  }
+  if (!mentions) return [];
+  const source = parse(path, text);
+  return findCallSites(source, keys).map((s) => {
+    const pos = s.call.getStart(source);
+    return { flag: s.flag, path, line: lineOf(source, pos), snippet: snippetAt(text, source, pos) };
+  });
+}
+
+export {
+  CALLEE_NAMES,
+  scriptKind,
+  parse,
+  findCallSites,
+  lineOf,
+  snippetAt,
+  scanText
+};

package/dist/cleanup-QYR3DM6S.js

@@ -0,0 +1,371 @@
+import {
+  findCallSites,
+  lineOf,
+  parse,
+  scriptKind,
+  snippetAt
+} from "./chunk-TJEVOUI3.js";
+import "./chunk-KGDBDK5S.js";
+
+// src/cleanup.ts
+import ts from "typescript";
+var truthy = (c) => Boolean(c);
+var typeName = (v) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+function skipOuter(node) {
+  let p = node.parent;
+  while (ts.isParenthesizedExpression(p)) p = p.parent;
+  return p;
+}
+function isPure(node) {
+  if (ts.isCallExpression(node) || ts.isNewExpression(node) || ts.isAwaitExpression(node) || ts.isYieldExpression(node) || ts.isTaggedTemplateExpression(node) || ts.isDeleteExpression(node) || ts.isSpreadElement(node)) return false;
+  if (ts.isFunctionExpression(node) || ts.isArrowFunction(node)) return true;
+  if (ts.isClassExpression(node)) return false;
+  if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) && (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken)) return false;
+  if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) return false;
+  let pure = true;
+  ts.forEachChild(node, (child) => {
+    if (pure && !isPure(child)) pure = false;
+  });
+  return pure;
+}
+function fallbackKind(arg) {
+  if (!arg) return null;
+  let e = arg;
+  while (ts.isParenthesizedExpression(e)) e = e.expression;
+  if (e.kind === ts.SyntaxKind.TrueKeyword || e.kind === ts.SyntaxKind.FalseKeyword) return "boolean";
+  if (ts.isStringLiteral(e) || ts.isNoSubstitutionTemplateLiteral(e)) return "string";
+  if (ts.isNumericLiteral(e) || ts.isPrefixUnaryExpression(e) && ts.isNumericLiteral(e.operand)) return "number";
+  if (ts.isObjectLiteralExpression(e) || ts.isArrayLiteralExpression(e) || e.kind === ts.SyntaxKind.NullKeyword) return "json";
+  return null;
+}
+function unsupportedReason(site, value) {
+  const { call, name } = site;
+  if (name === "evaluate" || name.endsWith("Details")) return `${name}() returns an evaluation object, not the value`;
+  if (call.questionDotToken || (call.flags & ts.NodeFlags.OptionalChain) !== 0) return "optional call (?.) may also yield undefined";
+  let accessor;
+  if (name === "boolean" || name === "getBooleanValue") accessor = "boolean";
+  else if (name === "string" || name === "getStringValue") accessor = "string";
+  else if (name === "number" || name === "getNumberValue") accessor = "number";
+  else if (name === "json" || name === "getObjectValue") accessor = "json";
+  else accessor = fallbackKind(call.arguments[1]);
+  if (accessor === null) return "the accessor type depends on a fallback that is not a literal";
+  if (accessor !== "json" && accessor !== typeName(value)) return `this is a ${accessor} read but the value is a ${typeName(value)}: today it returns its fallback, not the value`;
+  if (name.startsWith("get") && !ts.isAwaitExpression(skipOuter(call))) return `${name}() may return a promise (OpenFeature server SDK); only awaited calls are rewritten`;
+  if (!isPure(call.expression) || !call.arguments.every(isPure)) return "the call or its arguments may have side effects";
+  return null;
+}
+var src = (ctx, n) => ctx.text.slice(n.getStart(ctx.source), n.end);
+function lineBounds(text, start, end) {
+  let lineStart = start;
+  while (lineStart > 0 && text[lineStart - 1] !== "\n") lineStart--;
+  let lineEnd = end;
+  while (lineEnd < text.length && text[lineEnd] !== "\n") lineEnd++;
+  const alone = text.slice(lineStart, start).trim() === "" && text.slice(end, lineEnd).trim() === "";
+  return { lineStart, lineEnd: lineEnd < text.length ? lineEnd + 1 : lineEnd, alone };
+}
+function removeStatement(ctx, node) {
+  const start = node.getStart(ctx.source);
+  const b = lineBounds(ctx.text, start, node.end);
+  return b.alone ? { start: b.lineStart, end: b.lineEnd, text: "" } : { start, end: node.end, text: "" };
+}
+function literalText(c, at) {
+  const parent = at.parent;
+  if (typeof c === "number") {
+    const s = JSON.stringify(c);
+    const tight = ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent) || ts.isCallExpression(parent);
+    const operand = ts.isBinaryExpression(parent) || ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent);
+    return tight && parent.expression === at || c < 0 && (tight || operand) ? `(${s})` : s;
+  }
+  if (typeof c === "object" && c !== null) {
+    const s = JSON.stringify(c);
+    return !Array.isArray(c) && (ts.isExpressionStatement(parent) || ts.isArrowFunction(parent) && parent.body === at) ? `(${s})` : s;
+  }
+  return JSON.stringify(c);
+}
+function moved(ctx, from, target) {
+  const s = src(ctx, from);
+  const parent = target.parent;
+  const statementStart = ts.isExpressionStatement(parent) || ts.isArrowFunction(parent) && parent.body === target;
+  return statementStart && /^(\{|function\b|class\b|let\b)/.test(s) ? `(${s})` : s;
+}
+var ATOMIC = /^(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*|\d+(?:\.\d+)?|"[^"\\\n]*")$/;
+function place(ctx, target, text) {
+  let node = target;
+  if (ATOMIC.test(text) && ts.isParenthesizedExpression(node.parent)) {
+    const outer = node.parent.parent;
+    const memberOfNumber = /^\d/.test(text) && (ts.isPropertyAccessExpression(outer) || ts.isElementAccessExpression(outer)) && outer.expression === node.parent;
+    if (!memberOfNumber) node = node.parent;
+  }
+  const holder = node.parent;
+  if (ts.isJsxExpression(holder) && (ts.isJsxElement(holder.parent) || ts.isJsxFragment(holder.parent))) {
+    if (text.startsWith("<")) return { start: holder.getStart(ctx.source), end: holder.end, text };
+    if (text === "false" || text === "null") return removeStatement(ctx, holder);
+  }
+  return { start: node.getStart(ctx.source), end: node.end, text };
+}
+function inBooleanContext(node) {
+  const p = node.parent;
+  if (ts.isParenthesizedExpression(p)) return inBooleanContext(p);
+  if (ts.isPrefixUnaryExpression(p) && p.operator === ts.SyntaxKind.ExclamationToken) return true;
+  if ((ts.isIfStatement(p) || ts.isWhileStatement(p) || ts.isDoStatement(p)) && p.expression === node) return true;
+  if (ts.isForStatement(p) && p.condition === node) return true;
+  if (ts.isConditionalExpression(p) && p.condition === node) return true;
+  if (ts.isBinaryExpression(p) && (p.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || p.operatorToken.kind === ts.SyntaxKind.BarBarToken)) return inBooleanContext(p);
+  return false;
+}
+function literalValue(e) {
+  let x = e;
+  while (ts.isParenthesizedExpression(x)) x = x.expression;
+  if (ts.isStringLiteral(x) || ts.isNoSubstitutionTemplateLiteral(x)) return { value: x.text };
+  if (ts.isNumericLiteral(x)) return { value: Number(x.text) };
+  if (ts.isPrefixUnaryExpression(x) && x.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(x.operand)) return { value: -Number(x.operand.text) };
+  if (x.kind === ts.SyntaxKind.TrueKeyword) return { value: true };
+  if (x.kind === ts.SyntaxKind.FalseKeyword) return { value: false };
+  if (x.kind === ts.SyntaxKind.NullKeyword) return { value: null };
+  return null;
+}
+function hasMultilineTemplate(ctx, node) {
+  let found = false;
+  const visit = (n) => {
+    if (found) return;
+    if ((ts.isNoSubstitutionTemplateLiteral(n) || ts.isTemplateExpression(n)) && src(ctx, n).includes("\n")) found = true;
+    else ts.forEachChild(n, visit);
+  };
+  visit(node);
+  return found;
+}
+function canUnwrap(ctx, block) {
+  if (hasMultilineTemplate(ctx, block)) return false;
+  const declared = /* @__PURE__ */ new Set();
+  const bind = (name) => {
+    if (ts.isIdentifier(name)) declared.add(name.text);
+    else for (const el of name.elements) if (!ts.isOmittedExpression(el)) bind(el.name);
+  };
+  for (const s of block.statements) {
+    if (ts.isVariableStatement(s) && (s.declarationList.flags & ts.NodeFlags.BlockScoped) !== 0) s.declarationList.declarations.forEach((d) => bind(d.name));
+    else if ((ts.isClassDeclaration(s) || ts.isFunctionDeclaration(s) || ts.isEnumDeclaration(s)) && s.name) declared.add(s.name.text);
+  }
+  if (declared.size === 0) return true;
+  let clash = false;
+  const visit = (n) => {
+    if (clash || n === block) return;
+    if (ts.isIdentifier(n) && declared.has(n.text)) clash = true;
+    else ts.forEachChild(n, visit);
+  };
+  visit(ctx.source);
+  return !clash;
+}
+function isStatementList(n) {
+  return ts.isBlock(n) || ts.isSourceFile(n) || ts.isModuleBlock(n) || ts.isCaseClause(n) || ts.isDefaultClause(n);
+}
+function rewriteIf(ctx, stmt, c) {
+  const taken = truthy(c) ? stmt.thenStatement : stmt.elseStatement;
+  const start = stmt.getStart(ctx.source);
+  const inList = isStatementList(stmt.parent);
+  if (!taken) {
+    if (inList) return removeStatement(ctx, stmt);
+    if (ts.isIfStatement(stmt.parent) && stmt.parent.elseStatement === stmt) return { start: stmt.parent.thenStatement.end, end: stmt.end, text: "" };
+    return { start, end: stmt.end, text: "{}" };
+  }
+  const bounds = lineBounds(ctx.text, start, stmt.end);
+  const startsLine = ctx.text.slice(bounds.lineStart, start).trim() === "";
+  if (ts.isBlock(taken) && inList && startsLine && canUnwrap(ctx, taken)) {
+    const inner = ctx.text.slice(taken.getStart(ctx.source) + 1, taken.end - 1);
+    const lines = inner.split("\n");
+    while (lines.length > 0 && lines[0].trim() === "") lines.shift();
+    while (lines.length > 0 && lines.at(-1).trim() === "") lines.pop();
+    if (lines.length === 0) return removeStatement(ctx, stmt);
+    const outerIndent = ctx.text.slice(bounds.lineStart, start);
+    const innerIndent = /^[ \t]*/.exec(lines[0])[0];
+    const out = lines.map((l, i) => {
+      const body = l.startsWith(innerIndent) ? l.slice(innerIndent.length) : l.trimStart();
+      return body === "" ? "" : (i === 0 ? "" : outerIndent) + body;
+    });
+    return { start, end: stmt.end, text: out.join("\n") };
+  }
+  return { start, end: stmt.end, text: src(ctx, taken) };
+}
+function referencesOf(ctx, decl) {
+  const checker = ctx.checker();
+  const symbol = checker.getSymbolAtLocation(decl.name);
+  const refs = [];
+  let exported = false;
+  if (!symbol) return { refs, exported: true };
+  const visit = (n) => {
+    if (ts.isIdentifier(n) && n !== decl.name && n.text === decl.name.text) {
+      const p = n.parent;
+      if (ts.isExportSpecifier(p)) {
+        if (checker.getExportSpecifierLocalTargetSymbol(p) === symbol) exported = true;
+      } else if (ts.isShorthandPropertyAssignment(p)) {
+        if (checker.getShorthandAssignmentValueSymbol(p) === symbol) refs.push(n);
+      } else if (checker.getSymbolAtLocation(n) === symbol) refs.push(n);
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(ctx.source);
+  return { refs, exported };
+}
+var AND = ts.SyntaxKind.AmpersandAmpersandToken;
+var OR = ts.SyntaxKind.BarBarToken;
+function editFor(ctx, start, value, depth = 0) {
+  let node = start;
+  let c = value;
+  for (; ; ) {
+    const p = node.parent;
+    if (ts.isParenthesizedExpression(p) || ts.isAwaitExpression(p) || ts.isNonNullExpression(p) || ts.isAsExpression(p) || ts.isSatisfiesExpression(p)) {
+      node = p;
+      continue;
+    }
+    if (ts.isPrefixUnaryExpression(p) && p.operator === ts.SyntaxKind.ExclamationToken) {
+      node = p;
+      c = !truthy(c);
+      continue;
+    }
+    if (ts.isBinaryExpression(p)) {
+      const op = p.operatorToken.kind;
+      const isLeft = p.left === node;
+      if (op === AND || op === OR) {
+        const decides = op === AND ? !truthy(c) : truthy(c);
+        if (isLeft) {
+          if (!decides) return place(ctx, p, moved(ctx, p.right, p));
+          node = p;
+          continue;
+        }
+        if (!inBooleanContext(p)) break;
+        if (!decides) return place(ctx, p, moved(ctx, p.left, p));
+        if (!isPure(p.left)) break;
+        node = p;
+        c = op === OR;
+        continue;
+      }
+      if (op === ts.SyntaxKind.QuestionQuestionToken && isLeft) {
+        if (c === null) return place(ctx, p, moved(ctx, p.right, p));
+        node = p;
+        continue;
+      }
+      const strict = op === ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsEqualsToken;
+      const loose = op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsToken;
+      if ((strict || loose) && (typeof c !== "object" || c === null)) {
+        const other = literalValue(isLeft ? p.right : p.left);
+        if (other && (strict || typeName(other.value) === typeName(c))) {
+          const equal = other.value === c;
+          node = p;
+          c = op === ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts.SyntaxKind.EqualsEqualsToken ? equal : !equal;
+          continue;
+        }
+      }
+      break;
+    }
+    if (ts.isConditionalExpression(p) && p.condition === node) {
+      return place(ctx, p, moved(ctx, truthy(c) ? p.whenTrue : p.whenFalse, p));
+    }
+    if (ts.isIfStatement(p) && p.expression === node) return rewriteIf(ctx, p, c);
+    if (ts.isVariableDeclaration(p) && p.initializer === node && ts.isIdentifier(p.name) && ts.isVariableDeclarationList(p.parent) && (p.parent.flags & ts.NodeFlags.Const) !== 0 && depth < 20) {
+      const decl = p;
+      const { refs, exported } = referencesOf(ctx, decl);
+      const first = refs[0];
+      if (first) {
+        if (ts.isShorthandPropertyAssignment(first.parent)) return { start: first.parent.getStart(ctx.source), end: first.parent.end, text: `${first.text}: ${literalText(c, first.parent)}` };
+        return editFor(ctx, first, c, depth + 1);
+      }
+      const list = p.parent;
+      const statement = list.parent;
+      const isExported = exported || ts.isVariableStatement(statement) && (ts.getCombinedModifierFlags(decl) & ts.ModifierFlags.Export) !== 0;
+      if (!isExported && list.declarations.length === 1 && ts.isVariableStatement(statement) && isStatementList(statement.parent)) return removeStatement(ctx, statement);
+    }
+    break;
+  }
+  return place(ctx, node, literalText(c, node));
+}
+function syntaxErrors(source) {
+  return (source.parseDiagnostics ?? []).length;
+}
+function checkerFor(source) {
+  const fileName = source.fileName;
+  const host = {
+    getSourceFile: (f) => f === fileName ? source : void 0,
+    getDefaultLibFileName: () => "lib.d.ts",
+    writeFile: () => void 0,
+    getCurrentDirectory: () => "/nanoflags-cleanup",
+    getCanonicalFileName: (f) => f,
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => "\n",
+    fileExists: (f) => f === fileName,
+    readFile: () => void 0
+  };
+  const program = ts.createProgram([fileName], { noLib: true, noResolve: true, allowJs: true, jsx: ts.JsxEmit.Preserve, target: ts.ScriptTarget.Latest, noEmit: true, types: [] }, host);
+  return program.getTypeChecker();
+}
+function step(path, text, keys, value) {
+  const ext = /\.[a-z]+$/.exec(path)?.[0] ?? ".ts";
+  const source = ts.createSourceFile(`/nanoflags-cleanup/file${ext}`, text, ts.ScriptTarget.Latest, true, scriptKind(path));
+  const site = findCallSites(source, keys).find((s) => unsupportedReason(s, value) === null);
+  if (!site) return null;
+  let checker = null;
+  const ctx = { path, text, source, checker: () => checker ??= checkerFor(source) };
+  const edit = editFor(ctx, site.call, value);
+  return text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+}
+function unreachableStatements(text, source) {
+  const out = [];
+  const visit = (n) => {
+    if (isStatementList(n)) {
+      const list = n.statements;
+      for (let i = 0; i + 1 < list.length; i++) {
+        const s = list[i];
+        const next = list[i + 1];
+        if ((ts.isReturnStatement(s) || ts.isThrowStatement(s) || ts.isBreakStatement(s) || ts.isContinueStatement(s)) && !ts.isFunctionDeclaration(next)) {
+          const pos = next.getStart(source);
+          out.push({ line: lineOf(source, pos), snippet: snippetAt(text, source, pos) });
+          break;
+        }
+      }
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(source);
+  return out;
+}
+function cleanupText(path, text, flag, value) {
+  const keys = /* @__PURE__ */ new Set([flag]);
+  const original = parse(path, text);
+  const sites = findCallSites(original, keys).map((s) => {
+    const pos = s.call.getStart(original);
+    const reason = unsupportedReason(s, value);
+    return { line: lineOf(original, pos), snippet: snippetAt(text, original, pos), ...reason === null ? {} : { reason } };
+  });
+  if (sites.every((s) => s.reason !== void 0)) return { output: text, transformed: [], skipped: sites, unreachable: [] };
+  let current = text;
+  for (let i = 0; i < 2e3; i++) {
+    const next = step(path, current, keys, value);
+    if (next === null || next === current) break;
+    current = next;
+  }
+  const final = parse(path, current);
+  const left = findCallSites(final, keys);
+  const failed = syntaxErrors(final) > syntaxErrors(original) || left.some((s) => unsupportedReason(s, value) === null);
+  if (failed) {
+    return { output: text, transformed: [], skipped: sites.map((s) => ({ ...s, reason: s.reason ?? "the rewrite could not be completed safely; the file was left unchanged" })), unreachable: [] };
+  }
+  const remaining = /* @__PURE__ */ new Map();
+  for (const s of left) {
+    const snip = snippetAt(current, final, s.call.getStart(final));
+    remaining.set(snip, (remaining.get(snip) ?? 0) + 1);
+  }
+  const unmatched = [];
+  const skippedBefore = sites.filter((s) => s.reason !== void 0);
+  for (const s of skippedBefore) {
+    const n = remaining.get(s.snippet) ?? 0;
+    if (n > 0) remaining.set(s.snippet, n - 1);
+    else unmatched.push(s);
+  }
+  const gone = skippedBefore.length - left.length;
+  const skipped = skippedBefore.map((s) => gone > 0 && gone === unmatched.length && unmatched.includes(s) ? { ...s, removed: true } : s);
+  const already = new Set(unreachableStatements(text, original).map((u) => u.snippet));
+  const unreachable = unreachableStatements(current, final).filter((u) => !already.has(u.snippet));
+  return { output: current, transformed: sites.filter((s) => s.reason === void 0), skipped, unreachable };
+}
+export {
+  cleanupText,
+  unsupportedReason
+};

package/dist/refs-CYG6GHJL.js

@@ -0,0 +1,19 @@
+import {
+  CALLEE_NAMES,
+  findCallSites,
+  lineOf,
+  parse,
+  scanText,
+  scriptKind,
+  snippetAt
+} from "./chunk-TJEVOUI3.js";
+import "./chunk-KGDBDK5S.js";
+export {
+  CALLEE_NAMES,
+  findCallSites,
+  lineOf,
+  parse,
+  scanText,
+  scriptKind,
+  snippetAt
+};