@opencraw/captcha-tesseract 0.0.45 → 0.0.47

package/dist/charset/charset.algorithm.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The characters a captcha may use, as one string without repeats: what
+ * Tesseract is limited to (`tessedit_char_whitelist`) and what a read is
+ * filtered through.
+ *
+ * A string lists characters, with `a-z` style ranges (`'A-Za-z0-9'`,
+ * `'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'`); a `-` first or last is itself. A
+ * RegExp is a one-character class (`/[A-HJ-NP-Z2-9]/`), tested against every
+ * printable ASCII character. Unless `caseSensitive`, each letter brings its
+ * other case: a case-blind site draws either.
+ *
+ * @param charset - The list, or the class.
+ * @param caseSensitive - Whether `a` and `A` are different characters.
+ * @returns The characters.
+ * @throws Error when the charset allows nothing.
+ */
+export declare function expandCharset(charset: string | RegExp, caseSensitive: boolean): string;
+/**
+ * A read kept to the charset: characters outside it (a stray `|` for an `l`, a
+ * space) are dropped.
+ *
+ * @param text - What Tesseract read.
+ * @param characters - From {@link expandCharset}.
+ * @returns The filtered read.
+ */
+export declare function keepCharset(text: string, characters: string): string;
+//# sourceMappingURL=charset.algorithm.d.ts.map

package/dist/charset/index.d.ts

@@ -0,0 +1,2 @@
+export { expandCharset, keepCharset } from './charset.algorithm';
+//# sourceMappingURL=index.d.ts.map

package/dist/image-cleanup/clean-image.algorithm.d.ts

@@ -0,0 +1,39 @@
+/** How a captcha image is cleaned before Tesseract reads it. */
+export interface CleanupOptions {
+    /** How many times larger: Tesseract reads glyphs of 20 px and more best. Default 3. */
+    scale?: number;
+    /** The luminance (0–255) under which a pixel is ink; `'otsu'` (the default) finds it from the image. */
+    threshold?: number | 'otsu';
+    /** Light text on a dark ground is turned dark on light: `'auto'` (the default) when ink covers most of the image. */
+    invert?: boolean | 'auto';
+    /** A 3×3 median filter against salt-and-pepper noise, run after thresholding. Default off. */
+    median?: boolean;
+    /** White margin around the text, in output pixels: Tesseract misses glyphs touching the edge. Default 10. */
+    padding?: number;
+}
+/** PNG output for Tesseract, not for storage: no row filter search and light compression, many times faster to write. */
+export declare const FAST_PNG: {
+    filterType: number;
+    deflateLevel: number;
+};
+/**
+ * Cleans a captcha image for OCR: grayscale, black ink on white (a threshold
+ * picked by Otsu's method unless given, turned the right way round), an
+ * optional median filter, scaled up with hard edges, and a white margin.
+ *
+ * Like photocopying a smudged note at high contrast before reading it.
+ *
+ * @param png - The image, as PNG bytes (a screenshot).
+ * @param options - The cleanup settings.
+ * @returns The cleaned image, as PNG bytes.
+ */
+export declare function cleanImage(png: Buffer, options?: CleanupOptions): Buffer;
+/**
+ * The threshold that best splits the luminances in two groups (Otsu): the
+ * value maximising the variance between ink and ground.
+ *
+ * @param luminance - One 0–255 value per pixel.
+ * @returns The threshold: values at or under it are ink.
+ */
+export declare function otsuThreshold(luminance: Uint8Array): number;
+//# sourceMappingURL=clean-image.algorithm.d.ts.map

package/dist/image-cleanup/index.d.ts

@@ -0,0 +1,4 @@
+export { cleanImage, otsuThreshold } from './clean-image.algorithm';
+export type { CleanupOptions } from './clean-image.algorithm';
+export { respaceGlyphs } from './respace-glyphs.algorithm';
+//# sourceMappingURL=index.d.ts.map

package/dist/image-cleanup/respace-glyphs.algorithm.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pulls the glyphs of a cleaned image apart: each run of columns holding ink
+ * (a character, or characters that touch) is laid out again with `gap` white
+ * columns between runs. Tesseract reads a line with context and can bend a
+ * character to fit its neighbours (a `4` after lowercase letters read as
+ * `a`); spaced apart, each is read more on its own shape.
+ *
+ * Like reading a word letter by letter with a finger under each one.
+ *
+ * @param png - A cleaned image (black ink on white), as PNG bytes.
+ * @param gap - White columns before, between and after the runs.
+ * @returns The respaced image, as PNG bytes; the same height.
+ */
+export declare function respaceGlyphs(png: Buffer, gap: number): Buffer;
+//# sourceMappingURL=respace-glyphs.algorithm.d.ts.map

package/dist/index.d.ts

@@ -1 +1,6 @@
-export * from "./src/index.js";
+export { tesseractReader, judgeRead } from './reader';
+export type { ChallengeLike, ImageRead, ReadSymbol, SolveContextLike, TesseractRead, TesseractReader, TesseractReaderOptions } from './reader';
+export { expandCharset, keepCharset } from './charset';
+export { cleanImage, otsuThreshold } from './image-cleanup';
+export type { CleanupOptions } from './image-cleanup';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.esm.js

