@preventive/compare 0.0.0-stage → 1.0.0

package/src/names/diff.js

@@ -0,0 +1,33 @@
+// 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.
+
+import { changeSet } from '@preventive/diff'
+import { blocksHold } from '../blocks.js'
+import { markedBlocks } from '../marked.js'
+import { format } from '../pretty.js'
+import { bindsAlike } from './binds.js'
+import { renameMap } from './rename.js'
+
+const ranges = ({ a0, a1, b0, b1 }) => ({ a0, a1, b0, b1 })
+
+export async function renamedDiff(before, after, { extension = 'js', otherExtension = extension, whitespace = 'none' } = {}) {
+  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
+  }
+  const options = { horizon: 0, whitespace }
+  const blocks = changeSet(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)
+  if (marks === null) warnings.push('a renamed text with lines the old one does not have; none marked')
+  return { before: renamed, blocks, reason: mapped.reason ?? null, reads: mapped.reads ?? [], marks: marks ?? [], warnings }
+}

package/src/names/misread.js

@@ -0,0 +1,38 @@
+// The variables the names given would read wrongly: two of a scope named
+// alike, a `var` named as a block's it hoists past, a body's as its parameter,
+// or a name read resolving to another variable, a global's to any.
+
+import { hoistedPast, resolve } from './syntax.js'
+
+export function misread({ scopes, variables, occurrences, globals }, given) {
+  const names = new Map(scopes.map((at) => [at, new Map()])), wrong = new Set()
+  const named = (at) => names.get(at)
+  for (const at of scopes) {
+    for (const variable of at.names.values()) {
+      const taken = named(at).get(given.get(variable))
+      if (taken) wrong.add(taken).add(variable)
+      else named(at).set(given.get(variable), variable)
+    }
+  }
+  for (const variable of variables) {
+    for (const path of variable.through ?? []) for (const there of hoistedPast(variable, path, given.get(variable), named)) wrong.add(there).add(variable)
+  }
+  for (const at of scopes) {
+    if (!at.parameters) continue
+    for (const variable of new Set(at.names.values())) {
+      const parameter = named(at.parameters).get(given.get(variable))
+      if (parameter && parameter !== variable) wrong.add(parameter).add(variable)
+    }
+  }
+  for (const [, variable, where] of occurrences) {
+    const found = resolve(given.get(variable), where, named)
+    if (found === variable) continue
+    wrong.add(variable)
+    if (found) wrong.add(found)
+  }
+  for (const [node, where] of globals) {
+    const found = resolve(node.name, where, named)
+    if (found) wrong.add(found)
+  }
+  return wrong
+}

package/src/names/pairing.js

