@preventive/compare 0.0.0-stage → 1.0.0

package/src/blocks.js

@@ -0,0 +1,17 @@
+// Whether a change set takes `before` to `after` as @preventive/diff holds its
+// own to, every kept line alike, its terminator with it: renamedDiff's check on
+// the blocks it gives, and markedBlocks' test of lines alike.
+
+import { DiffError, formatChangeSet } from '@preventive/diff'
+import { checkLineOptions } from './text.js'
+
+export function blocksHold(before, after, blocks, options) {
+  const { whitespace, ignoreCase } = checkLineOptions(options)
+  try {
+    formatChangeSet(before, after, blocks, { format: 'normal', whitespace, ignoreCase })
+    return true
+  } catch (error) {
+    if (error instanceof DiffError) return false
+    throw error
+  }
+}

package/src/changes.js

@@ -0,0 +1,90 @@
+// compareTrees: a path in both trees is modified or type-changed, a path in one
+// added or deleted unless renames.js pairs it with another, as git diff -M does
+// and, unless `renamesByPath` is false, by the paths a build moves files to.
+
+import { MAX_SCORE } from './similarity.js'
+import { findRenames } from './renames.js'
+import { checkLineOptions, contentOf } from './text.js'
+import { readTree, sameContent } from './tree.js'
+
+// git's defaults: -M at 50%, diff.renameLimit at 1000.
+const DEFAULT_RENAMES = 50
+const DEFAULT_RENAME_LIMIT = 1000
+
+// Code point order, which is git's byte order for UTF-8 paths; `<` on strings
+// would put U+E000..U+FFFF after astral characters.
+function byPath(a, b) {
+  const shared = Math.min(a.length, b.length)
+  for (let i = 0; i < shared; i++) {
+    if (a[i] !== b[i]) return a.codePointAt(i) - b.codePointAt(i)
+  }
+  return a.length - b.length
+}
+
+// -M's percentage as the least score out of MAX_SCORE, or null for no renames.
+function minimumScore(renames) {
+  if (renames === false) return null
+  const percent = renames === true ? DEFAULT_RENAMES : renames
+  if (typeof percent !== 'number') throw new TypeError(`renames must be a boolean or a percentage, not ${typeof renames}`)
+  if (!(percent > 0 && percent <= 100)) throw new RangeError(`renames must be a percentage above 0 and at most 100, not ${renames}`)
+  return Math.max(1, Math.trunc(MAX_SCORE * percent / 100))
+}
+
+function checkOptions({ renamesByPath, renameLimit, renameGroup, paths, lines }) {
+  if (typeof renamesByPath !== 'boolean') throw new TypeError(`renamesByPath must be a boolean, not ${typeof renamesByPath}`)
+  if (renameLimit !== Infinity && !(Number.isSafeInteger(renameLimit) && renameLimit >= 0)) throw new RangeError(`renameLimit must be a whole number or Infinity, not ${renameLimit}`)
+  if (renameGroup !== null && typeof renameGroup !== 'function') throw new TypeError(`renameGroup must be a function, not ${typeof renameGroup}`)
+  if (paths !== 'tree' && paths !== 'keys') throw new RangeError(`paths must be 'tree' or 'keys', not ${paths}`)
+  if (typeof lines !== 'boolean') throw new TypeError(`lines must be a boolean, not ${typeof lines}`)
+}
+
+const sameFile = (a, b) => sameContent(a, b) && (a.type !== 'file' || a.mode === b.mode)
+
+const status = (kind, old, fresh, similarity = null) => ({ status: kind, old, new: fresh, similarity })
+
+function pathChanges(old, fresh) {
+  const added = [], changes = [], deleted = []
+  for (const [path, file] of old) {
+    const now = fresh.get(path)
+    if (now === undefined) deleted.push(file)
+    else if (now.type !== file.type) changes.push(status('type-changed', file, now))
+    else if (!sameFile(file, now)) changes.push(status('modified', file, now))
+  }
+  for (const [path, file] of fresh) if (!old.has(path)) added.push(file)
+  deleted.sort((a, b) => byPath(a.path, b.path))
+  added.sort((a, b) => byPath(a.path, b.path))
+  return { changes, deleted, added }
+}
+
+// With `group`, renames are looked for within each group alone, as in a tree
+// of its own: a file is never taken for one of another group.
+function renamePairs(deleted, added, { group, ...options }) {
+  if (group === null) return findRenames(deleted, added, options)
+  const pairs = new Map()
+  const groupsOf = (files) => Map.groupBy(files.keys(), (i) => group(files[i].path))
+  const sourcesBy = groupsOf(deleted)
+  for (const [key, ds] of groupsOf(added)) {
+    const ss = sourcesBy.get(key)
+    if (ss === undefined) continue
+    for (const [d, { source, score }] of findRenames(ss.map((s) => deleted[s]), ds.map((i) => added[i]), options)) pairs.set(ds[d], { source: ss[source], score })
+  }
+  return pairs
+}
+
+export function compareTrees(a, b, { renames = true, renamesByPath = true, renameLimit = DEFAULT_RENAME_LIMIT, renameGroup = null, paths = 'tree', lines = true, horizon, whitespace, ignoreCase } = {}) {
+  const minimum = minimumScore(renames)
+  checkOptions({ renamesByPath, renameLimit, renameGroup, paths, lines })
+  const lineOptions = checkLineOptions({ horizon, whitespace, ignoreCase })
+  const keys = paths === 'keys'
+  const { changes, deleted, added } = pathChanges(readTree(a, 'old', keys), readTree(b, 'new', keys))
+  const pairs = minimum === null ? new Map() : renamePairs(deleted, added, { minimum, limit: renameLimit, byPath: renamesByPath, group: renameGroup })
+  for (const [d, file] of added.entries()) {
+    const pair = pairs.get(d)
+    changes.push(pair === undefined ? status('added', null, file) : status('renamed', deleted[pair.source], file, Math.trunc(pair.score * 100 / MAX_SCORE)))
+  }
+  const moved = new Set(pairs.values().map(({ source }) => source))
+  for (const [s, file] of deleted.entries()) if (!moved.has(s)) changes.push(status('deleted', file, null))
+  // A rename stands at its new path, as git lists it.
+  changes.sort((x, y) => byPath((x.new ?? x.old).path, (y.new ?? y.old).path))
+  return lines ? changes.map((change) => ({ ...change, ...contentOf(change.old, change.new, lineOptions) })) : changes
+}