@@ -1,44 +1,13 @@
-import { PNG } from 'pngjs';
-import { createRequire } from 'node:module';
-import { join, dirname } from 'node:path';
-import { createWorker, OEM } from 'tesseract.js';
-
-/** The printable ASCII characters a RegExp charset is tested against. */
-const PRINTABLE = Array.from({
-  length: 0x7E - 0x21 + 1
-}, (_, index) => String.fromCodePoint(0x21 + index));
-/**
- * The characters a captcha may use, as one string without repeats: what
- * Tesseract is limited to (`tessedit_char_whitelist`) and what a read is
- * filtered through.
- *
- * A string lists characters, with `a-z` style ranges (`'A-Za-z0-9'`,
- * `'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'`); a `-` first or last is itself. A
- * RegExp is a one-character class (`/[A-HJ-NP-Z2-9]/`), tested against every
- * printable ASCII character. Unless `caseSensitive`, each letter brings its
- * other case: a case-blind site draws either.
- *
- * @param charset - The list, or the class.
- * @param caseSensitive - Whether `a` and `A` are different characters.
- * @returns The characters.
- * @throws Error when the charset allows nothing.
- */
+// src/charset/charset.algorithm.ts
+var PRINTABLE = Array.from({ length: 126 - 33 + 1 }, (_, index) => String.fromCodePoint(33 + index));
 function expandCharset(charset, caseSensitive) {
-  const listed = typeof charset === 'string' ? expandRanges(charset) : PRINTABLE.filter(character => new RegExp(charset.source, charset.flags.replaceAll('g', '')).test(character));
-  const characters = new Set(caseSensitive ? listed : listed.flatMap(character => [character, character.toLowerCase(), character.toUpperCase()]));
+  const listed = typeof charset === "string" ? expandRanges(charset) : PRINTABLE.filter((character) => new RegExp(charset.source, charset.flags.replaceAll("g", "")).test(character));
+  const characters = new Set(caseSensitive ? listed : listed.flatMap((character) => [character, character.toLowerCase(), character.toUpperCase()]));
   if (characters.size === 0) throw new Error(`the charset ${String(charset)} allows no character`);
-  return [...characters].join('');
+  return [...characters].join("");
 }
