@preventive/compare 0.0.0-stage → 1.0.1

package/src/pretty.js

@@ -0,0 +1,106 @@
+// A file formatted by oxfmt, used only where checks apart from oxfmt find it differs in layout
+// alone: a script's syntax tree as oxc parses it, a style sheet's as css-tree does (an optional peer,
+// CSS refused without it), JSON's strings and comments as written.
+
+import { getOxc } from '#oxc'
+import { indentless, sameCss } from './css.js'
+import { loadCssTree, loadFormatter } from './peers.js'
+
+const PRETTY_OPTIONS = { quoteProps: 'preserve', trailingComma: 'none', arrowParens: 'avoid', embeddedLanguageFormatting: 'off' }
+
+const SCRIPTS = new Set(['js', 'mjs', 'cjs', 'jsx', 'ts', 'mts', 'cts', 'tsx'])
+const NUMBER = /(?<![\p{L}\p{N}_$])(?:0[box][\d_a-f]+n?|\d[\d_]*(?:\.[\d_]*)?(?:e[+-]?\d+)?n?)|(?<![\p{N}.])\.\d[\d_]*(?:e[+-]?\d+)?/giu
+const POSITION = new Set(['start', 'end', 'range', 'loc'])
+// JSON's strings, quoted either way or in backticks as its kin may have them, and its comments, compared
+// as written, split from the rest; one unclosed runs to its line's end, or the end.
+const LITERAL = /("(?:[^"\\\n]|\\(?:\r\n|[^]))*(?:"|(?=\n)|$)|'(?:[^'\\\n]|\\(?:\r\n|[^]))*(?:'|(?=\n)|$)|`(?:[^`\\]|\\[^])*(?:`|$)|\/\*[^]*?(?:\*\/|$)|\/\/.*)/u
+
+// A number as the formatter spells it (`.50E+3` as `0.5e3`), but for what JSON may read as another
+// type: a point keeps a digit after it, a whole number its zero exponent (`1.0`, `1e0`).
+function numberSpelling(text) {
+  const number = text.toLowerCase()
+  const parts = /^0[box]|n$/u.test(number) ? null : /^([^e]*)(?:e([+-]?)0*(\d+))?$/u.exec(number)
+  if (!parts) return number
+  const [, mantissa = '', sign = '', exponent = ''] = parts
+  const fraction = (mantissa.startsWith('.') ? `0${mantissa}` : mantissa).replace(/(\.\d+?)0+$/u, '$1').replace(/\.$/u, '')
+  const zero = /^0+$/u.test(exponent)
+  return exponent === '' || (zero && fraction.includes('.')) ? fraction : `${fraction}e${sign === '-' && !zero ? '-' : ''}${exponent}`
+}
+
+const sorted = (flags) => [...flags].toSorted().join('')
+const scriptForm = (text) => text.replaceAll(NUMBER, numberSpelling).replaceAll(/\\(?=["'])|[\s();]/gu, '').replaceAll("'", '"')
+  .replaceAll(/(?<=\/)[dgimsuvy]{2,}(?![\p{L}\p{N}_$])/gu, sorted)
+
+// JSON has no point without a digit either side: such a number is kept as written, or a copy would read as
+// valid, as would one with other blanks than JSON's four, which stay.
+const jsonNumber = (text) => (/^\.|\.(?!\d)/u.test(text) ? text.toLowerCase() : numberSpelling(text))
+const jsonForm = (text) => text.split(LITERAL).map((part, i) => (i % 2 ? (part.startsWith('/') ? indentless(part) : part) : part.replaceAll(/[\t\n\r ]/gu, '').replaceAll(NUMBER, jsonNumber)))
+
+const sameList = (a, b) => a.length === b.length && a.every((item, i) => item === b[i])
+
+function parsed(text, extension) {
+  const lang = extension === 'tsx' ? 'tsx' : /^[cm]?ts$/u.test(extension) ? 'ts' : 'jsx'
+  const sourceType = extension.startsWith('m') ? 'module' : extension.startsWith('c') ? 'commonjs' : 'unambiguous'
+  const result = getOxc().parseSync(`file.${extension}`, text, { lang, sourceType, preserveParens: false })
+  return result.errors.length > 0 ? null : result
+}
+
+const comments = ({ comments: list }) => list.map(({ type, value }) => `${type} ${indentless(value)}`)
+// `a && (b && c)` and `(a && b) && c` read alike, as do `||` and `??` chains.
+function chain(node, operator) {
+  const operands = [], rest = [node]
+  while (rest.length > 0) {
+    const next = rest.pop()
+    if (next?.type === 'LogicalExpression' && next.operator === operator) rest.push(next.right, next.left)
+    else operands.push(next)
+  }
+  return operands
+}
+const fields = (node) => Object.keys(node).filter((key) => !POSITION.has(key) && !(node.type === 'Literal' && (key === 'raw' || key === 'regex' || (key === 'value' && node.regex))))
+
+function sameTree(a, b) {
+  const work = [[a, b]]
+  while (work.length > 0) {
+    const [x, y] = work.pop()
+    if (x === y) continue
+    if (typeof x !== 'object' || typeof y !== 'object' || x === null || y === null || Array.isArray(x) !== Array.isArray(y)) return false
+    let pairs
+    if (Array.isArray(x)) pairs = [x, y].map((list) => list.filter((node) => node?.type !== 'EmptyStatement'))
+    else if (x.type === 'LogicalExpression' && y.type === 'LogicalExpression' && x.operator === y.operator) pairs = [chain(x, x.operator), chain(y, y.operator)]
+    else {
+      const [keys, others] = [fields(x), fields(y)]
+      if (keys.join() !== others.join()) return false
+      if (x.type === 'Literal' && x.regex && (x.regex.pattern !== y.regex?.pattern || sorted(x.regex.flags) !== sorted(y.regex.flags))) return false
+      pairs = [keys.map((key) => x[key]), keys.map((key) => y[key])]
+    }
+    if (pairs[0].length !== pairs[1].length) return false
+    pairs[0].forEach((node, i) => work.push([node, pairs[1][i]]))
+  }
+  return true
+}
+
+// A safeguard on oxfmt's own output, not a comparison of any two texts: exported
+// for tests alone, not by the package. CSS is read by `csstree` where given.
+export function sameCode(text, formatted, extension = 'js', csstree = null) {
+  if (extension === 'css') return csstree !== null && sameCss(csstree, text, formatted)
+  if (extension === 'json') return sameList(jsonForm(text), jsonForm(formatted))
+  if (!SCRIPTS.has(extension) || scriptForm(text) !== scriptForm(formatted)) return false
+  const [before, after] = [parsed(text, extension), parsed(formatted, extension)]
+  return before !== null && after !== null && sameList(comments(before), comments(after)) && sameTree(before.program, after.program)
+}
+
+// Only what can be checked is formatted: scripts, JSON, and CSS where css-tree is there to read it.
+// oxfmt is loaded outside the try: one missing is thrown, not taken for a file that won't format.
+export async function format(text, extension) {
+  const csstree = extension === 'css' ? await loadCssTree() : null
+  if (!(SCRIPTS.has(extension) || extension === 'json' || csstree)) return { error: 'unsupported' }
+  const oxfmt = await loadFormatter()
+  const result = await oxfmt(`pretty.${extension}`, text, PRETTY_OPTIONS).catch(() => null)
+  if (result === null || result.errors.length > 0) return { error: 'unformattable' }
+  // A check that fails in itself, its stack say, refuses the copy as one that finds it changed would.
+  try {
+    return sameCode(text, result.code, extension, csstree) ? { code: result.code } : { error: 'pretty-mismatch' }
+  } catch {
+    return { error: 'pretty-mismatch' }
+  }
+}

package/src/quote.js

@@ -0,0 +1,16 @@
+// Paths as git's quote_c_style writes them under core.quotePath: C-quoted when
+// holding a control, `"`, `\` or anything past ASCII, each UTF-8 byte of such
+// a character escaped by its C letter or in octal. A space stays bare.
+
+import { utf8fromString } from '@exodus/bytes/utf8.js'
+
+const LETTERS = new Map([[0x07, 'a'], [0x08, 'b'], [0x09, 't'], [0x0A, 'n'], [0x0B, 'v'], [0x0C, 'f'], [0x0D, 'r'], [0x22, '"'], [0x5C, '\\']])
+const UNSAFE = /[^ !#-[\]-~]/gu
+
+const escapeByte = (byte) => `\\${LETTERS.get(byte) ?? byte.toString(8).padStart(3, '0')}`
+
+// `prefix`, git's `a/` or `b/`, goes inside the quotes: "a/x\ty".
+export function quote(name, prefix = '') {
+  const escaped = name.replace(UNSAFE, (char) => Array.from(utf8fromString(char), escapeByte).join(''))
+  return escaped === name ? prefix + name : `"${prefix}${escaped}"`
+}

package/src/renames.js

@@ -0,0 +1,206 @@
+// 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, ours, renames told by path.
+
+import { crc32 } from '@exodus/bytes/crc.js'
+import { MAX_SCORE, similarity, spanCounts } from './similarity.js'
+import { bytesOf, sameContent } from './tree.js'
+
+// git's limits: identical files weighed per destination, scores kept per one.
+const SAME_CONTENT_CANDIDATES = 100
+const CANDIDATES = 4
+
+const basename = (path) => path.slice(path.lastIndexOf('/') + 1)
+
+// A CRC-32, to bucket files of equal bytes; sameContent still decides.
+function contentKey(file, bytes) {
+  if (file.type === 'symlink') return `l${file.target}`
+  const data = bytes(file)
+  return `f${data.length}:${crc32(data)}`
+}
+
+// git's find_identical_files: the first unused identical source of the same
+// basename among the first 100, or else the first of them.
+function exactRenames({ sources, dests, sourceNames, destNames, used, record, bytes }) {
+  const byContent = Map.groupBy(sources.keys(), (s) => contentKey(sources[s], bytes))
+  for (let d = 0; d < dests.length; d++) {
+    let best = -1, left = SAME_CONTENT_CANDIDATES
+    for (const s of byContent.get(contentKey(dests[d], bytes)) ?? []) {
+      if (used.has(s) || !sameContent(sources[s], dests[d])) continue
+      if (best === -1 || sourceNames[s] === destNames[d]) best = s
+      if (sourceNames[s] === destNames[d] || --left === 0) break
+    }
+    if (best !== -1) record(d, best, MAX_SCORE)
+  }
+}
+
+// A TypeScript extension and the JavaScript one it compiles to.
+const SCRIPTS = new Map([['.ts', '.js'], ['.mts', '.mjs'], ['.cts', '.cjs'], ['.tsx', '.jsx']])
+// Extensions a file keeps its kind across, as triage's Compare groups them.
+const FAMILIES = new Map([
+  ...['.js', '.mjs', '.cjs', '.jsx', '.ts', '.mts', '.cts', '.tsx'].map((extension) => [extension, 'script']),
+  ...['.css', '.scss', '.sass', '.less'].map((extension) => [extension, 'style']),
+])
+
+function splitPath(path) {
+  const dirs = path.split('/')
+  const name = dirs.pop()
+  const dot = name.lastIndexOf('.')
+  return dot > 0 ? { dirs, stem: name.slice(0, dot), extension: name.slice(dot) } : { dirs, stem: name, extension: '' }
+}
+
+// A path less what a build changes: `lib` and `src` alike, and a TypeScript
+// extension as its JavaScript one.
+function buildKey(path) {
+  const { dirs, stem, extension } = splitPath(path)
+  return JSON.stringify([dirs.map((dir) => (dir === 'lib' || dir === 'src' ? null : dir)), stem, SCRIPTS.get(extension) ?? extension])
+}
+
+// The keys a path meets a partner on, as triage's Compare has them: its stem,
+// its extension's family, and its directories, as they are or with one open --
+// past the last node_modules and its package's name, which a group keeps.
+function familyKeys(path) {
+  const { dirs, stem, extension } = splitPath(path)
+  const head = [stem, FAMILIES.get(extension) ?? extension]
+  const modules = dirs.lastIndexOf('node_modules')
+  const first = modules === -1 ? 0 : modules + (dirs[modules + 1]?.startsWith('@') ? 3 : 2)
+  const keys = [JSON.stringify([...head, dirs])]
+  for (let i = first; i < dirs.length; i++) keys.push(JSON.stringify([...head, dirs.toSpliced(i, 1, null)]))
+  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.
+function outdone({ pairs, used, scoreOf }, { remaining, open }, { s, d, score }, minimum) {
+  const better = Math.max(minimum, score + Math.trunc((MAX_SCORE - score) / 2))
+  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)
+}
+
+// Paths a build changes: however a pair scores, the best of a file's partners.
+function buildRenames(context, left, weigh, minimum) {
+  const { sources, dests, pairs, used, record, scoreOf } = context
+  const byKey = Map.groupBy(left.remaining.filter((s) => sources[s].type === 'file'), (s) => buildKey(sources[s].path))
+  const candidates = left.open.filter((d) => dests[d].type === 'file')
+    .flatMap((d) => (byKey.get(buildKey(dests[d].path)) ?? []).map((s) => ({ s, d, score: scoreOf(s, d, 0) })))
+  for (const pair of candidates.sort((x, y) => y.score - x.score)) {
+    if (!pairs.has(pair.d) && !used.has(pair.s) && !(weigh && outdone(context, left, pair, minimum))) record(pair.d, pair.s, pair.score)
+  }
+}
+
+// Paths triage's Compare pairs: one file each other's only partner by family
+// and directory (its detectRenames), however the pair scores.
+function familyRenames(context, left, weigh, minimum) {
+  const { sources, dests, pairs, used, record, scoreOf } = context
+  const buckets = new Map()
+  const keyed = (files, indices, side) => new Map(indices.filter((i) => files[i].type === 'file').map((i) => {
+    const keys = familyKeys(files[i].path)
+    for (const key of keys) {
+      (buckets.get(key) ?? buckets.set(key, { sources: [], dests: [] }).get(key))[side].push(i)
+    }
+    return [i, keys]
+  }))
+  const destKeys = keyed(dests, left.open.filter((d) => !pairs.has(d)), 'dests')
+  const sourceKeys = keyed(sources, left.remaining.filter((s) => !used.has(s)), 'sources')
+  // The one file of `side` the keys meet, or -1 for none or several.
+  const partner = (keys, side) => {
+    const met = new Set(keys.flatMap((key) => buckets.get(key)[side]))
+    return met.size === 1 ? [...met][0] : -1
+  }
+  for (const [s, keys] of sourceKeys) {
+    const d = partner(keys, 'dests')
+    if (d === -1 || partner(destKeys.get(d), 'sources') !== s) continue
+    const pair = { s, d, score: scoreOf(s, d, 0) }
+    if (!(weigh && outdone(context, left, pair, minimum))) record(d, s, pair.score)
+  }
+}
+
+// Renames told by path, which git does not look for. Under -M100%, or past the
+// rename limit, no other candidate is scored, so none can be better.
+function pathRenames(context, minimum, limit) {
+  const left = unpaired(context)
+  const weigh = minimum < MAX_SCORE && left.remaining.length * left.open.length <= limit * limit
+  buildRenames(context, left, weigh, minimum)
+  familyRenames(context, left, weigh, minimum)
+}
+
+// Each index by its basename, or -1 where two share one.
+function byBasename(names, indices) {
+  const map = new Map()
+  for (const i of indices) map.set(names[i], map.has(names[i]) ? -1 : i)
+  return map
+}
+
+function basenameRenames({ sourceNames, destNames, record, scoreOf }, { remaining, open }, minimum) {
+  const byDest = byBasename(destNames, open), bySource = byBasename(sourceNames, remaining)
+  for (const s of remaining) {
+    const d = byDest.get(sourceNames[s])
+    if (d === undefined || d === -1 || bySource.get(sourceNames[s]) === -1) continue
+    const score = scoreOf(s, d, minimum)
+    if (score >= minimum) record(d, s, score)
+  }
+}
+
+// git's candidate order: best score, then a shared basename. Sorts are stable,
+// as git's is, so equals keep destination and slot order.
+const byScore = (a, b) => b.score - a.score || b.nameScore - a.nameScore
+
+// git's record_if_better: the first of the worst kept is replaced by a better.
+function keepIfBetter(kept, candidate) {
+  if (kept.length < CANDIDATES) {
+    kept.push(candidate)
+    return
+  }
+  let worst = 0
+  for (let i = 1; i < kept.length; i++) if (byScore(kept[i], kept[worst]) > 0) worst = i
+  if (byScore(kept[worst], candidate) > 0) kept[worst] = candidate
+}
+
+function scoredRenames({ sourceNames, destNames, pairs, used, record, scoreOf }, { remaining, open }, minimum) {
+  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)
+  }
+  for (const { dst, src, score } of all.sort(byScore)) {
+    if (score < minimum) break
+    if (!pairs.has(dst) && !used.has(src)) record(dst, src, score)
+  }
+}
+
+const unpaired = ({ sources, dests, pairs, used }) => ({
+  remaining: sources.keys().filter((s) => !used.has(s)).toArray(),
+  open: dests.keys().filter((d) => !pairs.has(d)).toArray(),
+})
+
+// Each added file's rename by its index in `dests`: { source, score }. A
+// `minimum` of MAX_SCORE takes identical content alone, but for `byPath`, and
+// more than `limit` squared pairs left skips the scoring.
+export function findRenames(sources, dests, { minimum, limit, byPath }) {
+  const pairs = new Map(), used = new Set()
+  if (sources.length === 0 || dests.length === 0) return pairs
+  // A file's bytes, its text encoded once, and their span counts once.
+  const counted = new Map(), encoded = new Map()
+  const bytes = (file) => (file.type === 'file' ? encoded.get(file) ?? encoded.set(file, bytesOf(file.data)).get(file) : null)
+  const counts = (data) => counted.get(data) ?? counted.set(data, spanCounts(data)).get(data)
+  const context = {
+    sources, dests, pairs, used,
+    sourceNames: sources.map((file) => basename(file.path)),
+    destNames: dests.map((file) => basename(file.path)),
+    record(d, s, score) {
+      pairs.set(d, { source: s, score })
+      used.add(s)
+    },
+    bytes,
+    scoreOf: (s, d, least) => similarity(bytes(sources[s]), bytes(dests[d]), least, counts),
+  }
+  exactRenames(context)
+  if (byPath) pathRenames(context, minimum, limit)
+  if (minimum >= MAX_SCORE) return pairs
+  basenameRenames(context, unpaired(context), minimum + Math.trunc(0.5 * (MAX_SCORE - minimum)))
+  const left = unpaired(context)
+  if (left.remaining.length * left.open.length <= limit * limit) scoredRenames(context, left, minimum)
+  return pairs
+}

package/src/same-bytes.js

@@ -0,0 +1,18 @@
+// Whether two byte arrays hold the same bytes, four at a time where both line
+// up alike: two to three times as fast as byte by byte. Node has its own
+// (same-bytes.node.js); indexedDB.cmp, which copies both first, is slower.
+
+export function sameBytes(x, y) {
+  const n = x.length
+  if (n !== y.length) return false
+  let i = 0
+  if (n >= 32 && (x.byteOffset & 3) === (y.byteOffset & 3)) {
+    for (const start = (4 - (x.byteOffset & 3)) & 3; i < start; i++) if (x[i] !== y[i]) return false
+    const words = (n - i) >>> 2
+    const a = new Int32Array(x.buffer, x.byteOffset + i, words), b = new Int32Array(y.buffer, y.byteOffset + i, words)
+    for (let j = 0; j < words; j++) if (a[j] !== b[j]) return false
+    i += words * 4
+  }
+  for (; i < n; i++) if (x[i] !== y[i]) return false
+  return true
+}

package/src/same-bytes.node.js

@@ -0,0 +1,7 @@
+// same-bytes.js on Node, by its memcmp: three or four times as fast again
+// past a few hundred bytes. The one module here only Node runs, as
+// package.json imports picks it under the `node` condition.
+
+import { Buffer } from 'node:buffer'
+
+export const sameBytes = (x, y) => x.length === y.length && Buffer.compare(x, y) === 0

package/src/script.js

@@ -0,0 +1,57 @@
+// One shortest edit script between two lines' words (Myers): which of them it
+// keeps. Where each step's paths end, one per diagonal walked, is kept in one
+// row, `reached` telling where a step's run starts and its lowest diagonal.
+
+// Where the path on diagonal `k` ended at a step, as `reached` tells.
+const endOf = (ends, { lo, start }, k) => ends[start + (k - lo) / 2]
+
+// The diagonal a script reaches diagonal `k` from at step `d`: of those either
+// side, the one whose path ends further on, as the step before tells.
+function from(k, d, { low, high }, ends, before) {
+  return k === -d || k - 1 < low || (k !== d && k + 1 <= high && endOf(ends, before, k - 1) < endOf(ends, before, k + 1)) ? k + 1 : k - 1
+}
+
+// The words a script keeps, walked back from its end; the shared ends kept outright.
+function mark(kept, ends, reached, { first, n, m, d: edits, ...bounds }) {
+  kept.a.fill(1, 0, first).fill(1, n)
+  kept.b.fill(1, 0, first).fill(1, m)
+  let x = n, y = m
+  for (let d = edits; d > 0; d--) {
+    const k = x - y
+    const back = from(k, d, bounds, ends, reached[d]), end = endOf(ends, reached[d], back)
+    for (let at = back > k ? end : end + 1; at < x; at++) kept.a[at] = kept.b[at - k] = 1
+    x = end
+    y = x - back
+  }
+  for (let at = first; at < x; at++) kept.a[at] = kept.b[at] = 1
+}
+
+// The words of each of two lines the script keeps, marked in `kept`, their
+// shared ends matched outright; and the work it took, the diagonals off both
+// middles never walked, each word read twice over to mark and range it.
+export function script(a, b, kept) {
+  let first = 0, m = b.length, n = a.length, steps = 2 * (n + m)
+  while (first < n && first < m && a[first] === b[first]) first++
+  while (n > first && m > first && a[n - 1] === b[m - 1]) {
+    n--
+    m--
+  }
+  const bounds = { high: n - first, low: first - m }, ends = [first], reached = [{ lo: 1, start: 0 }]
+  for (let d = 0; d <= bounds.high - bounds.low; d++) {
+    const before = reached[d], hi = Math.min(d, bounds.high), lo = Math.max(-d, bounds.low + ((bounds.low + d) & 1))
+    reached.push({ lo, start: ends.length })
+    for (let k = lo; k <= hi; k += 2) {
+      const back = from(k, d, bounds, ends, before), end = endOf(ends, before, back)
+      let x = back > k ? end : end + 1
+      const start = x
+      while (x < n && x - k < m && a[x] === b[x - k]) x++
+      steps += 2 + x - start
+      ends.push(x)
+      if (x >= n && x - k >= m) {
+        mark(kept, ends, reached, { first, n, m, d, ...bounds })
+        return steps
+      }
+    }
+  }
+  throw new Error('no edit script between two lines')
+}

package/src/similarity.js

@@ -0,0 +1,53 @@
+// git's rename score (diffcore-delta.c, estimate_similarity in diffcore-rename.c,
+// git >= 2.44), bit for bit since it decides which renames git finds: bytes of
+// the new file in spans the old file has too, over the larger file's size.
+
+// Scores are out of 60000; 50% is 30000.
+export const MAX_SCORE = 60000
+
+const HASHBASE = 107927
+
+// git's binary test, used here only to decide whether a CR before an LF counts.
+const looksBinary = (data) => data.subarray(0, 8000).includes(0)
+
+const spanHash = (accum1, accum2) => ((accum1 + Math.imul(accum2, 0x61)) >>> 0) % HASHBASE
+
+// Bytes per span hash, a span ending at an LF or after 64 bytes; sorted by
+// hash, as git keeps them, so two files compare in one walk down both.
+export function spanCounts(data) {
+  const text = !looksBinary(data)
+  const counts = new Map()
+  const add = (hash, n) => counts.set(hash, (counts.get(hash) ?? 0) + n)
+  let accum1 = 0, accum2 = 0, n = 0
+  for (let i = 0; i < data.length; i++) {
+    const c = data[i]
+    if (text && c === 0x0D && data[i + 1] === 0x0A) continue
+    const old1 = accum1
+    accum1 = (((accum1 << 7) ^ (accum2 >>> 25)) + c) >>> 0
+    accum2 = ((accum2 << 7) ^ (old1 >>> 25)) >>> 0
+    if (++n < 64 && c !== 0x0A) continue
+    add(spanHash(accum1, accum2), n)
+    n = 0
+    accum1 = 0
+    accum2 = 0
+  }
+  if (n > 0) add(spanHash(accum1, accum2), n)
+  const hashes = Uint32Array.from(counts.keys()).sort()
+  return { hashes, bytes: Float64Array.from(hashes, (hash) => counts.get(hash)) }
+}
+
+// Two files' bytes, null for a link, which scores 0, as do sizes too far apart
+// for `minimum`, unread. `counts` gives span counts, cached: one file meets many.
+export function similarity(src, dst, minimum, counts) {
+  if (src === null || dst === null || dst.length === 0) return 0
+  const delta = Math.abs(src.length - dst.length), max = Math.max(src.length, dst.length)
+  if (max * (MAX_SCORE - minimum) < delta * MAX_SCORE) return 0
+  const a = counts(src), b = counts(dst)
+  let copied = 0
+  for (let i = 0, j = 0; i < a.hashes.length && j < b.hashes.length;) {
+    if (a.hashes[i] < b.hashes[j]) i++
+    else if (a.hashes[i] > b.hashes[j]) j++
+    else copied += Math.min(a.bytes[i++], b.bytes[j++])
+  }
+  return Math.trunc(copied * MAX_SCORE / max)
+}

package/src/text.js

@@ -0,0 +1,41 @@
+// Content as @preventive/diff's lines. Text is UTF-8 (lines are strings) with no
+// NUL, as deptree's compare command takes it; git only wants no NUL in the
+// 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'
+
+// A link's content is its target, as git stores it; a missing side is empty.
+export function textOf(file) {
+  if (file === null) return ''
+  const content = file.type === 'symlink' ? file.target : file.data
+  if (typeof content === 'string') return content.includes('\0') ? undefined : content
+  if (content.includes(0)) return undefined
+  try {
+    return utf8toString(content)
+  } catch {
+    return undefined
+  }
+}
+
+const WHITESPACE = new Set(['none', 'all', 'change', 'trailing'])
+
+// diff's options for a change set: how far into the lines the two files share
+// at either end a run free to move may go (`horizon`: without limit, as git
+// has it, unless given -- 0 as diff -U0 has it, the context as -u does); and
+// which lines are the same (-w, -b, -Z as `whitespace`; -i).
+export function checkLineOptions({ horizon = Infinity, whitespace = 'none', ignoreCase = false } = {}) {
+  if (horizon !== Infinity && !(Number.isSafeInteger(horizon) && horizon >= 0)) throw new RangeError(`horizon must be a whole number or Infinity, not ${horizon}`)
+  if (!WHITESPACE.has(whitespace)) throw new RangeError(`whitespace must be 'none', 'all', 'change' or 'trailing', not ${whitespace}`)
+  if (typeof ignoreCase !== 'boolean') throw new TypeError(`ignoreCase must be a boolean, not ${typeof ignoreCase}`)
+  return { horizon, whitespace, ignoreCase }
+}
+
+// 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 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') }
+}

package/src/tree.js

@@ -0,0 +1,98 @@
+// A tree as git sees one: files and links by path, read from tar-shaped entries
+// (archive's unpack, Vfs.entries), or by names taken as keys. Directories add
+// nothing, and a hard link is a copy of its target.
+
+import { utf8fromString } from '@exodus/bytes/utf8.js'
+import { sameBytes } from '#same-bytes'
+import { CompareError } from './error.js'
+
+const FILE = new Set(['file', 'contiguous-file'])
+const OTHER = new Set(['fifo', 'character-device', 'block-device'])
+const BAD_SEGMENT = /(?:^|\/)\.{0,2}(?:\/|$)/u
+
+function checkMode(mode) {
+  if (!Number.isInteger(mode) || mode < 0 || mode > 0o7777) throw new RangeError(`a mode must be an integer from 0 to 0o7777, not ${mode}`)
+}
+
+// `.` is the root, which only a directory may name. A lone surrogate has no
+// UTF-8, so no name git could hold. A key may be any non-empty name, `.` too.
+function checkName(name, type, tree, keys) {
+  if (typeof name !== 'string') throw new TypeError(`an entry's name must be a string, not ${typeof name}`)
+  if (name === '.' && type === 'directory') return
+  if (keys ? name === '' : BAD_SEGMENT.test(name)) throw new CompareError(keys ? 'a name must not be empty' : 'a name must be a relative path with no empty, `.` or `..` segment', name, tree)
+  if (!name.isWellFormed()) throw new CompareError('a name must be well-formed Unicode', name, tree)
+}
+
+function checkLinkname(linkname, name, tree) {
+  if (typeof linkname !== 'string' || linkname === '') throw new CompareError('a link must name its target', name, tree)
+  if (!linkname.isWellFormed()) throw new CompareError('a link target must be well-formed Unicode', name, tree)
+  return linkname
+}
+
+// Text is kept as text, to be compared as it is; it must have UTF-8 to stand for.
+function dataOf(data) {
+  if (data === undefined) return new Uint8Array(0)
+  if (data instanceof Uint8Array) return data
+  if (typeof data !== 'string') throw new TypeError(`a file's data must be a string or a Uint8Array, not ${typeof data}`)
+  if (!data.isWellFormed()) throw new TypeError("a file's text must be well-formed Unicode")
+  return data
+}
+
+// The bytes a file's data stands for: its text as UTF-8.
+export const bytesOf = (data) => (typeof data === 'string' ? utf8fromString(data) : data)
+
+function readEntry(entry, tree, keys) {
+  if (typeof entry !== 'object' || entry === null) throw new TypeError(`an entry must be an object, not ${entry === null ? 'null' : typeof entry}`)
+  const { name, type = 'file', mode, linkname, data } = entry
+  checkName(name, type, tree, keys)
+  if (mode !== undefined) checkMode(mode)
+  if (FILE.has(type)) return { path: name, type: 'file', mode: mode ?? 0o644, data: dataOf(data) }
+  if (type === 'symlink' || type === 'hardlink') return { path: name, type, target: checkLinkname(linkname, name, tree) }
+  if (type === 'directory') return { path: name, type }
+  if (OTHER.has(type)) throw new CompareError(`a ${type} is neither a file nor a link`, name, tree)
+  throw new TypeError(`${JSON.stringify(type)} is not an entry type`)
+}
+
+// A mode is not content.
+export function sameContent(a, b) {
+  if (a.type !== b.type) return false
+  if (a.type === 'symlink') return a.target === b.target
+  if (a.data === b.data) return true
+  if (typeof a.data === 'string' && typeof b.data === 'string') return false
+  return sameBytes(bytesOf(a.data), bytesOf(b.data))
+}
+
+// Through any chain of hard links, to a file or a link of the tree.
+function resolveLink(link, held, tree) {
+  const seen = new Set([link.path])
+  let target = held.get(link.target)
+  while (target?.type === 'hardlink') {
+    if (seen.has(target.path)) throw new CompareError('a hard link leads back to itself', link.path, tree)
+    seen.add(target.path)
+    target = held.get(target.target)
+  }
+  if (target === undefined || target.type === 'directory') throw new CompareError('a hard link must name a file or a link in the tree', link.path, tree)
+  return { ...target, path: link.path }
+}
+
+// Nothing may lie under a file or a link, where a tar extracting it would
+// write through the link -- unless names are keys, and no tree's paths.
+export function readTree(entries, tree, keys) {
+  const held = new Map()
+  for (const entry of entries) {
+    const read = readEntry(entry, tree, keys)
+    if (read.type === 'directory' && read.path === '.') continue
+    if (held.has(read.path)) throw new CompareError('a name is given twice', read.path, tree)
+    held.set(read.path, read)
+  }
+  const files = new Map()
+  for (const [path, read] of held) {
+    for (let at = keys ? -1 : path.lastIndexOf('/'); at > 0; at = path.lastIndexOf('/', at - 1)) {
+      const above = held.get(path.slice(0, at))
+      if (above !== undefined && above.type !== 'directory') throw new CompareError(`a path lies under a ${above.type === 'symlink' ? 'link' : 'file'}`, path, tree)
+    }
+    if (read.type === 'hardlink') files.set(path, resolveLink(read, held, tree))
+    else if (read.type !== 'directory') files.set(path, read)
+  }
+  return files
+}

package/src/whitespace.js

@@ -0,0 +1,44 @@
+// Whether diff -w, as `blocks` were found with it, hides a change in blanks of
+// more than one kind: a line kept as unchanged whose blanks between the same
+// two characters differ and mix kinds, as spaces turned to tabs.
+
+import { blocksHold } from './blocks.js'
+
+// The blanks diff -w leaves out of a line: the C locale's.
+const BLANK = /[ \t\n\v\f\r]/u
+
+const lines = (text) => {
+  const list = text.split('\n')
+  if (list.at(-1) === '') list.pop()
+  return list
+}
+
+// Two lines alike but for their blanks: whether, before any of their other
+// characters or after the last, their blanks differ and hold two kinds.
+function mixesBlanks(x, y) {
+  for (let i = 0, j = 0; ; i++, j++) {
+    let gapX = '', gapY = ''
+    while (i < x.length && BLANK.test(x[i])) gapX += x[i++]
+    while (j < y.length && BLANK.test(y[j])) gapY += y[j++]
+    if (gapX !== gapY && new Set(gapX + gapY).size > 1) return true
+    if (i >= x.length || j >= y.length) return false
+  }
+}
+
+// Blocks that don't carry `before` to `after` under -w, or are not blocks at
+// all, may hide anything and would line up the wrong lines here: they count as hiding.
+export function hidesMixedWhitespace(before, after, blocks) {
+  try {
+    if (!blocksHold(before, after, blocks, { whitespace: 'all' })) return true
+  } catch {
+    return true
+  }
+  const a = lines(before), b = lines(after)
+  let ai = 0, bi = 0
+  for (let run = 0; run <= blocks.length; run++) {
+    const end = run < blocks.length ? blocks[run].a0 : a.length
+    for (; ai < end; ai++, bi++) if (a[ai] !== b[bi] && mixesBlanks(a[ai], b[bi])) return true
+    if (run < blocks.length) ({ a1: ai, b1: bi } = blocks[run])
+  }
+  return false
+}