@preventive/compare 1.2.5 → 1.2.7

package/names.d.ts

@@ -21,12 +21,15 @@ export type RenameReason = 'unparsed' | 'dynamic' | 'jsx' | 'block-function' | '
 // The diff of two JavaScript files minified on both sides with renamed names
 // set aside. The old side is given the new side's names wherever a minifier
 // renamed a variable alike throughout (a declared variable's short ASCII name,
-// not a script's top level -- but where the file's other version is a module,
-// as a bundle's chunk is once it exports, the same file loaded alike -- a name
-// exported or imported as itself, or a shorthand property's), checked to bind
+// not a script's top level -- but where either version of the file is a module,
+// as a bundle's chunk is once it exports, or declares 16 names or more there,
+// every one short, as a minifier renames a script's top level only told that no
+// other script reads it: the same file loaded alike -- a name exported or
+// imported as itself, or a shorthand property's), checked to bind
 // every name as before by this package's scope analysis and again by oxc's
 // minifier; formatted again where that changes its layout alone and still binds
-// alike; diffed as diff -U0 has it; and the blocks checked to take `before` to
+// alike; diffed as diff -U0 has it, and as --minimal does where that is cheap
+// (lines by lines changed up to 2e8); and the blocks checked to take `before` to
 // the new side (thrown should they not). `reason` says why no names were given;
 // `reads` the properties either text reads names through (`name`, `toString`,
 // `stack`, `callee`, `caller`), sorted, as code reading its names may act

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preventive/compare",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "Git-compatible file tree diffs and minified JavaScript comparison",
   "type": "module",
   "main": "./compare.js",

package/src/names/analyze.js

@@ -248,8 +248,18 @@ function resolved(program, s) {
   return { scopes: s.scopes, variables: s.variables, occurrences: deduplicated, globals, names, reads: s.reads, module: program.sourceType === 'module', commonjs: program.sourceType === 'commonjs', own }
 }
 
+const minified = (name) => name.length <= RENAMED_MAX_LENGTH && MINIFIED.test(name)
 // A short minified name, declared, and kept by no export, import or shorthand.
-const renamable = (variable) => variable.name.length <= RENAMED_MAX_LENGTH && MINIFIED.test(variable.name) && !variable.kept
+const renamable = (variable) => minified(variable.name) && !variable.kept
+
+// A script whose top level a minifier renamed: many names there, every one short.
+// A minifier renames a script's top level only told that no other script reads
+// it, as a bundle's chunk loaded as a module is; globals others read are few.
+const MANY_TOP_LEVEL = 16
+export function minifiedTopLevel(analysis) {
+  const top = analysis.variables.filter((variable) => variable.scope.parent === null)
+  return top.length >= MANY_TOP_LEVEL && top.every((variable) => minified(variable.name))
+}
 
 // A script's analysis with its top level its own, as a module's: renamable there
 // too. Still read as a script, `this` and all, but no global of it set aside.

package/src/names/check.js

