@preventive/compare 1.2.1 → 1.2.3

package/compare.d.ts

@@ -42,12 +42,15 @@ export type Status = 'added' | 'deleted' | 'modified' | 'renamed' | 'type-change
 // retained module load or `export {}` runs the same on both sides only within
 // one module format -- an `export {}` emits a marker transpiled to CommonJS, a
 // module load runs as one format and throws as the other -- so where the runtime
-// loads a module or carries a bare `export {}` a rename across formats (a `.d.mts`
-// to a `.d.cts`, either to a package-resolved `.d.ts` whose format is not known
-// here) is not stamped; a hashbang, a directive or a pragma runs the same either
+// loads a module, carries a bare `export {}`, or default-exports an identifier a
+// rename whose extensions fix different formats (a `.d.mts` to a `.d.cts`, or a
+// `.d.ts` to or from either) is not stamped, while a rename between two of the same
+// extension (two `.d.ts`, two `.d.mts`, two `.d.cts`) is; a hashbang, a directive or a pragma runs the same either
 // way, so a runtime of only those cancels across formats. A modification keeps its
-// path, hence its format, and an added or deleted file matches only an empty
-// runtime. A rename is otherwise taken by its matching
+// path, hence its format, and a deleted file matches only an empty runtime; an
+// added one an empty runtime or a single bare `export {}`, as nothing loaded it
+// before and what now does runs nothing of that alone, as a module or not. A
+// rename is otherwise taken by its matching
 // source, as any file's is here: a relative load may resolve to another module
 // once the file moves, but that is shown as a rename of its own, not traced. A
 // modification of a package-resolved `.d.ts` is taken to keep its format, though
@@ -107,7 +110,17 @@ 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%. git has no such pass, so false is git's own -M.
+// 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.
 //
 // `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
@@ -217,12 +230,15 @@ export type TypeOnlyReason = 'unsupported' | 'unparsed' | 'code' | 'disagree'
 //   function's signature, `import type` and `export type`, a namespace of types
 //   alone -- and those it leaves to run: a module load that binds from it
 //   (`import`, `export *`, `export { a } from` a module, `import { type A }` whose
-//   inline `type` loads it all the same) and a bare `export {}`. `export { type A }`
+//   inline `type` loads it all the same), a bare `export {}`, and `export default E`
+//   on a bare identifier (the idiom a declaration file's default export takes,
+//   `declare const _d: T; export default _d`). `export { type A }`
 //   is code, not a run statement: it is `export {}` only once stripping takes its
 //   specifiers out, not as the source has it; nor is `export as namespace N`, left
 //   as invalid JavaScript that throws when imported, nor a side-effect load that
 //   binds nothing -- a bare `import`, an empty `import {}`, `export {}` with a
-//   source -- which loads a module for no type;
+//   source -- which loads a module for no type, nor an `export default` of anything
+//   but a bare identifier (a value expression, an object, a class body);
 // - Node's stripTypeScriptTypes erases, to the character, what oxc finds erased
 //   and leaves nothing it does not, but comments, the hashbang and those;
 // - what it leaves, the run statements set aside, read token by token apart from
@@ -244,7 +260,7 @@ export type TypeOnlyReason = 'unsupported' | 'unparsed' | 'code' | 'disagree'
 // point. A triple-slash directive counts only in the prologue,
 // before the first statement, where TypeScript honours it; below one it is prose, so moving
 // it out of the prologue drops it from `runtime`, as removing it does. `loads` is whether any
-// run statement is a module load or a bare `export {}`: the runtime that runs as one module
+// run statement is a module load, a bare `export {}`, or an `export default` on an identifier: the runtime that runs as one module
 // format and throws, or emits a different marker, as the other -- a hashbang, directive or
 // pragma does not. A change is types only where both sides prove and leave the same `runtime`:
 // it then touches erased types and ordinary comments alone. Where `loads`, a rename across

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preventive/compare",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Git-compatible file tree diffs and minified JavaScript comparison",
   "type": "module",
   "main": "./compare.js",
@@ -48,6 +48,7 @@
     "pretty.js",
     "src/blocks.js",
     "src/changes.js",
+    "src/chunks.js",
     "src/css.js",
     "src/erasure.js",
     "src/error.js",

package/pretty.d.ts

@@ -1,7 +1,10 @@
 // `text` formatted by oxfmt as a file with `extension`, changing what is written
