@stabrise/scaledp 0.1.0

package/dist/ocr-OHX2WM3e.js

@@ -0,0 +1,1294 @@
+import { h as getConfig, i as Stage, s as DetectionError, u as OcrError } from "./pipeline-DACqGkpN.js";
+import { A as polygonArea, D as boxPoints, S as isRotated, _ as boxFromBBox, a as cropBox, c as encodeImage, i as createCanvas, j as polygonPerimeter, k as minAreaRect, l as imageDataToCanvas, m as toNchwFloat32, n as IMAGENET_STD, o as cropGeometry, p as toImageData, r as context2d, s as decodeImage, t as IMAGENET_MEAN, u as letterbox, v as boxFromPolygon, w as mergeOverlappingBoxes } from "./image-CAH2rLv9.js";
+import { a as isCached, n as ensureModelFiles, r as evict } from "./model-cache-BEaqqRZ9.js";
+import { i as resolveParams, t as BASE_STAGE_DEFAULTS } from "./params-DapwK9Ns.js";
+import { n as boxesToText, t as boxesToFormattedText } from "./text-ahMLpxN9.js";
+import { t as createDetectorOutput } from "./detector-output-lyF1Mqb8.js";
+import { n as createDocument, t as createImage } from "./image-DoZDJkcR.js";
+import { i as loadOrt, t as createSession } from "./ort-CXDoPrtw.js";
+//#region src/ocr/db-postprocess.ts
+/**
+* Differentiable Binarization post-processing.
+*
+* Port of `scaledp/models/detectors/paddle_onnx/db_postprocess.py`. Takes the
+* model's probability map and turns it into text quads, with the same
+* thresholds, ordering and filtering as Python so box output matches.
+*/
+/**
+* ScaleDP's own values, from `predict_det.py`. Note `boxThresh` is 0.3 there
+* and the stage-level `scoreThreshold` never reaches this code -- a Python bug
+* that is not reproduced: here `boxThresh` is what the stage actually sets.
+*/
+const DB_POSTPROCESS_DEFAULTS = Object.freeze({
+	thresh: .5,
+	boxThresh: .3,
+	maxCandidates: 1e3,
+	unclipRatio: 2.5,
+	minSize: 3
+});
+/**
+* Boundary pixels of each 8-connected foreground component.
+*
+* cv2.findContours traces outlines; we collect boundary pixels instead. For the
+* only consumers here -- minAreaRect and its convex hull -- the two are
+* equivalent, and this avoids porting Suzuki-Abe border following.
+*/
+function findComponentBoundaries(map, thresh, maxCandidates) {
+	const { data, width, height } = map;
+	const visited = new Uint8Array(width * height);
+	const components = [];
+	const isForeground = (x, y) => x >= 0 && y >= 0 && x < width && y < height && data[y * width + x] > thresh;
+	const stack = [];
+	for (let start = 0; start < visited.length && components.length < maxCandidates; start++) {
+		if (visited[start] || !(data[start] > thresh)) continue;
+		const boundary = [];
+		stack.length = 0;
+		stack.push(start);
+		visited[start] = 1;
+		while (stack.length > 0) {
+			const index = stack.pop();
+			const x = index % width;
+			const y = (index - x) / width;
+			let onBoundary = false;
+			for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+				if (dx === 0 && dy === 0) continue;
+				const nx = x + dx;
+				const ny = y + dy;
+				if (!isForeground(nx, ny)) {
+					onBoundary = true;
+					continue;
+				}
+				const neighbour = ny * width + nx;
+				if (!visited[neighbour]) {
+					visited[neighbour] = 1;
+					stack.push(neighbour);
+				}
+			}
+			if (onBoundary) boundary.push([x, y]);
+		}
+		if (boundary.length >= 3) components.push(boundary);
+	}
+	return components;
+}
+/**
+* Corners of the minimum-area rect, ordered top-left, top-right, bottom-right,
+* bottom-left, together with the rect's shorter side.
+*
+* Port of `get_mini_boxes`: sort the four corners by x, then decide within each
+* pair which is the upper one.
+*/
+function miniBox(points) {
+	const rect = minAreaRect(points);
+	const [p0, p1, p2, p3] = [...boxPoints(rect)].sort((a, b) => a[0] - b[0]);
+	const [topLeft, bottomLeft] = p0[1] <= p1[1] ? [p0, p1] : [p1, p0];
+	const [topRight, bottomRight] = p2[1] <= p3[1] ? [p2, p3] : [p3, p2];
+	return {
+		points: [
+			topLeft,
+			topRight,
+			bottomRight,
+			bottomLeft
+		],
+		sside: Math.min(rect.size[0], rect.size[1])
+	};
+}
+/**
+* Mean probability inside a quad -- port of `box_score_fast`.
+*
+* Python builds an integer mask with `cv2.fillPoly` and averages the
+* probability map under it, so this reproduces OpenCV's fill convention:
+* vertices are truncated to integers and treated as pixel *centres*, scanlines
+* run at integer y, and both ends of each span are inclusive. Sampling at
+* pixel centres instead (the more usual rasterisation rule) drops the boundary
+* row and column, which shifts the score by around 1% and changes which
+* candidates clear `boxThresh`.
+*/
+function boxScore(map, points) {
+	const { data, width, height } = map;
+	const xs = points.map((p) => p[0]);
+	const ys = points.map((p) => p[1]);
+	const clamp = (value, max) => Math.min(Math.max(value, 0), max);
+	const xmin = clamp(Math.floor(Math.min(...xs)), width - 1);
+	const xmax = clamp(Math.ceil(Math.max(...xs)), width - 1);
+	const ymin = clamp(Math.floor(Math.min(...ys)), height - 1);
+	const ymax = clamp(Math.ceil(Math.max(...ys)), height - 1);
+	if (xmax < xmin || ymax < ymin) return 0;
+	const local = points.map(([x, y]) => [Math.trunc(x - xmin), Math.trunc(y - ymin)]);
+	const maskWidth = xmax - xmin;
+	const maskHeight = ymax - ymin;
+	let sum = 0;
+	let count = 0;
+	for (let y = 0; y <= maskHeight; y++) {
+		let left = Number.POSITIVE_INFINITY;
+		let right = Number.NEGATIVE_INFINITY;
+		for (let i = 0; i < local.length; i++) {
+			const a = local[i];
+			const b = local[(i + 1) % local.length];
+			if (a[1] === b[1]) {
+				if (a[1] !== y) continue;
+				left = Math.min(left, a[0], b[0]);
+				right = Math.max(right, a[0], b[0]);
+				continue;
+			}
+			if (y < Math.min(a[1], b[1]) || y > Math.max(a[1], b[1])) continue;
+			const x = a[0] + (y - a[1]) / (b[1] - a[1]) * (b[0] - a[0]);
+			left = Math.min(left, x);
+			right = Math.max(right, x);
+		}
+		if (left > right) continue;
+		const from = Math.max(0, Math.ceil(left));
+		const to = Math.min(maskWidth, Math.floor(right));
+		const rowOffset = (y + ymin) * width + xmin;
+		for (let x = from; x <= to; x++) {
+			sum += data[rowOffset + x];
+			count++;
+		}
+	}
+	return count === 0 ? 0 : sum / count;
+}
+/**
+* Grow a detected rect outward -- port of `unclip`.
+*
+* Python offsets the polygon with a Clipper round join and then takes the
+* minimum-area rect of the result. For a rectangle those two steps compose
+* exactly: offsetting outward by `d` produces a rounded rectangle whose
+* min-area rect is the original grown by `d` on each of the four sides. That
+* identity is what lets this avoid a Clipper dependency entirely.
+*/
+function unclipRect(points, unclipRatio) {
+	const rect = minAreaRect(points);
+	const perimeter = polygonPerimeter(points);
+	const distance = perimeter === 0 ? 0 : polygonArea(points) * unclipRatio / perimeter;
+	return boxPoints({
+		center: rect.center,
+		size: [rect.size[0] + distance * 2, rect.size[1] + distance * 2],
+		angle: rect.angle
+	});
+}
+/**
+* Reorder four points clockwise from the top-left -- port of
+* `order_points_clockwise`. Top-left has the smallest x+y, bottom-right the
+* largest; the remaining two are separated by y-x.
+*/
+function orderPointsClockwise(points) {
+	const bySum = [...points].sort((a, b) => a[0] + a[1] - (b[0] + b[1]));
+	const topLeft = bySum[0];
+	const bottomRight = bySum[bySum.length - 1];
+	const rest = bySum.slice(1, -1).sort((a, b) => a[1] - a[0] - (b[1] - b[0]));
+	return [
+		topLeft,
+		rest[0],
+		bottomRight,
+		rest[1]
+	];
+}
+/**
+* Probability map -> text quads in source-image coordinates.
+*
+* `scale` is the uniform factor the source was resized by. Coordinates restore
+* by *dividing* by it, with no offset to subtract, because the letterbox pads
+* bottom and right only.
+*/
+function quadsFromProbabilityMap(map, source, scale, options = {}) {
+	const opts = {
+		...DB_POSTPROCESS_DEFAULTS,
+		...options
+	};
+	const quads = [];
+	for (const boundary of findComponentBoundaries(map, opts.thresh, opts.maxCandidates)) {
+		const candidate = miniBox(boundary);
+		if (candidate.sside < opts.minSize) continue;
+		const score = boxScore(map, candidate.points);
+		if (score < opts.boxThresh) continue;
+		const expanded = miniBox(unclipRect(candidate.points, opts.unclipRatio));
+		if (expanded.sside < opts.minSize + 2) continue;
+		const ordered = orderPointsClockwise(expanded.points.map(([x, y]) => [Math.min(Math.max(Math.round(x / scale), 0), source.width), Math.min(Math.max(Math.round(y / scale), 0), source.height)]));
+		const width = Math.hypot(ordered[0][0] - ordered[1][0], ordered[0][1] - ordered[1][1]);
+		const height = Math.hypot(ordered[0][0] - ordered[3][0], ordered[0][1] - ordered[3][1]);
+		if (width <= 3 || height <= 3) continue;
+		quads.push({
+			points: ordered,
+			score
+		});
+	}
+	return quads;
+}
+//#endregion
+//#region src/ocr/dbnet-onnx.ts
+/**
+* DBNet ONNX text detection -- the direct mirror of
+* `scaledp/models/detectors/DBNetOnnxDetector.py`, so ScaleDP's own detection
+* model runs unchanged in the browser.
+*
+* Preprocessing reproduces `paddle_onnx/operators.py` exactly, including one
+* quirk that matters: the Python path converts RGB to BGR and never converts
+* back, so the model is fed BGR channels normalised against *RGB* ImageNet
+* statistics. Feeding true RGB instead shifts the boxes.
+*
+* The model detects text *lines*, not words -- one region per line, in Python
+* as here. Nothing downstream subdivides them either: `TesseractRecognizer`
+* reads each region with PSM.SINGLE_WORD and returns one box per region, which
+* is what ScaleDP does too. `TesseractOcr`, which runs tesseract's own layout
+* analysis over the whole page, is the stage that yields word boxes.
+*/
+/** Fixed input size from ScaleDP's `DetResizeForTest` config. */
+const DBNET_INPUT_SIZE = 1280;
+/** Model ScaleDP's DBNetOnnxDetector documents and its tests use. */
+const DEFAULT_DBNET_MODEL = "StabRise/text_detection_dbnet_ml_v0.2";
+const DBNET_DETECTOR_DEFAULTS = Object.freeze({
+	...BASE_STAGE_DEFAULTS,
+	inputCol: "image",
+	outputCol: "boxes",
+	keepInputData: true,
+	model: DEFAULT_DBNET_MODEL,
+	scoreThreshold: DB_POSTPROCESS_DEFAULTS.boxThresh,
+	binaryThreshold: DB_POSTPROCESS_DEFAULTS.thresh,
+	unclipRatio: DB_POSTPROCESS_DEFAULTS.unclipRatio,
+	mergeBoxes: true
+});
+function modelSpec(model) {
+	return /^https?:\/\//.test(model) ? {
+		repo: "dbnet",
+		files: [{ path: model }]
+	} : {
+		repo: model,
+		files: [{ path: "model.onnx" }]
+	};
+}
+var DbnetOnnxDetector = class extends Stage {
+	name = "DbnetOnnxDetector";
+	session = null;
+	loading = null;
+	constructor(options = {}) {
+		super(resolveParams(DBNET_DETECTOR_DEFAULTS, options));
+	}
+	async init() {
+		await this.getSession();
+	}
+	getSession() {
+		if (this.session) return Promise.resolve(this.session);
+		if (this.loading) return this.loading;
+		this.loading = (async () => {
+			const spec = modelSpec(this.params.model);
+			const bytes = (await ensureModelFiles(spec))[spec.files[0]?.path ?? ""];
+			if (!bytes) throw new DetectionError(`Model ${this.params.model} not found`, this.name);
+			const session = await createSession(bytes, { executionProviders: getConfig().executionProviders });
+			this.session = session;
+			return session;
+		})();
+		this.loading.catch(() => {
+			this.loading = null;
+		});
+		return this.loading;
+	}
+	async dispose() {
+		await this.session?.release();
+		this.session = null;
+		this.loading = null;
+	}
+	async apply(input, row) {
+		const image = input;
+		if (image?.exception) throw new DetectionError(`Upstream stage failed: ${image.exception}`, this.name);
+		if (!image || !(image.data instanceof Uint8Array) || image.data.byteLength === 0) throw new DetectionError("Expected an Image with decoded bytes", this.name);
+		const bitmap = await decodeImage(image.data);
+		let boxes;
+		try {
+			boxes = await this.detect(bitmap);
+		} finally {
+			bitmap.close();
+		}
+		return createDetectorOutput({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "dbnet-onnx",
+			bboxes: boxes
+		});
+	}
+	/** Run the model over one decoded image and return boxes in its coordinates. */
+	async detect(source) {
+		const session = await this.getSession();
+		const fitted = letterbox(source, {
+			width: DBNET_INPUT_SIZE,
+			height: DBNET_INPUT_SIZE
+		}, {
+			padding: "end",
+			fill: "#ffffff"
+		});
+		const tensorData = toNchwFloat32(toImageData(fitted.canvas), {
+			mean: IMAGENET_MEAN,
+			std: IMAGENET_STD,
+			bgr: true
+		});
+		const { Tensor } = await import("onnxruntime-web");
+		const inputName = session.inputNames[0];
+		const outputName = session.outputNames[0];
+		if (!inputName || !outputName) throw new DetectionError("Model exposes no input or output", this.name);
+		const output = (await session.run({ [inputName]: new Tensor("float32", tensorData, [
+			1,
+			3,
+			DBNET_INPUT_SIZE,
+			DBNET_INPUT_SIZE
+		]) }))[outputName];
+		if (!output) throw new DetectionError(`Model produced no "${outputName}" output`, this.name);
+		const [, , height = DBNET_INPUT_SIZE, width = DBNET_INPUT_SIZE] = output.dims;
+		const boxes = quadsFromProbabilityMap({
+			data: output.data,
+			width,
+			height
+		}, {
+			width: source.width,
+			height: source.height
+		}, fitted.scale, {
+			thresh: this.params.binaryThreshold,
+			boxThresh: this.params.scoreThreshold,
+			unclipRatio: this.params.unclipRatio
+		}).map((quad) => boxFromPolygon(quad.points, { score: quad.score }));
+		return this.params.mergeBoxes ? mergeOverlappingBoxes(boxes, .02, 10, .3) : boxes;
+	}
+	onError(message, row) {
+		return createDetectorOutput({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "dbnet-onnx",
+			exception: message
+		});
+	}
+};
+//#endregion
+//#region src/ocr/detector-registry.ts
+const DETECTOR_MODELS = Object.freeze([
+	{
+		id: "paddle",
+		name: "PaddleOCR DB (follows the OCR preset)",
+		kind: "paddle",
+		notes: "Shares the detection model already downloaded for the selected OCR preset."
+	},
+	{
+		id: "dbnet-v0.2",
+		name: "StabRise DBNet ONNX v0.2 (~5 MB)",
+		kind: "dbnet-onnx",
+		repo: "StabRise/text_detection_dbnet_ml_v0.2",
+		approxBytes: 48e5,
+		notes: "The same detection model ScaleDP uses server-side."
+	},
+	{
+		id: "dbnet-v0.1",
+		name: "StabRise DBNet ONNX v0.1 (~5 MB)",
+		kind: "dbnet-onnx",
+		repo: "StabRise/text_detection_dbnet_ml_v0.1",
+		approxBytes: 48e5,
+		notes: "The earlier revision, kept for comparison."
+	}
+]);
+const DEFAULT_DETECTOR_ID = "paddle";
+function getDetectorModel(id) {
+	return DETECTOR_MODELS.find((m) => m.id === id);
+}
+//#endregion
+//#region src/ocr/line-orientation.ts
+/**
+* 0 / 180 degree line-orientation classifier.
+*
+* Port of `scaledp/models/detectors/HasDetectLineOrientation.py`. Tiny, and it
+* meaningfully improves recognition on rotated crops -- an upside-down line
+* otherwise recognises as noise.
+*
+* Reproduces the same BGR-with-RGB-statistics quirk as the DBNet path: the
+* Python code converts to BGR and normalises with RGB ImageNet constants.
+*/
+const DEFAULT_ORIENTATION_MODEL = "StabRise/line_orientation_detection_v0.1";
+/** Model input, width x height. */
+const ORIENTATION_INPUT = {
+	width: 160,
+	height: 80
+};
+const LABELS = ["0_degree", "180_degree"];
+var LineOrientationClassifier = class {
+	model;
+	session = null;
+	loading = null;
+	constructor(model = DEFAULT_ORIENTATION_MODEL) {
+		this.model = model;
+	}
+	getSession() {
+		if (this.session) return Promise.resolve(this.session);
+		if (this.loading) return this.loading;
+		this.loading = (async () => {
+			const bytes = (await ensureModelFiles({
+				repo: this.model,
+				files: [{ path: "model.onnx" }]
+			}))["model.onnx"];
+			if (!bytes) throw new DetectionError(`Model ${this.model} has no model.onnx`, "LineOrientation");
+			const session = await createSession(bytes);
+			this.session = session;
+			return session;
+		})();
+		this.loading.catch(() => {
+			this.loading = null;
+		});
+		return this.loading;
+	}
+	async classify(source) {
+		const session = await this.getSession();
+		const canvas = createCanvas(ORIENTATION_INPUT.width, ORIENTATION_INPUT.height);
+		context2d(canvas).drawImage(source, 0, 0, canvas.width, canvas.height);
+		const data = toNchwFloat32(toImageData(canvas), {
+			mean: IMAGENET_MEAN,
+			std: IMAGENET_STD,
+			bgr: true
+		});
+		const { Tensor } = await import("onnxruntime-web");
+		const inputName = session.inputNames[0];
+		const outputName = session.outputNames[0];
+		if (!inputName || !outputName) throw new DetectionError("Model exposes no input or output", "LineOrientation");
+		const logits = (await session.run({ [inputName]: new Tensor("float32", data, [
+			1,
+			3,
+			ORIENTATION_INPUT.height,
+			ORIENTATION_INPUT.width
+		]) }))[outputName]?.data;
+		if (!logits || logits.length < 2) throw new DetectionError("Classifier produced no logits", "LineOrientation");
+		return logits[1] > logits[0] ? LABELS[1] : LABELS[0];
+	}
+	async dispose() {
+		await this.session?.release();
+		this.session = null;
+		this.loading = null;
+	}
+};
+//#endregion
+//#region src/ocr/line-orientation-stage.ts
+/**
+* Line-orientation detection and correction.
+*
+* Port of ScaleDP's `HasDetectLineOrientation`, which `TesseractRecognizer`
+* mixes in: each detected box is cropped, classified 0 or 180 degrees, and the
+* upside-down ones are turned before recognition. An inverted line otherwise
+* recognises as noise.
+*
+* Python does this per crop inside the recognizer. Here it is a stage of its
+* own, because `PaddleTextRecognizer` detects and recognises in a single pass
+* and has no seam to hook into. Flipping each inverted region in place on a
+* copy of the page gets the same result and costs one recognition pass rather
+* than one per box; the regions are rectangles, so a 180-degree turn leaves
+* every box's coordinates untouched and downstream stages need no adjustment.
+*/
+const LINE_ORIENTATION_DEFAULTS = Object.freeze({
+	...BASE_STAGE_DEFAULTS,
+	inputCol: "image",
+	inputCols: ["image", "boxes"],
+	outputCol: "oriented",
+	orientationCol: "orientations",
+	keepInputData: true,
+	model: DEFAULT_ORIENTATION_MODEL,
+	correct: true,
+	onlyRotated: true,
+	padding: 2,
+	imageType: "png"
+});
+function boxesOf$1(source) {
+	if (typeof source !== "object" || source === null) return [];
+	return source.bboxes ?? [];
+}
+var LineOrientationDetector = class extends Stage {
+	name = "LineOrientationDetector";
+	classifier = null;
+	constructor(options = {}) {
+		super(resolveParams(LINE_ORIENTATION_DEFAULTS, options, { inputCols: (value) => {
+			if (value.length !== 2) throw new RangeError("inputCols must be [imageColumn, boxColumn]");
+		} }));
+	}
+	async init() {
+		this.classifier ??= new LineOrientationClassifier(this.params.model);
+	}
+	/** One row in, one row out -- but two columns written, so expand not apply. */
+	async expand(_input, row, ctx) {
+		const { inputCols, outputCol, orientationCol, correct, onlyRotated, padding } = this.params;
+		const [imageCol, boxCol] = inputCols;
+		const image = row[imageCol];
+		if (image?.exception) throw new DetectionError(`Upstream stage failed: ${image.exception}`, this.name);
+		if (!image || !(image.data instanceof Uint8Array) || image.data.byteLength === 0) throw new DetectionError("Expected an Image with decoded bytes", this.name);
+		await this.init();
+		const classifier = this.classifier;
+		const boxes = boxesOf$1(row[boxCol]);
+		const bitmap = await decodeImage(image.data);
+		try {
+			const canvas = createCanvas(bitmap.width, bitmap.height);
+			const ctx2d = context2d(canvas);
+			ctx2d.drawImage(bitmap, 0, 0);
+			const orientations = [];
+			let flipped = 0;
+			for (const box of boxes) {
+				ctx.signal?.throwIfAborted();
+				if (onlyRotated && !isRotated(box)) {
+					orientations.push("0_degree");
+					continue;
+				}
+				const crop = cropBox(bitmap, box, { padding });
+				const orientation = await classifier.classify(crop);
+				orientations.push(orientation);
+				if (orientation === "180_degree" && correct) {
+					flipRegion(ctx2d, canvas, box);
+					flipped++;
+				}
+			}
+			const corrected = flipped > 0 ? createImage({
+				path: image.path,
+				resolution: image.resolution,
+				data: await encodeImage(canvas, `image/${this.params.imageType}`),
+				imageType: this.params.imageType,
+				width: canvas.width,
+				height: canvas.height
+			}) : image;
+			return [{
+				...row,
+				[outputCol]: corrected,
+				[orientationCol]: orientations
+			}];
+		} finally {
+			bitmap.close();
+		}
+	}
+	async apply() {
+		throw new DetectionError("unreachable: expand handles every row", this.name);
+	}
+	onError(message, row) {
+		return createImage({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			exception: message
+		});
+	}
+	async dispose() {
+		await this.classifier?.dispose();
+		this.classifier = null;
+	}
+};
+/**
+* Turn one box's region 180 degrees in place.
+*
+* A rectangle maps onto itself under a 180-degree rotation about its own
+* centre, whatever its angle, so the box's coordinates stay valid and
+* downstream stages need no adjustment.
+*
+* The draw is clipped to the box's own rotated outline. Without that a rotated
+* box turns its whole axis-aligned envelope, dragging neighbouring text through
+* the rotation with it -- and the envelope of a skewed box is meaningfully
+* larger than the box.
+*/
+function flipRegion(ctx, canvas, box) {
+	const pad = 1;
+	const x = Math.max(0, Math.min(Math.round(box.x) - pad, canvas.width - 1));
+	const y = Math.max(0, Math.min(Math.round(box.y) - pad, canvas.height - 1));
+	const width = Math.min(Math.round(box.width) + 2, canvas.width - x);
+	const height = Math.min(Math.round(box.height) + 2, canvas.height - y);
+	if (width < 1 || height < 1) return;
+	const region = createCanvas(width, height);
+	context2d(region).drawImage(canvas, x, y, width, height, 0, 0, width, height);
+	const cx = x + width / 2;
+	const cy = y + height / 2;
+	ctx.save();
+	ctx.beginPath();
+	if (Math.abs(box.angle) < 3) ctx.rect(x, y, width, height);
+	else {
+		const rad = box.angle * Math.PI / 180;
+		const cos = Math.cos(rad);
+		const sin = Math.sin(rad);
+		[
+			[-box.width / 2, -box.height / 2],
+			[box.width / 2, -box.height / 2],
+			[box.width / 2, box.height / 2],
+			[-box.width / 2, box.height / 2]
+		].forEach(([px, py], index) => {
+			const rx = px * cos - py * sin + cx;
+			const ry = px * sin + py * cos + cy;
+			if (index === 0) ctx.moveTo(rx, ry);
+			else ctx.lineTo(rx, ry);
+		});
+		ctx.closePath();
+	}
+	ctx.clip();
+	ctx.translate(cx, cy);
+	ctx.rotate(Math.PI);
+	ctx.drawImage(region, -width / 2, -height / 2);
+	ctx.restore();
+}
+//#endregion
+//#region src/ocr/presets.ts
+const PADDLE_OCR_PRESETS = Object.freeze([
+	{
+		value: "v6-small",
+		label: "Latin / CJK (default)",
+		scripts: [
+			"Latin",
+			"Han",
+			"Hiragana",
+			"Katakana"
+		]
+	},
+	{
+		value: "v6-medium",
+		label: "Latin / CJK (medium, more accurate)",
+		scripts: [
+			"Latin",
+			"Han",
+			"Hiragana",
+			"Katakana"
+		]
+	},
+	{
+		value: "v6-tiny",
+		label: "Latin / CJK (tiny, fastest)",
+		scripts: ["Latin", "Han"]
+	},
+	{
+		value: "v5-latin-mobile",
+		label: "Latin (French, German, Spanish, ...)",
+		scripts: ["Latin"]
+	},
+	{
+		value: "v5-eslav-mobile",
+		label: "Latin + Cyrillic (Russian, Ukrainian, ...)",
+		scripts: ["Latin", "Cyrillic"]
+	},
+	{
+		value: "v5-cyrillic-mobile",
+		label: "Cyrillic only",
+		scripts: ["Cyrillic"]
+	},
+	{
+		value: "v5-devanagari-mobile",
+		label: "Latin + Hindi (Devanagari)",
+		scripts: ["Latin", "Devanagari"]
+	},
+	{
+		value: "v5-arabic-mobile",
+		label: "Latin + Arabic",
+		scripts: ["Latin", "Arabic"]
+	},
+	{
+		value: "v5-greek-mobile",
+		label: "Latin + Greek",
+		scripts: ["Latin", "Greek"]
+	},
+	{
+		value: "v5-korean-mobile",
+		label: "Latin + Korean",
+		scripts: ["Latin", "Hangul"]
+	},
+	{
+		value: "v5-thai-mobile",
+		label: "Latin + Thai",
+		scripts: ["Latin", "Thai"]
+	},
+	{
+		value: "v5-tamil-mobile",
+		label: "Latin + Tamil",
+		scripts: ["Latin", "Tamil"]
+	},
+	{
+		value: "v5-telugu-mobile",
+		label: "Latin + Telugu",
+		scripts: ["Latin", "Telugu"]
+	},
+	{
+		value: "v5-en-mobile",
+		label: "English only (fastest)",
+		scripts: ["Latin"]
+	}
+]);
+const DEFAULT_OCR_PRESET = "v6-small";
+function isKnownPreset(value) {
+	return PADDLE_OCR_PRESETS.some((p) => p.value === value);
+}
+/** Presets able to read a script name as reported by OSD script detection. */
+function presetsForScript(script) {
+	return PADDLE_OCR_PRESETS.filter((p) => p.scripts.includes(script));
+}
+//#endregion
+//#region src/ocr/paddle-service.ts
+/**
+* PaddleOcrService lifecycle: model fetching, caching and per-preset reuse.
+*
+* Models are pulled through our own ModelCache and handed to the service as
+* ArrayBuffers, rather than letting ppu-paddle-ocr fetch them itself. Its
+* browser build re-downloads ~6 MB on every page load, relying only on the HTTP
+* cache; routing through IndexedDB makes a repeat visit instant and offline-safe.
+*/
+let modulePromise = null;
+async function loadPpu() {
+	if (modulePromise) return modulePromise;
+	modulePromise = (async () => {
+		await loadOrt();
+		try {
+			return await import("ppu-paddle-ocr/web");
+		} catch (cause) {
+			throw new Error("ppu-paddle-ocr is required for PaddleOCR stages. Install it: npm i ppu-paddle-ocr", { cause });
+		}
+	})();
+	return modulePromise;
+}
+/** The three files a preset needs, as a ModelSpec our cache understands. */
+async function specForPreset(preset) {
+	const ppu = await loadPpu();
+	const urls = preset in ppu.MODEL_PRESETS ? ppu.MODEL_PRESETS[preset] : ppu.DEFAULT_MODEL;
+	const roles = [
+		"detection",
+		"recognition",
+		"charactersDictionary"
+	];
+	return {
+		spec: {
+			repo: `ppu-paddle-ocr/${preset}`,
+			files: roles.map((r) => ({ path: urls[r] }))
+		},
+		roles: [...roles]
+	};
+}
+/**
+* Absolute model URLs bypass `modelHost`: ppu-paddle-ocr publishes its own
+* catalogue and the paths are meaningful only against that host.
+*/
+async function fetchPresetFiles(preset) {
+	const { spec, roles } = await specForPreset(preset);
+	const files = await ensureModelFiles({
+		...spec,
+		files: spec.files.map((f) => ({ ...f }))
+	});
+	const out = {};
+	for (const [i, role] of roles.entries()) {
+		const path = spec.files[i]?.path;
+		if (path && files[path]) out[role] = files[path];
+	}
+	return out;
+}
+const services = /* @__PURE__ */ new Map();
+async function getPaddleService(preset = DEFAULT_OCR_PRESET) {
+	const existing = services.get(preset);
+	if (existing) return existing;
+	const promise = (async () => {
+		const ppu = await loadPpu();
+		const model = await fetchPresetFiles(preset);
+		const service = new ppu.PaddleOcrService({
+			model,
+			session: {
+				executionProviders: [...getConfig().executionProviders],
+				graphOptimizationLevel: "all"
+			}
+		});
+		await service.initialize();
+		return service;
+	})();
+	promise.catch(() => services.delete(preset));
+	services.set(preset, promise);
+	return promise;
+}
+async function isPresetCached(preset) {
+	const { spec } = await specForPreset(preset);
+	return isCached(spec);
+}
+/** Pre-warm a preset so the first OCR call does not pay the download. */
+async function loadPreset(preset) {
+	await getPaddleService(preset);
+}
+async function removePreset(preset) {
+	const { spec } = await specForPreset(preset);
+	const service = services.get(preset);
+	services.delete(preset);
+	await service?.then((s) => s.destroy()).catch(() => void 0);
+	await evict(spec);
+}
+/** Tear down every cached service. */
+async function disposePaddleServices() {
+	const pending = [...services.values()];
+	services.clear();
+	await Promise.all(pending.map((p) => p.then((s) => s.destroy()).catch(() => void 0)));
+}
+//#endregion
+//#region src/ocr/paddle.ts
+/**
+* PaddleOCR text detection and recognition -- the default OCR engines.
+*
+* `PaddleTextDetector` mirrors ScaleDP's detector stages (image -> boxes) and
+* `PaddleTextRecognizer` mirrors its OCR stages (image -> Document with text
+* and boxes). Both run PP-OCR models through ppu-paddle-ocr on onnxruntime-web.
+*/
+const PADDLE_DETECTOR_DEFAULTS = Object.freeze({
+	...BASE_STAGE_DEFAULTS,
+	inputCol: "image",
+	outputCol: "boxes",
+	keepInputData: true,
+	preset: DEFAULT_OCR_PRESET,
+	scoreThreshold: 0
+});
+function validatePreset(value) {
+	if (!isKnownPreset(value)) throw new RangeError(`Unknown OCR preset "${value}". See PADDLE_OCR_PRESETS for valid values.`);
+}
+/** Decode a stage input into something ppu-paddle-ocr accepts. */
+async function toCanvas(input) {
+	if (typeof OffscreenCanvas !== "undefined" && input instanceof OffscreenCanvas) return input;
+	if (typeof ImageData !== "undefined" && input instanceof ImageData) return imageDataToCanvas(input);
+	const image = input;
+	if (image?.exception) throw new OcrError(`Upstream stage failed: ${image.exception}`, "toCanvas");
+	if (!image || !(image.data instanceof Uint8Array) || image.data.byteLength === 0) throw new OcrError("Expected an Image with decoded bytes", "toCanvas");
+	const bitmap = await decodeImage(image.data);
+	try {
+		const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+		const ctx = canvas.getContext("2d");
+		if (!ctx) throw new OcrError("Failed to acquire a 2D context", "toCanvas");
+		ctx.drawImage(bitmap, 0, 0);
+		return canvas;
+	} finally {
+		bitmap.close();
+	}
+}
+/** Text detection only: image -> word boxes, no recognition. */
+var PaddleTextDetector = class extends Stage {
+	name = "PaddleTextDetector";
+	constructor(options = {}) {
+		super(resolveParams(PADDLE_DETECTOR_DEFAULTS, options, { preset: validatePreset }));
+	}
+	async init() {
+		await getPaddleService(this.params.preset);
+	}
+	async apply(input, row) {
+		const service = await getPaddleService(this.params.preset);
+		const canvas = await toCanvas(input);
+		const { boxes } = await service.detect(canvas);
+		return createDetectorOutput({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "paddle",
+			bboxes: boxes.map((b) => boxFromBBox([
+				b.x,
+				b.y,
+				b.x + b.width,
+				b.y + b.height
+			], { score: 1 }))
+		});
+	}
+	onError(message, row) {
+		return createDetectorOutput({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "paddle",
+			exception: message
+		});
+	}
+};
+const PADDLE_RECOGNIZER_DEFAULTS = Object.freeze({
+	...BASE_STAGE_DEFAULTS,
+	inputCol: "image",
+	outputCol: "text",
+	keepInputData: true,
+	preset: DEFAULT_OCR_PRESET,
+	scoreThreshold: .5,
+	strategy: "per-box",
+	keepFormatting: false,
+	lineTolerance: 0
+});
+/** Full OCR: image -> Document with text and word-level boxes. */
+var PaddleTextRecognizer = class extends Stage {
+	name = "PaddleTextRecognizer";
+	constructor(options = {}) {
+		super(resolveParams(PADDLE_RECOGNIZER_DEFAULTS, options, { preset: validatePreset }));
+	}
+	async init() {
+		await getPaddleService(this.params.preset);
+	}
+	async apply(input, row) {
+		const { preset, strategy, scoreThreshold, keepFormatting, lineTolerance } = this.params;
+		const service = await getPaddleService(preset);
+		const canvas = await toCanvas(input);
+		const result = await service.recognize(canvas, {
+			flatten: true,
+			strategy,
+			noCache: true
+		});
+		const bboxes = ("results" in result ? result.results : []).filter((item) => item.confidence >= scoreThreshold).map((item) => boxFromBBox([
+			item.box.x,
+			item.box.y,
+			item.box.x + item.box.width,
+			item.box.y + item.box.height
+		], {
+			text: item.text,
+			score: item.confidence
+		}));
+		return createDocument({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "ocr",
+			text: keepFormatting ? boxesToFormattedText(bboxes, lineTolerance) : boxesToText(bboxes),
+			bboxes
+		});
+	}
+	onError(message, row) {
+		return createDocument({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "ocr",
+			exception: message
+		});
+	}
+};
+//#endregion
+//#region src/ocr/script-detect.ts
+/**
+* Writing-script detection via Tesseract's OSD model.
+*
+* Kept separate from recognition on purpose: when the recognition model is
+* wrong for the page the text comes back garbled, and that is precisely when
+* knowing the script is most useful. Running OSD independently means the
+* answer stays trustworthy.
+*
+* Feeds the preset picker -- see `presetsForScript`.
+*/
+let workerPromise = null;
+async function getOsdWorker() {
+	if (workerPromise) return workerPromise;
+	workerPromise = (async () => {
+		let mod;
+		try {
+			mod = await import("tesseract.js");
+		} catch (cause) {
+			throw new Error("tesseract.js is required for script detection. Install it: npm i tesseract.js", { cause });
+		}
+		return mod.createWorker("osd", mod.OEM.TESSERACT_ONLY);
+	})();
+	workerPromise.catch(() => {
+		workerPromise = null;
+	});
+	return workerPromise;
+}
+/** Detect the dominant writing script on a page. Returns null when unsure. */
+async function detectScript(source) {
+	const worker = await getOsdWorker();
+	let canvas;
+	if (typeof OffscreenCanvas !== "undefined" && source instanceof OffscreenCanvas) canvas = source;
+	else if (typeof ImageData !== "undefined" && source instanceof ImageData) canvas = imageDataToCanvas(source);
+	else if (typeof ImageBitmap !== "undefined" && source instanceof ImageBitmap) canvas = imageDataToCanvas(toImageData(source));
+	else {
+		const image = source;
+		if (!(image.data instanceof Uint8Array) || image.data.byteLength === 0) throw new OcrError("Expected an Image with decoded bytes", "detectScript");
+		const bitmap = await decodeImage(image.data);
+		try {
+			canvas = imageDataToCanvas(toImageData(bitmap));
+		} finally {
+			bitmap.close();
+		}
+	}
+	const blob = await canvas.convertToBlob({ type: "image/png" });
+	const { data } = await worker.detect(blob);
+	if (!data?.script) return null;
+	return {
+		script: data.script,
+		confidence: data.script_confidence ?? 0
+	};
+}
+/** Presets able to read the detected script, best-first. */
+async function suggestPresets(source) {
+	const detected = await detectScript(source);
+	return detected ? presetsForScript(detected.script) : [];
+}
+/** Tear down the shared OSD worker. */
+async function disposeScriptDetection() {
+	const pending = workerPromise;
+	workerPromise = null;
+	await pending?.then((w) => w.terminate()).catch(() => void 0);
+}
+//#endregion
+//#region src/ocr/tesseract.ts
+/**
+* Tesseract OCR, mirroring ScaleDP's `TesseractOcr` stage.
+*
+* Recognition runs on tesseract-wasm; script detection uses tesseract.js's OSD
+* model. The two are deliberately independent -- script detection still works
+* when the recognition model is wrong for the page and garbles the text, which
+* is exactly when you most want to know the script.
+*
+* Both the worker URL and the traineddata location come from `configure()`.
+* The pdftools prototype hardcoded `/tesseract-worker.js` and a raw GitHub URL,
+* neither of which a library can assume.
+*/
+/** tessdata_fast is a good default: far smaller than tessdata, barely less accurate. */
+const DEFAULT_TESSDATA_URL = "https://raw.githubusercontent.com/tesseract-ocr/tessdata_fast/main/";
+const TESSERACT_OCR_DEFAULTS = Object.freeze({
+	...BASE_STAGE_DEFAULTS,
+	inputCol: "image",
+	outputCol: "text",
+	keepInputData: true,
+	lang: ["eng"],
+	scoreThreshold: .5,
+	keepFormatting: false,
+	lineTolerance: 0
+});
+let clientPromise = null;
+let loadedLanguage = null;
+function trainedDataUrl(lang) {
+	return `${(getConfig().tesseract.dataUrl ?? "https://raw.githubusercontent.com/tesseract-ocr/tessdata_fast/main/").replace(/\/?$/, "/")}${lang}.traineddata`;
+}
+/**
+* The shared Tesseract client, loading the model for `lang` if needed.
+*
+* Exported so the crop-based recognizer reuses this one client rather than
+* standing up a second worker and loading the same traineddata twice.
+*/
+async function getTesseractClient(lang) {
+	if (clientPromise && loadedLanguage === lang) return clientPromise;
+	if (clientPromise) {
+		const previous = clientPromise;
+		clientPromise = null;
+		await previous.then((c) => c.destroy()).catch(() => void 0);
+	}
+	loadedLanguage = lang;
+	clientPromise = (async () => {
+		let mod;
+		try {
+			mod = await import("tesseract-wasm");
+		} catch (cause) {
+			throw new Error("tesseract-wasm is required for the Tesseract engine. Install it: npm i tesseract-wasm", { cause });
+		}
+		const { workerUrl } = getConfig().tesseract;
+		const client = new mod.OCRClient(workerUrl ? { workerURL: workerUrl } : {});
+		const response = await fetch(trainedDataUrl(lang));
+		if (!response.ok) throw new OcrError(`Failed to fetch ${lang}.traineddata: ${response.status} ${response.statusText}`, "TesseractOcr");
+		await client.loadModel(new Uint8Array(await response.arrayBuffer()));
+		return client;
+	})();
+	clientPromise.catch(() => {
+		clientPromise = null;
+		loadedLanguage = null;
+	});
+	return clientPromise;
+}
+/** Tear down the shared Tesseract client. */
+async function disposeTesseract() {
+	const pending = clientPromise;
+	clientPromise = null;
+	loadedLanguage = null;
+	await pending?.then((c) => c.destroy()).catch(() => void 0);
+}
+var TesseractOcr = class extends Stage {
+	name = "TesseractOcr";
+	constructor(options = {}) {
+		super(resolveParams(TESSERACT_OCR_DEFAULTS, options, { lang: (value) => {
+			if (value.length === 0) throw new RangeError("lang must not be empty");
+		} }));
+	}
+	/** tesseract-wasm loads one model, so multi-language means a joined code. */
+	get language() {
+		return this.params.lang.join("+");
+	}
+	async init() {
+		await getTesseractClient(this.language);
+	}
+	async apply(input, row) {
+		const image = input;
+		if (image?.exception) throw new OcrError(`Upstream stage failed: ${image.exception}`, this.name);
+		if (!image || !(image.data instanceof Uint8Array) || image.data.byteLength === 0) throw new OcrError("Expected an Image with decoded bytes", this.name);
+		const client = await getTesseractClient(this.language);
+		const bitmap = await decodeImage(image.data);
+		let words;
+		try {
+			await client.loadImage(toImageData(bitmap));
+			words = await client.getTextBoxes("word");
+		} finally {
+			bitmap.close();
+		}
+		const { scoreThreshold, keepFormatting, lineTolerance } = this.params;
+		const bboxes = words.filter((word) => word.confidence >= scoreThreshold && word.text.trim().length > 0).map((word) => boxFromBBox([
+			word.rect.left,
+			word.rect.top,
+			word.rect.right,
+			word.rect.bottom
+		], {
+			text: word.text.trim(),
+			score: word.confidence
+		}));
+		return createDocument({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "tesseract",
+			text: keepFormatting ? boxesToFormattedText(bboxes, lineTolerance) : boxesToText(bboxes),
+			bboxes
+		});
+	}
+	onError(message, row) {
+		return createDocument({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "tesseract",
+			exception: message
+		});
+	}
+	async dispose() {
+		await disposeTesseract();
+	}
+};
+//#endregion
+//#region src/ocr/tesseract-recognizer.ts
+/**
+* Recognize text inside boxes a detector already found.
+*
+* Port of ScaleDP's `TesseractRecognizer` (a `BaseRecognizer`), which is the
+* half of the OCR story `PaddleTextRecognizer` cannot cover: Paddle detects and
+* recognises in a single pass over the page, so boxes produced by a *separate*
+* detector never reach it -- rotated boxes in particular. This stage takes those
+* boxes, straightens each one, and reads it.
+*/
+const TESSERACT_RECOGNIZER_DEFAULTS = Object.freeze({
+	...BASE_STAGE_DEFAULTS,
+	inputCol: "image",
+	inputCols: ["image", "boxes"],
+	outputCol: "text",
+	keepInputData: true,
+	lang: ["eng"],
+	scaleFactor: 1,
+	padding: 5,
+	scoreThreshold: .5,
+	keepFormatting: false,
+	lineTolerance: 0,
+	boxLevel: "region",
+	detectLineOrientation: true,
+	onlyRotated: false,
+	oriModel: DEFAULT_ORIENTATION_MODEL
+});
+function boxesOf(source) {
+	if (typeof source !== "object" || source === null) return [];
+	return source.bboxes ?? [];
+}
+var TesseractRecognizer = class extends Stage {
+	name = "TesseractRecognizer";
+	orientation = null;
+	constructor(options = {}) {
+		super(resolveParams(TESSERACT_RECOGNIZER_DEFAULTS, options, {
+			inputCols: (value) => {
+				if (value.length !== 2) throw new RangeError("inputCols must be [imageColumn, boxColumn]");
+			},
+			lang: (value) => {
+				if (value.length === 0) throw new RangeError("lang must not be empty");
+			}
+		}));
+	}
+	get language() {
+		return this.params.lang.join("+");
+	}
+	async init() {
+		await getTesseractClient(this.language);
+		if (this.params.detectLineOrientation) this.orientation ??= new LineOrientationClassifier(this.params.oriModel);
+	}
+	async apply(_input, row, ctx) {
+		const { inputCols, scaleFactor, padding, scoreThreshold, keepFormatting, lineTolerance, boxLevel, detectLineOrientation, onlyRotated } = this.params;
+		const [imageCol, boxCol] = inputCols;
+		const image = row[imageCol];
+		if (image?.exception) throw new OcrError(`Upstream stage failed: ${image.exception}`, this.name);
+		if (!image || !(image.data instanceof Uint8Array) || image.data.byteLength === 0) throw new OcrError("Expected an Image with decoded bytes", this.name);
+		const source = row[boxCol];
+		if (source === void 0) throw new OcrError(`No boxes in column "${boxCol}". This stage reads a detector's output; run a text detector before it.`, this.name);
+		await this.init();
+		const client = await getTesseractClient(this.language);
+		const bitmap = await decodeImage(image.data);
+		const recognized = [];
+		try {
+			for (const box of boxesOf(source)) {
+				ctx.signal?.throwIfAborted();
+				const geometry = cropGeometry(box, {
+					scaleFactor,
+					padding
+				});
+				let crop = cropBox(bitmap, box, {
+					scaleFactor,
+					padding
+				});
+				let inverted = false;
+				if (detectLineOrientation && this.orientation) {
+					inverted = await this.orientation.classify(crop) === "180_degree";
+					if (inverted) crop = rotate180(crop);
+				}
+				if (onlyRotated && !isRotated(box) && !inverted) continue;
+				await client.loadImage(toImageData(crop));
+				const items = await client.getTextBoxes("word");
+				const words = items.filter((item) => item.text.trim());
+				if (words.length === 0) continue;
+				const score = items.reduce((sum, item) => sum + item.confidence, 0) / (items.length || 1);
+				if (score < scoreThreshold) continue;
+				if (boxLevel === "word") {
+					for (const item of words) recognized.push(wordBox(item.rect, geometry, inverted, scaleFactor, item.text.trim(), item.confidence));
+					continue;
+				}
+				recognized.push({
+					...box,
+					text: words.map((item) => item.text.trim()).join(" "),
+					score
+				});
+			}
+		} finally {
+			bitmap.close();
+		}
+		const bboxes = scaleFactor === 1 || boxLevel === "word" ? recognized : recognized.map((box) => ({
+			...box,
+			x: Math.round(box.x / scaleFactor),
+			y: Math.round(box.y / scaleFactor),
+			width: Math.round(box.width / scaleFactor),
+			height: Math.round(box.height / scaleFactor)
+		}));
+		return createDocument({
+			path: String(row[this.params.pathCol] ?? image.path),
+			type: "tesseract-recognizer",
+			text: keepFormatting ? boxesToFormattedText(bboxes, lineTolerance) : boxesToText(bboxes),
+			bboxes
+		});
+	}
+	onError(message, row) {
+		return createDocument({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "tesseract-recognizer",
+			exception: message
+		});
+	}
+	async dispose() {
+		await this.orientation?.dispose();
+		this.orientation = null;
+	}
+};
+/**
+* One word's box, in the page's coordinates.
+*
+* tesseract reports the rect in the crop's own space: straightened, padded,
+* scaled, and turned the right way up if the line was upside down. Undo the
+* turn, then push the four corners back through the crop's own transform, so a
+* word inside a skewed line comes back skewed the same way.
+*/
+function wordBox(rect, geometry, inverted, scaleFactor, text, score) {
+	const { width, height, map } = geometry;
+	const [left, top, right, bottom] = inverted ? [
+		width - rect.right,
+		height - rect.bottom,
+		width - rect.left,
+		height - rect.top
+	] : [
+		rect.left,
+		rect.top,
+		rect.right,
+		rect.bottom
+	];
+	const toPage = (x, y) => {
+		const [px, py] = map(x, y);
+		return [px / scaleFactor, py / scaleFactor];
+	};
+	const corners = [
+		toPage(left, top),
+		toPage(right, top),
+		toPage(right, bottom),
+		toPage(left, bottom)
+	];
+	return boxFromPolygon(corners, {
+		text,
+		score
+	});
+}
+/** Turn a crop 180 degrees, so an inverted line reads the right way up. */
+function rotate180(source) {
+	const out = new OffscreenCanvas(source.width, source.height);
+	const ctx = out.getContext("2d");
+	if (!ctx) throw new OcrError("Failed to acquire a 2D context", "TesseractRecognizer");
+	ctx.translate(source.width / 2, source.height / 2);
+	ctx.rotate(Math.PI);
+	ctx.drawImage(source, -source.width / 2, -source.height / 2);
+	return out;
+}
+//#endregion
+export { getDetectorModel as A, quadsFromProbabilityMap as B, LINE_ORIENTATION_DEFAULTS as C, ORIENTATION_INPUT as D, LineOrientationClassifier as E, DB_POSTPROCESS_DEFAULTS as F, boxScore as I, findComponentBoundaries as L, DBNET_INPUT_SIZE as M, DEFAULT_DBNET_MODEL as N, DEFAULT_DETECTOR_ID as O, DbnetOnnxDetector as P, miniBox as R, presetsForScript as S, DEFAULT_ORIENTATION_MODEL as T, unclipRect as V, loadPreset as _, TesseractOcr as a, PADDLE_OCR_PRESETS as b, disposeScriptDetection as c, PADDLE_RECOGNIZER_DEFAULTS as d, PaddleTextDetector as f, isPresetCached as g, getPaddleService as h, TESSERACT_OCR_DEFAULTS as i, DBNET_DETECTOR_DEFAULTS as j, DETECTOR_MODELS as k, suggestPresets as l, disposePaddleServices as m, TesseractRecognizer as n, disposeTesseract as o, PaddleTextRecognizer as p, DEFAULT_TESSDATA_URL as r, detectScript as s, TESSERACT_RECOGNIZER_DEFAULTS as t, PADDLE_DETECTOR_DEFAULTS as u, removePreset as v, LineOrientationDetector as w, isKnownPreset as x, DEFAULT_OCR_PRESET as y, orderPointsClockwise as z };
+
+//# sourceMappingURL=ocr-OHX2WM3e.js.map