@@ -0,0 +1,111 @@
+// Which old variable became which new one: each pair of lines, as the diff of
+// 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'
+
+// 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) => changeSet(a, b, { horizon: 0, whitespace: 'all' })
+
+// A text's lines with its renamable variables' names set aside (`key`), and
+// each line's such variables in order (`lines`).
+function keyed(text, { occurrences }) {
+  const starts = [0]
+  for (let at = text.indexOf('\n'); at !== -1; at = text.indexOf('\n', at + 1)) starts.push(at + 1)
+  const lines = starts.map(() => [])
+  let at = 0, key = '', line = 0
+  for (const [node, variable] of occurrences) {
+    if (!variable.aside) continue
+    key += text.slice(at, node.start)
+    at = node.end
+    while (line + 1 < starts.length && starts[line + 1] <= node.start) line++
+    lines[line].push(variable)
+  }
+  return { key: key + text.slice(at), lines }
+}
+
+const tallies = () => ({ backward: new Map(), forward: new Map() })
+function count(map, from, to) {
+  if (!map.has(from)) map.set(from, new Map())
+  map.get(from).set(to, (map.get(from).get(to) ?? 0) + 1)
+}
+
+// Pairs of lines counted, a long run of unchanged ones apart from the rest. 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(), unchanged = tallies()
+  // Lines reading variables one side has and the other not say nothing.
+  const tally = ({ backward, forward }, pa, pb) => {
+    const news = kb.lines[pb], olds = ka.lines[pa]
+    if (olds.length !== news.length) return
+    olds.forEach((variable, k) => {
+      count(forward, variable, news[k])
+      count(backward, news[k], variable)
+    })
+  }
+  const keysA = ka.key.split('\n'), keysB = kb.key.split('\n')
+  const trimmed = (lines, from, to) => `${lines.slice(from, to).map((line) => line.replace(/[;,]\s*$/u, '')).join('\n')}\n`
+  let i = 0, j = 0
+  for (const block of [...changes(ka.key, kb.key), { a0: ka.lines.length, a1: ka.lines.length, b0: kb.lines.length, b1: kb.lines.length }]) {
+    const anchored = block.a0 - i >= ANCHORED_RUN
+    while (i < block.a0) tally(anchored ? unchanged : changed, i++, j++)
+    const [olds, news] = [block.a1 - block.a0, block.b1 - block.b0]
+    if (olds === news) for (let k = 0; k < olds; k++) tally(changed, block.a0 + k, block.b0 + k)
+    else if (olds > 0 && news > 0) {
+      let x = 0, y = 0
+      for (const inner of [...changes(trimmed(keysA, block.a0, block.a1), trimmed(keysB, block.b0, block.b1)), { a0: olds, a1: olds, b0: news, b1: news }]) {
+        while (x < inner.a0) tally(changed, block.a0 + x++, block.b0 + y++)
+        x = inner.a1
+        y = inner.b1
+      }
+    }
+    i = block.a1
+    j = block.b1
+  }
+  return { changed, unchanged }
+}
+
+// The most counted of those not yet paired, none where two tie.
+function best(counts, taken) {
+  let found = null, most = 0
+  for (const [other, n] of counts) {
+    if (taken(other)) continue
+    if (n > most) {
+      found = other
+      most = n
+    } else if (n === most) found = null
+  }
+  return found
+}
+
+// Pairs each the other's best, into `map`, until none more pair.
+function matched({ backward, forward }, { map, paired }, eligible = () => true) {
+  const chosen = []
+  for (let more = true; more;) {
+    more = false
+    for (const [variable, counts] of forward) {
+      if (map.has(variable)) continue
+      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)
+      paired.add(to)
+      chosen.push(variable)
+      more = true
+    }
+  }
+  return chosen
+}
+
+// Unchanged lines pair first; changed ones then pair only what those say
+// nothing of, as `weak` pairs, the first to give way where names read wrongly.
+export function pairing(before, after, a, b) {
+  const { changed, unchanged } = tallied(keyed(before, a), keyed(after, b))
+  const found = { map: new Map(), paired: new Set() }
+  matched(unchanged, found)
+  const weak = new Set(matched(changed, found, (old, to) => !unchanged.forward.has(old) && !unchanged.backward.has(to)))
+  return { map: found.map, weak }
+}

package/src/names/rename.js