-// no more than layout needs (keys keep their quotes, no trailing commas or arrow
-// parentheses are added, template literals stay), the copy used only where checks
-// of oxfmt's output, apart from oxfmt, find it changes the layout alone:
+// no more than layout needs (keys keep their quotes, names their escapes, a comment
+// its place after an operator; no trailing commas or arrow parentheses are added,
+// template literals stay), but for an untyped script's (`js`, `mjs`, `cjs`, `jsx`)
+// `!0` and `!1`, as a minifier writes `true` and `false`, written so, as TypeScript
+// types them otherwise; the copy used only where checks of oxfmt's output, apart
+// from oxfmt, find it changes the layout alone:
 // - a script's (`js`, `mjs`, `cjs`, `jsx`, `ts`, `mts`, `cts`, `tsx`) syntax tree as
 //   oxc parses it, its comments and its text;
 // - a style sheet's (`css`) tree as css-tree, an optional peer, parses it, but for

package/src/changes.js

@@ -54,9 +54,13 @@ const DECLARATION = /\.d\.(?:[^./]+\.)?[cm]?ts$/u
 // a change across them is not types only.
 const fixedModule = (path) => (path.endsWith('.mts') ? 'module' : path.endsWith('.cts') ? 'commonjs' : null)
 
+// A runtime of a single bare `export {}`, any trailing `;`, as proveTypeOnly spells one: its blanks as the
+// source has them, a comment within it a single blank.
+const EXPORT_EMPTY = /^export\s*\{\s*\}\s*;?$/u
+
 // A file's proof: that it holds types alone but for its `runtime` -- a hashbang, the module loads and
 // `export {}` stripping leaves -- which a change must leave byte for byte untouched to be types only.