-/**
- * A read kept to the charset: characters outside it (a stray `|` for an `l`, a
- * space) are dropped.
- *
- * @param text - What Tesseract read.
- * @param characters - From {@link expandCharset}.
- * @returns The filtered read.
- */
 function keepCharset(text, characters) {
-  return [...text].filter(character => characters.includes(character)).join('');
+  return [...text].filter((character) => characters.includes(character)).join("");
 }
 function expandRanges(list) {
   const characters = [];
@@ -46,7 +15,7 @@ function expandRanges(list) {
   for (let index = 0; index < chars.length; index += 1) {
     const from = chars[index];
     const to = chars[index + 2];
-    if (to !== undefined && chars[index + 1] === '-') {
+    if (to !== void 0 && chars[index + 1] === "-") {
       const start = from.codePointAt(0) ?? 0;
       const end = to.codePointAt(0) ?? 0;
       if (end < start) throw new Error(`the charset range ${from}-${to} runs backwards`);
@@ -59,50 +28,27 @@ function expandRanges(list) {
   return characters;
 }
 
-const WHITE$1 = 255;
-const BLACK = 0;
-/** PNG output for Tesseract, not for storage: no row filter search and light compression, many times faster to write. */
-const FAST_PNG = {
-  filterType: 0,
-  deflateLevel: 1
-};
-/**
- * Cleans a captcha image for OCR: grayscale, black ink on white (a threshold
- * picked by Otsu's method unless given, turned the right way round), an
- * optional median filter, scaled up with hard edges, and a white margin.
- *
- * Like photocopying a smudged note at high contrast before reading it.
- *
- * @param png - The image, as PNG bytes (a screenshot).
- * @param options - The cleanup settings.
- * @returns The cleaned image, as PNG bytes.
- */
+// src/image-cleanup/clean-image.algorithm.ts
+import { PNG } from "pngjs";
+var WHITE = 255;
+var BLACK = 0;
+var FAST_PNG = { filterType: 0, deflateLevel: 1 };
 function cleanImage(png, options = {}) {
   const image = PNG.sync.read(png);
   const scale = Math.max(1, Math.round(options.scale ?? 3));
   const padding = Math.max(0, Math.round(options.padding ?? 10));
-  // Scaled up smoothly before thresholding: anti-aliased edges become smooth curves, not staircases (an 8 stays an 8).
   const width = image.width * scale;
   const height = image.height * scale;
   const luminance = upscale(luminanceOf(image.data, image.width * image.height), image.width, image.height, scale);
-  const threshold = options.threshold === undefined || options.threshold === 'otsu' ? otsuThreshold(luminance) : options.threshold;
-  let ink = luminance.map(value => value <= threshold ? 1 : 0);
+  const threshold = options.threshold === void 0 || options.threshold === "otsu" ? otsuThreshold(luminance) : options.threshold;
+  let ink = luminance.map((value) => value <= threshold ? 1 : 0);
   const inkShare = ink.reduce((sum, value) => sum + value, 0) / ink.length;
-  if (options.invert === true || (options.invert ?? 'auto') === 'auto' && inkShare > 0.5) ink = ink.map(value => 1 - value);
+  if (options.invert === true || (options.invert ?? "auto") === "auto" && inkShare > 0.5) ink = ink.map((value) => 1 - value);
   if (options.median === true) ink = medianOf(ink, width, height);
   return PNG.sync.write(render(ink, width, height, padding), FAST_PNG);
 }
-/**
- * The threshold that best splits the luminances in two groups (Otsu): the
- * value maximising the variance between ink and ground.
- *
- * @param luminance - One 0–255 value per pixel.
- * @returns The threshold: values at or under it are ink.
- */
 function otsuThreshold(luminance) {
-  const histogram = Array.from({
-    length: 256
-  }, () => 0);
+  const histogram = Array.from({ length: 256 }, () => 0);
   for (const value of luminance) histogram[value] += 1;
   const total = luminance.length;
   const sum = histogram.reduce((accumulator, count, value) => accumulator + value * count, 0);
@@ -129,8 +75,7 @@ function luminanceOf(rgba, pixels) {
   for (let pixel = 0; pixel < pixels; pixel += 1) {
     const offset = pixel * 4;
     const alpha = rgba[offset + 3] / 255;
-    // A transparent pixel is the white page behind it.
-    const blend = channel => channel * alpha + WHITE$1 * (1 - alpha);
+    const blend = (channel) => channel * alpha + WHITE * (1 - alpha);
     const red = blend(rgba[offset]);
     const green = blend(rgba[offset + 1]);
     const blue = blend(rgba[offset + 2]);
@@ -145,7 +90,6 @@ function medianOf(ink, width, height) {
   }
   return filtered;
 }
-/** 1 when most of the pixel's 3×3 neighbourhood (inside the image) is ink. */
 function majorityAround(ink, width, height, x, y) {
   let votes = 0;
   let seen = 0;
@@ -159,11 +103,8 @@ function majorityAround(ink, width, height, x, y) {
 }
 function render(ink, width, height, padding) {
   const outWidth = width + padding * 2;
-  const out = new PNG({
-    width: outWidth,
-    height: height + padding * 2
-  });
-  out.data.fill(WHITE$1);
+  const out = new PNG({ width: outWidth, height: height + padding * 2 });
+  out.data.fill(WHITE);
   for (let y = 0; y < height; y += 1) {
     for (let x = 0; x < width; x += 1) {
       const start = ((y + padding) * outWidth + x + padding) * 4;
@@ -172,7 +113,6 @@ function render(ink, width, height, padding) {
   }
   return out;
 }
-/** Bilinear upscaling of a luminance map. */
 function upscale(luminance, width, height, scale) {
   if (scale === 1) return luminance;
   const outWidth = width * scale;
@@ -194,30 +134,16 @@ function upscale(luminance, width, height, scale) {
   return scaled;
 }
 
-const WHITE = 255;
-const INK_UNDER = 128;
-/**
- * Pulls the glyphs of a cleaned image apart: each run of columns holding ink
- * (a character, or characters that touch) is laid out again with `gap` white
- * columns between runs. Tesseract reads a line with context and can bend a
- * character to fit its neighbours (a `4` after lowercase letters read as
- * `a`); spaced apart, each is read more on its own shape.
- *
- * Like reading a word letter by letter with a finger under each one.
- *
- * @param png - A cleaned image (black ink on white), as PNG bytes.
- * @param gap - White columns before, between and after the runs.
- * @returns The respaced image, as PNG bytes; the same height.
- */
+// src/image-cleanup/respace-glyphs.algorithm.ts
+import { PNG as PNG2 } from "pngjs";
+var WHITE2 = 255;
+var INK_UNDER = 128;
 function respaceGlyphs(png, gap) {
-  const image = PNG.sync.read(png);
+  const image = PNG2.sync.read(png);
   const runs = inkRuns(image);
   const width = runs.reduce((total, [start, end]) => total + (end - start) + gap, gap);
-  const out = new PNG({
-    width,
-    height: image.height
-  });
-  out.data.fill(WHITE);
+  const out = new PNG2({ width, height: image.height });
+  out.data.fill(WHITE2);
   let at = gap;
   for (const [start, end] of runs) {
     for (let y = 0; y < image.height; y += 1) {
@@ -226,9 +152,8 @@ function respaceGlyphs(png, gap) {
     }
     at += end - start + gap;
   }
-  return PNG.sync.write(out, FAST_PNG);
+  return PNG2.sync.write(out, FAST_PNG);
 }
-/** The column ranges `[start, end)` that hold ink, left to right. */
 function inkRuns(image) {
   const runs = [];
   let start = -1;
@@ -250,129 +175,67 @@ function hasInk(image, x) {
   return false;
 }
 
-/** Letters whose small and capital forms have the same shape: only their height tells them apart. */
-const SAME_SHAPE = new Set('cosuvwxz');
-/** Letters whose small form has a tail under the line, and whose capital does not. */
-const TAILED = new Set('py');
-/** Small letters that reach under the line: not used to find it. */
-const DESCENDERS = new Set('gjpqy');
-/** Characters as tall as a capital: digits and capitals. */
-const CAPITAL_HEIGHT = /^[\dA-Z]$/;
-/**
- * Puts right the case of letters that Tesseract, reading one line with no
- * reference, cannot tell by shape: `c`/`C`, `o`/`O`, `s`/`S`, `v`/`V`, `w`/`W`,
- * `x`/`X`, `z`/`Z` by their height against the line's capitals and digits,
- * `p`/`P` and `y`/`Y` by a tail under the line. (`j`/`J` are left: many
- * fonts drop the capital under the line too.) Only letters whose two cases
- * the charset both allows are changed; a line with no capital or digit to
- * measure against is left as read.
- *
- * Like telling `o` from `O` in a handwritten code by comparing it with the `8`
- * next to it.
- *
- * @param symbols - The characters read, with their boxes.
- * @param characters - The charset.
- * @returns The characters, with their case put right.
- */
+// src/reader/letter-case.algorithm.ts
+var SAME_SHAPE = new Set("cosuvwxz");
+var TAILED = new Set("py");
+var DESCENDERS = new Set("gjpqy");
+var CAPITAL_HEIGHT = /^[\dA-Z]$/;
 function fixLetterCase(symbols, characters) {
-  const boxed = symbols.filter(symbol => symbol.box !== undefined);
-  const capitals = boxed.filter(symbol => CAPITAL_HEIGHT.test(symbol.text) && !SAME_SHAPE.has(symbol.text.toLowerCase()) && !TAILED.has(symbol.text.toLowerCase()));
+  const boxed = symbols.filter((symbol) => symbol.box !== void 0);
+  const capitals = boxed.filter((symbol) => CAPITAL_HEIGHT.test(symbol.text) && !SAME_SHAPE.has(symbol.text.toLowerCase()) && !TAILED.has(symbol.text.toLowerCase()));
   if (capitals.length === 0) return [...symbols];
-  const capital = median(capitals.map(symbol => heightOf(symbol)));
-  // Either case of a tailed letter may be misread, so neither helps find the line.
-  const baseline = median(boxed.filter(symbol => !DESCENDERS.has(symbol.text.toLowerCase())).map(symbol => symbol.box?.y1 ?? 0));
-  return symbols.map(symbol => {
+  const capital = median(capitals.map((symbol) => heightOf(symbol)));
+  const baseline = median(boxed.filter((symbol) => !DESCENDERS.has(symbol.text.toLowerCase())).map((symbol) => symbol.box?.y1 ?? 0));
+  return symbols.map((symbol) => {
     const lower = symbol.text.toLowerCase();
     const upper = symbol.text.toUpperCase();
-    if (lower === upper || symbol.box === undefined || !characters.includes(lower) || !characters.includes(upper)) return symbol;
+    if (lower === upper || symbol.box === void 0 || !characters.includes(lower) || !characters.includes(upper)) return symbol;
     if (SAME_SHAPE.has(lower)) {
       const ratio = heightOf(symbol) / capital;
-      if (ratio >= 0.86) return {
-        ...symbol,
-        text: upper
-      };
-      if (ratio <= 0.8) return {
-        ...symbol,
-        text: lower
-      };
+      if (ratio >= 0.86) return { ...symbol, text: upper };
+      if (ratio <= 0.8) return { ...symbol, text: lower };
     }
-    if (TAILED.has(lower)) return {
-      ...symbol,
-      text: symbol.box.y1 > baseline + capital * 0.12 ? lower : upper
-    };
+    if (TAILED.has(lower)) return { ...symbol, text: symbol.box.y1 > baseline + capital * 0.12 ? lower : upper };
     return symbol;
   });
 }
 function heightOf(symbol) {
-  return symbol.box === undefined ? 0 : symbol.box.y1 - symbol.box.y0;
+  return symbol.box === void 0 ? 0 : symbol.box.y1 - symbol.box.y0;
 }
 function median(values) {
-  // A copy, sorted in place: the package targets ES2022, which has no toSorted.
   const sorted = Float64Array.from(values).sort();
   return sorted[Math.floor(sorted.length / 2)] ?? 0;
 }
 
-/**
- * Judges a read before anything is submitted: kept to the charset, it must
- * have the code's length, and every character must be sure enough. This is
- * the only check possible before posting the form, and it is free: a read
- * that fails it is refreshed, never sent. A clipped last character is the
- * usual failure: Tesseract reads it short, or unsure.
- *
- * @param raw - Tesseract's text.
- * @param symbols - Its characters with their confidence.
- * @param rules - The charset, the length, the least confidence.
- * @returns The filtered text, its least confidence, and the problem, if any.
- */
+// src/reader/read-check.policy.ts
 function judgeRead(raw, symbols, rules) {
   const text = keepCharset(raw, rules.characters);
-  const kept = symbols.filter(symbol => keepCharset(symbol.text, rules.characters) !== '');
-  const confidence = kept.length === 0 ? 0 : Math.round(Math.min(...kept.map(symbol => symbol.confidence)));
-  const [shortest, longest] = typeof rules.length === 'number' ? [rules.length, rules.length] : rules.length ?? [1, Infinity];
-  if (text.length < shortest || text.length > longest) return {
-    text,
-    confidence,
-    problem: `read ${text.length} characters ("${text}"), expected ${shortest === longest ? shortest : `${shortest} to ${longest}`}`
-  };
-  if (confidence < rules.minConfidence) return {
-    text,
-    confidence,
-    problem: `a character read at ${confidence}% confidence, under ${rules.minConfidence}%`
-  };
-  return {
-    text,
-    confidence
-  };
+  const kept = symbols.filter((symbol) => keepCharset(symbol.text, rules.characters) !== "");
+  const confidence = kept.length === 0 ? 0 : Math.round(Math.min(...kept.map((symbol) => symbol.confidence)));
+  const [shortest, longest] = typeof rules.length === "number" ? [rules.length, rules.length] : rules.length ?? [1, Infinity];
+  if (text.length < shortest || text.length > longest) return { text, confidence, problem: `read ${text.length} characters ("${text}"), expected ${shortest === longest ? shortest : `${shortest} to ${longest}`}` };
+  if (confidence < rules.minConfidence) return { text, confidence, problem: `a character read at ${confidence}% confidence, under ${rules.minConfidence}%` };
+  return { text, confidence };
 }
 
-/** The bundled English model: the small LSTM one, which is what a line of loose characters needs. */
+// src/reader/tesseract-engine.client.ts
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { createWorker, OEM } from "tesseract.js";
 function bundledLangPath() {
-  const require = createRequire(import.meta.url);
-  return join(dirname(require.resolve('@tesseract.js-data/eng/package.json')), '4.0.0_best_int');
+  const require2 = createRequire(import.meta.url);
+  return join(dirname(require2.resolve("@tesseract.js-data/eng/package.json")), "4.0.0_best_int");
 }
-/**
- * One Tesseract worker (a thread running Tesseract in WebAssembly), started
- * on the first read and reused: reads queue on it. The language data comes
- * from disk, never from a CDN, and nothing is cached in the working
- * directory.
- */
-class TesseractEngine {
-  options;
-  worker;
+var TesseractEngine = class {
   constructor(options) {
     this.options = options;
   }
+  options;
+  worker;
   start() {
     this.worker ??= (async () => {
-      const worker = await createWorker(this.options.lang, OEM.LSTM_ONLY, {
-        langPath: this.options.langPath ?? bundledLangPath(),
-        gzip: true,
-        cacheMethod: 'none'
-      });
-      await worker.setParameters({
-        tessedit_char_whitelist: this.options.whitelist,
-        tessedit_pageseg_mode: String(this.options.pageSegMode)
-      });
+      const worker = await createWorker(this.options.lang, OEM.LSTM_ONLY, { langPath: this.options.langPath ?? bundledLangPath(), gzip: true, cacheMethod: "none" });
+      await worker.setParameters({ tessedit_char_whitelist: this.options.whitelist, tessedit_pageseg_mode: String(this.options.pageSegMode) });
       return worker;
     })();
     return this.worker;
@@ -385,211 +248,115 @@ class TesseractEngine {
    */
   async read(png) {
     const worker = await this.start();
-    const {
-      data
-    } = await worker.recognize(png, {}, {
-      text: true,
-      blocks: true
-    });
-    return {
-      raw: data.text.trim(),
-      symbols: symbolsOf(data.blocks ?? [])
-    };
+    const { data } = await worker.recognize(png, {}, { text: true, blocks: true });
+    return { raw: data.text.trim(), symbols: symbolsOf(data.blocks ?? []) };
   }
   /** Stops the worker thread, if it started. */
   async close() {
     const worker = this.worker;
-    this.worker = undefined;
-    if (worker === undefined) return;
+    this.worker = void 0;
+    if (worker === void 0) return;
     const started = await worker;
     await started.terminate();
   }
-}
+};
 function symbolsOf(blocks) {
-  return blocks.flatMap(block => block.paragraphs.flatMap(paragraph => paragraph.lines.flatMap(line => line.words.flatMap(word => word.symbols.map(symbol => ({
-    text: symbol.text,
-    confidence: symbol.confidence,
-    box: symbol.bbox
-  }))))));
+  return blocks.flatMap((block) => block.paragraphs.flatMap((paragraph) => paragraph.lines.flatMap((line) => line.words.flatMap((word) => word.symbols.map((symbol) => ({ text: symbol.text, confidence: symbol.confidence, box: symbol.bbox }))))));
 }
 
-const DEFAULT_REFRESHES = 5;
-const DEFAULT_MIN_CONFIDENCE = 30;
-const DEFAULT_TIMEOUT_MS = 60_000;
-/** White columns (of the cleaned image) between glyphs for the cross-check read. */
-const CROSS_CHECK_GAP = 10;
-/** An image counts as settled once its `src` stayed the same this long. */
-const SETTLE_MS = 300;
-const SETTLE_LIMIT_MS = 5000;
-/**
- * A captcha reader for OpenCraw's form captchas: it reads the code in the
- * challenge's image with Tesseract, refreshes the image while the read is not
- * good enough (wrong length, an unsure character, and no form is posted for
- * that), fills the challenge's answer field, and returns `solved`. The engine
- * posts the form, checks the page and tells the verdict, which goes to
- * `audit` with the read.
- *
- * @param options - The charset, the length, the checks, the cleanup, the audit.
- * @returns The reader, to register as a captcha solver.
- */
+// src/reader/tesseract-reader.use-case.ts
+var DEFAULT_REFRESHES = 5;
+var DEFAULT_MIN_CONFIDENCE = 30;
+var DEFAULT_TIMEOUT_MS = 6e4;
+var CROSS_CHECK_GAP = 10;
+var SETTLE_MS = 300;
+var SETTLE_LIMIT_MS = 5e3;
 function tesseractReader(options = {}) {
   const caseSensitive = options.caseSensitive ?? false;
-  const characters = expandCharset(options.charset ?? 'A-Za-z0-9', caseSensitive);
-  const rules = {
-    characters,
-    length: options.length,
-    minConfidence: options.minConfidence ?? DEFAULT_MIN_CONFIDENCE
-  };
-  const engine = new TesseractEngine({
-    lang: options.lang ?? 'eng',
-    langPath: options.langPath,
-    whitelist: characters,
-    pageSegMode: options.pageSegMode ?? 7
-  });
+  const characters = expandCharset(options.charset ?? "A-Za-z0-9", caseSensitive);
+  const rules = { characters, length: options.length, minConfidence: options.minConfidence ?? DEFAULT_MIN_CONFIDENCE };
+  const engine = new TesseractEngine({ lang: options.lang ?? "eng", langPath: options.langPath, whitelist: characters, pageSegMode: options.pageSegMode ?? 7 });
   const refreshes = options.refreshes ?? DEFAULT_REFRESHES;
-  /** The read an attempt submitted, waiting for the page's verdict. */
-  const submitted = new WeakMap();
-  const audit = async (read, context) => {
+  const submitted = /* @__PURE__ */ new WeakMap();
+  const audit = async (read2, context) => {
     try {
-      await options.audit?.(read);
+      await options.audit?.(read2);
     } catch (error) {
-      context?.log('warn', `audit failed: ${error instanceof Error ? error.message : String(error)}`);
+      context?.log("warn", `audit failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   };
   const crossCheck = options.crossCheck ?? true;
-  /** One Tesseract read of a cleaned image, judged. */
-  const readOnce = async cleaned => {
-    const {
-      raw,
-      symbols: read
-    } = await engine.read(cleaned);
-    // Tesseract sees one line with no size reference: the case of same-shape letters is put right by their size.
-    const symbols = caseSensitive ? fixLetterCase(read, characters) : read;
-    return {
-      raw,
-      symbols,
-      judged: judgeRead(caseSensitive ? symbols.map(symbol => symbol.text).join('') : raw, symbols, rules)
-    };
+  const readOnce = async (cleaned) => {
+    const { raw, symbols: read2 } = await engine.read(cleaned);
+    const symbols = caseSensitive ? fixLetterCase(read2, characters) : read2;
+    return { raw, symbols, judged: judgeRead(caseSensitive ? symbols.map((symbol) => symbol.text).join("") : raw, symbols, rules) };
   };
-  const read = async png => {
+  const read = async (png) => {
     const started = Date.now();
     const cleaned = cleanImage(png, options.preprocess);
-    const {
-      raw,
-      symbols,
-      judged
-    } = await readOnce(cleaned);
-    const done = {
-      raw,
-      symbols,
-      image: png,
-      cleaned
-    };
-    if (!crossCheck || judged.problem !== undefined) return {
-      ...judged,
-      ...done,
-      durationMs: Date.now() - started
-    };
-    const {
-      judged: second
-    } = await readOnce(respaceGlyphs(cleaned, CROSS_CHECK_GAP));
+    const { raw, symbols, judged } = await readOnce(cleaned);
+    const done = { raw, symbols, image: png, cleaned };
+    if (!crossCheck || judged.problem !== void 0) return { ...judged, ...done, durationMs: Date.now() - started };
+    const { judged: second } = await readOnce(respaceGlyphs(cleaned, CROSS_CHECK_GAP));
     const confidence = Math.min(judged.confidence, second.confidence);
     const problem = second.text === judged.text ? second.problem : `a second read, with the characters spaced apart, gave "${second.text}"`;
-    return {
-      text: judged.text,
-      confidence,
-      second: second.text,
-      ...(problem !== undefined && {
-        problem
-      }),
-      ...done,
-      durationMs: Date.now() - started
-    };
+    return { text: judged.text, confidence, second: second.text, ...problem !== void 0 && { problem }, ...done, durationMs: Date.now() - started };
   };
   const solve = async (challenge, context) => {
-    const {
-      page,
-      signal
-    } = context;
-    if (challenge.selector === undefined) return {
-      status: 'failed',
-      reason: `a ${challenge.kind} challenge has no image to read`
-    };
-    if (challenge.field === undefined) return {
-      status: 'failed',
-      reason: 'the captcha step names no field for the answer'
-    };
-    let problem = 'no read';
+    const { page, signal } = context;
+    if (challenge.selector === void 0) return { status: "failed", reason: `a ${challenge.kind} challenge has no image to read` };
+    if (challenge.field === void 0) return { status: "failed", reason: "the captcha step names no field for the answer" };
+    let problem = "no read";
     for (let attempt = 1; attempt <= refreshes; attempt += 1) {
       if (signal.aborted) break;
       await settle(page, challenge.selector);
       const result = await read(await page.locator(challenge.selector).first().screenshot());
-      const record = {
-        ...result,
-        url: challenge.url,
-        attempt: context.attempt,
-        read: attempt,
-        outcome: 'refreshed'
-      };
-      if (result.problem === undefined) {
+      const record = { ...result, url: challenge.url, attempt: context.attempt, read: attempt, outcome: "refreshed" };
+      if (result.problem === void 0) {
         await page.locator(challenge.field).first().fill(result.text);
         submitted.set(challenge, record);
-        context.log('debug', `read "${result.text}" (${result.confidence}%)`);
-        return {
-          status: 'solved'
-        };
+        context.log("debug", `read "${result.text}" (${result.confidence}%)`);
+        return { status: "solved" };
       }
       problem = result.problem;
-      await audit({
-        ...record,
-        reason: problem
-      }, context);
-      if (attempt === refreshes || challenge.refresh === undefined) break;
-      context.log('debug', `refreshing the image: ${problem}`);
+      await audit({ ...record, reason: problem }, context);
+      if (attempt === refreshes || challenge.refresh === void 0) break;
+      context.log("debug", `refreshing the image: ${problem}`);
       await page.locator(challenge.refresh).first().click();
     }
-    return {
-      status: 'failed',
-      reason: `no good read after ${refreshes} image${refreshes === 1 ? '' : 's'}: ${problem}`
-    };
+    return { status: "failed", reason: `no good read after ${refreshes} image${refreshes === 1 ? "" : "s"}: ${problem}` };
   };
   return {
-    name: options.name ?? 'tesseract',
+    name: options.name ?? "tesseract",
     timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     solve,
     read,
     async verdict(challenge, verdict) {
       const record = submitted.get(challenge);
-      if (record === undefined) return;
+      if (record === void 0) return;
       submitted.delete(challenge);
-      await audit(verdict.status === 'solved' ? {
-        ...record,
-        outcome: 'solved'
-      } : {
-        ...record,
-        outcome: 'rejected',
-        reason: verdict.reason
-      });
+      await audit(verdict.status === "solved" ? { ...record, outcome: "solved" } : { ...record, outcome: "rejected", reason: verdict.reason });
     },
     close: () => engine.close()
   };
 }
-/**
- * Waits for the image to settle: its `src` unchanged for a moment and the
- * element visible. Changing a filter can make a page draw a new captcha in
- * the background; reading the old one would submit a stale code.
- */
 async function settle(page, selector) {
   const image = page.locator(selector).first();
   const deadline = Date.now() + SETTLE_LIMIT_MS;
-  let source = await image.getAttribute('src');
-  for (;;) {
+  let source = await image.getAttribute("src");
+  for (; ; ) {
     await page.waitForTimeout(SETTLE_MS);
-    const now = await image.getAttribute('src');
-    if (Date.now() >= deadline || now === source && (await image.isVisible())) return;
+    const now = await image.getAttribute("src");
+    if (Date.now() >= deadline || now === source && await image.isVisible()) return;
     source = now;
   }
 }
-
-export { cleanImage, expandCharset, judgeRead, keepCharset, otsuThreshold, tesseractReader };
+export {
+  cleanImage,
+  expandCharset,
+  judgeRead,
+  keepCharset,
+  otsuThreshold,
+  tesseractReader
+};
 //# sourceMappingURL=index.esm.js.map

package/dist/reader/index.d.ts

@@ -0,0 +1,4 @@
+export { tesseractReader } from './tesseract-reader.use-case';
+export { judgeRead } from './read-check.policy';
+export type { ChallengeLike, ImageRead, ReadSymbol, SolveContextLike, TesseractRead, TesseractReader, TesseractReaderOptions } from './reader.contract';
+//# sourceMappingURL=index.d.ts.map

package/dist/reader/letter-case.algorithm.d.ts

@@ -0,0 +1,19 @@
+import type { ReadSymbol } from './reader.contract';
+/**
+ * Puts right the case of letters that Tesseract, reading one line with no
+ * reference, cannot tell by shape: `c`/`C`, `o`/`O`, `s`/`S`, `v`/`V`, `w`/`W`,
+ * `x`/`X`, `z`/`Z` by their height against the line's capitals and digits,
+ * `p`/`P` and `y`/`Y` by a tail under the line. (`j`/`J` are left: many
+ * fonts drop the capital under the line too.) Only letters whose two cases
+ * the charset both allows are changed; a line with no capital or digit to
+ * measure against is left as read.
+ *
+ * Like telling `o` from `O` in a handwritten code by comparing it with the `8`
+ * next to it.
+ *
+ * @param symbols - The characters read, with their boxes.
+ * @param characters - The charset.
+ * @returns The characters, with their case put right.
+ */
+export declare function fixLetterCase(symbols: readonly ReadSymbol[], characters: string): ReadSymbol[];
+//# sourceMappingURL=letter-case.algorithm.d.ts.map

package/dist/reader/read-check.policy.d.ts

@@ -0,0 +1,25 @@
+import type { ReadSymbol } from './reader.contract';
+export interface ReadRules {
+    characters: string;
+    length?: number | [number, number];
+    minConfidence: number;
+}
+export interface JudgedRead {
+    text: string;
+    confidence: number;
+    problem?: string;
+}
+/**
+ * Judges a read before anything is submitted: kept to the charset, it must
+ * have the code's length, and every character must be sure enough. This is
+ * the only check possible before posting the form, and it is free: a read
+ * that fails it is refreshed, never sent. A clipped last character is the
+ * usual failure: Tesseract reads it short, or unsure.
+ *
+ * @param raw - Tesseract's text.
+ * @param symbols - Its characters with their confidence.
+ * @param rules - The charset, the length, the least confidence.
+ * @returns The filtered text, its least confidence, and the problem, if any.
+ */
+export declare function judgeRead(raw: string, symbols: readonly ReadSymbol[], rules: ReadRules): JudgedRead;
+//# sourceMappingURL=read-check.policy.d.ts.map

package/dist/reader/reader.contract.d.ts

@@ -0,0 +1,123 @@
+import type { CleanupOptions } from '../image-cleanup';
+/** An element on the page, as Playwright's `Locator` offers it. */
+export interface ElementHandleLike {
+    first: () => ElementHandleLike;
+    screenshot: () => Promise<Buffer>;
+    click: () => Promise<void>;
+    fill: (value: string) => Promise<void>;
+    getAttribute: (name: string) => Promise<string | null>;
+    isVisible: () => Promise<boolean>;
+}
+export interface PageLike {
+    locator: (selector: string) => ElementHandleLike;
+    waitForTimeout: (ms: number) => Promise<void>;
+}
+/** The challenge as the engine hands it over: the image's selector, and the form's field and refresh control. */
+export interface ChallengeLike {
+    kind: string;
+    url: string;
+    selector?: string;
+    field?: string;
+    refresh?: string;
+}
+export interface SolveContextLike {
+    page: PageLike;
+    attempt: number;
+    signal: AbortSignal;
+    log: (level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: Record<string, unknown>) => void;
+}
+export type SolveOutcome = {
+    status: 'solved';
+} | {
+    status: 'failed';
+    reason: string;
+};
+export type SolveVerdict = {
+    status: 'solved';
+} | {
+    status: 'rejected';
+    reason: string;
+};
+/** One character Tesseract read, how sure it was (0–100), and where (pixels of the cleaned image). */
+export interface ReadSymbol {
+    text: string;
+    confidence: number;
+    box?: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+}
+/** What one reading of an image gave. */
+export interface ImageRead {
+    /** What was read, kept to the charset. */
+    text: string;
+    /** Tesseract's text before filtering. */
+    raw: string;
+    /** The least sure character's confidence (0–100): whole-word confidence is too noisy on six loose characters. */
+    confidence: number;
+    symbols: ReadSymbol[];
+    /** The cross-check's read, with the characters spaced apart, when one was made (the first read passed its checks). */
+    second?: string;
+    /** Why the read is not good enough to submit (a wrong length, a low confidence, a cross-check that disagreed), when it is not. */
+    problem?: string;
+    /** The image as captured, and as Tesseract saw it after cleanup (PNG). */
+    image: Buffer;
+    cleaned: Buffer;
+    durationMs: number;
+}
+/** One read as the audit sees it, with how it ended. */
+export interface TesseractRead extends ImageRead {
+    url: string;
+    /** The engine's attempt, from 1. */
+    attempt: number;
+    /** The read within the attempt, from 1: each refresh adds one. */
+    read: number;
+    /** `refreshed`: not good enough, never submitted. `rejected` / `solved`: submitted, and what the page said. */
+    outcome: 'refreshed' | 'rejected' | 'solved';
+    reason?: string;
+}
+export interface TesseractReaderOptions {
+    /** The name recipes use. Default `tesseract`. */
+    name?: string;
+    /** The characters the captcha uses: a list with ranges (`'A-Za-z0-9'`, the default) or a one-character RegExp class. */
+    charset?: string | RegExp;
+    /** The code's length, or its range. A read of another length is refreshed, never submitted. */
+    length?: number | [number, number];
+    /** Whether `a` and `A` differ. Default `false`: each letter allows its other case too. */
+    caseSensitive?: boolean;
+    /** The least confidence (0–100) every character must have. Default 30. */
+    minConfidence?: number;
+    /** Reads (after refreshing the image) before an attempt gives up. Default 5. */
+    refreshes?: number;
+    /**
+     * Reads the code a second time with its characters spaced apart, and submits only when both reads agree.
+     * Tesseract reads a line with context and can bend a character to fit its neighbours (a `4` after lowercase
+     * letters read as `a`); read apart, it rarely makes the same mistake. Default `true`: on 100 real captchas it cut
+     * wrong submissions from 6 to 1, for a few more (free) refreshes and a second read of each passing image.
+     */
+    crossCheck?: boolean;
+    /** Image cleanup before OCR. */
+    preprocess?: CleanupOptions;
+    /** Tesseract's page segmentation mode: 7 one line (default), 8 one word, 13 a raw line. */
+    pageSegMode?: 7 | 8 | 13;
+    /** Tesseract language (default `eng`) and where its `.traineddata.gz` is (default: the bundled English model). */
+    lang?: string;
+    langPath?: string;
+    /** Called for every read; a throw is logged and ignored. */
+    audit?: (read: TesseractRead) => Promise<void> | void;
+    /** How long one attempt may take, refreshes included, when the recipe does not say. Default 60000. */
+    timeoutMs?: number;
+}
+/** The reader: an OpenCraw captcha solver, and `read` for reading an image directly. */
+export interface TesseractReader {
+    readonly name: string;
+    readonly timeoutMs: number;
+    solve(challenge: ChallengeLike, context: SolveContextLike): Promise<SolveOutcome>;
+    verdict(challenge: ChallengeLike, verdict: SolveVerdict): Promise<void>;
+    close(): Promise<void>;
+    /** Reads a captcha image (PNG bytes) and judges the read, without a page. */
+    read(png: Buffer): Promise<ImageRead>;
+}
+//# sourceMappingURL=reader.contract.d.ts.map

package/dist/reader/tesseract-engine.client.d.ts

@@ -0,0 +1,32 @@
+import type { ReadSymbol } from './reader.contract';
+export interface EngineOptions {
+    lang: string;
+    langPath?: string;
+    whitelist: string;
+    pageSegMode: 7 | 8 | 13;
+}
+/**
+ * One Tesseract worker (a thread running Tesseract in WebAssembly), started
+ * on the first read and reused: reads queue on it. The language data comes
+ * from disk, never from a CDN, and nothing is cached in the working
+ * directory.
+ */
+export declare class TesseractEngine {
+    private readonly options;
+    private worker;
+    constructor(options: EngineOptions);
+    private start;
+    /**
+     * Reads one image.
+     *
+     * @param png - The cleaned image.
+     * @returns The text and each character with its confidence.
+     */
+    read(png: Buffer): Promise<{
+        raw: string;
+        symbols: ReadSymbol[];
+    }>;
+    /** Stops the worker thread, if it started. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=tesseract-engine.client.d.ts.map

package/dist/reader/tesseract-reader.use-case.d.ts

@@ -0,0 +1,14 @@
+import type { TesseractReader, TesseractReaderOptions } from './reader.contract';
+/**
+ * A captcha reader for OpenCraw's form captchas: it reads the code in the
+ * challenge's image with Tesseract, refreshes the image while the read is not
+ * good enough (wrong length, an unsure character, and no form is posted for
+ * that), fills the challenge's answer field, and returns `solved`. The engine
+ * posts the form, checks the page and tells the verdict, which goes to
+ * `audit` with the read.
+ *
+ * @param options - The charset, the length, the checks, the cleanup, the audit.
+ * @returns The reader, to register as a captcha solver.
+ */
+export declare function tesseractReader(options?: TesseractReaderOptions): TesseractReader;
+//# sourceMappingURL=tesseract-reader.use-case.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencraw/captcha-tesseract",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "type": "module",
   "main": "./dist/index.esm.js",
   "module": "./dist/index.esm.js",
@@ -46,29 +46,15 @@
     "node": ">=20"
   },
   "sideEffects": false,
-  "nx": {
-    "targets": {
-      "e2e": {
-        "executor": "nx:run-commands",
-        "dependsOn": [
-          "build",
-          {
-            "projects": [
-              "@opencraw/core"
-            ],
-            "target": "build"
-          }
-        ],
-        "inputs": [
-          "default",
-          "^production",
-          "{workspaceRoot}/packages/core/e2e/**"
-        ],
-        "options": {
-          "command": "tsc -p tsconfig.e2e.json && jest --config jest.e2e.config.cts",
-          "cwd": "packages/captcha-tesseract"
-        }
-      }
-    }
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --packages=external --format=esm --outfile=dist/index.esm.js --sourcemap && tsc -p tsconfig.lib.json --emitDeclarationOnly --declaration --declarationDir dist/src --tsBuildInfoFile dist/src/tsconfig.lib.tsbuildinfo && node ../../declaration-specifiers.mjs dist/src",
+    "e2e": "tsc -p tsconfig.e2e.json && jest --config jest.e2e.config.cts",
+    "lint": "eslint .",
+    "test": "jest",
+    "typecheck": "tsc --build tsconfig.json --emitDeclarationOnly"
+  },
+  "devDependencies": {
+    "@opencraw/core": "^0.3.0",
+    "playwright": "^1.64.1"
   }
 }