@preventive/compare 1.2.6 → 1.2.8

package/compare.d.ts

@@ -84,7 +84,9 @@ export interface FileChange extends FileStatus {
 // `diff -U0` and the normal format, the context to match `diff -u` (diff's
 // --horizon-lines); `whitespace` (-w as 'all', -b as 'change', -Z as
 // 'trailing') and `ignoreCase` (-i) say which lines are the same, so that a
-// file changed in nothing else has no blocks.
+// file changed in nothing else has no blocks. Ignoring blanks or case never
+// shows more lines than minding them, and where it shows no fewer, its blocks
+// are those minding them: it does nothing there.
 export interface LineOptions {
   horizon?: number
   whitespace?: 'none' | 'all' | 'change' | 'trailing'
@@ -110,17 +112,19 @@ export interface LineOptions {
 // and their directories but for one -- not a package's name under
 // node_modules -- each the other's only such partner. Either gives way only
 // to a candidate that is a rename by itself and scores at least halfway from
-// the pair's score to 100%. Last, of the files no other pass took, it pairs
-// bundle chunks whose hash changed with their content: in one directory, of
-// one extension, names alike but for what follows the last separator (`-`,
-// `.`, `_`) they share, six or more characters of a hash's (letters, digits,
-// `-` and `_`, not lowercase letters alone), as `index-CyWAfh-p.js` and
-// `index-hRvO4yU2.js` are. Minified onto a line, such a chunk scores little
-// as git splits it, so it is scored with its spans ending after `,` `;` `=`
-// `{` `}` too, and taken at git's stricter score for a basename, halfway from
-// -M's to 100%: the best pairs first, its similarity that score, and none
-// past the rename limit, as they are scored. git has no such passes, so false
-// is git's own -M.
+// the pair's score to 100%. And before git scores every pair left, lest a file
+// elsewhere take either version, it pairs bundle chunks whose hash changed
+// with their content: in one directory, names alike but for what follows the
+// last separator (`-`, `.`, `_`) they share, up to the extensions they end in
+// alike, six or more characters of a hash's (letters, digits, `-` and `_`, not
+// lowercase letters alone), as `index-CyWAfh-p.js` and `index-hRvO4yU2.js`
+// are, or `main.3f9a2c1d.chunk.js` and `main.8b7e6a5f.chunk.js`. Minified onto
+// a line, such a chunk scores little as git splits it, so it is scored with
+// its spans ending after `,` `;` `=` `{` `}` too, and taken at git's stricter
+// score for a basename, halfway from -M's to 100%: the best pairs first, its
+// similarity that score, giving way as a pair by path does but only where git
+// takes the candidate it gives way to, and none past the rename limit, as they
+// are scored. git has no such passes, so false is git's own -M.
 //
 // `renameLimit` is git's diff.renameLimit: when more deleted files times added
 // files are left, in a group, after the renames that need no scoring than its

package/names.d.ts

@@ -27,35 +27,47 @@ export type RenameReason = 'unparsed' | 'dynamic' | 'jsx' | 'block-function' | '
 // 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 as --minimal does where that is cheap
-// (lines by lines changed up to 2e8); and the blocks checked to take `before` to
+// minifier, line for line the old side's (`before`, each line where it was);
+// diffed as diff -U0 has it, and as --minimal does where that is cheap
+// (the square of the lines changed up to 2e8, or 10,000 a line of the two
+// texts); 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
 // otherwise renamed: none where none is renamed, and `name` only where a name
 // renamed is a function's or class's, the one name it reads (`function f`,
-// `f = () => {}`); `marks` the plain diff's blocks that differ in renamed names
-// alone; and `warnings` what a check that should never fail found.
+// `f = () => {}`); `assumed` all a script's top level was taken as its own on,
+// where a name there changed or was given to one from there (none where
+// none): 'module' where a version of the file is one, 'minified' where a
+// script's top level declares 16 names or more, every one short; `marks` the
+// plain diff's blocks that differ in renamed names alone; and `warnings` what
+// a check that should never fail found.
 export function renamedDiff(before: string, after: string, options?: RenameOptions & { whitespace?: Whitespace }): Promise<{
   before: string
   blocks: Pick<Block, 'a0' | 'a1' | 'b0' | 'b1'>[]
   reason: RenameReason | null
   reads: string[]
+  assumed: TopLevelAssumption[]
   marks: Pick<Block, 'a0' | 'a1' | 'b0' | 'b1'>[]
   warnings: string[]
 }>
 
+// What a script's top level renamed as a module's is taken to be on, each one apart.
+export type TopLevelAssumption = 'module' | 'minified'
+
 export type Whitespace = 'none' | 'all' | 'change' | 'trailing'
 
 // renamedDiff for each of `whitespace`'s settings (`['none']` unless given),
 // `diffs` in their order: the names found and the old side given them once
-// for all, as are `before`, `reason`, `reads` and `warnings`; each setting's
-// `blocks` checked as renamedDiff's are, and its `marks` read as they are.
+// for all, as are `before`, `reason`, `reads`, `assumed` and `warnings`; each setting's
+// `blocks` checked as renamedDiff's are, and its `marks` read as they are. A
+// setting ignoring blanks never shows more lines than 'none', and where it
+// shows no fewer, its blocks are those of 'none': it does nothing there.
 export function renamedDiffs(before: string, after: string, options?: RenameOptions & { whitespace?: Whitespace[] }): Promise<{
   before: string
   reason: RenameReason | null
   reads: string[]
+  assumed: TopLevelAssumption[]
   diffs: { whitespace: Whitespace; blocks: Pick<Block, 'a0' | 'a1' | 'b0' | 'b1'>[]; marks: Pick<Block, 'a0' | 'a1' | 'b0' | 'b1'>[] }[]
   warnings: string[]
 }>

package/names.js

@@ -1,8 +1,8 @@
 // JavaScript minified on both sides, its renamed names told apart from its
 // changes: the old side given the new side's names wherever a minifier
 // renamed a variable alike throughout, so that the two then diff as they are.
-// Built on oxc-parser and oxc-minify, and oxfmt for renamedDiff, optional
-// peers: on Node loaded on first use, elsewhere oxc with this module.
+// Built on oxc-parser and oxc-minify, optional peers: on Node loaded on first
+// use, elsewhere oxc with this module.
 // compare.js loads none. Typed and described in names.d.ts.
 
 // The diff of two such files with renamed names set aside, checked to hide no

package/package.json

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

package/src/chunks.js

@@ -1,6 +1,8 @@
 // Bundle chunks a build renamed: `index-CyWAfh-p.js` for `index-hRvO4yU2.js`
-// in one directory, the hash in a name following its content. Minified code
-// is a line or a few, so a chunk is scored with spans ending after punctuation.
+// in one directory, the hash in a name following its content, and the same
+// for `main.3f9a2c1d.chunk.js` or `index-CyWAfh-p.js.map`, extensions after
+// the hash. Minified code is a line or a few, so a chunk is scored with spans
+// ending after punctuation.
 
 // A content hash: six or more of base64url's characters, not all lowercase
 // letters, which a word is.
@@ -13,23 +15,28 @@ function nameOf(path) {
   const name = path.slice(slash + 1)
   const dot = name.lastIndexOf('.')
   const extension = dot > 0 ? name.slice(dot) : ''
-  const stem = name.slice(0, name.length - extension.length)
-  return { stem, key: `${path.slice(0, slash + 1)}\0${extension}\0${stem.length}` }
+  return { name, key: `${path.slice(0, slash + 1)}\0${extension}\0${name.length}` }
 }
 
-// Whether two stems of a length are one chunk's, its hash all that differs:
-// what follows the last separator they share before they differ.
+// Whether two names of a length are one chunk's, its hash all that differs:
+// what follows the last separator they share before they differ, up to the
+// first `.` of the end they share, their extensions.
 function oneChunk(a, b) {
-  let start = 0
+  let end = a.length, start = 0
   while (start < a.length && a[start] === b[start]) start++
+  while (end > start && a[end - 1] === b[end - 1]) end--
   while (start > 0 && !SEPARATORS.includes(a[start - 1])) start--
-  const x = a.slice(start), y = b.slice(start)
+  while (end < a.length && a[end] !== '.') end++
+  const x = a.slice(start, end), y = b.slice(start, end)
   return start > 0 && HASH.test(x) && HASH.test(y) && (RANDOM.test(x) || RANDOM.test(y))
 }
 
-// Chunks no other pass claimed, by directory, extension and name's length,
-// each pair at least `bar`: the best first, as git takes its candidates.
-export function chunkRenames({ sources, dests, pairs, used, record, punctuatedScoreOf }, { remaining, open }, bar) {
+// Chunks git's scored pass has yet to claim, by directory, extension and
+// name's length, each pair at least `bar`: the best first, as git takes its
+// candidates, but for a pair `outdone` by a file's other candidate, set aside
+// and returned, best first, for git to pair that candidate with another file:
+// it holds its files, so that a later pair of either is set aside behind it.
+export function chunkRenames({ sources, dests, pairs, used, record, punctuatedScoreOf }, { remaining, open }, bar, outdone) {
   const names = (files, indices) => new Map(indices.filter((i) => files[i].type === 'file').map((i) => [i, nameOf(files[i].path)]))
   const destNames = names(dests, open), sourceNames = names(sources, remaining)
   const byKey = Map.groupBy(sourceNames.keys(), (s) => sourceNames.get(s).key)
@@ -39,13 +46,20 @@ export function chunkRenames({ sources, dests, pairs, used, record, punctuatedSc
     const ss = byKey.get(key) ?? []
     for (const d of ds) {
       for (const s of ss) {
-        if (!oneChunk(sourceNames.get(s).stem, destNames.get(d).stem)) continue
+        if (!oneChunk(sourceNames.get(s).name, destNames.get(d).name)) continue
         const score = punctuatedScoreOf(s, d, bar)
         if (score >= bar) candidates.push({ s, d, score })
       }
     }
   }
-  for (const { s, d, score } of candidates.sort((x, y) => y.score - x.score)) {
-    if (!pairs.has(d) && !used.has(s)) record(d, s, score)
+  const aside = [], heldDests = new Set(), heldSources = new Set()
+  for (const pair of candidates.sort((x, y) => y.score - x.score)) {
+    if (pairs.has(pair.d) || used.has(pair.s)) continue
+    if (heldSources.has(pair.s) || heldDests.has(pair.d) || outdone(pair)) {
+      aside.push(pair)
+      heldSources.add(pair.s)
+      heldDests.add(pair.d)
+    } else record(pair.d, pair.s, pair.score)
   }
+  return aside
 }

package/src/marked.js

@@ -2,9 +2,8 @@
 // (`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'
+import { checkLineOptions, lineChangeSet } from './text.js'
 
 const records = (text) => (text === '' ? [] : text.split(/(?<=\n)/u))
 
@@ -14,7 +13,7 @@ export function markedBlocks(before, given, after, options) {
   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)
+  return lineChangeSet(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/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,47 +1,46 @@
 // 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 at its shortest where affordable, and the diff
-// checked to hide no change.
+// old side renamed, line for line the old side's, diffed at its shortest where
+// affordable, and the diff checked to hide no change.
 
 import { blocksHold } from '../blocks.js'
 import { markedBlocks } from '../marked.js'
-import { format } from '../pretty.js'
-import { checkLineOptions, shortestChangeSet } from '../text.js'
-import { bindsAlike } from './binds.js'
+import { checkLineOptions, shownChangeSet } from '../text.js'
 import { renameMap } from './rename.js'
 
 const ranges = ({ a0, a1, b0, b1 }) => ({ a0, a1, b0, b1 })
 
 // The same, diffed once for each whitespace setting given, in order: the names
 // found and the old side given them once for all.
-export async function renamedDiffs(before, after, { extension = 'js', otherExtension = extension, whitespace = ['none'] } = {}) {
+function diffsOf(before, after, { extension = 'js', otherExtension = extension, whitespace = ['none'] } = {}) {
   if (!Array.isArray(whitespace)) throw new TypeError(`whitespace must be an array, not ${typeof whitespace}`)
   const settings = whitespace.map((setting) => checkLineOptions({ horizon: 0, whitespace: setting }))
   const warnings = []
   const mapped = renameMap(before, after, { extension, otherExtension })
   if (mapped.invariant) warnings.push(`a rename map check failed: ${mapped.invariant}`)
-  let renamed = before
-  if (!mapped.reason) {
-    // A name's new length may move the lines it is on.
-    const formatted = await format(mapped.text, extension)
-    const read = 'code' in formatted && bindsAlike(before, formatted.code, mapped.kind)
-    if ('code' in formatted && !read) warnings.push("the renamed old side, formatted, read otherwise")
-    renamed = read ? formatted.code : mapped.text
-  }
+  // Not formatted again: its lines are the old side's, each where it was, and
+  // formatting a formatted text lays it out other than the new side was.
+  const renamed = mapped.reason ? before : mapped.text
   let unmarked = false
   const diffs = settings.map((options) => {
-    const blocks = shortestChangeSet(renamed, after, options).map(ranges)
+    const blocks = shownChangeSet(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.
+    // The plain diff's blocks the renamed text, line for line the old side's, says differ in names alone.
     const marks = mapped.reason ? [] : markedBlocks(before, mapped.text, after, options)
     unmarked ||= marks === null
     return { whitespace: options.whitespace, blocks, marks: marks ?? [] }
   })
   if (unmarked) warnings.push('a renamed text with lines the old one does not have; none marked')
-  return { before: renamed, reason: mapped.reason ?? null, reads: mapped.reads ?? [], diffs, warnings }
+  return { before: renamed, reason: mapped.reason ?? null, reads: mapped.reads ?? [], assumed: mapped.assumed ?? [], diffs, warnings }
+}
+
+// A promise still, as callers await it: what goes wrong rejects it.
+export function renamedDiffs(before, after, options) {
+  return new Promise((resolve) => {
+    resolve(diffsOf(before, after, options))
+  })
 }
 
 export async function renamedDiff(before, after, { whitespace = 'none', ...options } = {}) {
-  const { before: renamed, reason, reads, diffs: [{ blocks, marks }], warnings } = await renamedDiffs(before, after, { ...options, whitespace: [whitespace] })
-  return { before: renamed, blocks, reason, reads, marks, warnings }
+  const { before: renamed, reason, reads, assumed, diffs: [{ blocks, marks }], warnings } = await renamedDiffs(before, after, { ...options, whitespace: [whitespace] })
+  return { before: renamed, blocks, reason, reads, assumed, marks, warnings }
 }

package/src/names/pairing.js

@@ -151,13 +151,13 @@ 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)
@@ -182,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.
@@ -199,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
@@ -209,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
@@ -217,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

@@ -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
   }
 }
@@ -39,7 +42,10 @@ function renamedNames(before, after, { extension = 'js', otherExtension = extens
   // 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)]
+  // Each says so apart: a version a module; a script's top level a minifier's throughout.
+  const scripts = [a, b].map((side) => !side.own)
+  const why = [[a, b].some((side) => side.module) && 'module', [a, b].some((side, i) => scripts[i] && minifiedTopLevel(side)) && 'minified'].filter(Boolean)
+  if (why.length > 0) [a, b] = [ownTopLevel(a), ownTopLevel(b)]
   checkAnalysis(before, a)
   checkAnalysis(after, b)
   const paired = pairing(before, after, a, b)
@@ -62,7 +68,10 @@ function renamedNames(before, after, { extension = 'js', otherExtension = extens
   // class's alone: one only where a name renamed is one's.
   const naming = changed.some((variable) => variable.naming || paired.map.get(variable)?.naming)
   const reads = changed.length === 0 ? [] : [...new Set([...a.reads, ...b.reads])].filter((read) => read !== 'name' || naming).toSorted()
-  return { text, renamed, apart: changed.length - renamed, kind: { module: a.module, commonjs: a.commonjs, own: a.own }, reads }
+  // A script's top level taken as its own, as all `why` says, where a name there changed or took one from there.
+  const root = (variable) => variable.scope.parent === null
+  const assumed = changed.some((variable) => (scripts[0] && root(variable)) || (scripts[1] && paired.map.has(variable) && root(paired.map.get(variable)))) ? why : []
+  return { text, renamed, apart: changed.length - renamed, kind: { module: a.module, commonjs: a.commonjs, own: a.own }, reads, assumed }
 }
 
 // Any failure gives no names, and tells what failed. oxc is loaded first, out

package/src/patch.js

@@ -3,9 +3,9 @@
 // blocks, so a run of lines free to move may sit elsewhere than git puts it.
 
 import { utf8fromString, utf8toString } from '@exodus/bytes/utf8.js'
-import { changeSet, formatChangeSet } from '@preventive/diff'
+import { formatChangeSet } from '@preventive/diff'
 import { quote } from './quote.js'
-import { checkLineOptions, textOf } from './text.js'
+import { checkLineOptions, lineChangeSet, textOf } from './text.js'
 import { sameContent } from './tree.js'
 
 const STATUSES = new Set(['added', 'deleted', 'modified', 'renamed'])
@@ -45,7 +45,7 @@ function body(one, two, blocks, from, to, { context, ...options }) {
   if (oldText === undefined || newText === undefined) {
     return one !== null && two !== null && sameContent(one, two) ? '' : `Binary files ${from} and ${to} differ\n`
   }
-  const hunks = formatChangeSet(oldText, newText, blocks ?? changeSet(oldText, newText, options), { ...options, context, label: hunkNames(oldText) })
+  const hunks = formatChangeSet(oldText, newText, blocks ?? lineChangeSet(oldText, newText, options), { ...options, context, label: hunkNames(oldText) })
   return hunks === '' ? '' : `--- ${label(from)}\n+++ ${label(to)}\n${hunks}`
 }
 

package/src/pretty.js

@@ -31,8 +31,10 @@ const sorted = (flags) => [...flags].toSorted().join('')
 // A script's text but for what the formatter may respell, beside the syntax tree compared after:
 // blanks, parentheses, semicolons, quotes and numbers, and a comma before a closing bracket, past any
 // comments (`import { a, b, }`). A regular expression's flags it may reorder are sorted where the
-// syntax tree has them (respelled).
-const scriptForm = (text) => text.replaceAll(NUMBER, numberSpelling).replaceAll(/,(?=(?:\s|\/\/[^\n]*|\/\*[^]*?\*\/)*[\])}>])/gu, '')
+// syntax tree has them (respelled). Each comment read one way alone, to its line's end (any line
+// terminator's) or its first `*/`: one that might end anywhere tries, where no bracket follows, every
+// way to split a run of them.
+const scriptForm = (text) => text.replaceAll(NUMBER, numberSpelling).replaceAll(/,(?=(?:\s|\/\/[^\n\r\u2028\u2029]*(?![^\n\r\u2028\u2029])|\/\*(?:[^*]|\*(?!\/))*\*\/)*[\])}>])/gu, '')
   .replaceAll(/\\(?=["'])|[\s();]/gu, '').replaceAll("'", '"')
 
 // JSON has no point without a digit either side: such a number is kept as written, or a copy would read as

package/src/renames.js

@@ -1,6 +1,6 @@
 // git's -M pairing (diffcore_rename_extended): identical content, then a
 // basename unique among both sides' leftovers at a stricter score, then every
-// pair left scored; between the first two and after the last, ours, renames
+// pair left scored; between the first two and before the last, ours, renames
 // told by path, and bundle chunks (chunks.js).
 
 import { crc32 } from '@exodus/bytes/crc.js'
@@ -71,11 +71,14 @@ function familyKeys(path) {
   return keys
 }
 
-// Whether either file of a pair by path has a candidate that is a rename by
-// itself and scores at least halfway from the pair's score to 100%: sizes too
-// far apart for that go unread.
+// What a candidate scores to outdo a pair by path or a chunk's: halfway from
+// the pair's score to 100%, and a rename by itself.
+const halfway = (score, minimum) => Math.max(minimum, score + Math.trunc((MAX_SCORE - score) / 2))
+
+// Whether either file of such a pair has a candidate that outdoes it: sizes
+// too far apart for that go unread.
 function outdone({ pairs, used, scoreOf }, { remaining, open }, { s, d, score }, minimum) {
-  const better = Math.max(minimum, score + Math.trunc((MAX_SCORE - score) / 2))
+  const better = halfway(score, minimum)
   return open.some((o) => o !== d && !pairs.has(o) && scoreOf(s, o, better) >= better)
     || remaining.some((r) => r !== s && !used.has(r) && scoreOf(r, d, better) >= better)
 }
@@ -159,17 +162,29 @@ function keepIfBetter(kept, candidate) {
   if (byScore(kept[worst], candidate) > 0) kept[worst] = candidate
 }
 
-function scoredRenames({ sourceNames, destNames, pairs, used, record, scoreOf }, { remaining, open }, minimum) {
+// git's walk down every pair left, best first. A chunk set aside (`aside`,
+// best first) is taken where its files are both free once the walk is past
+// what could outdo it, before a pair scoring less takes either.
+function scoredRenames({ sourceNames, destNames, pairs, used, record, scoreOf }, { remaining, open }, minimum, aside) {
   const all = []
   for (const d of open) {
     const kept = []
     for (const s of remaining) keepIfBetter(kept, { score: scoreOf(s, d, minimum), nameScore: sourceNames[s] === destNames[d] ? 1 : 0, dst: d, src: s })
     all.push(...kept)
   }
+  let next = 0
+  const settle = (below) => {
+    for (; next < aside.length && halfway(aside[next].score, minimum) > below; next++) {
+      const { s, d, score } = aside[next]
+      if (!pairs.has(d) && !used.has(s)) record(d, s, score)
+    }
+  }
   for (const { dst, src, score } of all.sort(byScore)) {
     if (score < minimum) break
+    settle(score)
     if (!pairs.has(dst) && !used.has(src)) record(dst, src, score)
   }
+  settle(-Infinity)
 }
 
 const unpaired = ({ sources, dests, pairs, used }) => ({
@@ -210,7 +225,7 @@ export function findRenames(sources, dests, { minimum, limit, byPath }) {
   basenameRenames(context, unpaired(context), stricter(minimum))
   const left = unpaired(context)
   if (left.remaining.length * left.open.length > limit * limit) return pairs
-  scoredRenames(context, left, minimum)
-  if (byPath) chunkRenames(context, unpaired(context), stricter(minimum))
+  const aside = byPath ? chunkRenames(context, left, stricter(minimum), (pair) => outdone(context, left, pair, minimum)) : []
+  scoredRenames(context, unpaired(context), minimum, aside)
   return pairs
 }

package/src/text.js

@@ -3,7 +3,7 @@
 // first 8000 bytes, so a file git diffs as bytes may be binary here.
 
 import { utf8toString } from '@exodus/bytes/utf8.js'
-import { changeSet } from '@preventive/diff'
+import { DiffError, changeSet, formatChangeSet } from '@preventive/diff'
 
 // A link's content is its target, as git stores it; a missing side is empty.
 export function textOf(file) {
@@ -31,22 +31,72 @@ 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 changes = (blocks) => blocks.reduce((n, { a0, a1, b0, b1 }) => n + a1 - a0 + b1 - b0, 0)
+const records = (text) => (text === '' ? [] : text.split(/(?<=\n)/u))
+const minding = (options) => ({ ...options, ignoreCase: false, whitespace: 'none' })
+const ignoring = (options) => (options.whitespace ?? 'none') !== 'none' || Boolean(options.ignoreCase)
+
+// Ignoring blanks or case keeps every line minding them keeps, so it never
+// shows more: past the search's cutoff it may, and then it is the diff minding
+// them, its blocks diffed again ignoring them. Where it shows no fewer lines,
+// it is that diff, block for block: ignoring them does nothing there.
+function noLonger(a, b, options, blocks, minded) {
+  const A = records(a), B = records(b)
+  const block = (a0, a1, b0, b1) => ({ a0, a1, b0, b1, remove: A.slice(a0, a1), insert: B.slice(b0, b1) })
+  const again = minded.flatMap(({ a0, a1, b0, b1 }) => (a0 === a1 || b0 === b1
+    ? [block(a0, a1, b0, b1)]
+    : changeSet(A.slice(a0, a1).join(''), B.slice(b0, b1).join(''), options).map((part) => block(a0 + part.a0, a0 + part.a1, b0 + part.b0, b0 + part.b1))))
+  // Blocks put together from diffs of their own are held to what diff holds its own to.
+  const holds = (set) => {
+    try {
+      formatChangeSet(a, b, set, { format: 'normal', ignoreCase: options.ignoreCase, whitespace: options.whitespace })
+      return true
+    } catch (error) {
+      if (error instanceof DiffError) return false
+      throw error
+    }
+  }
+  const best = changes(again) < changes(blocks) && holds(again) ? again : blocks
+  return changes(best) < changes(minded) ? best : minded
+}
+
+// The diff as diff finds it, ignoring blanks or case never showing more.
+export function lineChangeSet(a, b, options) {
+  const blocks = changeSet(a, b, options)
+  return ignoring(options) ? noLonger(a, b, options, blocks, changeSet(a, b, minding(options))) : blocks
+}
+
+// The shortest diff where its cost 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. The search's work
+// grows as the square of the lines it changes: at most the quick diff's, or one
+// minding blanks and case, which changes no fewer. It may cost 2e8, or 10,000 a
+// line of the two texts, as their lines cost already to read.
+const SHORTEST_A_LINE = 1e4, SHORTEST_COST = 2e8
 const lineCount = (text) => text.split('\n').length
+function shortest(a, b, options, lines, bound) {
+  const budget = Math.max(SHORTEST_COST, SHORTEST_A_LINE * lines), quick = changeSet(a, b, options)
+  let changed = changes(quick)
+  if (changed ** 2 > budget) changed = Math.min(changed, bound())
+  return changed ** 2 > budget ? quick : changeSet(a, b, { ...options, minimal: true })
+}
+// For lines read, as names are paired by: ignoring blanks or case, what it
+// finds, its lines alike kept where minding them ties.
 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 })
+  return shortest(a, b, options, lines, () => (ignoring(options) ? changes(changeSet(a, b, minding(options))) : Infinity))
+}
+// For lines shown: ignoring blanks or case, never more than minding them.
+export function shownChangeSet(a, b, options, lines = lineCount(a) + lineCount(b)) {
+  if (!ignoring(options)) return shortestChangeSet(a, b, options, lines)
+  const minded = shortestChangeSet(a, b, minding(options), lines)
+  return noLonger(a, b, options, shortest(a, b, options, lines, () => changes(minded)), minded)
 }
 
 // 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)
   if (a === undefined || b === undefined) return { binary: true, blocks: [], insertions: null, deletions: null }
-  const blocks = a === b ? [] : changeSet(a, b, options)
+  const blocks = a === b ? [] : lineChangeSet(a, b, options)
   const lines = (from, to) => blocks.reduce((n, block) => n + block[to] - block[from], 0)
   return { binary: false, blocks, insertions: lines('b0', 'b1'), deletions: lines('a0', 'a1') }
 }