-// `loads` is whether that runtime holds a module load or `export {}`, the part that runs differently per
+// `loads` is whether that runtime holds a module load, `export {}`, or an `export default` on an identifier, the part that runs differently per
 // module format; a hashbang, a directive or a pragma does not, so a runtime of only those is format-free. A
 // side not there has none. Not proven where the proof throws, as no check should.
 function proven(file) {
@@ -71,28 +75,32 @@ function proven(file) {
 
 // Stamped where each side there is a declaration file proven to hold types alone and the two leave the
 // same runtime -- a change touching only erased types (and comments). A mode changing is a change of its
-// own. Where that runtime loads a module or carries a bare `export {}` it runs the same on both sides only
-// within one module format, so a rename across formats (a `.d.mts` to a `.d.cts`, either to a
-// package-resolved `.d.ts`) does not qualify; a hashbang, a directive or a pragma runs the same either way,
+// own. Where that runtime loads a module, carries a bare `export {}`, or default-exports an identifier it runs
+// the same on both sides only within one module format, so a rename cancels it only between two extensions
+// that fix the same format -- two `.d.ts` (both package-resolved), two `.d.mts`, or two `.d.cts`; a rename
+// whose extensions differ (a `.d.mts` to a `.d.cts`, or a `.d.ts` to or from either) does not qualify, since
+// an extension pins a format where a package-resolved `.d.ts` leaves it open. A hashbang, a directive or a pragma runs the same either way,
 // so a runtime of only those cancels across formats. A modification keeps its path, hence its format, and
-// an added or deleted file matches only an empty one.
+// a deleted file matches only an empty runtime; an added one an empty runtime or a single bare `export {}`
+// (EXPORT_EMPTY). Nothing loaded an added file before, so only what else the diff changes can, shown as a
+// change of its own, and that loading runs nothing of a bare `export {}` alone: it runs nothing as a module
+// and throws on it as CommonJS, whatever the extension. A module load beside it would run another module.
 // A rename is taken by its matching source, as any file's is here: a relative load in the runtime may
 // resolve to another module once the file moves, but that is the rename's doing, shown as a rename of its
-// own, not traced. Known limitation: a modification of a package-resolved `.d.ts` is taken to keep its
-// format, though the `package.json` that resolves it could change `type` between the two trees and flip it;
-// that flip is a change to `package.json`, seen in the diff on its own, and format is read from the
-// extension here, not resolved from a package.
+// own, not traced. Known limitation: a package-resolved `.d.ts` is taken to keep its format across a
+// modification (same path) and to share one across a rename to another `.d.ts`, since format is read from
+// the extension, not resolved from a package. The governing `package.json` could differ -- edited between
+// the two trees, or a different one at the rename's destination -- and flip the format; that flip rides the
+// `package.json` change or the move, each seen in the diff on its own, and is not traced here.
 
 function stamped(change) {
   const sides = [change.old, change.new].filter((file) => file !== null)
   if (!sides.every((file) => file.type === 'file' && DECLARATION.test(file.path))) return change
   if (change.old && change.new && change.old.mode !== change.new.mode) return change
   const fresh = proven(change.new), old = proven(change.old)
-  if (!old.proven || !fresh.proven || old.runtime !== fresh.runtime) return change
-  if (old.loads && change.old && change.new && change.old.path !== change.new.path) {
-    const format = fixedModule(change.old.path)
-    if (format === null || format !== fixedModule(change.new.path)) return change
-  }
+  if (!old.proven || !fresh.proven) return change
+  if (old.runtime !== fresh.runtime && !(change.old === null && EXPORT_EMPTY.test(fresh.runtime))) return change
+  if (old.loads && change.old && change.new && change.old.path !== change.new.path && fixedModule(change.old.path) !== fixedModule(change.new.path)) return change
   return { ...change, typeOnly: true }
 }
 

package/src/chunks.js

@@ -0,0 +1,51 @@
+// 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.
+
+// A content hash: six or more of base64url's characters, not all lowercase
+// letters, which a word is.
+const HASH = /^[\w-]{6,}$/u
+const RANDOM = /[\dA-Z]/u
+const SEPARATORS = '-._'
+
+function nameOf(path) {
+  const slash = path.lastIndexOf('/')
+  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}` }
+}
+
+// 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.
+function oneChunk(a, b) {
+  let start = 0
+  while (start < a.length && a[start] === b[start]) start++
+  while (start > 0 && !SEPARATORS.includes(a[start - 1])) start--
+  const x = a.slice(start), y = b.slice(start)
+  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) {
+  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 = []
+  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).stem, destNames.get(d).stem)) 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)
+  }
+}

package/src/erasure.js

@@ -72,7 +72,13 @@ export function strippedAs(statement) {
       // load; `export { a } from` a module re-exports a binding. A bare `export {}`, no source, is a marker.
       if (statement.source) return bindingless(statement) ? CODE : IMPORT
       return statement.specifiers.length === 0 ? INERT : CODE
-    case 'ExportDefaultDeclaration': return statement.declaration.type === 'TSInterfaceDeclaration' || statement.declaration.type === 'TSDeclareFunction' ? ERASED : CODE
+    case 'ExportDefaultDeclaration':
+      if (statement.declaration.type === 'TSInterfaceDeclaration' || statement.declaration.type === 'TSDeclareFunction') return ERASED
+      // `export default E`, a bare identifier, re-exports a binding by name: a run statement that runs as an
+      // ES module and throws as CommonJS, like `export {}`, so it is inert here, not code -- it is the idiom a
+      // declaration file's default export takes (`declare const _d: T; export default _d`). Any other default,
+      // a value expression or a class body among it, is code a declaration file has no reason to hold.
+      return statement.declaration.type === 'Identifier' ? INERT : CODE
     // `export as namespace N` is left verbatim, invalid as JavaScript, so importing the file throws.
     case 'TSNamespaceExportDeclaration': return CODE
     default: return erased(statement) ? ERASED : CODE

package/src/pretty.js

@@ -29,11 +29,11 @@ function numberSpelling(text) {
 
 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, numbers and a regular expression's flags, and a comma before
-// a closing bracket, past any comments (`import { a, b, }`).
+// 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, '')
   .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.
@@ -61,12 +61,25 @@ function chain(node, operator) {
   }
   return operands
 }
+// `!0` and `!1`, as a minifier writes `true` and `false`: the literal each reads as, which nothing binds
+// otherwise, so that either reads alike wherever it is; in a script without types alone, as TypeScript
+// types `!0` as `boolean` and `true` as `true`, and refuses `!0 as const`.
+const typed = (extension) => /^[cm]?tsx?$/u.test(extension)
+const BOOLEANS = new Map([['0', true], ['1', false]])
+const BOOLEAN_LITERALS = new Map([...BOOLEANS].map(([raw, value]) => [raw, { type: 'Literal', value }]))
+const booleanRaw = (node) => (node?.type === 'UnaryExpression' && node.operator === '!' && node.argument?.type === 'Literal'
+  && typeof node.argument.value === 'number' && BOOLEANS.has(node.argument.raw) ? node.argument.raw : null)
+const literal = (node) => BOOLEAN_LITERALS.get(booleanRaw(node)) ?? node
 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) {
+function sameTree(a, b, booleans) {
   const work = [[a, b]]
   while (work.length > 0) {
-    const [x, y] = work.pop()
+    let [x, y] = work.pop()
+    if (booleans) {
+      x = literal(x)
+      y = literal(y)
+    }
     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
@@ -84,42 +97,145 @@ function sameTree(a, b) {
   return true
 }
 
-// A script's types as the formatter writes them: a member's separator `;` where it was `,`
-// (`{ a: string, b: number }`), and no `|` or `&` before a union's or an intersection's first type
-// (`type P =\n  | A\n  | B`, `[K in\n  | A\n  | B]`). oxc reads a member with the separator ending it
-// and a union from the mark leading it, so each is taken where it is, in whatever context.
-function typed(text, program) {
-  const edits = [], work = [program]
+// Each node of a syntax tree given to `each`.
+function visit(program, each) {
+  const work = [program]
   while (work.length > 0) {
     const node = work.pop()
     // Pushed one by one: a spread of a file's statements could pass more arguments than a call takes.
     if (Array.isArray(node)) for (const item of node) work.push(item)
     else if (node !== null && typeof node === 'object') {
-      const members = node.type === 'TSTypeLiteral' ? node.members : node.type === 'TSInterfaceBody' ? node.body : []
-      for (const member of members) if (text[member.end - 1] === ',') edits.push([member.end - 1, ';'])
-      const mark = node.type === 'TSUnionType' ? '|' : node.type === 'TSIntersectionType' ? '&' : null
-      if (mark && text[node.start] === mark && node.types[0]?.start > node.start) edits.push([node.start, ''])
+      each(node)
       for (const key of Object.keys(node)) if (!POSITION.has(key) && typeof node[key] === 'object') work.push(node[key])
     }
   }
+}
+
+// `text` with each of `edits`, `[from, to, put]`, none overlapping another.
+function edited(text, edits) {
   let from = 0, out = ''
-  for (const [at, put] of edits.toSorted(([x], [y]) => x - y)) {
-    out += text.slice(from, at) + put
-    from = at + 1
+  for (const [start, end, put] of edits.toSorted(([x], [y]) => x - y)) {
+    out += text.slice(from, start) + put
+    from = end
   }
   return out + text.slice(from)
 }
 
+// A script as the formatter may write it, read off its syntax tree: each regular expression's flags
+// sorted (`/x/yu` as `/x/uy`), `!0` and `!1` as `true` and `false` where it reads `booleans` so, and
+// where it has `types`, a member's separator `;` where it was `,` (`{ a: string, b: number }`), and
+// no `|` or `&` before a union's or an intersection's first type (`type P =\n  | A\n  | B`,
+// `[K in\n  | A\n  | B]`). oxc reads a member with the separator ending it and a union from the mark
+// leading it, so each is taken where it is, in whatever context.
+function respelled(text, program, types, booleans) {
+  const edits = []
+  visit(program, (node) => {
+    if (node.regex) edits.push([node.end - node.regex.flags.length, node.end, sorted(node.regex.flags)])
+    const raw = booleans ? booleanRaw(node) : null
+    if (raw !== null) edits.push([node.start, node.end, String(BOOLEANS.get(raw))])
+    if (!types) return
+    const members = node.type === 'TSTypeLiteral' ? node.members : node.type === 'TSInterfaceBody' ? node.body : []
+    for (const member of members) if (text[member.end - 1] === ',') edits.push([member.end - 1, member.end, ';'])
+    const mark = node.type === 'TSUnionType' ? '|' : node.type === 'TSIntersectionType' ? '&' : null
+    if (mark && text[node.start] === mark && node.types[0]?.start > node.start) edits.push([node.start, node.start + 1, ''])
+  })
+  return edited(text, edits)
+}
+
 // 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) {
+// for tests alone, not by the package. CSS is read by `csstree` where given; a
+// script's text by `tree`, its syntax tree as parsed, where given.
+export function sameCode(text, formatted, extension = 'js', csstree = null, tree = parsed(text, extension)) {
   if (extension === 'css') return csstree !== null && sameCss(csstree, text, formatted)
   if (extension === 'json') return sameList(jsonForm(text), jsonForm(formatted))
   if (!SCRIPTS.has(extension)) return false
-  const [before, after] = [parsed(text, extension), parsed(formatted, extension)]
+  const [before, after] = [tree, parsed(formatted, extension)]
   if (before === null || after === null) return false
-  const form = (code, { program }) => scriptForm(/^[cm]?tsx?$/u.test(extension) ? typed(code, program) : code)
-  return form(text, before) === form(formatted, after) && sameList(comments(before), comments(after)) && sameTree(before.program, after.program)
+  // `!0` and `!1` read as `true` and `false` only where the text writes one so: format() writes them so
+  // nowhere else, so a copy of any other has none.
+  const types = typed(extension)
+  const booleans = !types && /![01]/u.test(text)
+  const form = (code, { program }) => scriptForm(respelled(code, program, types, booleans))
+  return form(text, before) === form(formatted, after) && sameList(comments(before), comments(after)) && sameTree(before.program, after.program, booleans)
+}
+
+// A name as written from where it starts, escapes and all.
+const NAME = /(?:\\u\{[\dA-Fa-f]+\}|\\u[\dA-Fa-f]{4}|[$\p{ID_Continue}\u{200C}\u{200D}])+/uy
+// What oxfmt may write after a block comment the file has after it: an operator, `,`, `?` or `:`.
+const MOVED = /[\t ]*([!%&*+,\-/:<=>?^|~]+|in(?:stanceof)?(?![$\p{ID_Continue}]))/uy
+const MARK = /[!%&*+,\-/:<=>?^|~]/u
+const NAME_PART = /[$\p{ID_Continue}]/u
+
+// Each name of a syntax tree, `[where it starts, what it reads, as written]`, in order: a shorthand
+// property's key and value, one name, once.
+function names(text, program) {
+  const found = new Map()
+  visit(program, (node) => {
+    if (node.type !== 'Identifier' && node.type !== 'PrivateIdentifier') return
+    const at = node.type === 'Identifier' ? node.start : node.start + 1
+    NAME.lastIndex = at
+    found.set(at, [at, node.name, NAME.exec(text)?.[0] ?? ''])
+  })
+  return [...found.values()].toSorted(([x], [y]) => x - y)
+}
+
+// Where the blanks on its line before `at` start.
+function blanksFrom(text, at) {
+  let from = at
+  while (from > 0 && (text[from - 1] === ' ' || text[from - 1] === '\t')) from--
+  return from
+}
+
+// The copy as the file writes what oxfmt writes otherwise, where that changes no more than its layout,
+// before it is checked as any copy is:
+// - a name's escapes, which oxfmt reads (`\u{61}` as `a`): a copy shows no character the file only
+//   escapes, one unseen, a joiner in a name say, or one like another;
+// - a block comment after an operator, a `,`, `?` or `:`, which oxfmt moves before it where the comment
+//   ends its line (`a &&/* c */\nb` as `a /* c */ && b`): where a comment is may matter to what reads
+//   it, a bundler a `#__PURE__` mark say, and a reader sees it where the file has it.
+// Names and comments are paired in order, as the check finds them alike or refuses the copy.
+function asWritten(text, code, extension, tree) {
+  if (!SCRIPTS.has(extension) || !/\\u|\/\*/u.test(text)) return code
+  const [before, after] = [tree, parsed(code, extension)]
+  if (before === null || after === null) return code
+  const edits = []
+  const [olds, news] = [names(text, before.program), names(code, after.program)]
+  if (olds.length === news.length) {
+    olds.forEach(([, name, written], i) => {
+      const [at, read, spelled] = news[i]
+      if (written !== spelled && written.includes('\\') && name === read) edits.push([at, at + spelled.length, written])
+    })
+  }
+  const [was, now] = [before.comments, after.comments]
+  for (let i = 0; was.length === now.length && i < now.length; i++) {
+    // A run of comments on one line moves as one.
+    const first = i
+    while (i + 1 < now.length && /^[\t ]*$/u.test(code.slice(now[i].end, now[i + 1].start))) i++
+    MOVED.lastIndex = now[i].end
+    const from = blanksFrom(code, now[first].start), moved = MOVED.exec(code)
+    if (moved === null || from === 0 || code[from - 1] === '\n') continue
+    const [, mark] = moved
+    // One the copy has before the comment too stayed, the one after another (`a + /* c */ +b`).
+    if (code.startsWith(mark, from - mark.length)) continue
+    const at = blanksFrom(text, was[first].start) - mark.length
+    if (at >= 0 && text.startsWith(mark, at) && !(mark.startsWith('i') ? NAME_PART : MARK).test(text[at - 1] ?? '')) {
+      edits.push([from, now[first].start, `${mark === ',' ? '' : ' '}${mark} `], [now[i].end, now[i].end + moved[0].length, ''])
+    }
+  }
+  return edited(code, edits)
+}
+
+// A script's `!0` and `!1` written as `true` and `false`, where it writes them so, as they read, from its
+// syntax tree as parsed (`tree`): set apart from a word it follows, as a minifier writes `return!0`.
+function withBooleans(text, tree) {
+  if (tree === null || !/![01]/u.test(text)) return text
+  const edits = []
+  visit(tree.program, (node) => {
+    const raw = booleanRaw(node)
+    if (raw === null || text.slice(node.start, node.end) !== `!${raw}`) return
+    edits.push([node.start, node.end, `${NAME_PART.test(text[node.start - 1] ?? '') ? ' ' : ''}${BOOLEANS.get(raw)}`])
+  })
+  return edited(text, edits)
 }
 
 // A script's block comments over more than one line, a license's say, each end their line: what oxfmt
@@ -149,12 +265,22 @@ 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)
+  // A script's syntax tree, read once for its copy's check: its `!0` and `!1` written as `true` and
+  // `false` before oxfmt formats it, where it has no types. A check that fails in itself, its stack say, refuses the copy as
+  // one that finds it changed would.
+  let tree
+  try {
+    tree = SCRIPTS.has(extension) ? parsed(text, extension) : null
+  } catch {
+    return { error: 'pretty-mismatch' }
+  }
+  const result = await oxfmt(`pretty.${extension}`, withBooleans(text, typed(extension) ? null : tree), 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.
+  // oxfmt's copy as it is, or where the check refuses it, as the file writes what oxfmt respelled: a
+  // copy the check takes respelled nothing so, as its text would differ.
+  const checked = (code) => (sameCode(text, code, extension, csstree, tree) ? { code } : null)
   try {
-    const code = breakAfterComments(result.code, extension)
-    return sameCode(text, code, extension, csstree) ? { code } : { error: 'pretty-mismatch' }
+    return checked(breakAfterComments(result.code, extension)) ?? checked(breakAfterComments(asWritten(text, result.code, extension, tree), extension)) ?? { error: 'pretty-mismatch' }
   } catch {
     return { error: 'pretty-mismatch' }
   }

package/src/renames.js

@@ -1,9 +1,11 @@
 // 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.
+// pair left scored; between the first two and after the last, ours, renames
+// told by path, and bundle chunks (chunks.js).
 
 import { crc32 } from '@exodus/bytes/crc.js'
-import { MAX_SCORE, similarity, spanCounts } from './similarity.js'
+import { chunkRenames } from './chunks.js'
+import { MAX_SCORE, PUNCTUATION, similarity, spanCounts } from './similarity.js'
 import { bytesOf, sameContent } from './tree.js'
 
 // git's limits: identical files weighed per destination, scores kept per one.
@@ -175,16 +177,21 @@ const unpaired = ({ sources, dests, pairs, used }) => ({
   open: dests.keys().filter((d) => !pairs.has(d)).toArray(),
 })
 
+// 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.
+const stricter = (minimum) => minimum + Math.trunc(0.5 * (MAX_SCORE - minimum))
+
 // 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.
+// more than `limit` squared pairs left skips the scoring, chunks' too.
 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()
+  // A file's bytes, its text encoded once, and their span counts once each way.
+  const counted = new Map(), encoded = new Map(), punctuated = 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 punctuatedCounts = (data) => punctuated.get(data) ?? punctuated.set(data, spanCounts(data, PUNCTUATION)).get(data)
   const context = {
     sources, dests, pairs, used,
     sourceNames: sources.map((file) => basename(file.path)),
@@ -195,12 +202,15 @@ export function findRenames(sources, dests, { minimum, limit, byPath }) {
     },
     bytes,
     scoreOf: (s, d, least) => similarity(bytes(sources[s]), bytes(dests[d]), least, counts),
+    punctuatedScoreOf: (s, d, least) => similarity(bytes(sources[s]), bytes(dests[d]), least, punctuatedCounts, true),
   }
   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)))