@@ -0,0 +1,69 @@
+// The old side of a file minified on both sides given the new side's names:
+// both analyzed, variables paired by their lines, the names given checked not
+// to read wrongly, and the result checked again by oxc (bindsAlike).
+
+import { getOxc } from '#oxc'
+import { analyze } from './analyze.js'
+import { bindsAlike } from './binds.js'
+import { checkAnalysis, checkGiven, checkPairing, checkRenamed } from './check.js'
+import { misread } from './misread.js'
+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 }) {
+  const apart = (name) => {
+    let named = name + APART
+    for (let n = 2; a.names.has(named) || b.names.has(named); n++) named = `${name}${APART}${n}`
+    return named
+  }
+  const given = new Map()
+  for (;;) {
+    for (const variable of a.variables) {
+      const own = variable.aside && !map.has(variable) && b.names.has(variable.name) ? apart(variable.name) : variable.name
+      given.set(variable, variable.aside && map.has(variable) ? map.get(variable).name : own)
+    }
+    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
+    if (yielding.filter((variable) => map.delete(variable)).length === 0) return null
+  }
+}
+
+function renamedNames(before, after, { extension = 'js', otherExtension = extension }) {
+  const a = analyze(before, extension), b = analyze(after, otherExtension)
+  if (a.reason || b.reason) return { reason: a.reason ?? b.reason }
+  checkAnalysis(before, a)
+  checkAnalysis(after, b)
+  const paired = pairing(before, after, a, b)
+  checkPairing(a, b, paired)
+  const given = givenNames(a, b, paired)
+  if (!given) return { reason: 'unverified' }
+  checkGiven(a, b, paired.map, given)
+  let at = 0, text = ''
+  for (const [node, variable] of a.occurrences) {
+    text += before.slice(at, node.start) + given.get(variable)
+    at = node.end
+  }
+  text += before.slice(at)
+  holds(before !== after || text === before, 'a text renamed as itself changed')
+  checkRenamed(a, given, text, extension)
+  if (!bindsAlike(before, text, a)) return { reason: 'unverified' }
+  const changed = a.variables.filter((variable) => given.get(variable) !== variable.name)
+  const renamed = changed.filter((variable) => paired.map.has(variable)).length
+  const reads = [...new Set([...a.reads, ...b.reads])].toSorted()
+  return { text, renamed, apart: changed.length - renamed, kind: { module: a.module, commonjs: a.commonjs, own: a.own }, reads }
+}
+
+// Any failure gives no names, and tells what failed. oxc is loaded first, out
+// of the try: one missing is thrown, not taken for a text it could not read.
+export function renameMap(before, after, options = {}) {
+  getOxc()
+  try {
+    return renamedNames(before, after, options)
+  } catch (error) {
+    return { reason: 'unverified', invariant: error instanceof Broken ? error.message : String(error) }
+  }
+}

package/src/names/syntax.js

@@ -0,0 +1,63 @@
+// Which names renaming touches, and the rules of the language it leans on.
+
+// A minifier's names: short and ASCII, so that none is renamed to or from one
+// a reader can't tell apart (a Cyrillic a, U+0430, or a zero-width joiner).
+export const RENAMED_MAX_LENGTH = 3
+export const MINIFIED = /^[A-Za-z_$][\w$]*$/u
+// Properties code reads names through, which renaming changes: as a member's
+// or a pattern's key, or any string written out (not `'' + f`).
+export const NAME_READS = new Set(['name', 'toString', 'stack', 'callee', 'caller'])
+// What a name renamed apart ends in: `e_old`, then `e_old2`.
+export const APART = '_old'
+// Words no variable may be named, in strict code or in a module.
+export const RESERVED = new Set(`await break case catch class const continue debugger default delete do else enum export extends false finally for
+  function if implements import in instanceof interface let new null package private protected public return static super switch this throw
+  true try typeof var void while with yield arguments eval`.split(/\s+/u))
+
+// A check that should never fail: renameMap then gives no names, and tells why.
+export class Broken extends Error {}
+export function holds(condition, what) {
+  if (!condition) throw new Broken(what)
+}
+
+// The names a pattern declares: `{ a, b: [c, ...d] = e }` declares a, c and d.
+export function declared(pattern, out = []) {
+  switch (pattern?.type) {
+    case 'Identifier': out.push(pattern); break
+    case 'ObjectPattern': for (const property of pattern.properties) declared(property.type === 'RestElement' ? property.argument : property.value, out); break
+    case 'ArrayPattern': for (const element of pattern.elements) declared(element, out); break
+    case 'RestElement': declared(pattern.argument, out); break
+    case 'AssignmentPattern': declared(pattern.left, out); break
+    default: break
+  }
+  return out
+}
+
+export function saysStrict(statements) {
+  for (const statement of statements) {
+    if (typeof statement.directive !== 'string') return false
+    if (statement.directive === 'use strict') return true
+  }
+  return false
+}
+
+// The variable a name read in `from` stands for, or null for a global's;
+// `names` gives a scope's names, its own unless others are asked after.
+export function resolve(name, from, names = (at) => at.names) {
+  for (let at = from; at; at = at.parent) if (names(at).has(name)) return names(at).get(name)
+  return null
+}
+
+// The variables of `name` a `var` hoists past up to its function: each a
+// redeclaration that does not compile, but past a `catch` whose simple
+// parameter it is, or one of its name beyond such a one.
+export function hoistedPast(variable, path, name, named) {
+  const met = []
+  let caught = false
+  for (const at of path) {
+    const there = named(at).get(name)
+    if (there === variable) caught ||= Boolean(at.caught)
+    else if (there && !(at.caught && at.simple && caught)) met.push(there)
+  }
+  return met
+}

