@scanmate/ocr 0.0.2

package/dist/index.esm.js

@@ -0,0 +1,947 @@
+import { distance } from 'fastest-levenshtein';
+import { isRaster, encodeImage, resampleRaster, createRaster } from '@scanmate/ink';
+import { mkdir, copyFile, stat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { createWorker, OEM } from 'tesseract.js';
+
+/**
+ * Characters and pairs OCR mistakes for one another, folded to one form each.
+ *
+ * Off by default, and deliberately so: `0` for `o` and `5` for `s` are OCR's
+ * commonest errors, and the very substitutions someone altering an amount or a
+ * reference would make. Folding them raises a score by hiding exactly what a
+ * check is for. Use it to compare prose, never figures.
+ *
+ * Applied after case folding, to lower-case text.
+ */
+const PAIRS = [[/rn/gu, 'm'], [/cl/gu, 'd'], [/vv/gu, 'w']];
+const SINGLES = new Map([['0', 'o'], ['1', 'l'], ['i', 'l'], ['|', 'l'], ['!', 'l'], ['5', 's'], ['8', 'b'], ['6', 'b'], ['2', 'z']]);
+function foldConfusables(text) {
+  let out = text;
+  for (const [pattern, replacement] of PAIRS) out = out.replaceAll(pattern, () => replacement);
+  let folded = '';
+  for (const character of out) folded += SINGLES.get(character) ?? character;
+  return folded;
+}
+
+/**
+ * Letters with diacritics, ligatures and look-alike forms, folded to plain
+ * Latin: `é` to `e`, `Æ` to `AE`, a circled or full-width `Ａ` to `A`.
+ *
+ * OCR drops and invents accents - a scanned `é` reads as `e` or `è` as the
+ * print allows - so text is compared with them folded away. Some bases are two
+ * letters, so folding can lengthen a string. The table is the project's own
+ * diacritics map (86 bases, 874 letters), kept as escapes so every code point
+ * is visible in review; it is expanded into a lookup once, on first use.
+ */
+/** [base, letters that fold to it] */
+const TABLE = [['A', '\u{41}\u{24B6}\u{FF21}\u{C0}\u{C1}\u{C2}\u{1EA6}\u{1EA4}\u{1EAA}\u{1EA8}\u{C3}\u{100}\u{102}\u{1EB0}\u{1EAE}\u{1EB4}\u{1EB2}\u{226}\u{1E0}\u{C4}\u{1DE}\u{1EA2}\u{C5}\u{1FA}\u{1CD}\u{200}\u{202}\u{1EA0}\u{1EAC}\u{1EB6}\u{1E00}\u{104}\u{23A}\u{2C6F}'], ['AA', '\u{A732}'], ['AE', '\u{C6}\u{1FC}\u{1E2}'], ['AO', '\u{A734}'], ['AU', '\u{A736}'], ['AV', '\u{A738}\u{A73A}'], ['AY', '\u{A73C}'], ['B', '\u{42}\u{24B7}\u{FF22}\u{1E02}\u{1E04}\u{1E06}\u{243}\u{182}\u{181}'], ['C', '\u{43}\u{24B8}\u{FF23}\u{106}\u{108}\u{10A}\u{10C}\u{C7}\u{1E08}\u{187}\u{23B}\u{A73E}'], ['D', '\u{44}\u{24B9}\u{FF24}\u{1E0A}\u{10E}\u{1E0C}\u{1E10}\u{1E12}\u{1E0E}\u{110}\u{18B}\u{18A}\u{189}\u{A779}'], ['DZ', '\u{1F1}\u{1C4}'], ['Dz', '\u{1F2}\u{1C5}'], ['E', '\u{45}\u{24BA}\u{FF25}\u{C8}\u{C9}\u{CA}\u{1EC0}\u{1EBE}\u{1EC4}\u{1EC2}\u{1EBC}\u{112}\u{1E14}\u{1E16}\u{114}\u{116}\u{CB}\u{1EBA}\u{11A}\u{204}\u{206}\u{1EB8}\u{1EC6}\u{228}\u{1E1C}\u{118}\u{1E18}\u{1E1A}\u{190}\u{18E}'], ['F', '\u{46}\u{24BB}\u{FF26}\u{1E1E}\u{191}\u{A77B}'], ['G', '\u{47}\u{24BC}\u{FF27}\u{1F4}\u{11C}\u{1E20}\u{11E}\u{120}\u{1E6}\u{122}\u{1E4}\u{193}\u{A7A0}\u{A77D}\u{A77E}'], ['H', '\u{48}\u{24BD}\u{FF28}\u{124}\u{1E22}\u{1E26}\u{21E}\u{1E24}\u{1E28}\u{1E2A}\u{126}\u{2C67}\u{2C75}\u{A78D}'], ['I', '\u{49}\u{24BE}\u{FF29}\u{CC}\u{CD}\u{CE}\u{128}\u{12A}\u{12C}\u{130}\u{CF}\u{1E2E}\u{1EC8}\u{1CF}\u{208}\u{20A}\u{1ECA}\u{12E}\u{1E2C}\u{197}'], ['J', '\u{4A}\u{24BF}\u{FF2A}\u{134}\u{248}'], ['K', '\u{4B}\u{24C0}\u{FF2B}\u{1E30}\u{1E8}\u{1E32}\u{136}\u{1E34}\u{198}\u{2C69}\u{A740}\u{A742}\u{A744}\u{A7A2}'], ['L', '\u{4C}\u{24C1}\u{FF2C}\u{13F}\u{139}\u{13D}\u{1E36}\u{1E38}\u{13B}\u{1E3C}\u{1E3A}\u{141}\u{23D}\u{2C62}\u{2C60}\u{A748}\u{A746}\u{A780}'], ['LJ', '\u{1C7}'], ['Lj', '\u{1C8}'], ['M', '\u{4D}\u{24C2}\u{FF2D}\u{1E3E}\u{1E40}\u{1E42}\u{2C6E}\u{19C}'], ['N', '\u{4E}\u{24C3}\u{FF2E}\u{1F8}\u{143}\u{D1}\u{1E44}\u{147}\u{1E46}\u{145}\u{1E4A}\u{1E48}\u{220}\u{19D}\u{A790}\u{A7A4}'], ['NJ', '\u{1CA}'], ['Nj', '\u{1CB}'], ['O', '\u{4F}\u{24C4}\u{FF2F}\u{D2}\u{D3}\u{D4}\u{1ED2}\u{1ED0}\u{1ED6}\u{1ED4}\u{D5}\u{1E4C}\u{22C}\u{1E4E}\u{14C}\u{1E50}\u{1E52}\u{14E}\u{22E}\u{230}\u{D6}\u{22A}\u{1ECE}\u{150}\u{1D1}\u{20C}\u{20E}\u{1A0}\u{1EDC}\u{1EDA}\u{1EE0}\u{1EDE}\u{1EE2}\u{1ECC}\u{1ED8}\u{1EA}\u{1EC}\u{D8}\u{1FE}\u{186}\u{19F}\u{A74A}\u{A74C}'], ['OI', '\u{1A2}'], ['OO', '\u{A74E}'], ['OU', '\u{222}'], ['OE', '\u{8C}\u{152}'], ['oe', '\u{9C}\u{153}'], ['P', '\u{50}\u{24C5}\u{FF30}\u{1E54}\u{1E56}\u{1A4}\u{2C63}\u{A750}\u{A752}\u{A754}'], ['Q', '\u{51}\u{24C6}\u{FF31}\u{A756}\u{A758}\u{24A}'], ['R', '\u{52}\u{24C7}\u{FF32}\u{154}\u{1E58}\u{158}\u{210}\u{212}\u{1E5A}\u{1E5C}\u{156}\u{1E5E}\u{24C}\u{2C64}\u{A75A}\u{A7A6}\u{A782}'], ['S', '\u{53}\u{24C8}\u{FF33}\u{1E9E}\u{15A}\u{1E64}\u{15C}\u{1E60}\u{160}\u{1E66}\u{1E62}\u{1E68}\u{218}\u{15E}\u{2C7E}\u{A7A8}\u{A784}'], ['T', '\u{54}\u{24C9}\u{FF34}\u{1E6A}\u{164}\u{1E6C}\u{21A}\u{162}\u{1E70}\u{1E6E}\u{166}\u{1AC}\u{1AE}\u{23E}\u{A786}'], ['TZ', '\u{A728}'], ['U', '\u{55}\u{24CA}\u{FF35}\u{D9}\u{DA}\u{DB}\u{168}\u{1E78}\u{16A}\u{1E7A}\u{16C}\u{DC}\u{1DB}\u{1D7}\u{1D5}\u{1D9}\u{1EE6}\u{16E}\u{170}\u{1D3}\u{214}\u{216}\u{1AF}\u{1EEA}\u{1EE8}\u{1EEE}\u{1EEC}\u{1EF0}\u{1EE4}\u{1E72}\u{172}\u{1E76}\u{1E74}\u{244}'], ['V', '\u{56}\u{24CB}\u{FF36}\u{1E7C}\u{1E7E}\u{1B2}\u{A75E}\u{245}'], ['VY', '\u{A760}'], ['W', '\u{57}\u{24CC}\u{FF37}\u{1E80}\u{1E82}\u{174}\u{1E86}\u{1E84}\u{1E88}\u{2C72}'], ['X', '\u{58}\u{24CD}\u{FF38}\u{1E8A}\u{1E8C}'], ['Y', '\u{59}\u{24CE}\u{FF39}\u{1EF2}\u{DD}\u{176}\u{1EF8}\u{232}\u{1E8E}\u{178}\u{1EF6}\u{1EF4}\u{1B3}\u{24E}\u{1EFE}'], ['Z', '\u{5A}\u{24CF}\u{FF3A}\u{179}\u{1E90}\u{17B}\u{17D}\u{1E92}\u{1E94}\u{1B5}\u{224}\u{2C7F}\u{2C6B}\u{A762}'], ['a', '\u{61}\u{24D0}\u{FF41}\u{1E9A}\u{E0}\u{E1}\u{E2}\u{1EA7}\u{1EA5}\u{1EAB}\u{1EA9}\u{E3}\u{101}\u{103}\u{1EB1}\u{1EAF}\u{1EB5}\u{1EB3}\u{227}\u{1E1}\u{E4}\u{1DF}\u{1EA3}\u{E5}\u{1FB}\u{1CE}\u{201}\u{203}\u{1EA1}\u{1EAD}\u{1EB7}\u{1E01}\u{105}\u{2C65}\u{250}'], ['aa', '\u{A733}'], ['ae', '\u{E6}\u{1FD}\u{1E3}'], ['ao', '\u{A735}'], ['au', '\u{A737}'], ['av', '\u{A739}\u{A73B}'], ['ay', '\u{A73D}'], ['b', '\u{62}\u{24D1}\u{FF42}\u{1E03}\u{1E05}\u{1E07}\u{180}\u{183}\u{253}'], ['c', '\u{63}\u{24D2}\u{FF43}\u{107}\u{109}\u{10B}\u{10D}\u{E7}\u{1E09}\u{188}\u{23C}\u{A73F}\u{2184}'], ['d', '\u{64}\u{24D3}\u{FF44}\u{1E0B}\u{10F}\u{1E0D}\u{1E11}\u{1E13}\u{1E0F}\u{111}\u{18C}\u{256}\u{257}\u{A77A}'], ['dz', '\u{1F3}\u{1C6}'], ['e', '\u{65}\u{24D4}\u{FF45}\u{E8}\u{E9}\u{EA}\u{1EC1}\u{1EBF}\u{1EC5}\u{1EC3}\u{1EBD}\u{113}\u{1E15}\u{1E17}\u{115}\u{117}\u{EB}\u{1EBB}\u{11B}\u{205}\u{207}\u{1EB9}\u{1EC7}\u{229}\u{1E1D}\u{119}\u{1E19}\u{1E1B}\u{247}\u{25B}\u{1DD}'], ['f', '\u{66}\u{24D5}\u{FF46}\u{1E1F}\u{192}\u{A77C}'], ['g', '\u{67}\u{24D6}\u{FF47}\u{1F5}\u{11D}\u{1E21}\u{11F}\u{121}\u{1E7}\u{123}\u{1E5}\u{260}\u{A7A1}\u{1D79}\u{A77F}'], ['h', '\u{68}\u{24D7}\u{FF48}\u{125}\u{1E23}\u{1E27}\u{21F}\u{1E25}\u{1E29}\u{1E2B}\u{1E96}\u{127}\u{2C68}\u{2C76}\u{265}'], ['hv', '\u{195}'], ['i', '\u{69}\u{24D8}\u{FF49}\u{EC}\u{ED}\u{EE}\u{129}\u{12B}\u{12D}\u{EF}\u{1E2F}\u{1EC9}\u{1D0}\u{209}\u{20B}\u{1ECB}\u{12F}\u{1E2D}\u{268}\u{131}'], ['j', '\u{6A}\u{24D9}\u{FF4A}\u{135}\u{1F0}\u{249}'], ['k', '\u{6B}\u{24DA}\u{FF4B}\u{1E31}\u{1E9}\u{1E33}\u{137}\u{1E35}\u{199}\u{2C6A}\u{A741}\u{A743}\u{A745}\u{A7A3}'], ['l', '\u{6C}\u{24DB}\u{FF4C}\u{140}\u{13A}\u{13E}\u{1E37}\u{1E39}\u{13C}\u{1E3D}\u{1E3B}\u{17F}\u{142}\u{19A}\u{26B}\u{2C61}\u{A749}\u{A781}\u{A747}'], ['lj', '\u{1C9}'], ['m', '\u{6D}\u{24DC}\u{FF4D}\u{1E3F}\u{1E41}\u{1E43}\u{271}\u{26F}'], ['n', '\u{6E}\u{24DD}\u{FF4E}\u{1F9}\u{144}\u{F1}\u{1E45}\u{148}\u{1E47}\u{146}\u{1E4B}\u{1E49}\u{19E}\u{272}\u{149}\u{A791}\u{A7A5}'], ['nj', '\u{1CC}'], ['o', '\u{6F}\u{24DE}\u{FF4F}\u{F2}\u{F3}\u{F4}\u{1ED3}\u{1ED1}\u{1ED7}\u{1ED5}\u{F5}\u{1E4D}\u{22D}\u{1E4F}\u{14D}\u{1E51}\u{1E53}\u{14F}\u{22F}\u{231}\u{F6}\u{22B}\u{1ECF}\u{151}\u{1D2}\u{20D}\u{20F}\u{1A1}\u{1EDD}\u{1EDB}\u{1EE1}\u{1EDF}\u{1EE3}\u{1ECD}\u{1ED9}\u{1EB}\u{1ED}\u{F8}\u{1FF}\u{254}\u{A74B}\u{A74D}\u{275}'], ['oi', '\u{1A3}'], ['ou', '\u{223}'], ['oo', '\u{A74F}'], ['p', '\u{70}\u{24DF}\u{FF50}\u{1E55}\u{1E57}\u{1A5}\u{1D7D}\u{A751}\u{A753}\u{A755}'], ['q', '\u{71}\u{24E0}\u{FF51}\u{24B}\u{A757}\u{A759}'], ['r', '\u{72}\u{24E1}\u{FF52}\u{155}\u{1E59}\u{159}\u{211}\u{213}\u{1E5B}\u{1E5D}\u{157}\u{1E5F}\u{24D}\u{27D}\u{A75B}\u{A7A7}\u{A783}'], ['s', '\u{73}\u{24E2}\u{FF53}\u{DF}\u{15B}\u{1E65}\u{15D}\u{1E61}\u{161}\u{1E67}\u{1E63}\u{1E69}\u{219}\u{15F}\u{23F}\u{A7A9}\u{A785}\u{1E9B}'], ['t', '\u{74}\u{24E3}\u{FF54}\u{1E6B}\u{1E97}\u{165}\u{1E6D}\u{21B}\u{163}\u{1E71}\u{1E6F}\u{167}\u{1AD}\u{288}\u{2C66}\u{A787}'], ['tz', '\u{A729}'], ['u', '\u{75}\u{24E4}\u{FF55}\u{F9}\u{FA}\u{FB}\u{169}\u{1E79}\u{16B}\u{1E7B}\u{16D}\u{FC}\u{1DC}\u{1D8}\u{1D6}\u{1DA}\u{1EE7}\u{16F}\u{171}\u{1D4}\u{215}\u{217}\u{1B0}\u{1EEB}\u{1EE9}\u{1EEF}\u{1EED}\u{1EF1}\u{1EE5}\u{1E73}\u{173}\u{1E77}\u{1E75}\u{289}'], ['v', '\u{76}\u{24E5}\u{FF56}\u{1E7D}\u{1E7F}\u{28B}\u{A75F}\u{28C}'], ['vy', '\u{A761}'], ['w', '\u{77}\u{24E6}\u{FF57}\u{1E81}\u{1E83}\u{175}\u{1E87}\u{1E85}\u{1E98}\u{1E89}\u{2C73}'], ['x', '\u{78}\u{24E7}\u{FF58}\u{1E8B}\u{1E8D}'], ['y', '\u{79}\u{24E8}\u{FF59}\u{1EF3}\u{FD}\u{177}\u{1EF9}\u{233}\u{1E8F}\u{FF}\u{1EF7}\u{1E99}\u{1EF5}\u{1B4}\u{24F}\u{1EFF}'], ['z', '\u{7A}\u{24E9}\u{FF5A}\u{17A}\u{1E91}\u{17C}\u{17E}\u{1E93}\u{1E95}\u{1B6}\u{225}\u{240}\u{2C6C}\u{A763}']];
+let lookup;
+/** Every folded letter and what it folds to. */
+function diacriticsMap() {
+  if (lookup !== undefined) return lookup;
+  lookup = new Map();
+  for (const [base, letters] of TABLE) for (const letter of letters) if (letter !== base) lookup.set(letter, base);
+  return lookup;
+}
+/** Replace every letter in the table by its plain base; everything else is kept as it is. */
+function foldDiacritics(text) {
+  const map = diacriticsMap();
+  let out = '';
+  for (const character of text) out += map.get(character) ?? character;
+  return out;
+}
+
+const DEFAULT_NORMALISE = {
+  nfkc: true,
+  typography: true,
+  dehyphenate: true,
+  diacritics: true,
+  caseFold: true,
+  dropNoise: true,
+  stripPunctuation: false,
+  confusables: false
+};
+const LINE_END_HYPHEN = /(\p{L})[-\u{AD}\u{2010}\u{2011}][\t ]*\r?\n[\t ]*(?=\p{Ll})/gu;
+const TYPOGRAPHY = [
+// single quotes and prime, double quotes and double prime
+[/[\u{2018}\u{2019}\u{201A}\u{201B}\u{2032}]/gu, '\''], [/[\u{201C}\u{201D}\u{201E}\u{201F}\u{2033}]/gu, '"'],
+// hyphens, figure dash, en and em dashes, horizontal bar, minus
+[/[\u{2010}\u{2011}\u{2012}\u{2013}\u{2014}\u{2015}\u{2212}]/gu, '-'], [/\u{2026}/gu, '...'],
+// no-break and typographic spaces
+[/[\u{A0}\u{2000}-\u{200A}\u{202F}\u{205F}\u{3000}]/gu, ' '],
+// zero-width space and non-joiner, word joiner, byte-order mark
+[/[\u{200B}\u{200C}\u{2060}\u{FEFF}]/gu, ''],
+// zero-width joiner, on its own: in a character class it reads as joining its neighbours
+[/\u{200D}/gu, '']];
+const MEANINGFUL = /[\p{L}\p{N}\p{Sc}]/u;
+const PUNCTUATION = /\p{P}+/gu;
+const WHITESPACE = /\s+/gu;
+function normaliseText(text, options = {}) {
+  const o = {
+    ...DEFAULT_NORMALISE,
+    ...options
+  };
+  let out = text;
+  if (o.nfkc) out = out.normalize('NFKC');
+  if (o.typography) for (const [pattern, replacement] of TYPOGRAPHY) out = out.replaceAll(pattern, () => replacement);
+  if (o.dehyphenate) out = out.replaceAll(LINE_END_HYPHEN, '$1');
+  if (o.diacritics) out = foldDiacritics(out);
+  if (o.caseFold) out = out.toLowerCase();
+  if (o.dropNoise) out = out.split(WHITESPACE).filter(token => MEANINGFUL.test(token)).join(' ');
+  if (o.stripPunctuation) out = out.replaceAll(PUNCTUATION, ' ');
+  if (o.confusables) out = foldConfusables(out);
+  return out.replaceAll(WHITESPACE, ' ').trim();
+}
+/** Normalised words, in order. */
+function tokenise(text, options = {}) {
+  const normalised = normaliseText(text, options);
+  return normalised === '' ? [] : normalised.split(' ');
+}
+
+/**
+ * Ways to say how alike two texts are. They fail differently, which is why
+ * several are reported rather than one:
+ *
+ * - edit distance counts every insertion, deletion and substitution, so it
+ *   notices a changed digit - and punishes text that reflowed;
+ * - set and bag measures (Jaccard, Dice, cosine, recall) ignore order, so they
+ *   survive reflow and a reading order OCR got wrong - and miss a swapped clause;
+ * - character and word error rates are what anyone who works with OCR expects
+ *   to see;
+ * - Jaro-Winkler is for short strings - names, references - and meaningless on
+ *   a page.
+ *
+ * All take text already normalised; similarities run from 0 to 1.
+ */
+/** Characters inserted, deleted or substituted to turn one text into the other (Myers' bit-parallel algorithm). */
+function levenshtein(a, b) {
+  return distance(a, b);
+}
+/** `1 - distance / longer length`: 1 for identical, 0 for nothing in common. */
+function levenshteinSimilarity(a, b) {
+  const longest = Math.max(a.length, b.length);
+  return longest === 0 ? 1 : 1 - distance(a, b) / longest;
+}
+/** Words inserted, deleted or substituted, as edit distance over words rather than characters. */
+function wordDistance(a, b) {
+  // Each distinct word becomes one private-use character, so the fast
+  // character routine does the work - while they last.
+  const codes = new Map();
+  const PRIVATE_USE = 0xE000;
+  const AVAILABLE = 0xF8FF - PRIVATE_USE + 1;
+  for (const word of [...a, ...b]) if (!codes.has(word)) codes.set(word, String.fromCodePoint(PRIVATE_USE + codes.size));
+  if (codes.size <= AVAILABLE) return distance(a.map(w => codes.get(w)).join(''), b.map(w => codes.get(w)).join(''));
+  let previous = Int32Array.from({
+    length: b.length + 1
+  }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const current = new Int32Array(b.length + 1);
+    current[0] = i;
+    for (let j = 1; j <= b.length; j++) current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    previous = current;
+  }
+  return previous[b.length];
+}
+/** Shared distinct words over all distinct words. */
+function jaccard(a, b) {
+  const left = new Set(a);
+  const right = new Set(b);
+  if (left.size === 0 && right.size === 0) return 1;
+  let shared = 0;
+  for (const word of left) if (right.has(word)) shared++;
+  return shared / (left.size + right.size - shared);
+}
+/** Sørensen-Dice over character bigrams, counted with multiplicity. */
+function dice(a, b) {
+  if (a === b) return 1;
+  if (a.length < 2 || b.length < 2) return 0;
+  const bigrams = new Map();
+  for (let i = 0; i < a.length - 1; i++) {
+    const pair = a.slice(i, i + 2);
+    bigrams.set(pair, (bigrams.get(pair) ?? 0) + 1);
+  }
+  let shared = 0;
+  for (let i = 0; i < b.length - 1; i++) {
+    const pair = b.slice(i, i + 2);
+    const count = bigrams.get(pair) ?? 0;
+    if (count > 0) {
+      shared++;
+      bigrams.set(pair, count - 1);
+    }
+  }
+  return 2 * shared / (a.length - 1 + b.length - 1);
+}
+/** Cosine of the two word-frequency vectors. */
+function cosine(a, b) {
+  const left = frequencies(a);
+  const right = frequencies(b);
+  if (left.size === 0 && right.size === 0) return 1;
+  let dot = 0;
+  for (const [word, count] of left) dot += count * (right.get(word) ?? 0);
+  const denominator = magnitude(left) * magnitude(right);
+  return denominator === 0 ? 0 : dot / denominator;
+}
+/** Share of the expected words found, each found word used once - the question "is what should be there, there?". */
+function wordRecall(expected, actual) {
+  if (expected.length === 0) return 1;
+  const available = frequencies(actual);
+  let found = 0;
+  for (const word of expected) {
+    const count = available.get(word) ?? 0;
+    if (count > 0) {
+      found++;
+      available.set(word, count - 1);
+    }
+  }
+  return found / expected.length;
+}
+/**
+ * Jaro-Winkler: characters matched within a window, transpositions counted, a
+ * bonus for a shared prefix of up to four. Tuned for short strings.
+ */
+function jaroWinkler(a, b, prefixScale = 0.1) {
+  if (a === b) return 1;
+  if (a.length === 0 || b.length === 0) return 0;
+  const window = Math.max(0, Math.floor(Math.max(a.length, b.length) / 2) - 1);
+  const left = a.split('');
+  const right = b.split('');
+  const aMatched = new Uint8Array(left.length);
+  const bMatched = new Uint8Array(right.length);
+  let matches = 0;
+  for (const [i, character] of left.entries()) {
+    const j = partner(right, bMatched, character, Math.max(0, i - window), Math.min(right.length - 1, i + window));
+    if (j === -1) continue;
+    aMatched[i] = 1;
+    bMatched[j] = 1;
+    matches++;
+  }
+  if (matches === 0) return 0;
+  // Matched characters of each, in order; every position where they disagree is half a transposition.
+  const leftMatched = left.filter((_, i) => aMatched[i] === 1);
+  const rightMatched = right.filter((_, j) => bMatched[j] === 1);
+  const transpositions = leftMatched.filter((character, k) => character !== rightMatched[k]).length;
+  const jaro = (matches / a.length + matches / b.length + (matches - transpositions / 2) / matches) / 3;
+  let prefix = 0;
+  while (prefix < Math.min(4, a.length, b.length) && a[prefix] === b[prefix]) prefix++;
+  return jaro + prefix * prefixScale * (1 - jaro);
+}
+/** The first unmatched `character` in `text[from..to]`, or `-1`. */
+function partner(text, matched, character, from, to) {
+  for (let j = from; j <= to; j++) if (matched[j] === 0 && text[j] === character) return j;
+  return -1;
+}
+function magnitude(counts) {
+  let sum = 0;
+  for (const count of counts.values()) sum += count * count;
+  return Math.sqrt(sum);
+}
+function frequencies(words) {
+  const counts = new Map();
+  for (const word of words) counts.set(word, (counts.get(word) ?? 0) + 1);
+  return counts;
+}
+
+/** Normalise both texts the same way, then measure them every way. */
+function compareTexts(expected, actual, options = {}) {
+  const a = normaliseText(expected, options);
+  const b = normaliseText(actual, options);
+  const aWords = a === '' ? [] : a.split(' ');
+  const bWords = b === '' ? [] : b.split(' ');
+  const edits = levenshtein(a, b);
+  const longest = Math.max(a.length, b.length);
+  return {
+    levenshtein: edits,
+    levenshteinSimilarity: longest === 0 ? 1 : 1 - edits / longest,
+    jaccard: jaccard(aWords, bWords),
+    dice: dice(a, b),
+    cosine: cosine(aWords, bWords),
+    jaroWinkler: jaroWinkler(a, b),
+    characterErrorRate: a.length === 0 ? b.length === 0 ? 0 : 1 : edits / a.length,
+    wordErrorRate: aWords.length === 0 ? bWords.length === 0 ? 0 : 1 : wordDistance(aWords, bWords) / aWords.length,
+    wordRecall: wordRecall(aWords, bWords),
+    lengthRatio: a.length === 0 ? b.length === 0 ? 1 : Infinity : b.length / a.length,
+    characters: a.length
+  };
+}
+
+/** A run that is only a figure: digits and the marks figures are written with. */
+const FIGURE = /^[\d\s.,:/%()+-]+$/u;
+/**
+ * Words shorter than this, in points, are specks, not writing - OCR reads a
+ * dot of toner as a comma or a `4`. Body text is 7 pt and up; its capitals
+ * stand about 5 pt tall.
+ */
+const MIN_WORD_HEIGHT = 4;
+function claimWords(references, words, lineOf, options) {
+  const claimed = references.map(() => []);
+  const groups = new Map();
+  for (const [i, word] of words.entries()) {
+    const owner = claimant(word, references);
+    if (owner !== -1) claimed[owner].push(word);else if (isWriting(word, options)) groups.set(lineOf[i], [...(groups.get(lineOf[i]) ?? []), word]);
+  }
+  return {
+    found: claimed.map(run => inReadingOrder(run).map(w => w.text).join(' ')),
+    added: [...groups.values()]
+  };
+}
+/**
+ * The rule every run is held to - on the page, and again when it is re-read on
+ * its own. A run that is only a figure agrees when its digits do, in order:
+ * OCR trades commas for full stops constantly, and `5,768,700.00` read as
+ * `5.768.700 00` is the same amount. Any other run must also keep its digits,
+ * and read within the similarity threshold.
+ */
+function judgeRun(expected, found, options) {
+  const want = normaliseText(expected, options.normalise);
+  if (want === '') return {
+    agrees: true
+  };
+  const read = normaliseText(found, options.normalise);
+  if (read === '') return {
+    agrees: false,
+    kind: 'missing',
+    reason: 'text',
+    similarity: 0
+  };
+  const similarity = levenshteinSimilarity(want, read);
+  if (digits(want) !== digits(read)) return {
+    agrees: false,
+    kind: 'changed',
+    reason: 'numbers',
+    similarity
+  };
+  if (FIGURE.test(want)) return {
+    agrees: true
+  };
+  if (similarity < options.matchThreshold) return {
+    agrees: false,
+    kind: 'changed',
+    reason: 'text',
+    similarity
+  };
+  return {
+    agrees: true
+  };
+}
+function judgeRuns(references, claims, options) {
+  const differences = [];
+  const expectedParts = [];
+  const alignedParts = [];
+  for (const [r, ref] of references.entries()) {
+    const found = claims.found[r];
+    const separator = ref.endsLine === true ? '\n' : ' ';
+    expectedParts.push(ref.text + separator);
+    alignedParts.push(found + separator);
+    const verdict = judgeRun(ref.text, found, options);
+    if (verdict.agrees) continue;
+    differences.push({
+      kind: verdict.kind,
+      expected: ref.text,
+      found: verdict.kind === 'missing' ? null : found,
+      similarity: verdict.similarity,
+      reason: verdict.reason,
+      ...box(ref)
+    });
+  }
+  // Added words, grouped along the engine's lines so a stray phrase is one difference.
+  for (const group of claims.added) {
+    const found = group.map(w => w.text).join(' ');
+    alignedParts.push(found + '\n');
+    differences.push({
+      kind: 'added',
+      expected: null,
+      found,
+      similarity: 0,
+      reason: 'text',
+      ...union(group)
+    });
+  }
+  return {
+    alignedText: alignedParts.join('').trim(),
+    expectedText: expectedParts.join('').trim(),
+    differences
+  };
+}
+/** Claim and judge in one go, for a page read once. */
+function matchWords(references, words, lineOf, options) {
+  return judgeRuns(references, claimWords(references, words, lineOf, options), options);
+}
+/**
+ * The run whose box - grown by a third of its height, at least 1.5 pt - holds
+ * the word's centre, the smallest where several do; `-1` when none does.
+ */
+function claimant(word, references) {
+  const cx = word.x + word.width / 2;
+  const cy = word.y + word.height / 2;
+  let best = -1;
+  let bestArea = Infinity;
+  for (const [r, ref] of references.entries()) {
+    const pad = Math.max(1.5, ref.height * 0.3);
+    const inside = cx >= ref.x - pad && cx <= ref.x + ref.width + pad && cy >= ref.y - pad && cy <= ref.y + ref.height + pad;
+    const area = ref.width * ref.height;
+    if (inside && area < bestArea) {
+      best = r;
+      bestArea = area;
+    }
+  }
+  return best;
+}
+/** A word no run claimed that counts as added: confidently read, big enough to be writing, not noise. */
+function isWriting(word, options) {
+  return (word.confidence ?? 0) >= options.minWordConfidence && word.height >= MIN_WORD_HEIGHT && normaliseText(word.text, options.normalise) !== '';
+}
+/** Every digit, in order - what a figure must reproduce exactly. */
+function digits(text) {
+  return text.replaceAll(/\D/gu, '');
+}
+/**
+ * Words as a reader meets them: rows top to bottom - a word starts a new row
+ * once its centre is more than half a word's height below the row's first -
+ * and each row left to right.
+ */
+function inReadingOrder(words) {
+  const byHeight = words.toSorted((a, b) => a.y + a.height / 2 - (b.y + b.height / 2));
+  const rows = [];
+  for (const word of byHeight) {
+    const row = rows.at(-1);
+    const centre = word.y + word.height / 2;
+    if (row !== undefined && centre - (row[0].y + row[0].height / 2) <= Math.min(row[0].height, word.height) / 2) row.push(word);else rows.push([word]);
+  }
+  return rows.flatMap(row => row.toSorted((a, b) => a.x - b.x));
+}
+function box(text) {
+  return {
+    x: text.x,
+    y: text.y,
+    width: text.width,
+    height: text.height
+  };
+}
+function union(texts) {
+  const left = Math.min(...texts.map(t => t.x));
+  const top = Math.min(...texts.map(t => t.y));
+  const right = Math.max(...texts.map(t => t.x + t.width));
+  const bottom = Math.max(...texts.map(t => t.y + t.height));
+  return {
+    x: left,
+    y: top,
+    width: right - left,
+    height: bottom - top
+  };
+}
+
+const DEFAULT_TESSERACT_OPTIONS = {
+  languages: ['eng'],
+  model: 'best',
+  cache: {
+    method: 'none',
+    path: join(tmpdir(), 'scanmate-ocr')
+  },
+  pageSegmentation: 3
+};
+const MODEL_FOLDER = {
+  best: '4.0.0_best_int',
+  standard: '4.0.0'
+};
+async function createTesseractEngine(options = {}) {
+  const languages = [...(options.languages ?? DEFAULT_TESSERACT_OPTIONS.languages)];
+  if (languages.length === 0) throw new RangeError('at least one language is needed');
+  const model = options.model ?? DEFAULT_TESSERACT_OPTIONS.model;
+  const cacheMethod = options.cache?.method ?? DEFAULT_TESSERACT_OPTIONS.cache.method;
+  const cachePath = options.cache?.path ?? DEFAULT_TESSERACT_OPTIONS.cache.path;
+  const pageSegmentation = options.pageSegmentation ?? DEFAULT_TESSERACT_OPTIONS.pageSegmentation;
+  const languageData = options.languageData ?? (await languageFolder(languages, model, cachePath));
+  if (cacheMethod !== 'none') await mkdir(cachePath, {
+    recursive: true
+  });
+  const worker = await createWorker(languages, OEM.LSTM_ONLY, {
+    langPath: languageData,
+    gzip: true,
+    cacheMethod,
+    cachePath
+  });
+  // Tesseract reports what it estimates ("Estimating resolution as 362") to
+  // stderr; a library has no business writing to its host's console.
+  await worker.setParameters({
+    debug_file: '/dev/null'
+  });
+  let terminated = false;
+  let applied = '';
+  const settings = {
+    languages,
+    model,
+    languageData,
+    cacheMethod,
+    cachePath,
+    pageSegmentation
+  };
+  const LAYOUT = {
+    page: pageSegmentation,
+    line: 7,
+    word: 8
+  };
+  return {
+    name: 'tesseract.js',
+    version: tesseractVersion(),
+    languages,
+    settings,
+    async recognise(image, hints = {}) {
+      const mode = LAYOUT[hints.layout ?? 'page'];
+      const characters = hints.characters ?? '';
+      // Parameters persist on the worker, so set them only when they change.
+      if (applied !== `${mode}|${characters}`) {
+        await worker.setParameters({
+          tessedit_pageseg_mode: String(mode),
+          tessedit_char_whitelist: characters
+        });
+        applied = `${mode}|${characters}`;
+      }
+      const bytes = isRaster(image) ? await encodeImage(image, {
+        format: 'png'
+      }) : image;
+      const {
+        data
+      } = await worker.recognize(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength), {}, {
+        text: true,
+        blocks: true
+      });
+      const lines = [];
+      const blocks = data.blocks ?? [];
+      for (const block of blocks) for (const paragraph of block.paragraphs) for (const line of paragraph.lines) lines.push({
+        text: line.text.trim(),
+        words: line.words.map(w => ({
+          text: w.text,
+          confidence: w.confidence,
+          x: w.bbox.x0,
+          y: w.bbox.y0,
+          width: w.bbox.x1 - w.bbox.x0,
+          height: w.bbox.y1 - w.bbox.y0
+        }))
+      });
+      return {
+        text: data.text ?? '',
+        confidence: data.confidence ?? 0,
+        lines
+      };
+    },
+    async terminate() {
+      if (terminated) return;
+      terminated = true;
+      await worker.terminate();
+    }
+  };
+}
+const require$1 = createRequire(import.meta.url);
+/**
+ * The folder tesseract.js will read every language from. One language: its
+ * package's own folder, read in place. Several: their files copied - once, and
+ * again only if a size differs - into one folder under `cachePath`.
+ */
+async function languageFolder(languages, model, cachePath) {
+  const sources = languages.map(code => ({
+    code,
+    folder: join(packageFolder(code), MODEL_FOLDER[model])
+  }));
+  if (sources.length === 1) return sources[0].folder;
+  const staged = join(cachePath, `tessdata-${MODEL_FOLDER[model]}`);
+  await mkdir(staged, {
+    recursive: true
+  });
+  for (const {
+    code,
+    folder
+  } of sources) {
+    const file = `${code}.traineddata.gz`;
+    const [from, to] = await Promise.all([sizeOf(join(folder, file)), sizeOf(join(staged, file))]);
+    if (to !== from) await copyFile(join(folder, file), join(staged, file));
+  }
+  return staged;
+}
+/** Bytes in a file, or `null` when there is no file. */
+async function sizeOf(path) {
+  try {
+    const {
+      size
+    } = await stat(path);
+    return size;
+  } catch {
+    return null;
+  }
+}
+function packageFolder(code) {
+  try {
+    return dirname(require$1.resolve(`@tesseract.js-data/${code}/package.json`));
+  } catch {
+    throw new Error(`no data for OCR language '${code}': install it with npm install @tesseract.js-data/${code}`);
+  }
+}
+function tesseractVersion() {
+  try {
+    return require$1('tesseract.js/package.json').version;
+  } catch {
+    return 'unknown';
+  }
+}
+
+const DEFAULT_RECHECK_PASSES = [{
+  dpi: 300,
+  layout: 'line'
+}, {
+  dpi: 400,
+  layout: 'line'
+}, {
+  dpi: 400,
+  layout: 'line',
+  stretch: true
+}, {
+  dpi: 500,
+  layout: 'line'
+}, {
+  dpi: 400,
+  layout: 'word'
+}, {
+  dpi: 600,
+  layout: 'line',
+  stretch: true
+}];
+/** What a figure may be read as, when a run is only a figure. */
+const FIGURE_CHARACTERS = '0123456789.,:/%()+-';
+/** White kept around a crop, in pixels: tesseract reads poorly off the edge of an image. */
+const MARGIN = 12;
+async function recheckRun(engine, image, run, options) {
+  const {
+    passes = DEFAULT_RECHECK_PASSES,
+    agree = 2
+  } = options;
+  const crop = cropRun(image.raster, image.dpi, run);
+  if (crop === null) return {
+    cleared: false,
+    reading: null,
+    passes: 0,
+    agreed: 0
+  };
+  const characters = FIGURE.test(run.text.trim()) ? FIGURE_CHARACTERS : undefined;
+  let agreed = 0;
+  let reading = null;
+  let tried = 0;
+  for (const pass of passes) {
+    if (agreed + (passes.length - tried) < agree) break;
+    tried++;
+    const scale = Math.max(1, pass.dpi / image.dpi);
+    const enlarged = scale === 1 ? crop : await resampleRaster(crop, Math.round(crop.width * scale), Math.round(crop.height * scale));
+    const prepared = frame(pass.stretch === true ? stretch(enlarged) : enlarged);
+    const read = await engine.recognise(prepared, {
+      layout: pass.layout,
+      characters
+    });
+    const text = read.lines.map(line => line.text).join(' ').trim();
+    if (judgeRun(run.text, text, options).agrees) {
+      agreed++;
+      reading ??= text;
+      if (agreed >= agree) return {
+        cleared: true,
+        reading,
+        passes: tried,
+        agreed
+      };
+    }
+  }
+  return {
+    cleared: false,
+    reading: null,
+    passes: tried,
+    agreed
+  };
+}
+/**
+ * The run's box on the image, grown by a quarter of its height (at least 2 pt)
+ * so the glyphs are whole; light text on a dark bar is turned dark on light.
+ */
+function cropRun(raster, dpi, run) {
+  const s = dpi / 72;
+  const pad = Math.max(2, run.height * 0.25);
+  const left = Math.max(0, Math.floor((run.x - pad) * s));
+  const top = Math.max(0, Math.floor((run.y - pad) * s));
+  const right = Math.min(raster.width, Math.ceil((run.x + run.width + pad) * s));
+  const bottom = Math.min(raster.height, Math.ceil((run.y + run.height + pad) * s));
+  if (right - left < 2 || bottom - top < 2) return null;
+  const out = createRaster(right - left, bottom - top);
+  for (let y = top; y < bottom; y++) out.data.set(raster.data.subarray((y * raster.width + left) * 4, (y * raster.width + right) * 4), (y - top) * out.width * 4);
+  let sum = 0;
+  for (let i = 0; i < out.data.length; i += 4) sum += luminance(out.data, i);
+  if (sum / (out.width * out.height) < 110) for (let i = 0; i < out.data.length; i += 4) for (let c = 0; c < 3; c++) out.data[i + c] = 255 - out.data[i + c];
+  return out;
+}
+/** Linear stretch so the darkest 2% become black and the lightest 2% white. */
+function stretch(raster) {
+  const values = new Uint8Array(raster.width * raster.height);
+  for (let p = 0; p < values.length; p++) values[p] = luminance(raster.data, p * 4);
+  const sorted = values.toSorted();
+  const low = sorted[Math.floor(sorted.length * 0.02)];
+  const high = sorted[Math.floor(sorted.length * 0.98)];
+  if (high <= low) return raster;
+  const out = createRaster(raster.width, raster.height);
+  for (const [p, value] of values.entries()) {
+    const v = Math.round((value - low) / (high - low) * 255);
+    out.data.fill(Math.min(255, Math.max(0, v)), p * 4, p * 4 + 3);
+  }
+  return out;
+}
+/** The crop on a white border. */
+function frame(raster) {
+  const out = createRaster(raster.width + 2 * MARGIN, raster.height + 2 * MARGIN);
+  for (let y = 0; y < raster.height; y++) out.data.set(raster.data.subarray(y * raster.width * 4, (y + 1) * raster.width * 4), ((y + MARGIN) * out.width + MARGIN) * 4);
+  return out;
+}
+function luminance(data, i) {
+  return 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
+}
+
+/**
+ * Read every aligned page and say how closely the scan's text matches the
+ * original's - per page, and for the document.
+ *
+ * The scan is read from its enhanced image when there is one, otherwise from
+ * the aligned scan enlarged to `targetDpi`. The original comes from its text
+ * layer when it has one, which is exact, so every error counted is the scan's;
+ * otherwise it is read the same way. Both are then compared run by run of the
+ * original, on the shared canvas, rather than in whatever order the engine
+ * read them.
+ *
+ * One engine serves the whole call. Pass `engine` to share one across calls;
+ * it is then left running.
+ */
+async function ocrPages(pages, options = {}) {
+  const engine = options.engine ?? (await createTesseractEngine(options.tesseract));
+  try {
+    const results = [];
+    for (const [position, page] of pages.entries()) {
+      const index = position + 1;
+      const started = Date.now();
+      options.onProgress?.({
+        stage: 'ocr',
+        phase: 'start',
+        page: page.page,
+        index,
+        total: pages.length
+      });
+      const result = await readPage(page, engine, options);
+      results.push(result);
+      options.onProgress?.({
+        stage: 'ocr',
+        phase: 'done',
+        page: page.page,
+        index,
+        total: pages.length,
+        durationMs: Date.now() - started,
+        detail: {
+          score: result.score,
+          original: result.original.source,
+          confidence: result.scanned.confidence,
+          differences: result.differences.length,
+          rechecked: result.rechecks.attempted,
+          cleared: result.rechecks.cleared
+        }
+      });
+    }
+    const characters = results.reduce((sum, r) => sum + r.metrics.characters, 0);
+    return {
+      score: characters === 0 ? mean(results.map(r => r.score)) : results.reduce((sum, r) => sum + r.score * r.metrics.characters, 0) / characters,
+      pageMean: mean(results.map(r => r.score)),
+      pages: results,
+      engine: {
+        name: engine.name,
+        version: engine.version,
+        languages: engine.languages
+      }
+    };
+  } finally {
+    if (options.engine === undefined) await engine.terminate();
+  }
+}
+async function readPage(page, engine, options) {
+  const {
+    original: originalSource = 'auto',
+    targetDpi = 300,
+    assumeDpi = 150,
+    normalise = DEFAULT_NORMALISE,
+    scoreMetric = 'levenshteinSimilarity',
+    matchThreshold = 0.8,
+    minWordConfidence = 60,
+    recheck = {}
+  } = options;
+  const warnings = [];
+  // The scan: its enhanced image as it is, or the aligned scan made fine enough to read.
+  const scanImage = page.enhanced ? {
+    raster: page.enhanced.raster,
+    dpi: page.enhanced.dpi ?? assumeDpi
+  } : await readable(page.aligned.raster, page.original.dpi ?? assumeDpi, targetDpi);
+  const scanned = placed(await engine.recognise(scanImage.raster), scanImage.dpi);
+  if (scanned.side.text.trim() === '') warnings.push('nothing could be read on the scanned page');
+  // The original: its own text where it has some, else read like the scan.
+  const items = page.metadata?.original?.textItems ?? [];
+  const useLayer = originalSource !== 'ocr' && items.length > 0;
+  if (originalSource === 'text-layer' && items.length === 0) warnings.push('the original has no text layer, so it was read by OCR');
+  let original;
+  let references;
+  if (useLayer) {
+    references = items.map(item => ({
+      text: item.text,
+      x: item.x,
+      y: item.y,
+      width: item.width,
+      height: item.height,
+      endsLine: item.endsLine,
+      confidence: null
+    }));
+    original = {
+      source: 'text-layer',
+      text: items.map(i => i.text + (i.endsLine === true ? '\n' : ' ')).join('').trim(),
+      confidence: null,
+      lines: references,
+      words: references
+    };
+  } else {
+    const image = await readable(page.original.raster, page.original.dpi ?? assumeDpi, targetDpi);
+    original = placed(await engine.recognise(image.raster), image.dpi).side;
+    references = original.lines.map(line => ({
+      ...line,
+      endsLine: true
+    }));
+  }
+  // Place the scan's words on the original's runs; give every doubted run a
+  // second look of its own before it counts as a difference.
+  const rules = {
+    normalise,
+    matchThreshold,
+    minWordConfidence
+  };
+  const claims = claimWords(references, scanned.side.words, scanned.lineOf, rules);
+  // Words over ink the original itself printed - a logo, a heading set as an
+  // image - belong to the original even though its text layer lacks them.
+  // Writing over printed matter is for @scanmate/diff to see, not this.
+  const originalDpi = page.original.dpi ?? assumeDpi;
+  claims.added = claims.added.map(group => group.filter(word => !printedUnder(page.original.raster, originalDpi, word))).filter(group => group.length > 0);
+  const rechecks = {
+    attempted: 0,
+    cleared: 0
+  };
+  const rechecked = new Set();
+  if (recheck !== false) for (const [r, run] of references.entries()) {
+    if (judgeRun(run.text, claims.found[r], rules).agrees) continue;
+    rechecks.attempted++;
+    rechecked.add(r);
+    const second = await recheckRun(engine, scanImage, run, {
+      ...rules,
+      ...recheck
+    });
+    if (second.reading === null) continue;
+    claims.found[r] = second.reading;
+    rechecks.cleared++;
+  }
+  const match = judgeRuns(references, claims, rules);
+  const runs = references.map((run, r) => ({
+    text: run.text,
+    found: claims.found[r],
+    agrees: judgeRun(run.text, claims.found[r], rules).agrees,
+    rechecked: rechecked.has(r),
+    x: run.x,
+    y: run.y,
+    width: run.width,
+    height: run.height
+  }));
+  const metrics = compareTexts(match.expectedText, match.alignedText, normalise);
+  if (scanned.side.confidence !== null && scanned.side.confidence < 60) warnings.push(`low OCR confidence on the scanned page (${Math.round(scanned.side.confidence)})`);
+  return {
+    page: page.page,
+    original,
+    scanned: scanned.side,
+    runs,
+    alignedText: match.alignedText,
+    score: metrics[scoreMetric],
+    metrics,
+    differences: match.differences,
+    rechecks,
+    warnings
+  };
+}
+/**
+ * At least this share of a word's box dark in the original means the original
+ * printed something there. Printed words - a logo's letters - cover a third of
+ * their box or more; a form's rule or a checkbox edge crossing a handwritten
+ * word covers a tenth. Only the first explains the word away.
+ */
+const PRINTED_SHARE = 0.2;
+/** The original has ink under the word: something is printed there, text layer or not. */
+function printedUnder(raster, dpi, word) {
+  const s = dpi / 72;
+  const left = Math.max(0, Math.floor(word.x * s));
+  const top = Math.max(0, Math.floor(word.y * s));
+  const right = Math.min(raster.width, Math.ceil((word.x + word.width) * s));
+  const bottom = Math.min(raster.height, Math.ceil((word.y + word.height) * s));
+  if (right <= left || bottom <= top) return false;
+  let dark = 0;
+  for (let y = top; y < bottom; y++) for (let x = left, i = (y * raster.width + left) * 4; x < right; x++, i += 4) if (0.299 * raster.data[i] + 0.587 * raster.data[i + 1] + 0.114 * raster.data[i + 2] < 128) dark++;
+  return dark / ((right - left) * (bottom - top)) >= PRINTED_SHARE;
+}
+/** An image at `targetDpi` or finer: enlarged when below it, kept as it is otherwise. */
+async function readable(raster, dpi, targetDpi) {
+  if (targetDpi === null || dpi >= targetDpi) return {
+    raster,
+    dpi
+  };
+  const scale = targetDpi / dpi;
+  return {
+    raster: await resampleRaster(raster, Math.round(raster.width * scale), Math.round(raster.height * scale)),
+    dpi: targetDpi
+  };
+}
+/** An engine's reading, moved from the image's pixels to points on the page. */
+function placed(read, dpi) {
+  const toPoints = 72 / dpi;
+  const words = [];
+  const lineOf = [];
+  const lines = [];
+  for (const [l, line] of read.lines.entries()) {
+    if (line.words.length === 0) continue;
+    const inPoints = line.words.map(w => ({
+      text: w.text,
+      confidence: w.confidence,
+      x: w.x * toPoints,
+      y: w.y * toPoints,
+      width: w.width * toPoints,
+      height: w.height * toPoints
+    }));
+    words.push(...inPoints);
+    lineOf.push(...inPoints.map(() => l));
+    const left = Math.min(...inPoints.map(w => w.x));
+    const top = Math.min(...inPoints.map(w => w.y));
+    lines.push({
+      text: line.text,
+      confidence: mean(inPoints.map(w => w.confidence ?? 0)),
+      x: left,
+      y: top,
+      width: Math.max(...inPoints.map(w => w.x + w.width)) - left,
+      height: Math.max(...inPoints.map(w => w.y + w.height)) - top
+    });
+  }
+  return {
+    side: {
+      source: 'ocr',
+      text: read.text.trim(),
+      confidence: read.confidence,
+      lines,
+      words
+    },
+    lineOf
+  };
+}
+function mean(values) {
+  return values.length === 0 ? 0 : values.reduce((a, b) => a + b, 0) / values.length;
+}
+
+export { DEFAULT_NORMALISE, DEFAULT_RECHECK_PASSES, DEFAULT_TESSERACT_OPTIONS, claimWords, compareTexts, cosine, createTesseractEngine, diacriticsMap, dice, foldConfusables, foldDiacritics, jaccard, jaroWinkler, judgeRun, judgeRuns, levenshtein, levenshteinSimilarity, matchWords, normaliseText, ocrPages, recheckRun, tokenise, wordDistance, wordRecall };
+//# sourceMappingURL=index.esm.js.map