package/src/css.js

@@ -0,0 +1,70 @@
+// Two style sheets alike but for layout, as css-tree reads them: one tree but for the ASCII case of what
+// CSS reads in any case (properties, at-rules, pseudo-classes, units, `!important`, hex colors where the
+// property's grammar takes them), zeros in a number that change neither its value nor its type
+// (`.50` as `0.5`), an attribute's value quoted, and comments' indentation.
+
+// A comment but for its lines' indentation, which formatting changes.
+export const indentless = (text) => text.replaceAll(/(?<![ \t])[ \t]*\r?\n[ \t]*/gu, '\n')
+
+const FOLDED = new Set(['Declaration.property', 'Atrule.name', 'Dimension.unit', 'PseudoClassSelector.name', 'PseudoElementSelector.name'])
+const NUMBERS = new Set(['Number', 'Dimension', 'Percentage'])
+
+// A number as written but for the zeros formatting adds before its point and drops after its last
+// digit (`.50` as `0.5`), one digit kept after the point (`1.00` as `1.0`), as `1` is an integer.
+const numberForm = (number) => number.replace(/^(?<sign>[+-]?)\./u, '$<sign>0.').replace(/^(?<kept>[+-]?\d*\.\d+?)0+(?!\d)/u, '$<kept>')
+const lower = (text) => text.replaceAll(/[A-Z]+/gu, (upper) => upper.toLowerCase())
+
+// A custom property's value, read as written but for CSS's own blanks at either end and its numbers in that form.
+function raw(csstree, value) {
+  const { Dimension: dimension, Number: number, Percentage: percentage } = csstree.tokenTypes
+  let at = 0, form = ''
+  csstree.tokenize(value, (type, start, end) => {
+    if (type !== number && type !== percentage && type !== dimension) return
+    form += value.slice(at, start) + numberForm(value.slice(start, end))
+    at = end
+  })
+  return (form + value.slice(at)).replaceAll(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/gu, '')
+}
+
+// The hex colors among a sheet's declarations, as each known property's grammar matches its value:
+// matched only where one holds a capital, the one case folding changes, as matching is slow.
+function colorsOf(csstree, tree) {
+  const colors = new Set()
+  csstree.walk(tree, { visit: 'Declaration', enter(declaration) {
+    if (!csstree.lexer.getProperty(declaration.property)) return
+    const hashes = []
+    csstree.walk(declaration.value, { visit: 'Hash', enter: (hash) => /[A-Z]/u.test(hash.value) && hashes.push(hash) })
+    if (hashes.length === 0) return
+    const match = csstree.lexer.matchProperty(declaration.property, declaration.value)
+    if (match.matched) for (const hash of hashes) if (match.isType(hash, 'hex-color')) colors.add(hash)
+  } })
+  return colors
+}
+
+// A sheet's tree and comments in one form; null where css-tree finds an error.
+function read(csstree, text) {
+  const comments = []
+  let failed = false
+  const tree = csstree.parse(text, { positions: false, parseCustomProperty: false, onComment: (value) => comments.push(indentless(value)), onParseError: () => { failed = true } })
+  if (failed) return null
+  const colors = colorsOf(csstree, tree)
+  return JSON.stringify([tree, comments], function form(key, value) {
+    if (key === 'loc') return undefined
+    // An attribute's unquoted value is the string it spells, unless it holds an escape: css-tree
+    // decodes those in strings alone.
+    if (key === 'value' && this.type === 'AttributeSelector' && value?.type === 'Identifier' && !value.name.includes('\\')) return { type: 'String', value: value.name }
+    if (typeof value !== 'string') return value
+    if (this.type === 'Declaration' && key === 'important') return lower(value) === 'important' || value
+    if (FOLDED.has(`${this.type}.${key}`) && !value.startsWith('--')) return lower(value)
+    if (key !== 'value') return value
+    if (this.type === 'Hash' && colors.has(this)) return lower(value)
+    if (NUMBERS.has(this.type)) return numberForm(value)
+    return this.type === 'Raw' ? raw(csstree, value) : value
+  })
+}
+
+// What css-tree throws on is format's to refuse.
+export function sameCss(csstree, text, formatted) {
+  const before = read(csstree, text)
+  return before !== null && before === read(csstree, formatted)
+}