+  basenameRenames(context, unpaired(context), stricter(minimum))
   const left = unpaired(context)
-  if (left.remaining.length * left.open.length <= limit * limit) scoredRenames(context, left, minimum)
+  if (left.remaining.length * left.open.length > limit * limit) return pairs
+  scoredRenames(context, left, minimum)
+  if (byPath) chunkRenames(context, unpaired(context), stricter(minimum))
   return pairs
 }

package/src/similarity.js

@@ -12,9 +12,15 @@ 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) {
+// The bytes a span ends after: git's LF, and for code minified onto a line or
+// a few (chunks.js), punctuation too, so that an edit shifts no span past it.
+const endingAfter = (chars) => Uint8Array.from({ length: 256 }, (_, c) => Number(c === 0x0A || chars.includes(String.fromCodePoint(c))))
+export const LINES = endingAfter('')
+export const PUNCTUATION = endingAfter(',;={}')
+
+// Bytes per span hash, a span ending after a byte `ends` has or 64 bytes;
+// sorted by hash, as git keeps them, so two files compare in one walk down both.
+export function spanCounts(data, ends = LINES) {
   const text = !looksBinary(data)
   const counts = new Map()
   const add = (hash, n) => counts.set(hash, (counts.get(hash) ?? 0) + n)
@@ -25,7 +31,7 @@ export function spanCounts(data) {
     const old1 = accum1
     accum1 = (((accum1 << 7) ^ (accum2 >>> 25)) + c) >>> 0
     accum2 = ((accum2 << 7) ^ (old1 >>> 25)) >>> 0
-    if (++n < 64 && c !== 0x0A) continue
+    if (++n < 64 && ends[c] === 0) continue
     add(spanHash(accum1, accum2), n)
     n = 0
     accum1 = 0
@@ -33,21 +39,46 @@ export function spanCounts(data) {
   }
   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)) }