@@ -24,12 +24,14 @@ export function checkAnalysis(text, { scopes, variables, occurrences, globals })
   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 }) {
+// Renamable variables alone paired, each new one once and by some line, the
+// weak among them.
+export function checkPairing(a, b, { map, support, 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}`)
+    holds(support.get(variable) > 0, `${variable.name} paired with ${to.name} by no line`)
     taken.add(to)
   }
   for (const variable of weak) holds(map.has(variable), `${variable.name} weak, and paired with none`)

package/src/names/diff.js

@@ -1,12 +1,12 @@
 // A diff of a file minified on both sides with renamed names set aside: the
 // old side renamed, formatted again where that changes its layout alone and
-// still binds alike, diffed, and the diff checked to hide no change.
+// still binds alike, diffed at its shortest where affordable, and the diff
+// checked to hide no change.
 
-import { changeSet } from '@preventive/diff'
 import { blocksHold } from '../blocks.js'
 import { markedBlocks } from '../marked.js'
 import { format } from '../pretty.js'
-import { checkLineOptions } from '../text.js'
+import { checkLineOptions, shortestChangeSet } from '../text.js'
 import { bindsAlike } from './binds.js'
 import { renameMap } from './rename.js'
 
@@ -30,7 +30,7 @@ export async function renamedDiffs(before, after, { extension = 'js', otherExten
   }
   let unmarked = false
   const diffs = settings.map((options) => {
-    const blocks = changeSet(renamed, after, options).map(ranges)
+    const blocks = shortestChangeSet(renamed, after, options).map(ranges)
     if (!blocksHold(renamed, after, blocks, options)) throw new Error('change blocks that do not take the old side to the new')
     // Read off the renamed text before formatting, line for line the old side's.
     const marks = mapped.reason ? [] : markedBlocks(before, mapped.text, after, options)

package/src/names/pairing.js

@@ -2,24 +2,14 @@
 // their keys (names set aside) pairs them, counts its variables as standing for
 // each other, and two each the other's most counted pair, a tie pairing neither.
 
-import { changeSet } from '@preventive/diff'
+import { shortestChangeSet } from '../text.js'
 import { RESERVED } from './syntax.js'
 
 // Unchanged lines between changes that pair as unchanged ones, not as changed.
 const ANCHORED_RUN = 3
 
 // Whitespace alone never tells a name apart.
-const changes = (a, b, minimal = false) => changeSet(a, b, { horizon: 0, whitespace: 'all', minimal })
-
-// The search's cutoff can face a run with lines alike far from its own: old code
-// that a block of new code now comes before, its lines faced with that block's
-// braces. The shortest diff instead, where its cost, lines by lines changed, allows.
-const MINIMAL_COST = 2e8
-function linedUp(a, b, lines) {
-  const quick = changes(a, b)
-  const changed = quick.reduce((n, { a0, a1, b0, b1 }) => n + a1 - a0 + b1 - b0, 0)
-  return lines * changed > MINIMAL_COST ? quick : changes(a, b, true)
-}
+const KEYS = { horizon: 0, whitespace: 'all' }
 
 // A text's lines with its renamable variables' names set aside (`key`), but
 // those `written` names (a pair found), each line's variables set aside in
@@ -79,7 +69,7 @@ const reading = (k, from = 0) => (x, y) => {
 // The pairs of lines a diff of `a` and `b` keeps, each told whether slack.
 function* kept(a, b, sameA, sameB) {
   const text = (lines) => lines.map((line) => `${line}\n`).join('')
-  const blocks = linedUp(text(a), text(b), a.length + b.length)
+  const blocks = shortestChangeSet(text(a), text(b), KEYS, a.length + b.length)
   const [looseA, looseB] = slack(a, b, blocks, sameA, sameB)
   let i = 0, j = 0
   for (const { a0, a1, b1 } of [...blocks, { a0: a.length, a1: a.length, b1: b.length }]) {
@@ -161,20 +151,20 @@ function moves(ka, kb, blocks, alike) {
   }
 }
 
-// Pairs of lines counted, a long run of unchanged ones apart from the rest, and
-// apart from both the variables a change's tokens pair (`tokened`) and those of
-// code moved (`moved`). Lines reading variables one side has and the other not
-// say nothing. In a change of unlike lengths, lines alike but for a final `;` or
-// `,` pair (a declaration others now follow: `let t = ...;` -> `let t = ...,`).
+// Pairs of lines counted, a long run of unchanged ones apart from the rest, as
+// is code moved, and apart from both the variables a change's tokens pair
+// (`tokened`). Lines reading variables one side has and the other not say
+// nothing. In a change of unlike lengths, lines alike but for a final `;` or `,`
+// pair (a declaration others now follow: `let t = ...;` -> `let t = ...,`).
 function tallied(ka, kb) {
-  const changed = tallies(), moved = tallies(), tokened = tallies(), unchanged = tallies()
+  const changed = tallies(), tokened = tallies(), unchanged = tallies()
   const counted = ({ backward, forward }, variable, other) => {
     count(forward, variable, other)
     count(backward, other, variable)
   }
   const alike = (counts, olds, news) => olds.length === news.length && olds.forEach((variable, k) => counted(counts, variable, news[k]))
   const trimmed = (lines, from, to) => plain(lines.slice(from, to).map((line) => line.replace(/[;,]\s*$/u, '')))
-  const blocks = linedUp(ka.key, kb.key, ka.keys.length + kb.keys.length)
+  const blocks = shortestChangeSet(ka.key, kb.key, KEYS, ka.keys.length + kb.keys.length)
   const [looseA, looseB] = slack(plain(ka.keys), plain(kb.keys), blocks, reading(ka), reading(kb))
   let i = 0, j = 0
   for (const block of [...blocks, { a0: ka.lines.length, a1: ka.lines.length, b0: kb.lines.length, b1: kb.lines.length }]) {
@@ -192,8 +182,19 @@ function tallied(ka, kb) {
     i = block.a1
     j = block.b1
   }
-  moves(ka, kb, blocks, (olds, news) => alike(moved, olds, news))
-  return { changed, moved, tokened, unchanged }
+  // Code moved counts a pair once a line, so that a moved line reading a variable
+  // often outweighs no lines in place reading it once each.
+  const once = (olds, news) => {
+    if (olds.length !== news.length) return
+    const seen = new Map()
+    olds.forEach((variable, k) => {
+      const others = seen.get(variable) ?? seen.set(variable, new Set()).get(variable)
+      if (!others.has(news[k])) counted(unchanged, variable, news[k])
+      others.add(news[k])
+    })
+  }
+  moves(ka, kb, blocks, once)
+  return { changed, tokened, unchanged }
 }
 
 // The most counted of those not yet paired, none where two tie.
@@ -209,8 +210,9 @@ function best(counts, taken) {
   return found
 }
 
-// Pairs each the other's best, into `map`, until none more pair.
-function matched({ backward, forward }, { map, paired }, eligible = () => true) {
+// Pairs each the other's best, into `map`, until none more pair: each pair's
+// count its `support`.
+function matched({ backward, forward }, { map, paired, support }, eligible = () => true) {
   const chosen = []
   for (let more = true; more;) {
     more = false
@@ -219,6 +221,7 @@ function matched({ backward, forward }, { map, paired }, eligible = () => true)
       const to = best(counts, (other) => paired.has(other))
       if (!to || best(backward.get(to), (other) => map.has(other)) !== variable || !eligible(variable, to)) continue
       map.set(variable, to)
+      support.set(variable, counts.get(to))
       paired.add(to)
       chosen.push(variable)
       more = true
@@ -227,23 +230,25 @@ function matched({ backward, forward }, { map, paired }, eligible = () => true)
   return chosen
 }
 
-// Unchanged lines pair first; changed ones then pair only what those say
-// nothing of, and a change's tokens only what no line says anything of: lines
-// reordered, a change's tokens may line up across them. Both are `weak` pairs,
-// the first to give way where names read wrongly. A second pass reads the
-// pairs found as names, so lines alike with every name set aside and diffed
-// against the wrong one line up by those.
+// Unchanged lines pair first, and code moved counted with them: a function's
+// code moved into a helper reads its variables as the helper's, the function's
+// own lines as its own, and the most lines decide. Changed ones then pair only
+// what those say nothing of, and a change's tokens only what no line says
+// anything of: lines reordered, a change's tokens may line up across them. Both
+// are `weak` pairs, the first to give way where names read wrongly. A second
+// pass reads the pairs found as names, so lines alike with every name set aside
+// and diffed against the wrong one line up by those.
 export function pairing(before, after, a, b) {
-  const found = { map: new Map(), paired: new Set() }, said = new Set(), weak = new Set()
+  const found = { map: new Map(), paired: new Set(), support: new Map() }, said = new Set(), weak = new Set()
   const passes = [[() => null, () => null], [(variable) => found.map.get(variable)?.name ?? null, (variable) => (found.paired.has(variable) ? variable.name : null)]]
   for (const [old, now] of passes) {
     // A pass pairs nothing where every variable of a side is paired already.
     if (!a.variables.some((variable) => variable.aside && !found.map.has(variable)) || !b.variables.some((variable) => variable.aside && !found.paired.has(variable))) break
-    const { changed, moved, tokened, unchanged } = tallied(keyed(before, a, old), keyed(after, b, now))
-    for (const [counts, tier] of [[unchanged, false], [changed, true], [tokened, true], [moved, true]]) {
+    const { changed, tokened, unchanged } = tallied(keyed(before, a, old), keyed(after, b, now))
+    for (const [counts, tier] of [[unchanged, false], [changed, true], [tokened, true]]) {
       for (const variable of matched(counts, found, (from, to) => !said.has(from) && !said.has(to))) if (tier) weak.add(variable)
       for (const variable of [...counts.forward.keys(), ...counts.backward.keys()]) said.add(variable)
     }
   }
-  return { map: found.map, weak }
+  return { map: found.map, support: found.support, weak }
 }

package/src/names/rename.js

@@ -3,7 +3,7 @@
 // to read wrongly, and the result checked again by oxc (bindsAlike).
 
 import { getOxc } from '#oxc'
-import { analyze, ownTopLevel } from './analyze.js'
+import { analyze, minifiedTopLevel, ownTopLevel } from './analyze.js'
 import { bindsAlike } from './binds.js'
 import { checkAnalysis, checkGiven, checkPairing, checkRenamed } from './check.js'
 import { misread } from './misread.js'
@@ -11,9 +11,10 @@ import { pairing } from './pairing.js'
 import { APART, Broken, holds } from './syntax.js'
 
 // Each old variable's name: its counterpart's, else its own, or one apart where
-// the new side has its own. Those misread yield, weak pairs first; null where
-// none can.
-function givenNames(a, b, { map, weak }) {
+// the new side has its own. Those misread yield, weak pairs first, else those
+// fewest lines pair: a pair that a few lines alone say gives way to one most
+// do. null where none can.
+function givenNames(a, b, { map, support, weak }) {
   const apart = (name) => {
     let named = name + APART
     for (let n = 2; a.names.has(named) || b.names.has(named); n++) named = `${name}${APART}${n}`
@@ -27,7 +28,9 @@ function givenNames(a, b, { map, weak }) {
     }
     const wrong = [...misread(a, given)]
     if (wrong.length === 0) return given
-    const yielding = wrong.some((variable) => weak.has(variable) && map.has(variable)) ? wrong.filter((variable) => weak.has(variable)) : wrong
+    const paired = wrong.filter((variable) => map.has(variable))
+    const least = paired.reduce((n, variable) => Math.min(n, support.get(variable)), Infinity)
+    const yielding = paired.some((variable) => weak.has(variable)) ? paired.filter((variable) => weak.has(variable)) : paired.filter((variable) => support.get(variable) === least)
     if (yielding.filter((variable) => map.delete(variable)).length === 0) return null
   }
 }
@@ -36,9 +39,10 @@ function renamedNames(before, after, { extension = 'js', otherExtension = extens
   let a = analyze(before, extension), b = analyze(after, otherExtension)
   if (a.reason || b.reason) return { reason: a.reason ?? b.reason }
   // A file is a module by how it is loaded, which its versions share, more than
-  // by its syntax: a bundle's chunk that one version exports from, the other not.
-  // Where its other version is a module, a script's top level is its own too.
-  if (a.module || b.module) [a, b] = [ownTopLevel(a), ownTopLevel(b)]
+  // by its syntax: a bundle's chunk that one version exports from, the other not,
+  // or that neither does, its top level renamed by a minifier as a module's is.
+  // Where either version is one, a script's top level is its own too.
+  if ([a, b].some((side) => side.module || minifiedTopLevel(side))) [a, b] = [ownTopLevel(a), ownTopLevel(b)]
   checkAnalysis(before, a)
   checkAnalysis(after, b)
   const paired = pairing(before, after, a, b)

package/src/text.js

@@ -31,6 +31,17 @@ export function checkLineOptions({ horizon = Infinity, whitespace = 'none', igno
   return { horizon, whitespace, ignoreCase }
 }
 
+// The shortest diff where its cost, lines by lines changed, allows, as --minimal
+// has it; past that the search's cutoff, which can face a run with lines alike
+// far from its own: old code that new code now comes before, faced with its braces.
+const SHORTEST_COST = 2e8
+const lineCount = (text) => text.split('\n').length
+export function shortestChangeSet(a, b, options, lines = lineCount(a) + lineCount(b)) {
+  const quick = changeSet(a, b, options)
+  const changed = quick.reduce((n, { a0, a1, b0, b1 }) => n + a1 - a0 + b1 - b0, 0)
+  return lines * changed > SHORTEST_COST ? quick : changeSet(a, b, { ...options, minimal: true })
+}
+
 // Binary content has no blocks and no counts, as --numstat prints `-` for it.
 export function contentOf(old, fresh, options) {
   const a = textOf(old), b = textOf(fresh)