package/src/error.js

@@ -0,0 +1,12 @@
+// A tree that cannot be a tree: `path` is the name at fault as its entry
+// spelled it, `tree` 'old' or 'new'. Wrong argument types stay TypeErrors.
+
+export class CompareError extends Error {
+  constructor(detail, path, tree) {
+    const where = tree === undefined ? '' : ` in the ${tree} tree`
+    super(path === undefined ? detail : `${detail}: ${JSON.stringify(path)}${where}`)
+    this.name = 'CompareError'
+    this.path = path
+    this.tree = tree
+  }
+}

package/src/layout.js

@@ -0,0 +1,94 @@
+// Two trees taken from different roots lined up: the directory one's files sit
+// under in the other (`root`), and each old path as the new tree lays it out.
+
+function throughRoot(root, path) {
+  if (!root) return path
+  if (root.base === '') return `${root.other}${path}`
+  return path.startsWith(root.base) ? path.slice(root.base.length) : null
+}
+
+// A path outside a root as one inside it reaches it.
+const outside = (root, path) => `${'../'.repeat(root.base.split('/').length - 1)}${path}`
+
+// Each old path as the new tree lays it out: through the root where the new
+// tree has it there, else as it is where it has that, else through the root,
+// one outside it a `../` further out, clear of every path taken.
+function rootPaths(base, other, root) {
+  const paths = new Map(), taken = new Set()
+  let moved = 0
+  for (const path of base) {
+    const to = throughRoot(root, path)
+    if (to === null || !other.has(to)) continue
+    paths.set(path, to)
+    taken.add(to)
+    if (to !== path) moved++
+  }
+  for (const path of base) {
+    if (paths.has(path) || !other.has(path) || taken.has(path)) continue
+    paths.set(path, path)
+    taken.add(path)
+  }
+  const paired = paths.size
+  for (const path of base) {
+    if (paths.has(path)) continue
+    let to = throughRoot(root, path) ?? outside(root, path)
+    while (other.has(to) || taken.has(to)) to = `../${to}`
+    paths.set(path, to)
+    taken.add(to)
+  }
+  return { paths, paired, moved }
+}
+
+export function detectRoot(basePaths, otherPaths) {
+  const base = new Set(basePaths), other = new Set(otherPaths)
+  const likeliest = (within, from) => {
+    const counts = new Map()
+    for (const path of within) {
+      for (let at = path.indexOf('/'); at !== -1; at = path.indexOf('/', at + 1)) {
+        if (from.has(path.slice(at + 1))) counts.set(path.slice(0, at + 1), (counts.get(path.slice(0, at + 1)) ?? 0) + 1)
+      }
+    }
+    let best = null, tied = false
+    for (const [dir, count] of counts) {
+      if (count > (counts.get(best) ?? 0)) [best, tied] = [dir, false]
+      else if (count === counts.get(best)) tied = true
+    }
+    return tied ? null : best
+  }
+  const same = rootPaths(base, other, null).paired
+  const found = [[{ base: '', other: likeliest(other, base) }, base], [{ base: likeliest(base, other), other: '' }, other]]
+    .filter(([root]) => root.base !== null && root.other !== null)
+    .map(([root, side]) => ({ root, side, ...rootPaths(base, other, root) }))
+    .filter(({ side, paired, moved }) => paired > same && moved * 2 >= side.size)
+  if (found.length === 2 && found[0].paired === found[1].paired) return null
+  return found.toSorted((a, b) => b.paired - a.paired)[0]?.root ?? null
+}
+
+export function treeLayout(basePaths, otherPaths) {
+  const base = [...basePaths], other = new Set(otherPaths)
+  const root = detectRoot(base, other)
+  return { root, paths: rootPaths(base, other, root).paths }
+}
+
+export function layoutDir({ root, paths }, dir, files) {
+  if (!root || dir === '.') return dir
+  for (const file of files) {
+    const to = paths.get(`${dir}/${file}`)
+    if (to?.endsWith(`/${file}`)) return to.slice(0, -file.length - 1)
+  }
+  const to = throughRoot(root, `${dir}/`)
+  return to === null ? outside(root, dir) : to.slice(0, -1) || '.'
+}
+
+export function layoutPackageDirs(baseDirs, otherDirs, layout) {
+  if (!baseDirs && !otherDirs) return null
+  const files = Map.groupBy([...baseDirs ?? []], ([, dir]) => dir)
+  const dirs = new Map([...files].map(([dir, entries]) => [dir, layoutDir(layout, dir, entries.map(([path]) => path.slice(dir.length + 1)))]))
+  return new Map([...[...baseDirs ?? []].map(([path, dir]) => [layout.paths.get(path) ?? path, dirs.get(dir)]), ...otherDirs ?? []])
+}
+
+export function rootLabel(root, prefix) {
+  if (!root) return { prefix, from: null, to: null }
+  const kept = prefix.startsWith(root.other) ? prefix : ''
+  return { prefix: kept, from: `./${root.base}${kept.slice(root.other.length)}`, to: `./${kept || root.other}` }
+}