package/src/oxc.js

@@ -0,0 +1,6 @@
+// oxc-parser and oxc-minify where Node does not run this: their own builds for
+// it (WASM, by their `browser` condition), loaded with names.js.
+import { minifySync } from 'oxc-minify'
+import { parseSync } from 'oxc-parser'
+
+export const getOxc = () => ({ parseSync, minifySync })

package/src/oxc.node.js

@@ -0,0 +1,16 @@
+import { createRequire } from 'node:module'
+
+// oxc-parser and oxc-minify, optional peers, required on first use; one missing
+// is thrown as the environment's error, not taken for a text that won't parse.
+const require = createRequire(import.meta.url)
+let oxc
+
+function load(name) {
+  try {
+    return require(name)
+  } catch (cause) {
+    throw new Error(`@preventive/compare/names.js needs the optional '${name}' peer dependency; install it (e.g. \`npm i ${name}\`)`, { cause })
+  }
+}
+
+export const getOxc = () => (oxc ??= { parseSync: load('oxc-parser').parseSync, minifySync: load('oxc-minify').minifySync })

package/src/pairs.js

@@ -0,0 +1,100 @@
+// Which of a change's removed lines was edited into which added one: the best
+// pairing in order where weighing every pair is cheap enough, else a lookahead.
+
+import { MAX_CHANGED, tokenized, wordView } from './words.js'
+
+// The longest change whose lines are paired at all; the most work weighing all
+// its pairs may take, in steps; and past it, how far ahead a removed line looks
+// for an added one instead.
+const MAX_LINES = 200
+const BUDGET = 5_000_000
+const LOOKAHEAD = 6
+// What a pair weighed and a word's count compared cost, in steps of a script.
+const PAIR = 60
+const VISIT = 3
+
+function counted(read) {
+  const counts = new Map()
+  for (const token of read?.tokens ?? []) counts.set(token, (counts.get(token) ?? 0) + 1)
+  return counts
+}
+
+// How much of each pair of lines changed, as wordRanges marks it, Infinity
+// where they are no line edited; and the work weighing them has taken.
+function weigher(olds, news) {
+  const ids = new Map(), reads = [olds, news].map((side) => side.map((line) => tokenized(line, ids)))
+  const counts = reads.map((side) => side.map(counted))
+  let work = 0
+  // The share of `line` in words `others` holds fewer of, changed whatever the script finds; past what a
+  // word view takes for one line edited, Infinity.
+  const unmatched = (mine, others, line) => {
+    let changed = 0
+    for (const [token, count] of mine) {
+      work += VISIT
+      if ((changed += token.length * Math.max(0, count - (others.get(token) ?? 0))) > MAX_CHANGED * line.length) return Infinity
+    }
+    return changed / Math.max(1, line.length)
+  }
+  // The least share of the pair changed, as their counts alone tell.
+  const floor = (i, j) => (reads[0][i] === null || reads[1][j] === null ? Infinity
+    : Math.min(unmatched(counts[0][i], counts[1][j], olds[i]), unmatched(counts[1][j], counts[0][i], news[j])))
+  const weighed = (i, j) => {
+    work += PAIR
+    if (floor(i, j) === Infinity) return Infinity
+    const { share, steps } = wordView(reads[0][i], reads[1][j])
+    work += steps
+    return share <= MAX_CHANGED ? share : Infinity
+  }
+  const shares = new Float64Array(olds.length * news.length).fill(Number.NaN)
+  const share = (i, j) => {
+    const key = i * news.length + j
+    if (Number.isNaN(shares[key])) shares[key] = olds[i] === news[j] ? 0 : weighed(i, j)
+    return shares[key]
+  }
+  return { share, floor, spent: () => work }
+}
+
+// The pairs in order that are the most, and of those the most alike, a pair
+// weighed 1000 less its share; null where weighing them all passes the budget.
+function aligned(n, m, { share, spent }) {
+  const value = Array.from({ length: n + 1 }, () => new Float64Array(m + 1))
+  const take = (i, j) => (share(i, j) === Infinity ? -Infinity : 1000 - share(i, j) + value[i][j])
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      value[i + 1][j + 1] = Math.max(value[i][j + 1], value[i + 1][j], take(i, j))
+      if (spent() > BUDGET) return null
+    }
+  }
+  const pairs = []
+  for (let i = n, j = m; i > 0 && j > 0;) {
+    if (value[i][j] === value[i][j - 1]) j--
+    else if (value[i][j] === value[i - 1][j]) i--
+    else pairs.push([--i, --j])
+  }
+  return pairs.toReversed()
+}
+
+// Each removed line in turn paired with the most alike of the next added lines
+// after the last one paired, those whose counts show less changed weighed first.
+function lookedAhead(n, m, { share, floor }) {
+  const pairs = []
+  for (let i = 0, next = 0; i < n && next < m; i++) {
+    let best = null, least = Infinity
+    const ahead = Array.from({ length: Math.min(m, next + LOOKAHEAD) - next }, (_, at) => [next + at, floor(i, next + at)])
+    for (const [j, low] of ahead.toSorted((p, q) => p[1] - q[1] || p[0] - q[0])) {
+      if (low > least) break
+      if (share(i, j) < least || (share(i, j) === least && j < best)) [best, least] = [j, share(i, j)]
+    }
+    if (best !== null) {
+      pairs.push([i, best])
+      next = best + 1
+    }
+  }
+  return pairs
+}
+
+export function pairLines(olds, news) {
+  if (olds.length > MAX_LINES || news.length > MAX_LINES) return []
+  const weigh = weigher(olds, news)
+  return aligned(olds.length, news.length, weigh) ?? lookedAhead(olds.length, news.length, weigh)
+}

