@preventive/compare 1.2.8 → 1.2.10

package/compare.d.ts

@@ -120,11 +120,17 @@ export interface LineOptions {
 // 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.
+// its spans ending after `,` `;` `=` `{` `}` too, and taken however it scores
+// where each is the other's only such chunk and their names are one but for a
+// hash as a build writes one -- the last 8 to 32 of those characters after a
+// `-` or `.`, with a letter, and a digit or a capital, no date nor a name's
+// part, nor two of one format, a character of a kind in each place -- as a
+// pair by path is (a build's chunk rewritten: playwright's
+// dashboard `index-*.js`, 31% alike from 1.61.1 to 1.62.0), else 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/compare.js

@@ -23,7 +23,9 @@ export { renameParts } from './src/paths.js'
 
 // Two trees taken from different roots lined up: the root between them and
 // each old path, directory and package directory as the new tree lays it out.
-export { layoutDir, layoutPackageDirs, rootLabel, treeLayout } from './src/layout.js'
+// The line and path helpers a view reads alone are in view.js too.
+export { layoutPackageDirs, treeLayout } from './src/layout.js'
+export { layoutDir, rootLabel } from './src/root.js'
 
 // Whether a TypeScript text holds types alone, so that Node runs nothing of it,
 // as compareTrees stamps a declaration file's change: proven on Node alone, where

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preventive/compare",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "description": "Git-compatible file tree diffs and minified JavaScript comparison",
   "type": "module",
   "main": "./compare.js",
@@ -21,6 +21,10 @@
     "./pretty.js": {
       "types": "./pretty.d.ts",
       "default": "./pretty.js"
+    },
+    "./view.js": {
+      "types": "./view.d.ts",
+      "default": "./view.js"
     }
   },
   "imports": {
@@ -46,6 +50,8 @@
     "names.js",
     "pretty.d.ts",
     "pretty.js",
+    "view.d.ts",
+    "view.js",
     "src/blocks.js",
     "src/changes.js",
     "src/chunks.js",
@@ -71,6 +77,7 @@
     "src/pretty.js",
     "src/quote.js",
     "src/renames.js",
+    "src/root.js",
     "src/same-bytes.js",
     "src/same-bytes.node.js",
     "src/script.js",

package/src/chunks.js

@@ -10,6 +10,42 @@ const HASH = /^[\w-]{6,}$/u
 const RANDOM = /[\dA-Z]/u
 const SEPARATORS = '-._'
 
+// A name's readings as one a build gave a hash, `[name]-[hash]` or
+// `[name].[contenthash]`, the shortest hash first: `[name, hash, extensions]`,
+// the hash 8 to 32 of base64url's characters after a `-` or `.`, with a
+// letter, and a digit or a capital, and only extensions after it, a `-` in
+// one too (`main.AbCd1234.hot-update.js`). None for a date
+// (`migration-20240101.js`) or a word (`lodash.debounce.js`).
+const EXTENSIONS = /^(?:\.[\w-]+)+$/u, HASHED = /^[\w-]{8,32}$/u
+function readings(name) {
+  const found = []
+  for (let at = name.length - 1; at > 0; at--) {
+    if (name[at] !== '-' && name[at] !== '.') continue
+    const end = name.indexOf('.', at + 1), extensions = name.slice(end), hash = name.slice(at + 1, end)
+    if (end !== -1 && HASHED.test(hash) && EXTENSIONS.test(extensions) && /[A-Za-z]/u.test(hash) && RANDOM.test(hash)) found.push([name.slice(0, at), hash, extensions])
+  }
+  return found
+}
+
+// Whether two names are one but for a hash: the shortest reading of one whose
+// hash the other's reading with those extensions does not share, its name
+// theirs. A part both share is an extension's (`index-AbCd1234.production2024.js`);
+// a `-` in a hash is the hash's (`index-CyWAfh-p.js`, `codeMirrorModule--QdMvsKi.css`)
+// and one before eight more the name's (`vendor-react-dom-AbCd1234.js`). Two
+// with a character of a kind in each place, a digit for a digit, a capital for
+// a capital, are of one format, a time's or a version's
+// (`migration-20240101T120000.js`, `migration-2024-Oct-14.js`), as two hashes
+// all but never are.
+const shape = (text) => text.replaceAll(/\d/gu, '0').replaceAll(/[a-z]/gu, 'a').replaceAll(/[A-Z]/gu, 'A')
+function oneButHash(a, b) {
+  const others = readings(b)
+  for (const [name, hash, extensions] of readings(a)) {
+    const other = others.find((reading) => reading[2] === extensions)
+    if (other && other[1] !== hash) return other[0] === name && shape(other[1]) !== shape(hash)
+  }
+  return false
+}
+
 function nameOf(path) {
   const slash = path.lastIndexOf('/')
   const name = path.slice(slash + 1)
@@ -32,25 +68,30 @@ function oneChunk(a, b) {
 }
 
 // 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.
+// name's length, each pair at least `bar` -- or however it scores, where each
+// is the other's only such chunk and their names are one but for a hash
+// (oneButHash), as a pair by path is: the build's own chunk, rewritten
+// (playwright's dashboard `index-*.js`, 31% alike from 1.61 to 1.62):
+// 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)
   const opens = Map.groupBy(destNames.keys(), (d) => destNames.get(d).key)
-  const candidates = []
+  const chunks = []
   for (const [key, ds] of opens) {
     const ss = byKey.get(key) ?? []
-    for (const d of ds) {
-      for (const s of ss) {
-        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 d of ds) for (const s of ss) if (oneChunk(sourceNames.get(s).name, destNames.get(d).name)) chunks.push({ s, d })
+  }
+  const byDest = Map.groupBy(chunks, ({ d }) => d), bySource = Map.groupBy(chunks, ({ s }) => s)
+  const candidates = []
+  for (const { s, d } of chunks) {
+    const only = bySource.get(s).length === 1 && byDest.get(d).length === 1 && oneButHash(sourceNames.get(s).name, destNames.get(d).name)
+    const score = punctuatedScoreOf(s, d, only ? 0 : bar)
+    if (only || score >= bar) candidates.push({ s, d, score })
   }
   const aside = [], heldDests = new Set(), heldSources = new Set()
   for (const pair of candidates.sort((x, y) => y.score - x.score)) {

package/src/layout.js

@@ -1,14 +1,7 @@
 // Two trees taken from different roots lined up: the directory one's files sit
 // under in the other (`root`), and each old path as the new tree lays it out.
 
-function throughRoot(root, path) {
-  if (!root) return path
-  if (root.base === '') return `${root.other}${path}`
-  return path.startsWith(root.base) ? path.slice(root.base.length) : null
-}
-
-// A path outside a root as one inside it reaches it.
-const outside = (root, path) => `${'../'.repeat(root.base.split('/').length - 1)}${path}`
+import { layoutDir, outside, throughRoot } from './root.js'
 
 // Each old path as the new tree lays it out: through the root where the new
 // tree has it there, else as it is where it has that, else through the root,
@@ -70,25 +63,9 @@ export function treeLayout(basePaths, otherPaths) {
   return { root, paths: rootPaths(base, other, root).paths }
 }
 
-export function layoutDir({ root, paths }, dir, files) {
-  if (!root || dir === '.') return dir
-  for (const file of files) {
-    const to = paths.get(`${dir}/${file}`)
-    if (to?.endsWith(`/${file}`)) return to.slice(0, -file.length - 1)
-  }
-  const to = throughRoot(root, `${dir}/`)
-  return to === null ? outside(root, dir) : to.slice(0, -1) || '.'
-}
-
 export function layoutPackageDirs(baseDirs, otherDirs, layout) {
   if (!baseDirs && !otherDirs) return null
   const files = Map.groupBy([...baseDirs ?? []], ([, dir]) => dir)
   const dirs = new Map([...files].map(([dir, entries]) => [dir, layoutDir(layout, dir, entries.map(([path]) => path.slice(dir.length + 1)))]))
   return new Map([...[...baseDirs ?? []].map(([path, dir]) => [layout.paths.get(path) ?? path, dirs.get(dir)]), ...otherDirs ?? []])
 }
-
-export function rootLabel(root, prefix) {
-  if (!root) return { prefix, from: null, to: null }
-  const kept = prefix.startsWith(root.other) ? prefix : ''
-  return { prefix: kept, from: `./${root.base}${kept.slice(root.other.length)}`, to: `./${kept || root.other}` }
-}

package/src/names/analyze.js

@@ -53,6 +53,7 @@ const fnOf = (where) => (where.fn ? where : fnOf(where.parent))
 function join(s, kept, gone) {
   if (kept === gone || !s.variables.includes(gone)) return
   for (const path of gone.through ?? []) (kept.through ??= []).push(path)
+  kept.varIn ??= gone.varIn
   for (const at of s.scopes) for (const [name, variable] of at.names) if (variable === gone) at.names.set(name, kept)
   for (const [node, [variable, where]] of s.declarations) if (variable === gone) s.declarations.set(node, [kept, where])
   s.variables.splice(s.variables.indexOf(gone), 1)
@@ -64,6 +65,7 @@ function declareVariables(node, where, s) {
   for (const id of node.declarations.flatMap((declarator) => declared(declarator.id))) {
     const variable = declare(s, node.kind === 'var' ? fnOf(where) : where, id)
     if (node.kind !== 'var') continue
+    variable.varIn = fnOf(where)
     const path = []
     for (let at = where; !at.fn; at = at.parent) path.push(at)
     if (path.length > 0) (variable.through ??= []).push(path)
@@ -111,6 +113,17 @@ function namingNames(node, s) {
   }
 }
 
+// Names a variable is set by after its declaration: an assignment's, an
+// update's, or a loop's that declares none.
+function writtenNames(node, s) {
+  switch (node.type) {
+    case 'AssignmentExpression': for (const id of declared(node.left)) s.writing.add(id); break
+    case 'UpdateExpression': for (const id of declared(node.argument)) s.writing.add(id); break
+    case 'ForInStatement': case 'ForOfStatement': if (node.left.type !== 'VariableDeclaration') for (const id of declared(node.left)) s.writing.add(id); break
+    default: break
+  }
+}
+
 // Names that are no variable's (keys, labels), names kept, and the properties
 // names are read through.
 function otherNames(node, s) {
@@ -166,7 +179,7 @@ function enterFunction(node, where, s) {
     for (const child of [node.superClass, node.body, ...node.decorators ?? []]) if (child) s.work.push([child, named])
     return
   }
-  const parameters = scope(s, named, true)
+  const parameters = Object.assign(scope(s, named, true), { arrow: node.type === 'ArrowFunctionExpression', parameter: true })
   if (node.body?.type === 'BlockStatement' && saysStrict(node.body.body)) parameters.strict = true
   for (const parameter of node.params) {
     for (const id of declared(parameter)) declare(s, parameters, id)
@@ -202,7 +215,7 @@ function enter(node, where, s) {
 
 // A work list rather than a recursion: a minified file's expressions nest deeply.
 function walk(program) {
-  const s = { declarations: new Map(), scopes: [], variables: [], keeping: new Set(), others: new Set(), naming: new Set(), reads: new Set(), references: [], work: [] }
+  const s = { declarations: new Map(), scopes: [], variables: [], keeping: new Set(), others: new Set(), naming: new Set(), writing: new Set(), reads: new Set(), references: [], work: [] }
   s.root = Object.assign(scope(s, null, true), { strict: program.sourceType === 'module' || saysStrict(program.body) })
   s.work.push([program, s.root])
   while (s.work.length > 0) {
@@ -212,6 +225,7 @@ function walk(program) {
       continue
     }
     namingNames(node, s)
+    writtenNames(node, s)
     const reason = visit(node, where, s)
     if (reason) return { reason }
     enter(node, where, s)
@@ -229,9 +243,29 @@ function resolved(program, s) {
     if (variable) occurrences.push([node, variable, where])
     else globals.push([node, where])
   }
+  // Set again (`reassigned`): written, or declared more than once, or a
+  // parameter of a function that reads `arguments`, which may write it
+  // (`arguments[0] = x`, outside strict code) -- an arrow's its function's,
+  // and a `var arguments` its function's own `arguments` still, unlike one a
+  // `let`, a parameter, a `catch` or an arrow's `var` declares.
+  const setting = new Set()
+  for (const [node, where] of globals) {
+    if (node.name !== 'arguments') continue
+    let at = where
+    while (at && !(at.parameter && !at.arrow)) at = at.parent
+    setting.add(at)
+  }
+  for (const variable of s.variables) {
+    const at = variable.varIn?.parameters ?? variable.varIn
+    if (variable.name === 'arguments' && at?.parameter && !at.arrow) setting.add(at)
+  }
+  for (const at of setting) for (const variable of at?.names.values() ?? []) variable.reassigned = true
+  const declaredAlready = new Set()
   for (const [node, variable] of occurrences) {
     if (s.keeping.has(node)) variable.kept = true
     if (s.naming.has(node)) variable.naming = true
+    if (s.writing.has(node) || (s.declarations.has(node) && declaredAlready.has(variable))) variable.reassigned = true
+    if (s.declarations.has(node)) declaredAlready.add(variable)
   }
   const own = program.sourceType === 'module' || program.sourceType === 'commonjs' || globals.some(([node]) => COMMONJS.has(node.name))
   for (const variable of s.variables) variable.aside = renamable(variable) && (own || variable.scope !== s.root)
@@ -245,7 +279,7 @@ function resolved(program, s) {
   }
   const deduplicated = occurrences.filter((entry, i) => i === 0 || entry[0].start !== occurrences[i - 1][0].start)
   const names = new Set([...s.variables.map(({ name }) => name), ...globals.map(([node]) => node.name)])
-  return { scopes: s.scopes, variables: s.variables, occurrences: deduplicated, globals, names, reads: s.reads, module: program.sourceType === 'module', commonjs: program.sourceType === 'commonjs', own }
+  return { scopes: s.scopes, variables: s.variables, occurrences: deduplicated, declaring: new Set(s.declarations.keys()), globals, names, reads: s.reads, module: program.sourceType === 'module', commonjs: program.sourceType === 'commonjs', own }
 }
 
 const minified = (name) => name.length <= RENAMED_MAX_LENGTH && MINIFIED.test(name)

package/src/names/pairing.js

@@ -1,6 +1,8 @@
-// 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.
+// Which old variable became which new one: a variable declared on a line each
+// side holds once is the one declared there on the other; 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 { shortestChangeSet } from '../text.js'
 import { RESERVED } from './syntax.js'
@@ -8,17 +10,22 @@ import { RESERVED } from './syntax.js'
 // Unchanged lines between changes that pair as unchanged ones, not as changed.
 const ANCHORED_RUN = 3
 
+// Where a name stood in a key with a slot for each.
+const SLOT = '\0'
+
 // Whitespace alone never tells a name apart.
 const KEYS = { horizon: 0, whitespace: 'all' }
 
 // A text's lines with its renamable variables' names set aside (`key`), but
 // those `written` names (a pair found), each line's variables set aside in
-// order (`lines`), and where in its key each stood (`places`).
-function keyed(text, { occurrences }, written = () => null) {
+// order (`lines`), where in its key each stood (`places`), and with `slots`,
+// whether it is declared there (`declares`) and the key with a slot where each
+// stood (`slotted`), so that two keys alike stand for names alike.
+function keyed(text, { occurrences, declaring }, written = () => null, slots = false) {
   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(() => []), places = starts.map(() => [])
-  let at = 0, key = '', line = 0, removed = 0
+  const declares = starts.map(() => []), lines = starts.map(() => []), places = starts.map(() => [])
+  let at = 0, key = '', line = 0, removed = 0, slotted = ''
   for (const [node, variable] of occurrences) {
     if (!variable.aside) continue
     const name = written(variable)
@@ -26,17 +33,19 @@ function keyed(text, { occurrences }, written = () => null) {
     if (name === null) {
       lines[line].push(variable)
       places[line].push(node.start - starts[line] - removed)
+      if (slots) declares[line].push(declaring.has(node))
     }
     key += text.slice(at, node.start) + (name ?? '')
+    if (slots) slotted += text.slice(at, node.start) + (name ?? SLOT)
     removed += node.end - node.start - (name?.length ?? 0)
     at = node.end
   }
   key += text.slice(at)
-  return { key, keys: key.split('\n'), lines, places }
+  return { key, keys: key.split('\n'), lines, places, declares, slotted: slots ? slotted + text.slice(at) : null }
 }
 
 // Lines as a diff that sets whitespace aside compares them.
-const SPACE = /[ \t\n\v\f\r]/gu
+const BLANKS = /[ \t\v\f\r]/gu, SPACE = /[ \t\n\v\f\r]/gu
 const plain = (lines) => lines.map((line) => line.replace(SPACE, ''))
 
 // The kept lines of each side a run of changes could stand in place of: a run
@@ -230,21 +239,67 @@ function matched({ backward, forward }, { map, paired, support }, eligible = ()
   return chosen
 }
 
+// A variable set once is where it is declared, as its uses may come to read
+// another: `function(e) { ...e.data... }` -> `function(e) { const i = f(e);
+// ...i.data... }`, where more lines read the new `i` as the old `e` did than
+// read `e` still. A line each side holds once, names set aside, is the same
+// line, as patience diff has it, wherever a diff puts it: each variable
+// declared there is the one declared in its place on the other side -- where
+// lines counted say so too, as a short line may stand once on each side for
+// code that is not the same, and where nothing else declared once says
+// otherwise. One set again may be two variables a minifier made one, its
+// declaration the first's alone (`var i = /\d/; ... i = q.prototype`): its
+// lines say.
+function declaredOnce(ka, kb, { changed, tokened, unchanged }) {
+  const once = (k) => {
+    const where = new Map()
+    k.slotted.replace(BLANKS, '').split('\n').forEach((key, line) => where.set(key, where.has(key) ? -1 : line))
+    return where
+  }
+  const from = new Map(), news = once(kb), olds = once(ka), to = new Map()
+  const add = (map, x, y) => map.set(x, map.has(x) && map.get(x) !== y ? null : y)
+  for (const [key, i] of olds) {
+    const j = news.get(key)
+    if (i === -1 || j === undefined || j === -1) continue
+    ka.lines[i].forEach((variable, n) => {
+      if (!ka.declares[i][n] || !kb.declares[j][n] || variable.reassigned || kb.lines[j][n].reassigned) return
+      add(to, variable, kb.lines[j][n])
+      add(from, kb.lines[j][n], variable)
+    })
+  }
+  // The first tier counting the pair, as were it found there: its count, and whether that tier's pairs are weak.
+  const tiers = [unchanged, changed, tokened]
+  return [...to].flatMap(([variable, other]) => {
+    const tier = tiers.findIndex(({ forward }) => forward.get(variable)?.has(other))
+    return other === null || from.get(other) !== variable || tier === -1 ? [] : [[variable, other, tiers[tier].forward.get(variable).get(other), tier > 0]]
+  })
+}
+
 // 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.
+// are `weak` pairs, the first to give way where names read wrongly; a pair
+// declared once on each side, found before them all, gives way as the tier
+// first counting it would have it. 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(), 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) {
+  for (const [pass, [old, now]] of passes.entries()) {
     // 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, tokened, unchanged } = tallied(keyed(before, a, old), keyed(after, b, now))
+    // Lines declaring once, read in the first pass: the second finds few more, at a cost.
+    const ka = keyed(before, a, old, pass === 0), kb = keyed(after, b, now, pass === 0), lines = tallied(ka, kb)
+    const { changed, tokened, unchanged } = lines
+    for (const [variable, other, support, weakly] of pass === 0 ? declaredOnce(ka, kb, lines) : []) {
+      found.map.set(variable, other)
+      found.paired.add(other)
+      found.support.set(variable, support)
+      if (weakly) weak.add(variable)
+    }
     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)

package/src/renames.js

@@ -193,7 +193,8 @@ const unpaired = ({ sources, dests, pairs, used }) => ({
 })
 
 // git's stricter score, halfway from -M's to 100%, for a pair that names alone
-// put forward: a basename both sides have once, or a chunk's.
+// put forward: a basename both sides have once, or a chunk's of a name either
+// side has more of.
 const stricter = (minimum) => minimum + Math.trunc(0.5 * (MAX_SCORE - minimum))
 
 // Each added file's rename by its index in `dests`: { source, score }. A

package/src/root.js

@@ -0,0 +1,29 @@
+// A path through the root two trees are lined up by (layout.js treeLayout),
+// and what a view of them shows of it: a directory of the old tree as the new
+// one lays it out, and the root as a heading reads it. Kept apart from what
+// finds the root, so a view that is given its trees lined up loads none of that.
+
+export function throughRoot(root, path) {
+  if (!root) return path
+  if (root.base === '') return `${root.other}${path}`
+  return path.startsWith(root.base) ? path.slice(root.base.length) : null
+}
+
+// A path outside a root as one inside it reaches it.
+export const outside = (root, path) => `${'../'.repeat(root.base.split('/').length - 1)}${path}`
+
+export function layoutDir({ root, paths }, dir, files) {
+  if (!root || dir === '.') return dir
+  for (const file of files) {
+    const to = paths.get(`${dir}/${file}`)
+    if (to?.endsWith(`/${file}`)) return to.slice(0, -file.length - 1)
+  }
+  const to = throughRoot(root, `${dir}/`)
+  return to === null ? outside(root, dir) : to.slice(0, -1) || '.'
+}
+
+export function rootLabel(root, prefix) {
+  if (!root) return { prefix, from: null, to: null }
+  const kept = prefix.startsWith(root.other) ? prefix : ''
+  return { prefix: kept, from: `./${root.base}${kept.slice(root.other.length)}`, to: `./${kept || root.other}` }
+}

package/view.d.ts

@@ -0,0 +1,3 @@
+// What view.js gives, as compare.js gives it.
+export { hidesMixedWhitespace, layoutDir, pairLines, renameParts, rootLabel, wordRanges } from './compare.js'
+export type { Layout, Root } from './compare.js'

package/view.js

@@ -0,0 +1,14 @@
+// What a view of two trees' changes reads them by, given the files they pair:
+// changed lines read word by word, which removed line was edited into which
+// added one, and whether diff -w hides blanks of more than one kind changing;
+// a rename written as `git diff --stat` writes one; and a directory and the
+// root as the new tree lays them out. compare.js gives these too; this loads
+// none of compareTrees, nor what finds the root, so a view whose files are
+// paired elsewhere (a server's) loads none of the pairing. Typed and described
+// in compare.d.ts.
+
+export { pairLines } from './src/pairs.js'
+export { wordRanges } from './src/words.js'
+export { hidesMixedWhitespace } from './src/whitespace.js'
+export { renameParts } from './src/paths.js'
+export { layoutDir, rootLabel } from './src/root.js'