package/src/marked.js

@@ -0,0 +1,20 @@
+// The blocks of the diff of `before` and `after` whose old lines, as `given`
+// (`before` renamed, line for line) has them, are their new lines: changed in
+// renamed names alone. null where `given` has another number of lines.
+
+import { changeSet } from '@preventive/diff'
+import { blocksHold } from './blocks.js'
+import { checkLineOptions } from './text.js'
+
+const records = (text) => (text === '' ? [] : text.split(/(?<=\n)/u))
+
+export function markedBlocks(before, given, after, options) {
+  const lineOptions = checkLineOptions(options)
+  const renamed = records(given)
+  if (renamed.length !== records(before).length) return null
+  // Lines alike are those an empty change set takes from one to the other.
+  const alike = (olds, news) => blocksHold(olds.join(''), news.join(''), [], lineOptions)
+  return changeSet(before, after, lineOptions)
+    .filter(({ a0, a1, b0, b1, insert }) => a1 - a0 === b1 - b0 && alike(renamed.slice(a0, a1), insert))
+    .map(({ a0, a1, b0, b1 }) => ({ a0, a1, b0, b1 }))
+}

package/src/names/analyze.js

@@ -0,0 +1,235 @@
+// A text's scopes and variables, each name read a variable's or a global's, or
+// `{ reason }` where names can't all be followed. Renamable (`aside`): short and
+// declared, and no script's global, export's or import's own name, or shorthand.
+
+import { getOxc } from '#oxc'
+import { MINIFIED, NAME_READS, RENAMED_MAX_LENGTH, declared, hoistedPast, holds, resolve, saysStrict } from './syntax.js'
+
+const FUNCTIONS = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'])
+// Statements whose `let`, `const`, `class` and functions are their own.
+const BLOCKS = new Set(['BlockStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement', 'SwitchStatement'])
+// Globals that make a script a CommonJS module, its top level its own.
+const COMMONJS = new Set(['exports', 'module', 'require'])
+
+// oxc is loaded outside the try: one missing is no text that won't parse. A text
+// oxc's semantic check finds an error in is one it can't vouch for.
+function parsed(text, extension) {
+  const sourceType = extension === 'mjs' ? 'module' : extension === 'cjs' ? 'commonjs' : 'unambiguous'
+  const { parseSync } = getOxc()
+  try {
+    const result = parseSync('file.js', text, { lang: 'jsx', sourceType, showSemanticErrors: true })
+    return result.errors.length > 0 ? null : result.program
+  } catch {
+    return null
+  }
+}
+
+function scope(s, parent, fn) {
+  const made = { parent, fn, names: new Map(), strict: parent?.strict ?? false }
+  s.scopes.push(made)
+  return made
+}
+
+// A body's `var` or function named as one of its parameters is that parameter:
+// `function f(a) { var a; return a }` returns its argument.
+function declare(s, where, node) {
+  const at = where.parameters?.names.has(node.name) ? where.parameters : where
+  let variable = at.names.get(node.name)
+  if (!variable) {
+    variable = { name: node.name, scope: at }
+    at.names.set(node.name, variable)
+    s.variables.push(variable)
+  }
+  s.declarations.set(node, [variable, at])
+  return variable
+}
+
+const fnOf = (where) => (where.fn ? where : fnOf(where.parent))
+
+// Two variables that must keep one name, read from then on as the first.
+function join(s, kept, gone) {
+  if (kept === gone || !s.variables.includes(gone)) return
+  for (const path of gone.through ?? []) (kept.through ??= []).push(path)
+  for (const at of s.scopes) for (const [name, variable] of at.names) if (variable === gone) at.names.set(name, kept)
+  for (const [node, [variable, where]] of s.declarations) if (variable === gone) s.declarations.set(node, [kept, where])
+  s.variables.splice(s.variables.indexOf(gone), 1)
+}
+
+// A `var` is its function's, passing the blocks it is in on the way (`through`);
+// one named as a `catch` parameter it is in keeps one name with it.
+function declareVariables(node, where, s) {
+  for (const id of node.declarations.flatMap((declarator) => declared(declarator.id))) {
+    const variable = declare(s, node.kind === 'var' ? fnOf(where) : where, id)
+    if (node.kind !== 'var') continue
+    const path = []
+    for (let at = where; !at.fn; at = at.parent) path.push(at)
+    if (path.length > 0) (variable.through ??= []).push(path)
+    const caught = path.find((at) => at.caught && at.names.has(id.name))
+    if (caught) join(s, caught.names.get(id.name), variable)
+  }
+}
+
+// An imported or exported name is no variable's; a variable imported or
+// exported by its own name keeps it.
+function moduleNames(node, s) {
+  if (node.type === 'ImportDeclaration') {
+    for (const specifier of node.specifiers) {
+      declare(s, s.root, specifier.local)
+      if (specifier.type !== 'ImportSpecifier') continue
+      s.others.add(specifier.imported)
+      if (specifier.imported.start === specifier.local.start) s.keeping.add(specifier.local)
+    }
+    return
+  }
+  for (const specifier of node.specifiers) {
+    s.others.add(specifier.exported)
+    if (node.source) s.others.add(specifier.local)
+    else if (specifier.exported.start === specifier.local.start) s.keeping.add(specifier.local)
+  }
+  if (node.declaration?.type === 'VariableDeclaration') for (const declarator of node.declaration.declarations) for (const id of declared(declarator.id)) s.keeping.add(id)
+  else if (node.declaration?.id) s.keeping.add(node.declaration.id)
+}
+
+// Names that are no variable's (keys, labels), names kept, and the properties
+// names are read through.
+function otherNames(node, s) {
+  switch (node.type) {
+    case 'ExportDefaultDeclaration': if (node.declaration.id) s.keeping.add(node.declaration.id); break
+    case 'ExportAllDeclaration': if (node.exported) s.others.add(node.exported); break
+    case 'ImportAttribute': s.others.add(node.key); break
+    case 'MemberExpression':
+      if (!node.computed) s.others.add(node.property)
+      if (!node.computed && NAME_READS.has(node.property.name)) s.reads.add(node.property.name)
+      break
+    case 'ObjectPattern':
+      for (const { type, computed, key } of node.properties) if (type === 'Property' && !computed && NAME_READS.has(key.name)) s.reads.add(key.name)
+      break
+    case 'Literal': if (NAME_READS.has(node.value)) s.reads.add(node.value); break
+    case 'TemplateLiteral': for (const { value } of node.quasis) if (NAME_READS.has(value.cooked)) s.reads.add(value.cooked); break
+    case 'Property': case 'MethodDefinition': case 'PropertyDefinition': case 'AccessorProperty':
+      if (node.computed) break
+      if (node.shorthand) s.keeping.add(node.key)
+      else s.others.add(node.key)
+      break
+    case 'LabeledStatement': case 'BreakStatement': case 'ContinueStatement': if (node.label) s.others.add(node.label); break
+    case 'MetaProperty': s.others.add(node.meta).add(node.property); break
+    default: break
+  }
+}
+
+// What a node declares, or why its names can't all be followed.
+function visit(node, where, s) {
+  switch (node.type) {
+    case 'JSXElement': case 'JSXFragment': return 'jsx'
+    case 'WithStatement': return 'dynamic'
+    case 'VariableDeclaration': declareVariables(node, where, s); return null
+    case 'FunctionDeclaration':
+      if (node.id && !where.fn && !where.strict) return 'block-function'
+      if (node.id) declare(s, where, node.id)
+      return null
+    // A function an `if` holds without braces is one in a block.
+    case 'IfStatement':
+      return !where.strict && [node.consequent, node.alternate].some((clause) => clause?.type === 'FunctionDeclaration') ? 'block-function' : null
+    case 'ClassDeclaration': if (node.id) declare(s, where, node.id); return null
+    case 'ImportDeclaration': case 'ExportNamedDeclaration': moduleNames(node, s); return null
+    default: otherNames(node, s); return null
+  }
+}
+
+// Parameters are a scope, the body's declarations one apart (a default reads
+// none: `(a = b) => { var b }`), and an expression's own name one around both.
+function enterFunction(node, where, s) {
+  const named = node.type !== 'FunctionDeclaration' && node.id ? scope(s, where, false) : where
+  if (named !== where) declare(s, named, node.id)
+  if (node.type === 'ClassExpression') {
+    for (const child of [node.superClass, node.body, ...node.decorators ?? []]) if (child) s.work.push([child, named])
+    return
+  }
+  const parameters = scope(s, named, true)
+  if (node.body?.type === 'BlockStatement' && saysStrict(node.body.body)) parameters.strict = true
+  for (const parameter of node.params) {
+    for (const id of declared(parameter)) declare(s, parameters, id)
+    s.work.push([parameter, parameters])
+  }
+  if (node.body?.type === 'BlockStatement') {
+    const body = Object.assign(scope(s, parameters, true), { parameters })
+    for (const statement of node.body.body) s.work.push([statement, body])
+  } else if (node.body) s.work.push([node.body, parameters])
+}
+
+// A node's children, each with the scope it is read in.
+function enter(node, where, s) {
+  if (FUNCTIONS.has(node.type) || node.type === 'ClassExpression') {
+    enterFunction(node, where, s)
+    return
+  }
+  let inner = where
+  if (BLOCKS.has(node.type)) inner = scope(s, where, false)
+  else if (node.type === 'ClassBody') inner = Object.assign(scope(s, where, false), { strict: true })
+  else if (node.type === 'StaticBlock') inner = scope(s, where, true)
+  else if (node.type === 'CatchClause') {
+    inner = Object.assign(scope(s, where, false), { caught: true, simple: node.param?.type === 'Identifier' })
+    for (const id of declared(node.param)) declare(s, inner, id)
+  }
+  // A switch's discriminant is read before its cases' scope is entered.
+  for (const [field, value] of Object.entries(node)) {
+    if (Array.isArray(value)) {
+      for (const child of value) if (child && typeof child.type === 'string') s.work.push([child, inner])
+    } else if (value && typeof value.type === 'string' && field !== 'type') s.work.push([value, field === 'discriminant' ? where : inner])
+  }
+}
+
+// A work list rather than a recursion: a minified file's expressions nest deeply.
+function walk(program) {
+  const s = { declarations: new Map(), scopes: [], variables: [], keeping: new Set(), others: new Set(), reads: new Set(), references: [], work: [] }
+  s.root = Object.assign(scope(s, null, true), { strict: program.sourceType === 'module' || saysStrict(program.body) })
+  s.work.push([program, s.root])
+  while (s.work.length > 0) {
+    const [node, where] = s.work.pop()
+    if (node.type === 'Identifier') {
+      if (!s.declarations.has(node) && !s.others.has(node)) s.references.push([node, where])
+      continue
+    }
+    const reason = visit(node, where, s)
+    if (reason) return { reason }
+    enter(node, where, s)
+  }
+  return s
+}
+
+// Each name read resolved outward from where it is read, else a global's.
+// `eval(...)` reads names by their spelling, wherever `eval` is declared.
+function resolved(program, s) {
+  const globals = [], occurrences = [...s.declarations].map(([node, [variable, where]]) => [node, variable, where])
+  for (const [node, where] of s.references) {
+    if (node.name === 'eval') return { reason: 'dynamic' }
+    const variable = resolve(node.name, where)
+    if (variable) occurrences.push([node, variable, where])
+    else globals.push([node, where])
+  }
+  for (const [node, variable] of occurrences) if (s.keeping.has(node)) variable.kept = true
+  const own = program.sourceType === 'module' || program.sourceType === 'commonjs' || globals.some(([node]) => COMMONJS.has(node.name))
+  for (const variable of s.variables) variable.aside = variable.name.length <= RENAMED_MAX_LENGTH && MINIFIED.test(variable.name) && !variable.kept && (own || variable.scope !== s.root)
+  // A shorthand property's two names are one, at one place.
+  const byStart = (x, y) => x[0].start - y[0].start
+  occurrences.sort(byStart)
+  globals.sort(byStart)
+  for (let i = 1; i < occurrences.length; i++) {
+    const [[node, variable], [previous, other]] = [occurrences[i], occurrences[i - 1]]
+    holds(node.start !== previous.start || variable === other, `${node.name} at ${node.start} two variables'`)
+  }
+  const deduplicated = occurrences.filter((entry, i) => i === 0 || entry[0].start !== occurrences[i - 1][0].start)
+  const names = new Set([...s.variables.map(({ name }) => name), ...globals.map(([node]) => node.name)])
+  return { scopes: s.scopes, variables: s.variables, occurrences: deduplicated, globals, names, reads: s.reads, module: program.sourceType === 'module', commonjs: program.sourceType === 'commonjs', own }
+}
+
+export function analyze(text, extension) {
+  const program = parsed(text, extension)
+  if (!program) return { reason: 'unparsed' }
+  const s = walk(program)
+  if (s.reason) return s
+  // A `var` named as a block's it hoists past does not compile, which oxc's
+  // semantic check misses beside a `catch`.
+  for (const variable of s.variables) for (const path of variable.through ?? []) if (hoistedPast(variable, path, variable.name, (at) => at.names).length > 0) return { reason: 'unparsed' }
+  return resolved(program, s)
+}