package/src/patch.js

@@ -0,0 +1,78 @@
+// The patch `git diff` writes (builtin_diff, fill_metainfo in diff.c), less its
+// `index` lines, which need git's object hashes. Hunks print each change's own
+// 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 { quote } from './quote.js'
+import { checkLineOptions, textOf } from './text.js'
+import { sameContent } from './tree.js'
+
+const STATUSES = new Set(['added', 'deleted', 'modified', 'renamed'])
+const gitMode = (file) => (file.type === 'symlink' ? '120000' : (0o100000 | file.mode).toString(8))
+
+// git ends a label holding a space with a tab, so patch reads the whole name.
+const label = (name) => (name.includes(' ') ? `${name}\t` : name)
+
+// git's default hunk name (def_ff in xemit.c): the nearest line above the hunk
+// starting with a letter, `_` or `$`, cut to 80 bytes, less trailing blanks.
+const FUNCTION_LINE = /^[A-Za-z_$]/u
+const BLANKS = /[\t\n\r ]+$/u
+
+// git may cut a character in two; this cuts before it.
+function cut(line) {
+  const bytes = utf8fromString(line)
+  let end = Math.min(bytes.length, 80)
+  while ((bytes[end] & 0xC0) === 0x80) end--
+  return utf8toString(bytes.subarray(0, end)).replace(BLANKS, '')
+}
+
+// git searches back only to the previous hunk's start, keeping what it found.
+function hunkNames(text) {
+  const lines = text.split('\n')
+  let found = null, searched = -1
+  return (start) => {
+    const line = lines.slice(searched + 1, start).findLast((candidate) => FUNCTION_LINE.test(candidate))
+    if (line !== undefined) found = cut(line)
+    searched = start - 1
+    return found
+  }
+}
+
+// `blocks` are the change's, found under `options`, or are found here.
+function body(one, two, blocks, from, to, { context, ...options }) {
+  const newText = textOf(two), oldText = textOf(one)
+  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) })
+  return hunks === '' ? '' : `--- ${label(from)}\n+++ ${label(to)}\n${hunks}`
+}
+
+// One `diff --git` section; `similarity` is a rename's. As git does, a header
+// with nothing under it is left out.
+function section(one, two, similarity, blocks, options) {
+  const a = quote((one ?? two).path, 'a/'), b = quote((two ?? one).path, 'b/')
+  let meta = ''
+  if (one === null) meta += `new file mode ${gitMode(two)}\n`
+  else if (two === null) meta += `deleted file mode ${gitMode(one)}\n`
+  else if (gitMode(one) !== gitMode(two)) meta += `old mode ${gitMode(one)}\nnew mode ${gitMode(two)}\n`
+  if (similarity !== null) meta += `similarity index ${similarity}%\nrename from ${quote(one.path)}\nrename to ${quote(two.path)}\n`
+  const rest = meta + body(one, two, blocks, one === null ? '/dev/null' : a, two === null ? '/dev/null' : b, options)
+  return rest === '' ? '' : `diff --git ${a} ${b}\n${rest}`
+}
+
+// The changes were found under the line options given (text.js), as their blocks
+// are held to them; a change found without lines has them found here.
+export function formatPatch(changes, { context = 3, ...lineOptions } = {}) {
+  if (!(Number.isInteger(context) && context >= 0)) throw new RangeError(`context must be a whole number of lines, not ${context}`)
+  const options = { context, ...checkLineOptions(lineOptions) }
+  let out = ''
+  for (const { status, old, new: fresh, similarity, blocks } of changes) {
+    // git writes a type change as a deletion and a creation.
+    if (status === 'type-changed') out += section(old, null, null, null, options) + section(null, fresh, null, null, options)
+    else if (STATUSES.has(status)) out += section(old, fresh, status === 'renamed' ? similarity : null, blocks, options)
+    else throw new TypeError(`${JSON.stringify(status)} is not a change's status`)
+  }
+  return out
+}

