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

package/lib/AcApPdfTextSession.js

@@ -0,0 +1,826 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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.");
+};
+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));
+};
+import { AcDbMText, AcDbText, AcDbTextStyleTableRecord, AcGePoint3d, AcGiMTextAttachmentPoint } from '@mlightcad/data-model';
+import { acapPdfFitWidthFactor, PDF_SHX_BIG_FONT, PDF_SHX_FONT, PDF_SHX_TEXT_STYLE, PDF_TEXT_STYLE_PREFIX } from './pdfImportEntities';
+import { arePdfTextLinesAdjacent, mergePdfTextLines } from './recognition/pdfTextMerge';
+/** TrueType face suggested for recovered outline text. */
+export var PDF_MESH_FONT = 'simsun';
+/** Text style suggested for recovered outline text. */
+export var PDF_MESH_TEXT_STYLE = "".concat(PDF_TEXT_STYLE_PREFIX).concat(PDF_MESH_FONT);
+var KINDS = ['shx', 'mesh'];
+/**
+ * State of a `pdftext` review: the lines with their text, and one text style
+ * choice per font kind. UI-free, so the panel stays a thin view over it.
+ *
+ * Style choices are written to the database by {@link syncStyles} so the
+ * preview draws with them; {@link restoreStyles} undoes that on Cancel.
+ */
+var AcApPdfTextSession = /** @class */ (function () {
+    function AcApPdfTextSession(input) {
+        var e_1, _a;
+        this.choices = new Map();
+        /** Original fonts of existing styles changed by {@link syncStyles}. */
+        this.snapshots = new Map();
+        /** Styles created by {@link syncStyles}. */
+        this.created = new Set();
+        this.db = input.db;
+        this.rows = input.rows;
+        this.fontKind = input.fontKind;
+        try {
+            for (var KINDS_1 = __values(KINDS), KINDS_1_1 = KINDS_1.next(); !KINDS_1_1.done; KINDS_1_1 = KINDS_1.next()) {
+                var kind = KINDS_1_1.value;
+                this.choices.set(kind, this.defaultChoice(kind));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (KINDS_1_1 && !KINDS_1_1.done && (_a = KINDS_1.return)) _a.call(KINDS_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    Object.defineProperty(AcApPdfTextSession.prototype, "kinds", {
+        /** Font kinds used by at least one line. */
+        get: function () {
+            var _this = this;
+            return KINDS.filter(function (kind) { return _this.rows.some(function (row) { return row.kind === kind; }); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** Style settings of a font kind. */
+    AcApPdfTextSession.prototype.choice = function (kind) {
+        return this.choices.get(kind);
+    };
+    /** Names of the text styles in the drawing, sorted. */
+    AcApPdfTextSession.prototype.styleNames = function () {
+        var e_2, _a;
+        var names = [];
+        try {
+            for (var _b = __values(this.db.tables.textStyleTable.newIterator()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var record = _c.value;
+                if (!this.created.has(record.name))
+                    names.push(record.name);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return names.sort(function (a, b) { return a.localeCompare(b); });
+    };
+    /** Uses an existing text style (and its fonts) for a font kind. */
+    AcApPdfTextSession.prototype.selectStyle = function (kind, name) {
+        var _a, _b;
+        var record = this.originalRecord(name);
+        if (!record)
+            return;
+        var choice = this.choices.get(kind);
+        choice.styleName = record.name;
+        choice.isNew = false;
+        var original = this.snapshots.get(record.name);
+        choice.font = (_a = original === null || original === void 0 ? void 0 : original.fileName) !== null && _a !== void 0 ? _a : record.fileName;
+        choice.bigFont = (_b = original === null || original === void 0 ? void 0 : original.bigFontFileName) !== null && _b !== void 0 ? _b : record.bigFontFileName;
+    };
+    /**
+     * Checks a name for a new text style (AutoCAD rules, no duplicate).
+     *
+     * @returns The reason it is rejected, or `undefined` when it is valid.
+     */
+    AcApPdfTextSession.prototype.validateNewStyleName = function (name, kind) {
+        var trimmed = name.trim();
+        if (!trimmed)
+            return 'empty';
+        if (/[;=<>`\\/,|*?":]/.test(trimmed))
+            return 'invalid';
+        var lower = trimmed.toLowerCase();
+        if (this.styleNames().some(function (item) { return item.toLowerCase() === lower; })) {
+            return 'exists';
+        }
+        // The other kind cannot create a style with the same name.
+        var other = KINDS.find(function (item) { return item !== kind; });
+        var otherChoice = other ? this.choices.get(other) : undefined;
+        if ((otherChoice === null || otherChoice === void 0 ? void 0 : otherChoice.isNew) &&
+            this.kinds.includes(other) &&
+            otherChoice.styleName.toLowerCase() === lower) {
+            return 'exists';
+        }
+        return undefined;
+    };
+    /**
+     * Creates a new text style for a font kind, keeping the current fonts.
+     *
+     * @returns The reason the name is rejected, or `undefined` on success.
+     */
+    AcApPdfTextSession.prototype.newStyle = function (kind, name) {
+        var error = this.validateNewStyleName(name, kind);
+        if (error)
+            return error;
+        var choice = this.choices.get(kind);
+        choice.styleName = name.trim();
+        choice.isNew = true;
+        return undefined;
+    };
+    /** Sets the primary font; a TrueType font drops the big font. */
+    AcApPdfTextSession.prototype.setFont = function (kind, font) {
+        var choice = this.choices.get(kind);
+        choice.font = font.trim();
+        if (this.fontKind(choice.font) === 'mesh')
+            choice.bigFont = '';
+    };
+    /** Sets the SHX big font (`''` for none). */
+    AcApPdfTextSession.prototype.setBigFont = function (kind, bigFont) {
+        this.choices.get(kind).bigFont = bigFont.trim();
+    };
+    /** Sets size options of a font kind. */
+    AcApPdfTextSession.prototype.setSize = function (kind, size) {
+        var choice = this.choices.get(kind);
+        if (size.heightScale !== undefined && size.heightScale > 0) {
+            choice.heightScale = size.heightScale;
+        }
+        if (size.autoWidth !== undefined)
+            choice.autoWidth = size.autoWidth;
+        if (size.widthFactor !== undefined && size.widthFactor > 0) {
+            choice.widthFactor = size.widthFactor;
+        }
+    };
+    /**
+     * Whether applying a kind's choice changes the fonts of an existing style,
+     * which also changes every text already using it.
+     */
+    AcApPdfTextSession.prototype.changesExistingStyle = function (kind) {
+        var _a;
+        var choice = this.choices.get(kind);
+        if (choice.isNew)
+            return false;
+        var record = this.originalRecord(choice.styleName);
+        if (!record)
+            return false;
+        var original = (_a = this.snapshots.get(record.name)) !== null && _a !== void 0 ? _a : {
+            fileName: record.fileName,
+            bigFontFileName: record.bigFontFileName
+        };
+        return (!sameName(original.fileName, choice.font) ||
+            !sameName(original.bigFontFileName, choice.bigFont));
+    };
+    /** Sets the text of a line; text the user changed is marked typed. */
+    AcApPdfTextSession.prototype.setText = function (index, text) {
+        var row = this.rows[index];
+        if (!row || row.text === text)
+            return;
+        row.text = text;
+        row.source = 'typed';
+        if (text.trim())
+            row.included = true;
+    };
+    /**
+     * Fills lines still without text from glyphs learned meanwhile (a typed
+     * line teaches the glyphs other lines reuse).
+     *
+     * @param lookup - Reads a line from known glyphs.
+     * @returns Indexes of the lines filled.
+     */
+    AcApPdfTextSession.prototype.fillUnread = function (lookup) {
+        var _this = this;
+        var filled = [];
+        this.rows.forEach(function (row, index) {
+            // Unread rows were not typed: partial text (a merge of read and
+            // unread characters) is replaced once the whole row can be read.
+            if (row.source !== 'unread')
+                return;
+            var text = lookupRow(row, lookup, _this.mergeMeasure(row.kind));
+            if (!text)
+                return;
+            row.text = text;
+            row.source = 'dictionary';
+            row.included = true;
+            filled.push(index);
+        });
+        return filled;
+    };
+    /**
+     * Sets the text measurer used when merging rows, so gaps between merged
+     * characters become the right number of spaces. Call it once the style
+     * fonts are loaded.
+     */
+    AcApPdfTextSession.prototype.setMeasurer = function (measure) {
+        this.measurer = measure;
+    };
+    /** Measures text in a font kind's chosen fonts, for {@link merge}. */
+    AcApPdfTextSession.prototype.mergeMeasure = function (kind) {
+        var measure = this.measurer;
+        if (!measure)
+            return undefined;
+        var choice = this.choices.get(kind);
+        return function (text, height) {
+            return measure(text, choice.font, height, choice.bigFont);
+        };
+    };
+    /** Includes or skips a line. */
+    AcApPdfTextSession.prototype.setIncluded = function (index, included) {
+        var row = this.rows[index];
+        if (row)
+            row.included = included;
+    };
+    /** Switches the font kind a line is converted to. */
+    AcApPdfTextSession.prototype.setKind = function (index, kind) {
+        var row = this.rows[index];
+        if (row)
+            row.kind = kind;
+    };
+    Object.defineProperty(AcApPdfTextSession.prototype, "readyRows", {
+        /** Lines converted on Apply: included, with text. */
+        get: function () {
+            return this.rows.filter(function (row) { return row.included && row.text.trim(); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcApPdfTextSession.prototype, "typedRows", {
+        /** Lines whose text the user typed, to teach the glyph dictionary. */
+        get: function () {
+            return this.readyRows.filter(function (row) { return row.source === 'typed'; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcApPdfTextSession.prototype, "learnable", {
+        /** Typed lines as line/text pairs the glyph dictionary can learn. */
+        get: function () {
+            var _this = this;
+            return this.typedRows.flatMap(function (row) { return _this.learnableOf(row); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Line/text pairs the glyph dictionary can learn from a row. A merged row
+     * on one baseline is one line. A merged block of several lines can only
+     * be paired with its parts while its text is unchanged.
+     */
+    AcApPdfTextSession.prototype.learnableOf = function (row) {
+        var _this = this;
+        var text = row.text.trim();
+        if (!text)
+            return [];
+        var merge = row.merge;
+        if (!merge || merge.paragraphs.length === 1) {
+            return [{ line: row.line, text: text }];
+        }
+        if (row.text !== merge.text)
+            return [];
+        return merge.parts.flatMap(function (part) {
+            return part.source === 'typed' ? _this.learnableOf(part) : [];
+        });
+    };
+    /**
+     * Merges rows into one row that becomes a single MTEXT: rows on one
+     * baseline join into one line, rows on different baselines into separate
+     * lines of the block. Already merged rows are merged by their parts.
+     *
+     * @param indexes - Rows to merge (at least two).
+     * @returns Index of the merged row, or `undefined` when nothing merged.
+     */
+    AcApPdfTextSession.prototype.merge = function (indexes) {
+        var _this = this;
+        var unique = __spreadArray([], __read(new Set(indexes)), false).filter(function (index) { return _this.rows[index]; })
+            .sort(function (a, b) { return a - b; });
+        if (unique.length < 2)
+            return undefined;
+        var selected = unique.map(function (index) { return _this.rows[index]; });
+        var parts = selected.flatMap(function (row) { return _this.partsOf(row); });
+        var kind = majorityKind(parts);
+        var result = mergePdfTextLines(parts, {
+            measure: this.mergeMeasure(kind)
+        });
+        var text = result.text;
+        var anyUnread = parts.some(function (part) { return part.source === 'unread' && !part.text.trim(); });
+        var merged = {
+            line: result.line,
+            kind: kind,
+            text: text,
+            source: anyUnread || !text.trim()
+                ? 'unread'
+                : parts.some(function (part) { return part.source === 'typed'; })
+                    ? 'typed'
+                    : parts.every(function (part) { return part.source === 'dictionary'; })
+                        ? 'dictionary'
+                        : 'ocr',
+            included: !!text.trim(),
+            merge: {
+                parts: parts,
+                paragraphs: result.paragraphs,
+                lineSpacing: result.lineSpacing,
+                text: text
+            }
+        };
+        for (var i = unique.length - 1; i >= 0; i--)
+            this.rows.splice(unique[i], 1);
+        this.rows.splice(unique[0], 0, merged);
+        return unique[0];
+    };
+    /**
+     * Splits a merged row back into the rows it was made of.
+     *
+     * @returns Indexes of the restored rows (empty when the row is not merged).
+     */
+    AcApPdfTextSession.prototype.split = function (index) {
+        var _a;
+        var row = this.rows[index];
+        if (!(row === null || row === void 0 ? void 0 : row.merge))
+            return [];
+        var parts = row.merge.parts;
+        (_a = this.rows).splice.apply(_a, __spreadArray([index, 1], __read(parts), false));
+        return parts.map(function (_, i) { return index + i; });
+    };
+    /**
+     * Merges rows that read as one line: on the same baseline, in the same
+     * direction and close together (typically characters the clustering left
+     * apart). Blocks of several lines are left alone.
+     *
+     * @returns Number of merged rows created.
+     */
+    AcApPdfTextSession.prototype.mergeAdjacent = function () {
+        var e_3, _a;
+        var _this = this;
+        var candidates = this.rows.filter(function (row) { return !row.merge || row.merge.paragraphs.length === 1; });
+        var boxes = candidates.map(function (row) { return worldBox(row.line); });
+        var parent = candidates.map(function (_, i) { return i; });
+        var find = function (i) {
+            return parent[i] === i ? i : (parent[i] = find(parent[i]));
+        };
+        for (var i = 0; i < candidates.length; i++) {
+            for (var j = i + 1; j < candidates.length; j++) {
+                // Cheap reject before the exact test: boxes too far apart.
+                var reach = 2 * Math.max(candidates[i].line.height, candidates[j].line.height);
+                if (boxes[i].minX - boxes[j].maxX > reach ||
+                    boxes[j].minX - boxes[i].maxX > reach ||
+                    boxes[i].minY - boxes[j].maxY > reach ||
+                    boxes[j].minY - boxes[i].maxY > reach) {
+                    continue;
+                }
+                if (arePdfTextLinesAdjacent(candidates[i].line, candidates[j].line)) {
+                    parent[find(i)] = find(j);
+                }
+            }
+        }
+        var groups = new Map();
+        candidates.forEach(function (row, i) {
+            var _a;
+            var root = find(i);
+            groups.set(root, __spreadArray(__spreadArray([], __read(((_a = groups.get(root)) !== null && _a !== void 0 ? _a : [])), false), [row], false));
+        });
+        var count = 0;
+        try {
+            for (var _b = __values(groups.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var group = _c.value;
+                if (group.length < 2)
+                    continue;
+                this.merge(group.map(function (row) { return _this.rows.indexOf(row); }));
+                count++;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return count;
+    };
+    /** The original rows a row stands for (itself unless merged). */
+    AcApPdfTextSession.prototype.partsOf = function (row) {
+        var _this = this;
+        var merge = row.merge;
+        if (!merge)
+            return [row];
+        // An edited single-line merge keeps its text as one part.
+        if (merge.paragraphs.length === 1 && row.text !== merge.text) {
+            return [__assign(__assign({}, row), { merge: undefined })];
+        }
+        return merge.parts.flatMap(function (part) { return _this.partsOf(part); });
+    };
+    /**
+     * Writes the style choices of the used font kinds to the database: creates
+     * new styles and updates the fonts of existing ones (originals are kept for
+     * {@link restoreStyles}). New styles no longer chosen are removed.
+     *
+     * @returns The fonts the styles use, to be loaded before drawing.
+     */
+    AcApPdfTextSession.prototype.syncStyles = function () {
+        var e_4, _a, e_5, _b, e_6, _c, e_7, _d;
+        var _this = this;
+        var table = this.db.tables.textStyleTable;
+        var wanted = new Set();
+        var fonts = new Set();
+        try {
+            for (var _e = __values(this.kinds), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var kind = _f.value;
+                var choice = this.choices.get(kind);
+                if (choice.font)
+                    fonts.add(choice.font);
+                if (choice.bigFont)
+                    fonts.add(choice.bigFont);
+                if (choice.isNew)
+                    wanted.add(choice.styleName);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        try {
+            for (var _g = __values(__spreadArray([], __read(this.created), false)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var name_1 = _h.value;
+                if (!wanted.has(name_1)) {
+                    table.remove(name_1);
+                    this.created.delete(name_1);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        // Existing styles whose choice moved elsewhere get their fonts back.
+        var edited = new Set(this.kinds
+            .map(function (kind) { return _this.choices.get(kind); })
+            .filter(function (choice) { return !choice.isNew; })
+            .map(function (choice) { return choice.styleName; }));
+        try {
+            for (var _j = __values(__spreadArray([], __read(this.snapshots), false)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var _l = __read(_k.value, 2), name_2 = _l[0], original = _l[1];
+                if (edited.has(name_2))
+                    continue;
+                var record = table.getAt(name_2);
+                if (record) {
+                    this.setFonts(record, original.fileName, original.bigFontFileName);
+                }
+                this.snapshots.delete(name_2);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        try {
+            for (var _m = __values(this.kinds), _o = _m.next(); !_o.done; _o = _m.next()) {
+                var kind = _o.value;
+                var choice = this.choices.get(kind);
+                var record = table.getAt(choice.styleName);
+                if (!record) {
+                    // Fonts are set before the record joins the database, which needs
+                    // no open-for-write.
+                    table.add(createStyleRecord(choice.styleName, choice));
+                    this.created.add(choice.styleName);
+                    continue;
+                }
+                if (!this.created.has(record.name) && !this.snapshots.has(record.name)) {
+                    this.snapshots.set(record.name, {
+                        fileName: record.fileName,
+                        bigFontFileName: record.bigFontFileName
+                    });
+                }
+                this.setFonts(record, choice.font, choice.bigFont);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return __spreadArray([], __read(fonts), false);
+    };
+    /** Undoes {@link syncStyles}: removes new styles, restores fonts. */
+    AcApPdfTextSession.prototype.restoreStyles = function () {
+        var e_8, _a, e_9, _b;
+        var table = this.db.tables.textStyleTable;
+        try {
+            for (var _c = __values(this.created), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var name_3 = _d.value;
+                table.remove(name_3);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        this.created.clear();
+        try {
+            for (var _e = __values(this.snapshots), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var _g = __read(_f.value, 2), name_4 = _g[0], original = _g[1];
+                var record = table.getAt(name_4);
+                if (record) {
+                    this.setFonts(record, original.fileName, original.bigFontFileName);
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        this.snapshots.clear();
+    };
+    /**
+     * Sets the fonts of a style record when they differ, opening it for write
+     * first: inside a command's transaction, database records may only change
+     * once opened for write.
+     */
+    AcApPdfTextSession.prototype.setFonts = function (record, font, bigFont) {
+        var _a;
+        if (record.fileName === font && record.bigFontFileName === bigFont)
+            return;
+        var writable = (_a = this.db.openObjectForWrite(record.objectId)) !== null && _a !== void 0 ? _a : record;
+        writable.fileName = font;
+        writable.bigFontFileName = bigFont;
+    };
+    /**
+     * Builds the text entity of a line with its kind's style choice.
+     *
+     * @param row - The line.
+     * @param measure - Measures natural text width for the width auto-fit.
+     */
+    AcApPdfTextSession.prototype.createText = function (row, measure) {
+        var choice = this.choices.get(row.kind);
+        var height = row.line.height * choice.heightScale;
+        var text = new AcDbText();
+        text.textString = row.text.trim();
+        text.styleName = choice.styleName;
+        text.position = new AcGePoint3d(row.line.position.x, row.line.position.y, 0);
+        text.height = height;
+        text.rotation = row.line.rotation;
+        text.widthFactor = choice.autoWidth
+            ? acapPdfFitWidthFactor(1, row.line.width, measure === null || measure === void 0 ? void 0 : measure(text.textString, choice.font, height, choice.bigFont))
+            : choice.widthFactor;
+        return text;
+    };
+    /**
+     * Builds the entity of a row: an MTEXT for a merged row, a TEXT otherwise.
+     *
+     * @param row - The row.
+     * @param measure - Measures natural text width for the width auto-fit.
+     */
+    AcApPdfTextSession.prototype.createEntity = function (row, measure) {
+        return row.merge
+            ? this.createMText(row, row.merge, measure)
+            : this.createText(row, measure);
+    };
+    /**
+     * Builds the MTEXT of a merged row: one paragraph per line, exact line
+     * spacing as measured, no word wrap. With width auto-fit each paragraph
+     * gets the `\W` width factor that makes it span its original width.
+     *
+     * It is attached bottom-left at the lowest ink of its last line, like a
+     * TEXT at its baseline. The viewer anchors MTEXT on the drawn glyphs, so
+     * this keeps the text where it was even when the glyphs are shorter than
+     * the cap height (a top-left anchor at the cap height moved such text
+     * down); for capitals and CJK the ink bottom also is the baseline.
+     */
+    AcApPdfTextSession.prototype.createMText = function (row, merge, measure) {
+        var choice = this.choices.get(row.kind);
+        var height = row.line.height * choice.heightScale;
+        var angle = row.line.rotation;
+        var last = merge.paragraphs[merge.paragraphs.length - 1];
+        var minU = Math.min.apply(Math, __spreadArray([], __read(merge.paragraphs.map(function (item) { return item.minU; })), false));
+        var lines = row.text.replace(/\s+$/, '').split('\n');
+        // Paragraph widths only match while the lines are the merged ones.
+        var widths = lines.length === merge.paragraphs.length
+            ? merge.paragraphs.map(function (item) { return item.maxU - item.minU; })
+            : lines.map(function () { return row.line.width; });
+        var contents = lines.map(function (line, i) {
+            var text = line.trim();
+            var factor = choice.autoWidth
+                ? acapPdfFitWidthFactor(1, widths[i], text
+                    ? measure === null || measure === void 0 ? void 0 : measure(text, choice.font, height, choice.bigFont)
+                    : undefined)
+                : choice.widthFactor;
+            var escaped = mtextEscape(text);
+            return Math.abs(factor - 1) < 0.005 || !escaped
+                ? escaped
+                : "{\\W".concat(Number(factor.toFixed(3)), ";").concat(escaped, "}");
+        });
+        var mtext = new AcDbMText();
+        mtext.contents = contents.join('\\P');
+        mtext.styleName = choice.styleName;
+        mtext.height = height;
+        mtext.width = 0;
+        mtext.rotation = angle;
+        mtext.attachmentPoint = AcGiMTextAttachmentPoint.BottomLeft;
+        mtext.location = toWorld(minU, last.bottom, angle);
+        if (lines.length > 1) {
+            // AutoCAD single spacing is 5/3 of the text height; "exactly" keeps
+            // the measured spacing regardless of the characters.
+            var spacing = merge.lineSpacing || (height * 5) / 3;
+            mtext.lineSpacingStyle = 2;
+            mtext.lineSpacingFactor = spacing / ((height * 5) / 3);
+        }
+        return mtext;
+    };
+    /**
+     * Default for a kind: the current style when it already draws with that
+     * engine, else the `PDF_SHX` / `PDF_simsun` style (created if missing).
+     */
+    AcApPdfTextSession.prototype.defaultChoice = function (kind) {
+        var _a;
+        var table = this.db.tables.textStyleTable;
+        var current = table.resolveAt(this.db.textstyle);
+        var name = current && this.fontKind(current.fileName) === kind
+            ? current.name
+            : kind === 'shx'
+                ? PDF_SHX_TEXT_STYLE
+                : PDF_MESH_TEXT_STYLE;
+        var record = table.getAt(name);
+        return {
+            styleName: (_a = record === null || record === void 0 ? void 0 : record.name) !== null && _a !== void 0 ? _a : name,
+            isNew: !record,
+            font: record
+                ? record.fileName
+                : kind === 'shx'
+                    ? PDF_SHX_FONT
+                    : PDF_MESH_FONT,
+            bigFont: record
+                ? record.bigFontFileName
+                : kind === 'shx'
+                    ? PDF_SHX_BIG_FONT
+                    : '',
+            heightScale: 1,
+            autoWidth: true,
+            widthFactor: 1
+        };
+    };
+    /** An existing style record not created by this session. */
+    AcApPdfTextSession.prototype.originalRecord = function (name) {
+        if (this.created.has(name))
+            return undefined;
+        return this.db.tables.textStyleTable.getAt(name);
+    };
+    return AcApPdfTextSession;
+}());
+export { AcApPdfTextSession };
+/**
+ * Reads a row from known glyphs: a merged block line by line, everything
+ * else as one line.
+ */
+function lookupRow(row, lookup, measure) {
+    var merge = row.merge;
+    if (!merge || merge.paragraphs.length === 1)
+        return lookup(row.line);
+    var texts = merge.parts.map(function (part) { return lookupRow(part, lookup, measure); });
+    if (texts.some(function (text) { return !text; }))
+        return undefined;
+    return mergePdfTextLines(merge.parts.map(function (part, i) { return ({ line: part.line, text: texts[i] }); }), { measure: measure }).text;
+}
+/** Kind of most glyphs (a single glyph is often misdetected). */
+function majorityKind(rows) {
+    var e_10, _a;
+    var shx = 0;
+    var mesh = 0;
+    try {
+        for (var rows_1 = __values(rows), rows_1_1 = rows_1.next(); !rows_1_1.done; rows_1_1 = rows_1.next()) {
+            var row = rows_1_1.value;
+            var weight = Math.max(1, row.line.glyphs.length);
+            if (row.kind === 'shx')
+                shx += weight;
+            else
+                mesh += weight;
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (rows_1_1 && !rows_1_1.done && (_a = rows_1.return)) _a.call(rows_1);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+    return mesh > shx ? 'mesh' : 'shx';
+}
+/** Axis-aligned world box of a line's strokes. */
+function worldBox(line) {
+    var e_11, _a, e_12, _b;
+    var minX = Infinity;
+    var minY = Infinity;
+    var maxX = -Infinity;
+    var maxY = -Infinity;
+    try {
+        for (var _c = __values(line.strokes), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var stroke = _d.value;
+            try {
+                for (var _e = (e_12 = 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_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    return { minX: minX, minY: minY, maxX: maxX, maxY: maxY };
+}
+/** MTEXT contents for plain text: escapes backslashes and braces. */
+function mtextEscape(text) {
+    return text.replace(/[\\{}]/g, function (char) { return "\\".concat(char); });
+}
+function toWorld(u, v, angle) {
+    var c = Math.cos(angle);
+    var s = Math.sin(angle);
+    return new AcGePoint3d(u * c - v * s, u * s + v * c, 0);
+}
+function sameName(a, b) {
+    return a.trim().toLowerCase() === b.trim().toLowerCase();
+}
+function createStyleRecord(name, fonts) {
+    return new AcDbTextStyleTableRecord({
+        name: name,
+        standardFlag: 0,
+        fixedTextHeight: 0,
+        widthFactor: 1,
+        obliqueAngle: 0,
+        textGenerationFlag: 0,
+        lastHeight: 2.5,
+        font: fonts.font,
+        bigFont: fonts.bigFont
+    });
+}
+//# sourceMappingURL=AcApPdfTextSession.js.map