package/src/names/binds.js

@@ -0,0 +1,20 @@
+// Whether `renamed` binds as `before` does by oxc's minifier: both mangled,
+// every variable named by its place alone, they read the same. A check apart
+// from analyze's, each catching what the other misses; the top level as `kind`.
+
+import { getOxc } from '#oxc'
+
+export function bindsAlike(before, renamed, { module = false, commonjs = false, own = module || commonjs } = {}) {
+  const { minifySync } = getOxc()
+  const file = module ? 'file.mjs' : commonjs ? 'file.cjs' : 'file.js'
+  const mangled = (text) => {
+    try {
+      const result = minifySync(file, text, { module, compress: false, mangle: { toplevel: own }, codegen: { removeWhitespace: true } })
+      return result.errors.length === 0 ? result.code : null
+    } catch {
+      return null
+    }
+  }
+  const code = mangled(before)
+  return code !== null && code === mangled(renamed)
+}

package/src/names/check.js

@@ -0,0 +1,68 @@
+// Checks that should never fail, between the steps of renaming: each throws a
+// Broken naming what failed, and renameMap then gives no names.
+
+import { analyze } from './analyze.js'
+import { APART, MINIFIED, RESERVED, holds } from './syntax.js'
+
+// Each name to rename written as that name where it is, read once and in
+// order, none a variable's and a global's both, each variable declared, read
+// and standing in its scopes by its own name.
+export function checkAnalysis(text, { scopes, variables, occurrences, globals }) {
+  const known = new Set(variables), read = new Set()
+  let end = 0
+  for (const [node, variable] of occurrences) {
+    holds(known.has(variable), `${node.name} at ${node.start} read as a variable none declares`)
+    holds(node.name === variable.name, `${node.name} at ${node.start} read as ${variable.name}`)
+    holds(node.start >= end && node.end > node.start, `${node.name} at ${node.start} out of order`)
+    holds(text.slice(node.start, node.end) === node.name, `${node.name} at ${node.start} written otherwise`)
+    end = node.end
+    read.add(node.start)
+  }
+  for (const [node] of globals) holds(!read.has(node.start), `${node.name} at ${node.start} both a variable's and a global's`)
+  const standing = new Set(occurrences.map(([, variable]) => variable))
+  for (const variable of variables) holds(standing.has(variable), `${variable.name} read nowhere`)
+  for (const at of scopes) for (const [name, variable] of at.names) holds(known.has(variable) && variable.name === name, `a scope's ${name} no variable of its name`)
+}
+
+// Renamable variables alone paired, each new one once, the weak among them.
+export function checkPairing(a, b, { map, weak }) {
+  const news = new Set(b.variables), taken = new Set()
+  for (const [variable, to] of map) {
+    holds(variable.aside && to.aside && news.has(to), `${variable.name} paired with ${to.name}, the two not both renamable`)
+    holds(!taken.has(to), `two variables paired with ${to.name}`)
+    taken.add(to)
+  }
+  for (const variable of weak) holds(map.has(variable), `${variable.name} weak, and paired with none`)
+}
+
+// Each name changed a renamable variable's, one a minifier gives and no
+// keyword, and its counterpart's or one apart that neither side holds.
+export function checkGiven(a, b, map, given) {
+  for (const variable of a.variables) {
+    const name = given.get(variable)
+    if (name === variable.name) continue
+    holds(variable.aside, `${variable.name}, which keeps its name, named ${name}`)
+    holds(MINIFIED.test(name) && !RESERVED.has(name), `${variable.name} named ${name}, which no variable may be`)
+    holds(map.has(variable) ? map.get(variable).name === name : name.startsWith(variable.name + APART) && !a.names.has(name) && !b.names.has(name),
+      `${variable.name} named ${name}, neither its counterpart's name nor one apart`)
+  }
+}
+
+// The renamed text read again: each name where it was, written as given, one
+// variable's names still one variable's and two's two, the same globals read.
+export function checkRenamed(a, given, text, extension) {
+  const r = analyze(text, extension)
+  holds(!r.reason, `the renamed text read again: ${r.reason}`)
+  checkAnalysis(text, r)
+  holds(r.occurrences.length === a.occurrences.length && r.globals.length === a.globals.length && r.variables.length === a.variables.length,
+    'the renamed text reads another number of names')
+  const backward = new Map(), forward = new Map()
+  a.occurrences.forEach(([, variable], i) => {
+    const [node, other] = r.occurrences[i]
+    holds(node.name === given.get(variable), `${variable.name} written ${node.name}, not ${given.get(variable)}`)
+    holds((forward.get(variable) ?? other) === other && (backward.get(other) ?? variable) === variable, `${variable.name}'s names read as another variable's`)
+    forward.set(variable, other)
+    backward.set(other, variable)
+  })
+  a.globals.forEach(([node], i) => holds(r.globals[i][0].name === node.name, `the global ${node.name} read as ${r.globals[i][0].name}`))
+}