package/src/paths.js

@@ -0,0 +1,22 @@
+// A rename written as `git diff --stat` writes one: the directories both share,
+// what changed, and the rest.
+
+export function renameParts(from, to, { extension = true } = {}) {
+  const a = from.split('/'), b = to.split('/')
+  let head = 0
+  while (head < a.length - 1 && head < b.length - 1 && a[head] === b[head]) head++
+  let tail = 0
+  while (tail < a.length - head - 1 && tail < b.length - head - 1 && a.at(-1 - tail) === b.at(-1 - tail)) tail++
+  const parts = {
+    head: head ? `${a.slice(0, head).join('/')}/` : '',
+    from: a.slice(head, a.length - tail).join('/'),
+    to: b.slice(head, b.length - tail).join('/'),
+    tail: tail ? `/${a.slice(-tail).join('/')}` : '',
+  }
+  const dot = parts.from.lastIndexOf('.')
+  if (extension && !parts.from.includes('/') && !parts.to.includes('/') && dot > 0
+      && parts.to.lastIndexOf('.') === dot && parts.from.slice(0, dot) === parts.to.slice(0, dot)) {
+    return { ...parts, head: parts.head + parts.from.slice(0, dot), from: parts.from.slice(dot), to: parts.to.slice(dot) }
+  }
+  return parts
+}

package/src/peers.js

@@ -0,0 +1,18 @@
+// pretty.js's optional peers, loaded on first use. oxfmt it can't do without:
+// one missing is thrown as the environment's error, not taken for a file that
+// won't format. css-tree checks CSS: null where missing, so CSS is refused.
+let csstree, format
+
+export async function loadFormatter() {
+  try {
+    format ??= (await import('oxfmt')).format
+  } catch (cause) {
+    throw new Error("@preventive/compare/pretty.js needs the optional 'oxfmt' peer dependency; install it (e.g. `npm i oxfmt`)", { cause })
+  }
+  return format
+}
+
+export async function loadCssTree() {
+  csstree ??= await import('css-tree').catch(() => null)
+  return csstree
+}