@mlightcad/cad-pdf-plugin 1.8.0-preview.2 → 1.8.0-preview.4

package/lib/AcApPdfTextCmd.js

@@ -0,0 +1,777 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { AcApDocManager, AcApFontUtil, AcApI18n, AcApLlmSettingsService, AcApPaletteService, AcApTextRecognitionService, acapZoomToVisible, AcEdCommand, AcEdOpenMode, resolveSelectedEntities } from '@mlightcad/cad-simple-viewer';
+import { AcGeBox2d, AcGePoint2d } from '@mlightcad/data-model';
+import { acapPdfT } from './acapPdfI18n';
+import { AcApPdfTextSession } from './AcApPdfTextSession';
+import { pdfEntityToStroke } from './pdfEntityStrokes';
+import { clusterPdfTextStrokes } from './recognition/pdfGlyphClustering';
+import { PdfGlyphDictionary } from './recognition/pdfGlyphDictionary';
+import { classifyPdfTextLineFont } from './recognition/pdfTextFontKind';
+import { AcUiPdfTextPanel } from './ui/AcUiPdfTextPanel';
+/** `localStorage` key of the persisted glyph dictionary. */
+export var PDF_GLYPH_STORAGE_KEY = 'mlightcad.pdftext.glyphs.v1';
+/** Most glyph shapes kept in storage (the most recently confirmed). */
+var PDF_GLYPH_STORAGE_LIMIT = 5000;
+/** Height of the rendered text line image sent to a recognizer, in pixels. */
+var OCR_IMAGE_TEXT_HEIGHT = 48;
+/** Delay before the preview follows an edit in the panel, in ms. */
+var PREVIEW_DELAY = 120;
+/** Margin around a line framed in the drawing (passed to `zoomTo`). */
+var FOCUS_MARGIN = 3;
+/** Longest recognizer error message shown to the user. */
+var OCR_ERROR_MESSAGE_LIMIT = 200;
+/**
+ * `pdftext`: converts exploded text (SHX line text or outlined fonts that a
+ * PDF stores as paths) back into `AcDbText`.
+ *
+ * Workflow:
+ * 1. The user selects the strokes (a window around the text is enough;
+ *    frames and other large strokes are ignored).
+ * 2. Strokes are clustered into text lines with an estimated position,
+ *    height and rotation, and each line is classified as SHX line text or
+ *    TrueType outline text.
+ * 3. Lines whose glyphs are all in the glyph dictionary (shapes the user
+ *    already typed) are read from it.
+ * 4. All remaining lines are sent at once to OCR, when a recognizer is
+ *    registered in {@link AcApTextRecognitionService}.
+ * 5. A review panel opens in the palette. Per font kind the user picks an
+ *    existing text style or creates one, checks or replaces its fonts and
+ *    adjusts the size; per line the user fixes or types the text. The result
+ *    is previewed in the drawing. Apply converts everything in one undo step;
+ *    Cancel, or closing the palette, changes nothing. Without a DOM, what
+ *    was read is converted directly with the suggested styles.
+ *
+ * The dictionary is kept in `localStorage` (the 5000 most recently
+ * confirmed shapes), so later runs, on this drawing or
+ * another one using the same font, recognize more and more lines on their own.
+ */
+var AcApPdfTextCmd = /** @class */ (function (_super) {
+    __extends(AcApPdfTextCmd, _super);
+    function AcApPdfTextCmd() {
+        var _this = _super.call(this) || this;
+        /** Set once an OCR failure was reported in this run, so it does not nag. */
+        _this.ocrErrorShown = false;
+        _this.mode = AcEdOpenMode.Write;
+        return _this;
+    }
+    Object.defineProperty(AcApPdfTextCmd, "glyphDictionary", {
+        /**
+         * The shared glyph dictionary, loaded from `localStorage` on first use so
+         * glyphs taught in earlier sessions are recognized too.
+         */
+        get: function () {
+            var _a;
+            if (!AcApPdfTextCmd.dictionaryLoaded) {
+                AcApPdfTextCmd.dictionaryLoaded = true;
+                try {
+                    var raw = (_a = globalThis.localStorage) === null || _a === void 0 ? void 0 : _a.getItem(PDF_GLYPH_STORAGE_KEY);
+                    if (raw)
+                        AcApPdfTextCmd.dictionary.load(JSON.parse(raw));
+                }
+                catch (_b) {
+                    // Storage unavailable or corrupt: start empty.
+                }
+            }
+            return AcApPdfTextCmd.dictionary;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcApPdfTextCmd.saveDictionary = function () {
+        var _a;
+        try {
+            (_a = globalThis.localStorage) === null || _a === void 0 ? void 0 : _a.setItem(PDF_GLYPH_STORAGE_KEY, JSON.stringify(AcApPdfTextCmd.dictionary.toJSON(PDF_GLYPH_STORAGE_LIMIT)));
+        }
+        catch (_b) {
+            // Quota or privacy mode: the session dictionary still works.
+        }
+    };
+    AcApPdfTextCmd.prototype.execute = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolved, entityById, strokes, lines, dictionary, texts, sources, session, apply, changesExisting, fonts, measure, ready, ids, entities, _a, _b, _c, line, text;
+            var e_1, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, resolveSelectedEntities(context, {
+                            promptKey: 'pdftext'
+                        })];
+                    case 1:
+                        resolved = _e.sent();
+                        if (!resolved)
+                            return [2 /*return*/];
+                        context.view.selectionSet.clear();
+                        entityById = new Map();
+                        strokes = [];
+                        resolved.entities.forEach(function (entity, i) {
+                            var id = resolved.ids[i];
+                            var stroke = pdfEntityToStroke(entity, id);
+                            if (!stroke)
+                                return;
+                            entityById.set(id, entity);
+                            strokes.push(stroke);
+                        });
+                        lines = clusterPdfTextStrokes(strokes).lines;
+                        if (lines.length === 0) {
+                            this.notify(AcApI18n.t('jig.pdftext.noCandidates'), 'warning');
+                            return [2 /*return*/];
+                        }
+                        this.ocrErrorShown = false;
+                        return [4 /*yield*/, this.hintWhenOcrUnavailable()
+                            // 1. Lines whose glyphs are all known need neither OCR nor the user.
+                        ];
+                    case 2:
+                        _e.sent();
+                        dictionary = AcApPdfTextCmd.glyphDictionary;
+                        texts = lines.map(function (line) {
+                            return dictionary.lookup(line);
+                        });
+                        sources = texts.map(function (text) {
+                            return text ? 'dictionary' : 'unread';
+                        });
+                        // 2. All other lines go to OCR at once.
+                        return [4 /*yield*/, this.recognizeAll(lines, texts)];
+                    case 3:
+                        // 2. All other lines go to OCR at once.
+                        _e.sent();
+                        texts.forEach(function (text, i) {
+                            if (text && sources[i] === 'unread')
+                                sources[i] = 'ocr';
+                        });
+                        session = new AcApPdfTextSession({
+                            db: context.doc.database,
+                            fontKind: styleFontKind,
+                            rows: lines.map(function (line, i) {
+                                var _a;
+                                return ({
+                                    line: line,
+                                    kind: classifyPdfTextLineFont(line),
+                                    text: (_a = texts[i]) !== null && _a !== void 0 ? _a : '',
+                                    source: sources[i],
+                                    included: !!texts[i]
+                                });
+                            })
+                        });
+                        if (!(typeof document !== 'undefined')) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.review(context, session, entityById)];
+                    case 4:
+                        apply = _e.sent();
+                        if (!apply) {
+                            session.restoreStyles();
+                            this.notify(acapPdfT('jig.pdftext.cancelled'));
+                            return [2 /*return*/];
+                        }
+                        _e.label = 5;
+                    case 5:
+                        changesExisting = session.kinds.some(function (kind) {
+                            return session.changesExistingStyle(kind);
+                        });
+                        fonts = session.syncStyles();
+                        return [4 /*yield*/, loadFonts(fonts)];
+                    case 6:
+                        _e.sent();
+                        return [4 /*yield*/, prepareMeasure(fonts)];
+                    case 7:
+                        measure = _e.sent();
+                        ready = session.readyRows;
+                        ids = [];
+                        entities = ready.map(function (row) {
+                            ids.push.apply(ids, __spreadArray([], __read(row.line.strokes.map(function (stroke) { return stroke.id; })), false));
+                            return createRowEntity(session, row, entityById, measure);
+                        });
+                        if (entities.length > 0) {
+                            context.doc.database.tables.blockTable.modelSpace.appendEntity(entities);
+                            context.doc.entityService.eraseEntities(ids);
+                        }
+                        // Texts that already used a style whose fonts changed must redraw.
+                        if (changesExisting)
+                            AcApDocManager.instance.regen();
+                        try {
+                            // Only text the user typed is trusted to recognize other drawings.
+                            for (_a = __values(session.learnable), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                _c = _b.value, line = _c.line, text = _c.text;
+                                dictionary.learn(line, text);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        AcApPdfTextCmd.saveDictionary();
+                        this.notify(acapPdfT('jig.pdftext.summary', {
+                            converted: ready.length,
+                            automatic: ready.filter(function (row) { return row.source !== 'typed'; }).length,
+                            skipped: lines.length - ready.length
+                        }));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Shows the review panel in the palette and previews the result in the
+     * drawing until the user applies or cancels.
+     *
+     * @returns Whether the user applied.
+     */
+    AcApPdfTextCmd.prototype.review = function (context, session, entityById) {
+        return __awaiter(this, void 0, void 0, function () {
+            var view, strokeIds, scratch, previews, focused, hidden, timer, generation, clearPreview, refreshPreview, schedulePreview, setHidden, finish, result, panel, handle;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        view = context.view;
+                        strokeIds = session.rows.flatMap(function (row) {
+                            return row.line.strokes.map(function (stroke) { return stroke.id; });
+                        });
+                        scratch = new PdfGlyphDictionary();
+                        scratch.load(AcApPdfTextCmd.glyphDictionary.toJSON());
+                        previews = [];
+                        focused = [];
+                        hidden = false;
+                        generation = 0;
+                        clearPreview = function () {
+                            var e_2, _a;
+                            try {
+                                for (var previews_1 = __values(previews), previews_1_1 = previews_1.next(); !previews_1_1.done; previews_1_1 = previews_1.next()) {
+                                    var text = previews_1_1.value;
+                                    view.removeTransientEntity(text.objectId);
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (previews_1_1 && !previews_1_1.done && (_a = previews_1.return)) _a.call(previews_1);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                            previews = [];
+                        };
+                        refreshPreview = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var current, fonts, measure;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        current = ++generation;
+                                        fonts = session.syncStyles();
+                                        return [4 /*yield*/, loadFonts(fonts)];
+                                    case 1:
+                                        _a.sent();
+                                        return [4 /*yield*/, prepareMeasure(fonts)
+                                            // A newer edit (or the end of the review) superseded this one.
+                                        ];
+                                    case 2:
+                                        measure = _a.sent();
+                                        // A newer edit (or the end of the review) superseded this one.
+                                        if (current !== generation)
+                                            return [2 /*return*/];
+                                        // Merging measures text too: gaps become spaces in the chosen fonts.
+                                        session.setMeasurer(measure);
+                                        clearPreview();
+                                        previews = session.readyRows.map(function (row) {
+                                            return createRowEntity(session, row, entityById, measure);
+                                        });
+                                        if (previews.length > 0)
+                                            view.addTransientEntity(previews);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        schedulePreview = function () {
+                            if (timer)
+                                clearTimeout(timer);
+                            timer = setTimeout(function () {
+                                timer = undefined;
+                                void refreshPreview();
+                            }, PREVIEW_DELAY);
+                        };
+                        setHidden = function (hide) {
+                            var e_3, _a;
+                            hidden = hide;
+                            try {
+                                for (var strokeIds_1 = __values(strokeIds), strokeIds_1_1 = strokeIds_1.next(); !strokeIds_1_1.done; strokeIds_1_1 = strokeIds_1.next()) {
+                                    var id = strokeIds_1_1.value;
+                                    view.setEntitySceneVisible(id, !hide);
+                                }
+                            }
+                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                            finally {
+                                try {
+                                    if (strokeIds_1_1 && !strokeIds_1_1.done && (_a = strokeIds_1.return)) _a.call(strokeIds_1);
+                                }
+                                finally { if (e_3) throw e_3.error; }
+                            }
+                        };
+                        finish = function () { };
+                        result = new Promise(function (resolve) {
+                            finish = resolve;
+                        });
+                        panel = new AcUiPdfTextPanel({
+                            session: session,
+                            fonts: AcApDocManager.instance.avaiableFonts,
+                            replacementFont: function (font) { return AcApFontUtil.getReplacementFontName(font); },
+                            onChange: schedulePreview,
+                            onFocusRows: function (rows, zoom) {
+                                if (focused.length > 0)
+                                    view.unhighlight(focused);
+                                var lines = rows.map(function (row) { return row.line; });
+                                focused = lines.flatMap(function (line) { return line.strokes.map(function (stroke) { return stroke.id; }); });
+                                if (focused.length > 0)
+                                    view.highlight(focused);
+                                var box = zoom ? linesBox(lines) : undefined;
+                                if (box) {
+                                    acapZoomToVisible(view, box, FOCUS_MARGIN, handle.coveredInsets(view.canvas));
+                                }
+                            },
+                            onCommitRow: function (index) {
+                                var e_4, _a;
+                                var row = session.rows[index];
+                                if (!row)
+                                    return [];
+                                try {
+                                    for (var _b = __values(session.learnableOf(row)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                        var _d = _c.value, line = _d.line, text = _d.text;
+                                        scratch.learn(line, text);
+                                    }
+                                }
+                                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                finally {
+                                    try {
+                                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                                    }
+                                    finally { if (e_4) throw e_4.error; }
+                                }
+                                return session.fillUnread(function (line) { return scratch.lookup(line); });
+                            },
+                            onHideStrokes: setHidden,
+                            onClose: function (apply) { return finish(apply); }
+                        });
+                        handle = AcApPaletteService.open({
+                            id: 'pdftext',
+                            title: acapPdfT('jig.pdftext.panel.title'),
+                            element: panel.element
+                        }, { container: view.container });
+                        handle.onClosed(function () { return finish(false); });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 4, 5]);
+                        return [4 /*yield*/, refreshPreview()];
+                    case 2:
+                        _a.sent();
+                        panel.focusFirstUnread();
+                        return [4 /*yield*/, result];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        if (timer)
+                            clearTimeout(timer);
+                        generation++;
+                        clearPreview();
+                        if (hidden)
+                            setHidden(false);
+                        if (focused.length > 0)
+                            view.unhighlight(focused);
+                        handle.close();
+                        panel.destroy();
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Sends every line `texts` has no entry for to OCR in one batch, behind the
+     * busy indicator, and fills `texts` in place.
+     *
+     * OCR answers are not taught to the glyph dictionary: only text the user
+     * typed is trusted to recognize other drawings.
+     *
+     * @returns How many lines OCR read.
+     */
+    AcApPdfTextCmd.prototype.recognizeAll = function (lines, texts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pending, images, results, recognized;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!AcApTextRecognitionService.hasRecognizer)
+                            return [2 /*return*/, 0];
+                        pending = [];
+                        images = [];
+                        lines.forEach(function (line, i) {
+                            if (texts[i])
+                                return;
+                            var image = renderLineImage(line);
+                            if (!image)
+                                return;
+                            pending.push(i);
+                            images.push(image);
+                        });
+                        if (images.length === 0)
+                            return [2 /*return*/, 0];
+                        return [4 /*yield*/, AcApDocManager.instance.withBusyIndicator(function () {
+                                return AcApTextRecognitionService.recognizeBatch({ images: images, locale: AcApI18n.currentLocale }, { onError: function (error) { return _this.reportOcrError(error); } });
+                            }, acapPdfT('jig.pdftext.recognizing', { count: images.length }))];
+                    case 1:
+                        results = _a.sent();
+                        recognized = 0;
+                        pending.forEach(function (lineIndex, i) {
+                            if (!results[i])
+                                return;
+                            texts[lineIndex] = results[i];
+                            recognized++;
+                        });
+                        return [2 /*return*/, recognized];
+                }
+            });
+        });
+    };
+    /**
+     * Tells the user once per session how to turn on OCR suggestions when the
+     * shared AI model settings report no image-capable model.
+     */
+    AcApPdfTextCmd.prototype.hintWhenOcrUnavailable = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var status;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (AcApPdfTextCmd.ocrHintShown)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, AcApLlmSettingsService.getStatus()];
+                    case 1:
+                        status = _a.sent();
+                        if (!status || status.vision)
+                            return [2 /*return*/];
+                        AcApPdfTextCmd.ocrHintShown = true;
+                        this.notify(AcApI18n.t('jig.pdftext.ocrNotConfigured'));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Tells the user, once per run, why no suggestion came (bad API key,
+     * network, quota, ...) instead of leaving unexplained unread lines.
+     */
+    AcApPdfTextCmd.prototype.reportOcrError = function (error) {
+        console.warn('[pdftext] Text recognition failed:', error);
+        if (this.ocrErrorShown)
+            return;
+        this.ocrErrorShown = true;
+        this.notify(acapPdfT('jig.pdftext.ocrFailed', { message: ocrErrorMessage(error) }), 'error');
+    };
+    AcApPdfTextCmd.dictionary = new PdfGlyphDictionary();
+    AcApPdfTextCmd.dictionaryLoaded = false;
+    /** Set once the "OCR is off" hint was shown, so it does not nag. */
+    AcApPdfTextCmd.ocrHintShown = false;
+    return AcApPdfTextCmd;
+}(AcEdCommand));
+export { AcApPdfTextCmd };
+/**
+ * The TEXT (or MTEXT for merged rows) of a row, on the layer and in the
+ * colour of its strokes.
+ */
+function createRowEntity(session, row, entityById, measure) {
+    var _a;
+    var text = session.createEntity(row, measure);
+    var source = entityById.get((_a = row.line.strokes[0]) === null || _a === void 0 ? void 0 : _a.id);
+    if (source) {
+        text.layer = source.layer;
+        text.color = source.color.clone();
+    }
+    return text;
+}
+/** Loads the catalog fonts in `fonts` that are not loaded yet. */
+function loadFonts(fonts) {
+    return __awaiter(this, void 0, void 0, function () {
+        var missing, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    missing = fonts.filter(function (font) {
+                        return AcApFontUtil.findFontInfoByName(font) && !AcApFontUtil.isFontLoaded(font);
+                    });
+                    if (missing.length === 0)
+                        return [2 /*return*/];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, AcApDocManager.instance.loadFonts(missing)];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _a.sent();
+                    // Texts still draw with fallback fonts once these load later.
+                    console.warn('[pdftext] Could not load text style fonts:', error_1);
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Loads what width measuring needs and returns the measurer, or `undefined`
+ * when the fonts cannot be loaded (the width factor then stays 1).
+ */
+function prepareMeasure(fonts) {
+    return __awaiter(this, void 0, void 0, function () {
+        var error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, AcApFontUtil.prepareTextMeasurement(fonts)];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    error_2 = _a.sent();
+                    console.warn('[pdftext] Could not load fonts to fit text widths:', error_2);
+                    return [2 /*return*/, undefined];
+                case 3: return [2 /*return*/, function (text, font, height, bigFont) {
+                        return AcApFontUtil.measureTextWidth(text, font, height, bigFont || undefined);
+                    }];
+            }
+        });
+    });
+}
+/** World box around the strokes of lines. */
+function linesBox(lines) {
+    var e_5, _a, e_6, _b;
+    var minX = Infinity;
+    var minY = Infinity;
+    var maxX = -Infinity;
+    var maxY = -Infinity;
+    try {
+        for (var _c = __values(lines.flatMap(function (line) { return line.strokes; })), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var stroke = _d.value;
+            try {
+                for (var _e = (e_6 = void 0, __values(stroke.points)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var p = _f.value;
+                    minX = Math.min(minX, p.x);
+                    minY = Math.min(minY, p.y);
+                    maxX = Math.max(maxX, p.x);
+                    maxY = Math.max(maxY, p.y);
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    if (!Number.isFinite(minX))
+        return undefined;
+    return new AcGeBox2d(new AcGePoint2d(minX, minY), new AcGePoint2d(maxX, maxY));
+}
+/**
+ * Engine the viewer draws a style font with: the loaded font's own type,
+ * else the font catalog's, else that of the font substituted for a missing
+ * one (e.g. a `Standard` style without a known font draws in `simsun`).
+ */
+function styleFontKind(font) {
+    var _a, _b;
+    if (!font)
+        return undefined;
+    var direct = (_a = AcApFontUtil.getFontType(font)) !== null && _a !== void 0 ? _a : AcApFontUtil.getCatalogFontType(font);
+    if (direct)
+        return direct;
+    var replacement = AcApFontUtil.getReplacementFontName(font);
+    if (!replacement || replacement === font)
+        return undefined;
+    return ((_b = AcApFontUtil.getFontType(replacement)) !== null && _b !== void 0 ? _b : AcApFontUtil.getCatalogFontType(replacement));
+}
+/** One-line, length-limited description of a recognizer error. */
+function ocrErrorMessage(error) {
+    var raw = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : 'unknown error');
+    var text = raw.replace(/\s+/g, ' ').trim() || String(error);
+    return text.length > OCR_ERROR_MESSAGE_LIMIT
+        ? "".concat(text.slice(0, OCR_ERROR_MESSAGE_LIMIT - 1), "\u2026")
+        : text;
+}
+/**
+ * Renders a text line upright, dark on white, as a PNG data URL for OCR.
+ *
+ * @returns The data URL, or `undefined` outside a browser.
+ */
+function renderLineImage(line) {
+    var e_7, _a, e_8, _b, e_9, _c;
+    if (typeof document === 'undefined')
+        return undefined;
+    var scale = OCR_IMAGE_TEXT_HEIGHT / line.height;
+    var pad = OCR_IMAGE_TEXT_HEIGHT * 0.5;
+    var c = Math.cos(line.rotation);
+    var s = Math.sin(line.rotation);
+    var local = function (x, y) {
+        var dx = x - line.position.x;
+        var dy = y - line.position.y;
+        return { u: dx * c + dy * s, v: -dx * s + dy * c };
+    };
+    var minV = 0;
+    var maxV = line.height;
+    try {
+        for (var _d = __values(line.strokes), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var stroke = _e.value;
+            try {
+                for (var _f = (e_8 = void 0, __values(stroke.points)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var p = _g.value;
+                    var v = local(p.x, p.y).v;
+                    minV = Math.min(minV, v);
+                    maxV = Math.max(maxV, v);
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    var canvas = document.createElement('canvas');
+    canvas.width = Math.ceil(line.width * scale + pad * 2);
+    canvas.height = Math.ceil((maxV - minV) * scale + pad * 2);
+    var g = canvas.getContext('2d');
+    if (!g)
+        return undefined;
+    g.fillStyle = '#ffffff';
+    g.fillRect(0, 0, canvas.width, canvas.height);
+    g.strokeStyle = '#000000';
+    g.lineWidth = Math.max(1.5, OCR_IMAGE_TEXT_HEIGHT / 16);
+    g.lineCap = 'round';
+    g.lineJoin = 'round';
+    try {
+        for (var _h = __values(line.strokes), _j = _h.next(); !_j.done; _j = _h.next()) {
+            var stroke = _j.value;
+            g.beginPath();
+            stroke.points.forEach(function (p, i) {
+                var _a = local(p.x, p.y), u = _a.u, v = _a.v;
+                var px = pad + u * scale;
+                var py = pad + (maxV - v) * scale;
+                if (i === 0)
+                    g.moveTo(px, py);
+                else
+                    g.lineTo(px, py);
+            });
+            g.stroke();
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return canvas.toDataURL('image/png');
+}
+//# sourceMappingURL=AcApPdfTextCmd.js.map