+  return { hashes, bytes: Float64Array.from(hashes, (hash) => counts.get(hash)), total: counts.values().reduce((sum, bytes) => sum + bytes, 0) }
 }
 
-// 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)
+// Bytes of spans both have: git's walk down both.
+function copiedBytes(a, b) {
   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 copied
+}
+
+// The same, or 0 once the spans left could no longer bring it to `least`: a
+// score times the larger file's size, as the bytes copied times MAX_SCORE are.
+function copiedReaching(a, b, least) {
+  let copied = 0, restA = a.total, restB = b.total
+  for (let i = 0, j = 0; i < a.hashes.length && j < b.hashes.length;) {
+    if (a.hashes[i] < b.hashes[j]) restA -= a.bytes[i++]
+    else if (a.hashes[i] > b.hashes[j]) restB -= b.bytes[j++]
+    else {
+      copied += Math.min(a.bytes[i], b.bytes[j])
+      restA -= a.bytes[i++]
+      restB -= b.bytes[j++]
+    }
+    if ((copied + Math.min(restA, restB)) * MAX_SCORE < least) return 0
+  }
+  return copied
+}
+
+// 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. `early`, spans that can no longer reach `minimum` score 0 unwalked: not
+// for git's passes, whose candidates below it break ties by their scores.
+export function similarity(src, dst, minimum, counts, early = false) {
+  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)
+  const copied = early ? copiedReaching(a, b, minimum * max) : copiedBytes(a, b)
   return Math.trunc(copied * MAX_SCORE / max)
 }

package/src/types.node.js

@@ -194,9 +194,9 @@ export function proveWith(text, stripTypeScriptTypes) {
   // type specifier or a comment within it does not count; the hashbang, a directive and a pragma stand
   // verbatim, since what they say is the point. A triple-slash directive counts only in the prologue, before
   // the first statement, where TypeScript honours it; a comment blanked within an erased statement reads as
-  // blanks here, so only a kept one steers. `loads` is whether any run statement is a module load or
-  // `export {}`, the runtime that runs differently per module format -- a hashbang, directive or pragma does
-  // not.
+  // blanks here, so only a kept one steers. `loads` is whether any run statement is a module load, a bare
+  // `export {}`, or an `export default` on an identifier, the runtime that runs differently per module format
+  // -- a hashbang, directive or pragma does not.
   const prologue = tree.program.body.length > 0 ? tree.program.body[0].start : stripped.code.length
   const hashbang = tree.program.hashbang ? [tree.program.hashbang] : []
   const steering = tree.comments.filter(({ start, end }) => steers(stripped.code.slice(start, end), start < prologue))