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

package/lib/AcApPdfImportConvertor.js

@@ -1,3 +1,14 @@
+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 __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) {
@@ -34,6 +45,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -70,11 +92,22 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-import { AcApDocManager, AcApI18n, AcEdCorsorType } from '@mlightcad/cad-simple-viewer';
-import { AcCmColor, AcDbLine, AcDbPolyline, AcDbText, AcGePoint2d, AcGePoint3d, log } from '@mlightcad/data-model';
+import { AcApDocManager, AcApFontUtil, AcApI18n, AcEdCorsorType, AcEdPromptDoubleOptions, AcEdPromptIntegerOptions, AcEdPromptKeywordOptions, AcEdPromptPointOptions, AcEdPromptStatus } from '@mlightcad/cad-simple-viewer';
+import { AcCmColor, AcDbArc, AcDbBlockReference, AcDbBlockTableRecord, AcDbCircle, AcDbEllipse, AcDbLine, AcDbPolyline, AcDbRasterImage, AcDbRasterImageDef, AcDbSpline, AcDbText, AcGePoint2d, AcGePoint3d, AcGeVector3d, log } from '@mlightcad/data-model';
 import * as pdfjsLib from 'pdfjs-dist';
+import { acapPdfT } from './acapPdfI18n';
+import { resolveAcApPdfImportOptions } from './AcApPdfImportOptions';
+import { acapPdfImportResourceUrls } from './AcApPdfImportResources';
+import { acapPdfAppendEntities } from './pdfImportAppend';
+import { acapPdfCreatePatternHatch, acapPdfCreateSolidHatch, acapPdfEnsureDashLinetype, acapPdfEnsureTextStyle, acapPdfFitWidthFactor, acapPdfFontFamily, acapPdfShapeToLoop } from './pdfImportEntities';
+import { acapPdfRasterizeImage } from './pdfImportImages';
+import { buildPdfImportShapes, orderPdfImportPaints } from './pdfImportShapes';
 import { allocatePdfFallbackLayerName, collectPdfOcgLayers, normalizeCadLayerKey, pdfOperatorListHasOptionalContent } from './pdfOptionalContent';
-import { extractPdfImportSubpaths } from './pdfVectorImport';
+import { extractPdfImportSubpaths, PDF_IMPORT_FOREGROUND_COLOR } from './pdfVectorImport';
+import { buildPdfFormBlocks } from './recognition/pdfFormBlocks';
+import { acapPdfRecognizeHatches } from './recognition/pdfHatchRecognition';
+import { mergePdfTextRuns } from './recognition/pdfTextRunMerge';
+import { AcUiPdfImportDialog } from './ui/AcUiPdfImportDialog';
 /**
  * PDF.js worker shipped beside this module.
  *
@@ -86,6 +119,61 @@ import { extractPdfImportSubpaths } from './pdfVectorImport';
  */
 var PDF_WORKER_URL = new URL('../node_modules/pdfjs-dist/build/pdf.worker.mjs', import.meta.url);
 pdfjsLib.GlobalWorkerOptions.workerSrc = PDF_WORKER_URL.href;
+/**
+ * `getDocument` parameters. CMaps and standard fonts are required for CID
+ * (e.g. Chinese) fonts; without them PDF.js returns empty glyph runs.
+ */
+function pdfDocumentParams(data) {
+    return __assign(__assign({ data: data }, acapPdfImportResourceUrls(pdfjsLib.version)), { cMapPacked: true });
+}
+/** Mode last picked at the `-pdfimport` prompt; reused as the next default. */
+var lastImportMode = 'recover';
+/** i18n key of the prompt label for `mode`. */
+function importModeLabelKey(mode) {
+    return mode === 'visual'
+        ? 'jig.pdfimport.modeVisual'
+        : 'jig.pdfimport.modeRecover';
+}
+/** Adds the `jig.pdfimport.keywords.<name>` keyword to `keywords`. */
+function addPdfImportKeyword(keywords, name) {
+    var base = "jig.pdfimport.keywords.".concat(name);
+    return keywords.add(AcApI18n.t("".concat(base, ".display")), AcApI18n.t("".concat(base, ".global")), AcApI18n.t("".concat(base, ".local")));
+}
+/**
+ * Values last confirmed in the Import PDF dialog; the next `pdfimport` starts
+ * from them (page number excepted, as the next file differs).
+ */
+var lastDialogValues = {};
+/** Adapts a pdf.js document to what {@link AcUiPdfImportDialog} draws. */
+function pdfDialogDocument(pdf) {
+    var _this = this;
+    return {
+        numPages: pdf.numPages,
+        getPage: function (pageNumber) { return __awaiter(_this, void 0, void 0, function () {
+            var page;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, pdf.getPage(pageNumber)];
+                    case 1:
+                        page = _a.sent();
+                        return [2 /*return*/, {
+                                getSize: function (scale) {
+                                    var viewport = page.getViewport({ scale: scale });
+                                    return { width: viewport.width, height: viewport.height };
+                                },
+                                render: function (canvas, scale) {
+                                    var task = page.render({
+                                        canvas: canvas,
+                                        viewport: page.getViewport({ scale: scale })
+                                    });
+                                    return { promise: task.promise, cancel: function () { return task.cancel(); } };
+                                }
+                            }];
+                }
+            });
+        }); }
+    };
+}
 /**
  * Converts a PDF file into CAD entities appended to the current document's
  * model space.
@@ -94,7 +182,128 @@ var AcApPdfImportConvertor = /** @class */ (function () {
     function AcApPdfImportConvertor() {
     }
     /**
-     * Prompts the user to pick a PDF file and imports vector geometry.
+     * Prompts the user to pick a PDF file, shows the Import PDF dialog (page,
+     * insertion point, scale, import mode) and imports vector geometry
+     * (`pdfimport`).
+     *
+     * Returns without database edits when the picker or the dialog is
+     * dismissed. The command undo mark then has no committed changes, so
+     * nothing is pushed onto the undo stack.
+     *
+     * @param context - Application context for the target document
+     */
+    AcApPdfImportConvertor.prototype.importFromFilePicker = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var loaded, load, first, pdfBySource_1, result, source, values, pdf, insertionPoint, picked;
+            var _this = this;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        loaded = new Set();
+                        load = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var file, buffer, pdf;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.pickPdfFile()];
+                                    case 1:
+                                        file = _a.sent();
+                                        if (!file)
+                                            return [2 /*return*/, undefined];
+                                        return [4 /*yield*/, file.arrayBuffer()];
+                                    case 2:
+                                        buffer = _a.sent();
+                                        return [4 /*yield*/, pdfjsLib.getDocument(pdfDocumentParams(buffer)).promise];
+                                    case 3:
+                                        pdf = _a.sent();
+                                        loaded.add(pdf);
+                                        return [2 /*return*/, { pdf: pdf, document: pdfDialogDocument(pdf), fileName: file.name }];
+                                }
+                            });
+                        }); };
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, , 7, 9]);
+                        return [4 /*yield*/, load()
+                            // Chrome drops an SVG data-URI cursor after the native file dialog.
+                        ];
+                    case 2:
+                        first = _c.sent();
+                        // Chrome drops an SVG data-URI cursor after the native file dialog.
+                        restoreViewCursor(context);
+                        if (!first)
+                            return [2 /*return*/];
+                        pdfBySource_1 = new Map();
+                        pdfBySource_1.set(first, first.pdf);
+                        return [4 /*yield*/, AcUiPdfImportDialog.open({
+                                host: (_b = (_a = context.view) === null || _a === void 0 ? void 0 : _a.container) !== null && _b !== void 0 ? _b : document.body,
+                                source: first,
+                                initial: lastDialogValues,
+                                browse: function () { return __awaiter(_this, void 0, void 0, function () {
+                                    var next, error_1;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                _a.trys.push([0, 2, 3, 4]);
+                                                return [4 /*yield*/, load()];
+                                            case 1:
+                                                next = _a.sent();
+                                                if (next)
+                                                    pdfBySource_1.set(next, next.pdf);
+                                                return [2 /*return*/, next];
+                                            case 2:
+                                                error_1 = _a.sent();
+                                                log.warn('[pdfimport] Failed to open PDF:', error_1);
+                                                return [2 /*return*/, undefined];
+                                            case 3:
+                                                restoreViewCursor(context);
+                                                return [7 /*endfinally*/];
+                                            case 4: return [2 /*return*/];
+                                        }
+                                    });
+                                }); }
+                            })];
+                    case 3:
+                        result = _c.sent();
+                        if (!result)
+                            return [2 /*return*/];
+                        source = result.source, values = __rest(result, ["source"]);
+                        lastDialogValues = __assign(__assign({}, values), { pageNumber: undefined });
+                        pdf = pdfBySource_1.get(source);
+                        if (!pdf)
+                            return [2 /*return*/];
+                        insertionPoint = values.insertionPoint;
+                        if (!values.specifyOnScreen) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.promptInsertionPoint()];
+                    case 4:
+                        picked = _c.sent();
+                        if (!picked)
+                            return [2 /*return*/];
+                        insertionPoint = picked;
+                        _c.label = 5;
+                    case 5: return [4 /*yield*/, this.importDocument(context, pdf, resolveAcApPdfImportOptions({
+                            mode: values.mode,
+                            pageNumber: values.pageNumber,
+                            scale: values.scale,
+                            insertionPoint: insertionPoint
+                        }))];
+                    case 6:
+                        _c.sent();
+                        return [3 /*break*/, 9];
+                    case 7: return [4 /*yield*/, Promise.all(__spreadArray([], __read(loaded), false).map(function (pdf) { return pdf.destroy(); }))];
+                    case 8:
+                        _c.sent();
+                        restoreViewCursor(context);
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Prompts the user to pick a PDF file, asks for page / insertion point /
+     * scale / mode on the command line, and imports vector geometry
+     * (`-pdfimport`).
      *
      * Returns without database edits when the picker is dismissed. The command
      * undo mark then has no committed changes, so nothing is pushed onto the
@@ -102,13 +311,13 @@ var AcApPdfImportConvertor = /** @class */ (function () {
      *
      * @param context - Application context for the target document
      */
-    AcApPdfImportConvertor.prototype.importFromFilePicker = function (context) {
+    AcApPdfImportConvertor.prototype.importFromCommandLine = function (context) {
         return __awaiter(this, void 0, void 0, function () {
-            var file, buffer;
+            var file, buffer, pdf, prompted;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, , 4, 5]);
+                        _a.trys.push([0, , 10, 11]);
                         return [4 /*yield*/, this.pickPdfFile()];
                     case 1:
                         file = _a.sent();
@@ -117,15 +326,31 @@ var AcApPdfImportConvertor = /** @class */ (function () {
                         return [4 /*yield*/, file.arrayBuffer()];
                     case 2:
                         buffer = _a.sent();
-                        return [4 /*yield*/, this.convert(context, buffer)];
+                        return [4 /*yield*/, pdfjsLib.getDocument(pdfDocumentParams(buffer)).promise];
                     case 3:
-                        _a.sent();
-                        return [3 /*break*/, 5];
+                        pdf = _a.sent();
+                        _a.label = 4;
                     case 4:
+                        _a.trys.push([4, , 7, 9]);
+                        return [4 /*yield*/, this.promptImportOptions(pdf.numPages)];
+                    case 5:
+                        prompted = _a.sent();
+                        if (!prompted)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.importDocument(context, pdf, resolveAcApPdfImportOptions(prompted))];
+                    case 6:
+                        _a.sent();
+                        return [3 /*break*/, 9];
+                    case 7: return [4 /*yield*/, pdf.destroy()];
+                    case 8:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
                         // Chrome drops an SVG data-URI cursor after the native file dialog.
                         restoreViewCursor(context);
                         return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
+                    case 11: return [2 /*return*/];
                 }
             });
         });
@@ -135,7 +360,7 @@ var AcApPdfImportConvertor = /** @class */ (function () {
      *
      * Resolves `undefined` when the user cancels the picker. `cancel` does not
      * fire for every dismiss path, so closing the dialog (window focus with no
-     * selected file) also settles the promise. Otherwise `ipdf` would stay
+     * selected file) also settles the promise. Otherwise `pdfimport` would stay
      * inside its write transaction.
      */
     AcApPdfImportConvertor.prototype.pickPdfFile = function () {
@@ -180,13 +405,48 @@ var AcApPdfImportConvertor = /** @class */ (function () {
             }, 0);
         });
     };
+    /**
+     * Imports one PDF page into model space.
+     *
+     * @param context - Application context for the target document
+     * @param data - PDF file bytes
+     * @param pageNumberOrOptions - 1-based page number, or full import options
+     */
     AcApPdfImportConvertor.prototype.convert = function (context_1, data_1) {
-        return __awaiter(this, arguments, void 0, function (context, data, pageNumber) {
+        return __awaiter(this, arguments, void 0, function (context, data, pageNumberOrOptions) {
+            var options, pdf;
+            if (pageNumberOrOptions === void 0) { pageNumberOrOptions = 1; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = resolveAcApPdfImportOptions(typeof pageNumberOrOptions === 'number'
+                            ? { pageNumber: pageNumberOrOptions }
+                            : pageNumberOrOptions);
+                        return [4 /*yield*/, pdfjsLib.getDocument(pdfDocumentParams(data)).promise];
+                    case 1:
+                        pdf = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, , 4, 6]);
+                        return [4 /*yield*/, this.importDocument(context, pdf, options)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, pdf.destroy()];
+                    case 5:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcApPdfImportConvertor.prototype.importDocument = function (context, pdf, options) {
+        return __awaiter(this, void 0, void 0, function () {
             var _this = this;
-            if (pageNumber === void 0) { pageNumber = 1; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, AcApDocManager.instance.withBusyIndicator(function () { return _this.importPage(context, data, pageNumber); }, AcApI18n.t('main.message.importingPdf'))];
+                    case 0: return [4 /*yield*/, AcApDocManager.instance.withBusyIndicator(function () { return _this.importPage(context, pdf, options); }, AcApI18n.t('main.message.importingPdf'))];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];
@@ -194,86 +454,438 @@ var AcApPdfImportConvertor = /** @class */ (function () {
             });
         });
     };
-    AcApPdfImportConvertor.prototype.importPage = function (context, data, pageNumber) {
+    /**
+     * Command-line prompts: page (multi-page files only), then insertion point
+     * with `Scale` and `Mode` (recover the drawing / keep the PDF look)
+     * options.
+     *
+     * @returns Options to import with, or `undefined` when the user cancels.
+     */
+    AcApPdfImportConvertor.prototype.promptImportOptions = function (pageCount) {
         return __awaiter(this, void 0, void 0, function () {
-            var pdf, page, viewport, operatorList, optionalContentConfig, reservedLayerNames, ocgLayers, fallbackLayerName, _a, subpaths, texts, entities, usedLayerNames, subpaths_1, subpaths_1_1, subpath, entity, texts_1, texts_1_1, textRun, entity, layerService, existed, existedKeys, _b, _c, layerInfo, modelSpace, entities_1, entities_1_1, entity, err_1;
-            var e_1, _d, e_2, _e, e_3, _f, e_4, _g;
-            return __generator(this, function (_h) {
-                switch (_h.label) {
+            var editor, options, pagePrompt, pageResult, scale, mode, pointPrompt, result, picked, scalePrompt, scaleResult;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        _h.trys.push([0, 5, , 6]);
-                        return [4 /*yield*/, pdfjsLib.getDocument({ data: data }).promise];
+                        editor = AcApDocManager.instance.editor;
+                        options = {};
+                        if (!(pageCount > 1)) return [3 /*break*/, 2];
+                        pagePrompt = new AcEdPromptIntegerOptions(acapPdfT('jig.pdfimport.pageNumber', { count: pageCount }), 1, pageCount);
+                        pagePrompt.defaultValue = 1;
+                        pagePrompt.useDefaultValue = true;
+                        pagePrompt.allowNone = true;
+                        return [4 /*yield*/, editor.getInteger(pagePrompt)];
                     case 1:
-                        pdf = _h.sent();
-                        return [4 /*yield*/, pdf.getPage(pageNumber)];
+                        pageResult = _c.sent();
+                        if (pageResult.status === AcEdPromptStatus.OK) {
+                            options.pageNumber = (_a = pageResult.value) !== null && _a !== void 0 ? _a : 1;
+                        }
+                        else if (pageResult.status !== AcEdPromptStatus.None) {
+                            return [2 /*return*/, undefined];
+                        }
+                        _c.label = 2;
                     case 2:
-                        page = _h.sent();
-                        viewport = page.getViewport({ scale: 1 });
-                        return [4 /*yield*/, page.getOperatorList()];
+                        scale = 1;
+                        mode = lastImportMode;
+                        _c.label = 3;
                     case 3:
-                        operatorList = _h.sent();
+                        if (!true) return [3 /*break*/, 9];
+                        pointPrompt = new AcEdPromptPointOptions(acapPdfT('jig.pdfimport.insertionPoint', {
+                            scale: String(scale),
+                            mode: AcApI18n.t(importModeLabelKey(mode))
+                        }));
+                        pointPrompt.allowNone = true;
+                        addPdfImportKeyword(pointPrompt.keywords, 'scale');
+                        addPdfImportKeyword(pointPrompt.keywords, 'mode');
+                        return [4 /*yield*/, editor.getPoint(pointPrompt)];
+                    case 4:
+                        result = _c.sent();
+                        if (result.status === AcEdPromptStatus.OK && result.value) {
+                            options.insertionPoint = { x: result.value.x, y: result.value.y };
+                            return [3 /*break*/, 9];
+                        }
+                        if (result.status === AcEdPromptStatus.None)
+                            return [3 /*break*/, 9];
+                        if (result.status !== AcEdPromptStatus.Keyword)
+                            return [2 /*return*/, undefined];
+                        if (!(result.stringResult === 'Mode')) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.promptImportMode(mode)];
+                    case 5:
+                        picked = _c.sent();
+                        if (!picked)
+                            return [2 /*return*/, undefined];
+                        mode = picked;
+                        return [3 /*break*/, 3];
+                    case 6:
+                        if (!(result.stringResult === 'Scale')) return [3 /*break*/, 8];
+                        scalePrompt = new AcEdPromptDoubleOptions(AcApI18n.t('jig.pdfimport.scaleFactor'));
+                        scalePrompt.defaultValue = scale;
+                        scalePrompt.useDefaultValue = true;
+                        scalePrompt.allowNone = true;
+                        scalePrompt.allowNegative = false;
+                        scalePrompt.allowZero = false;
+                        return [4 /*yield*/, editor.getDouble(scalePrompt)];
+                    case 7:
+                        scaleResult = _c.sent();
+                        if (scaleResult.status === AcEdPromptStatus.OK) {
+                            scale = (_b = scaleResult.value) !== null && _b !== void 0 ? _b : scale;
+                        }
+                        else if (scaleResult.status !== AcEdPromptStatus.None) {
+                            return [2 /*return*/, undefined];
+                        }
+                        _c.label = 8;
+                    case 8: return [3 /*break*/, 3];
+                    case 9:
+                        options.scale = scale;
+                        options.mode = mode;
+                        lastImportMode = mode;
+                        return [2 /*return*/, options];
+                }
+            });
+        });
+    };
+    /**
+     * Asks for the import mode; Enter keeps `current`.
+     *
+     * @returns The chosen mode, or `undefined` when the user cancels.
+     */
+    AcApPdfImportConvertor.prototype.promptImportMode = function (current) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, recover, visual, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptKeywordOptions(AcApI18n.t('jig.pdfimport.modePrompt'));
+                        prompt.allowNone = true;
+                        recover = addPdfImportKeyword(prompt.keywords, 'recover');
+                        visual = addPdfImportKeyword(prompt.keywords, 'visual');
+                        prompt.keywords.default = current === 'visual' ? visual : recover;
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getKeywords(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        if (result.status === AcEdPromptStatus.None)
+                            return [2 /*return*/, current];
+                        if (result.status !== AcEdPromptStatus.OK &&
+                            result.status !== AcEdPromptStatus.Keyword) {
+                            return [2 /*return*/, undefined];
+                        }
+                        if (result.stringResult === 'Visual')
+                            return [2 /*return*/, 'visual'];
+                        if (result.stringResult === 'Recover')
+                            return [2 /*return*/, 'recover'];
+                        return [2 /*return*/, current];
+                }
+            });
+        });
+    };
+    /**
+     * Asks for the insertion point in the drawing. Enter takes the origin.
+     *
+     * @returns The point, or `undefined` when the user cancels.
+     */
+    AcApPdfImportConvertor.prototype.promptInsertionPoint = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.pdfimport.pickInsertionPoint'));
+                        prompt.allowNone = true;
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        if (result.status === AcEdPromptStatus.OK && result.value) {
+                            return [2 /*return*/, { x: result.value.x, y: result.value.y }];
+                        }
+                        if (result.status === AcEdPromptStatus.None)
+                            return [2 /*return*/, { x: 0, y: 0 }];
+                        return [2 /*return*/, undefined];
+                }
+            });
+        });
+    };
+    AcApPdfImportConvertor.prototype.importPage = function (context, pdf, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var page_1, viewport, operatorList, optionalContentConfig, reservedLayerNames, ocgLayers, fallbackLayerName, content, formBlocks_1, _a, items, stats, recognized, itemIndex_1, hatchAt, _b, _c, hatch, db_1, usedLayerNames_1, createEntity, entities, hatchCount, patternHatchCount, _d, _e, paint, index, found, hatch_1, entity, group, loops, hatch, group_1, group_1_1, item, entity, first, blockTable, referenceCount, _f, _g, block, blockEntities, name_1, record, insertionPoint, scale, _h, _j, placement, ref, texts, styleByFont_1, styleFor, textEntities, texts_1, texts_1_1, textRun, entity, style, imageEntities, _k, imageEntities_1, imageEntities_1_1, image, ordered, layerService, existed, existedKeys, _l, _m, layerInfo, err_1;
+            var e_1, _o, e_2, _p, e_3, _q, e_4, _r, e_5, _s, e_6, _t, e_7, _u, e_8, _v;
+            var _w, _x;
+            return __generator(this, function (_y) {
+                switch (_y.label) {
+                    case 0:
+                        _y.trys.push([0, 9, , 10]);
+                        return [4 /*yield*/, pdf.getPage(options.pageNumber)];
+                    case 1:
+                        page_1 = _y.sent();
+                        viewport = page_1.getViewport({ scale: 1 });
+                        return [4 /*yield*/, page_1.getOperatorList()];
+                    case 2:
+                        operatorList = _y.sent();
                         return [4 /*yield*/, pdf.getOptionalContentConfig({
                                 intent: 'display'
                             })];
-                    case 4:
-                        optionalContentConfig = (_h.sent());
+                    case 3:
+                        optionalContentConfig = (_y.sent());
                         reservedLayerNames = databaseLayerNames(context);
                         ocgLayers = collectPdfOcgLayers(operatorList, pdfjsLib.OPS.beginMarkedContentProps, optionalContentConfig, reservedLayerNames);
                         fallbackLayerName = pdfOperatorListHasOptionalContent(operatorList, pdfjsLib.OPS.beginMarkedContentProps)
                             ? allocatePdfFallbackLayerName(reservedLayerNames, __spreadArray([], __read(ocgLayers.values()), false).map(function (layer) { return layer.layerName; }))
                             : undefined;
-                        _a = extractPdfImportSubpaths(operatorList, pdfjsLib.OPS, viewport, ocgLayers, fallbackLayerName), subpaths = _a.subpaths, texts = _a.texts;
-                        entities = [];
-                        usedLayerNames = new Set();
+                        content = extractPdfImportSubpaths(operatorList, pdfjsLib.OPS, viewport, ocgLayers, fallbackLayerName, { remapContrastInk: true, paperTone: 'auto' });
+                        formBlocks_1 = options.formBlocks
+                            ? buildPdfFormBlocks(content, {
+                                curveRecognition: options.curveRecognition
+                            })
+                            : { blocks: [], consumed: new Set() };
+                        _a = buildPdfImportShapes({
+                            subpaths: content.subpaths.filter(function (_, index) { return !formBlocks_1.consumed.has(index); })
+                        }, options), items = _a.items, stats = _a.stats;
+                        recognized = options.recognizeHatches
+                            ? acapPdfRecognizeHatches(items, __assign({ tolerance: PDF_HATCH_TOLERANCE_MM * options.scale }, options.hatchRecognition), (_w = content.clipPaths) === null || _w === void 0 ? void 0 : _w.map(function (loops) {
+                                return loops.map(function (loop) {
+                                    return loop.map(function (p) { return ({
+                                        x: options.insertionPoint.x + p.x * options.scale,
+                                        y: options.insertionPoint.y + p.y * options.scale
+                                    }); });
+                                });
+                            }))
+                            : { hatches: [], consumed: new Set() };
+                        itemIndex_1 = new Map();
+                        items.forEach(function (item, index) { return itemIndex_1.set(item, index); });
+                        hatchAt = new Map();
                         try {
-                            for (subpaths_1 = __values(subpaths), subpaths_1_1 = subpaths_1.next(); !subpaths_1_1.done; subpaths_1_1 = subpaths_1.next()) {
-                                subpath = subpaths_1_1.value;
-                                if (subpath.layerName) {
-                                    usedLayerNames.add(subpath.layerName);
-                                }
-                                entity = this.subpathToEntity(subpath.points, subpath.layerName, subpath.color);
-                                if (entity)
-                                    entities.push(entity);
+                            for (_b = __values(recognized.hatches), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                hatch = _c.value;
+                                hatchAt.set(hatch.items[0], hatch);
                             }
                         }
                         catch (e_1_1) { e_1 = { error: e_1_1 }; }
                         finally {
                             try {
-                                if (subpaths_1_1 && !subpaths_1_1.done && (_d = subpaths_1.return)) _d.call(subpaths_1);
+                                if (_c && !_c.done && (_o = _b.return)) _o.call(_b);
                             }
                             finally { if (e_1) throw e_1.error; }
                         }
+                        db_1 = context.doc.database;
+                        usedLayerNames_1 = new Set();
+                        createEntity = function (item) {
+                            var entity = shapeToEntity(item.shape);
+                            if (!entity)
+                                return null;
+                            if (item.layerName) {
+                                usedLayerNames_1.add(item.layerName);
+                                entity.layer = item.layerName;
+                            }
+                            applyPdfColor(entity, item.color);
+                            if (options.lineWeights && item.lineWidth) {
+                                entity.lineWeight = nearestLineWeight(item.lineWidth);
+                            }
+                            if (options.dashLinetypes && item.dashPattern) {
+                                entity.lineType = acapPdfEnsureDashLinetype(db_1, item.dashPattern.map(function (length) { return length * options.scale; }));
+                            }
+                            return entity;
+                        };
+                        entities = [];
+                        hatchCount = 0;
+                        patternHatchCount = 0;
+                        try {
+                            for (_d = __values(orderPdfImportPaints(items, options.fillHatches)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                paint = _e.value;
+                                if (paint.kind === 'shape') {
+                                    index = itemIndex_1.get(paint.item);
+                                    if (index !== undefined && recognized.consumed.has(index)) {
+                                        found = hatchAt.get(index);
+                                        hatch_1 = found && createPatternHatch(db_1, found);
+                                        if (hatch_1) {
+                                            if (found.layerName)
+                                                usedLayerNames_1.add(found.layerName);
+                                            entities.push(hatch_1);
+                                            patternHatchCount++;
+                                        }
+                                        continue;
+                                    }
+                                    entity = createEntity(paint.item);
+                                    if (entity)
+                                        entities.push(entity);
+                                    continue;
+                                }
+                                group = paint.items;
+                                loops = group
+                                    .map(function (item) { return acapPdfShapeToLoop(item.shape); })
+                                    .filter(function (loop) { return !!loop; });
+                                hatch = acapPdfCreateSolidHatch(db_1, loops);
+                                if (!hatch) {
+                                    try {
+                                        // Nothing closed to fill: keep the outlines instead of dropping them.
+                                        for (group_1 = (e_3 = void 0, __values(group)), group_1_1 = group_1.next(); !group_1_1.done; group_1_1 = group_1.next()) {
+                                            item = group_1_1.value;
+                                            if (item.stroked)
+                                                continue;
+                                            entity = createEntity(item);
+                                            if (entity)
+                                                entities.push(entity);
+                                        }
+                                    }
+                                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                    finally {
+                                        try {
+                                            if (group_1_1 && !group_1_1.done && (_q = group_1.return)) _q.call(group_1);
+                                        }
+                                        finally { if (e_3) throw e_3.error; }
+                                    }
+                                    continue;
+                                }
+                                first = group[0];
+                                if (first.layerName) {
+                                    usedLayerNames_1.add(first.layerName);
+                                    hatch.layer = first.layerName;
+                                }
+                                applyPdfColor(hatch, (_x = first.fillColor) !== null && _x !== void 0 ? _x : first.color);
+                                entities.push(hatch);
+                                hatchCount++;
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_e && !_e.done && (_p = _d.return)) _p.call(_d);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        blockTable = db_1.tables.blockTable;
+                        referenceCount = 0;
+                        try {
+                            for (_f = __values(formBlocks_1.blocks), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                block = _g.value;
+                                blockEntities = block.shapes
+                                    .map(createEntity)
+                                    .filter(function (entity) { return entity !== null; });
+                                if (blockEntities.length === 0)
+                                    continue;
+                                name_1 = uniqueBlockName(context, PDF_FORM_BLOCK_PREFIX);
+                                record = new AcDbBlockTableRecord({
+                                    name: name_1,
+                                    origin: new AcGePoint3d(0, 0, 0)
+                                });
+                                blockTable.add(record);
+                                record.appendEntity(blockEntities);
+                                insertionPoint = options.insertionPoint, scale = options.scale;
+                                try {
+                                    for (_h = (e_5 = void 0, __values(block.references)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                                        placement = _j.value;
+                                        ref = new AcDbBlockReference(name_1);
+                                        ref.position = new AcGePoint3d(insertionPoint.x + placement.position.x * scale, insertionPoint.y + placement.position.y * scale, 0);
+                                        ref.rotation = placement.rotation;
+                                        ref.scaleFactors = new AcGePoint3d(placement.scaleX * scale, placement.scaleY * scale, 1);
+                                        if (placement.layerName) {
+                                            usedLayerNames_1.add(placement.layerName);
+                                            ref.layer = placement.layerName;
+                                        }
+                                        entities.push(ref);
+                                        referenceCount++;
+                                    }
+                                }
+                                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                finally {
+                                    try {
+                                        if (_j && !_j.done && (_s = _h.return)) _s.call(_h);
+                                    }
+                                    finally { if (e_5) throw e_5.error; }
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_g && !_g.done && (_r = _f.return)) _r.call(_f);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        texts = options.mergeTextRuns
+                            ? mergePdfTextRuns(content.texts)
+                            : content.texts;
+                        styleByFont_1 = new Map();
+                        styleFor = function (fontId) {
+                            if (!options.textStyles || fontId === undefined)
+                                return undefined;
+                            if (!styleByFont_1.has(fontId)) {
+                                var name_2 = pdfFontName(page_1, fontId);
+                                styleByFont_1.set(fontId, name_2
+                                    ? acapPdfEnsureTextStyle(db_1, acapPdfFontFamily(name_2))
+                                    : undefined);
+                            }
+                            return styleByFont_1.get(fontId);
+                        };
+                        textEntities = [];
                         try {
                             for (texts_1 = __values(texts), texts_1_1 = texts_1.next(); !texts_1_1.done; texts_1_1 = texts_1.next()) {
                                 textRun = texts_1_1.value;
                                 if (textRun.layerName) {
-                                    usedLayerNames.add(textRun.layerName);
+                                    usedLayerNames_1.add(textRun.layerName);
                                 }
-                                entity = this.textToEntity(textRun);
-                                if (entity)
-                                    entities.push(entity);
+                                entity = this.textToEntity(textRun, options);
+                                if (!entity)
+                                    continue;
+                                style = styleFor(textRun.fontId);
+                                if (style)
+                                    entity.styleName = style;
+                                textEntities.push({ entity: entity, run: textRun });
+                                entities.push(entity);
                             }
                         }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
                         finally {
                             try {
-                                if (texts_1_1 && !texts_1_1.done && (_e = texts_1.return)) _e.call(texts_1);
+                                if (texts_1_1 && !texts_1_1.done && (_t = texts_1.return)) _t.call(texts_1);
                             }
-                            finally { if (e_2) throw e_2.error; }
+                            finally { if (e_6) throw e_6.error; }
                         }
-                        if (entities.length === 0) {
+                        if (!options.fitTextWidth) return [3 /*break*/, 5];
+                        return [4 /*yield*/, fitTextWidths(db_1, textEntities, options.scale)];
+                    case 4:
+                        _y.sent();
+                        _y.label = 5;
+                    case 5:
+                        if (!(options.images && content.images)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, createImageEntities(page_1, db_1, content.images, options)];
+                    case 6:
+                        _k = _y.sent();
+                        return [3 /*break*/, 8];
+                    case 7:
+                        _k = [];
+                        _y.label = 8;
+                    case 8:
+                        imageEntities = _k;
+                        try {
+                            for (imageEntities_1 = __values(imageEntities), imageEntities_1_1 = imageEntities_1.next(); !imageEntities_1_1.done; imageEntities_1_1 = imageEntities_1.next()) {
+                                image = imageEntities_1_1.value;
+                                if (image.layer && image.layer !== '0')
+                                    usedLayerNames_1.add(image.layer);
+                            }
+                        }
+                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                        finally {
+                            try {
+                                if (imageEntities_1_1 && !imageEntities_1_1.done && (_u = imageEntities_1.return)) _u.call(imageEntities_1);
+                            }
+                            finally { if (e_7) throw e_7.error; }
+                        }
+                        ordered = imageEntities.length > 0
+                            ? imageEntities.concat(entities)
+                            : entities;
+                        if (ordered.length === 0) {
                             log.warn('[PdfImport] No vector geometry found in PDF page.');
                             return [2 /*return*/];
                         }
                         layerService = context.doc.layerService;
-                        existed = usedLayerNames.size > 0
-                            ? layerService.createLayers(__spreadArray([], __read(usedLayerNames), false)).existed
+                        existed = usedLayerNames_1.size > 0
+                            ? layerService.createLayers(__spreadArray([], __read(usedLayerNames_1), false)).existed
                             : [];
                         existedKeys = new Set(existed.map(normalizeCadLayerKey));
                         try {
-                            for (_b = __values(ocgLayers.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                                layerInfo = _c.value;
-                                if (!usedLayerNames.has(layerInfo.layerName))
+                            for (_l = __values(ocgLayers.values()), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                layerInfo = _m.value;
+                                if (!usedLayerNames_1.has(layerInfo.layerName))
                                     continue;
                                 if (existedKeys.has(normalizeCadLayerKey(layerInfo.layerName)))
                                     continue;
@@ -282,73 +894,38 @@ var AcApPdfImportConvertor = /** @class */ (function () {
                                 layerService.setLayerOn(layerInfo.layerName, false);
                             }
                         }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
-                            try {
-                                if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
-                            }
-                            finally { if (e_3) throw e_3.error; }
-                        }
-                        modelSpace = context.doc.database.tables.blockTable.modelSpace;
-                        try {
-                            for (entities_1 = __values(entities), entities_1_1 = entities_1.next(); !entities_1_1.done; entities_1_1 = entities_1.next()) {
-                                entity = entities_1_1.value;
-                                modelSpace.appendEntity(entity);
-                            }
-                        }
-                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
                         finally {
                             try {
-                                if (entities_1_1 && !entities_1_1.done && (_g = entities_1.return)) _g.call(entities_1);
+                                if (_m && !_m.done && (_v = _l.return)) _v.call(_l);
                             }
-                            finally { if (e_4) throw e_4.error; }
+                            finally { if (e_8) throw e_8.error; }
                         }
-                        log.info("[PdfImport] Imported ".concat(entities.length, " entities across ").concat(usedLayerNames.size, " CAD layer(s)."));
-                        return [3 /*break*/, 6];
-                    case 5:
-                        err_1 = _h.sent();
+                        acapPdfAppendEntities(context.doc.database.tables.blockTable.modelSpace, ordered);
+                        log.info("[PdfImport] Imported ".concat(ordered.length, " entities across ").concat(usedLayerNames_1.size, " CAD layer(s): ") +
+                            "".concat(stats.line, " lines, ").concat(stats.polyline, " polylines, ").concat(stats.circle, " circles, ") +
+                            "".concat(stats.arc, " arcs, ").concat(stats.ellipse, " ellipses, ").concat(stats.spline, " splines, ") +
+                            "mode ".concat(options.mode, ", ").concat(texts.length, " texts, ").concat(imageEntities.length, " images, ").concat(hatchCount, " hatches, ") +
+                            "".concat(patternHatchCount, " pattern hatches (").concat(recognized.consumed.size, " strokes), ").concat(formBlocks_1.blocks.length, " blocks ") +
+                            "(".concat(referenceCount, " references); ").concat(stats.duplicates, " duplicates skipped."));
+                        return [3 /*break*/, 10];
+                    case 9:
+                        err_1 = _y.sent();
                         log.error('[PdfImport] Failed to import PDF:', err_1);
                         throw err_1;
-                    case 6: return [2 /*return*/];
+                    case 10: return [2 /*return*/];
                 }
             });
         });
     };
-    AcApPdfImportConvertor.prototype.subpathToEntity = function (pts, layerName, color) {
-        if (pts.length < 2)
-            return null;
-        if (pts.length === 2) {
-            var line = new AcDbLine(new AcGePoint3d(pts[0].x, pts[0].y, 0), new AcGePoint3d(pts[1].x, pts[1].y, 0));
-            if (layerName) {
-                line.layer = layerName;
-            }
-            applyPdfColor(line, color);
-            return line;
-        }
-        var poly = new AcDbPolyline();
-        if (layerName) {
-            poly.layer = layerName;
-        }
-        applyPdfColor(poly, color);
-        for (var i = 0; i < pts.length; i++) {
-            poly.addVertexAt(i, new AcGePoint2d(pts[i].x, pts[i].y));
-        }
-        var first = pts[0];
-        var last = pts[pts.length - 1];
-        var dx = first.x - last.x;
-        var dy = first.y - last.y;
-        if (Math.sqrt(dx * dx + dy * dy) < 1e-6) {
-            poly.closed = true;
-        }
-        return poly;
-    };
-    AcApPdfImportConvertor.prototype.textToEntity = function (run) {
+    AcApPdfImportConvertor.prototype.textToEntity = function (run, options) {
         if (!run.text || run.height <= 0)
             return null;
+        var insertionPoint = options.insertionPoint, scale = options.scale;
         var text = new AcDbText();
         text.textString = run.text;
-        text.position = new AcGePoint3d(run.position.x, run.position.y, 0);
-        text.height = run.height;
+        text.position = new AcGePoint3d(insertionPoint.x + run.position.x * scale, insertionPoint.y + run.position.y * scale, 0);
+        text.height = run.height * scale;
         text.rotation = run.rotation;
         if (Number.isFinite(run.widthFactor) && run.widthFactor > 0) {
             text.widthFactor = run.widthFactor;
@@ -362,9 +939,323 @@ var AcApPdfImportConvertor = /** @class */ (function () {
     return AcApPdfImportConvertor;
 }());
 export { AcApPdfImportConvertor };
+/** File name prefix of image definitions created for PDF images. */
+var PDF_IMAGE_PREFIX = 'PDF_IMAGE_';
+/** How long to wait for PDF.js to deliver one decoded image. */
+var PDF_IMAGE_TIMEOUT_MS = 10000;
+/**
+ * Turns PDF image paints into raster images. Each image is redrawn upright
+ * with its rotation / mirroring baked in; the PNG is kept in memory on the
+ * entity (`AcDbRasterImage.image`) and its definition is named
+ * `PDF_IMAGE_<n>.png`.
+ */
+function createImageEntities(page, db, images, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var scale, insertionPoint, decoded, result, images_1, images_1_1, paint, image, pending_1, _a, a, b, c, d, e, f, raster, err_2, fileName, imageDef, entity, e_9_1;
+        var e_9, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    scale = options.scale, insertionPoint = options.insertionPoint;
+                    decoded = new Map();
+                    result = [];
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 12, 13, 14]);
+                    images_1 = __values(images), images_1_1 = images_1.next();
+                    _c.label = 2;
+                case 2:
+                    if (!!images_1_1.done) return [3 /*break*/, 11];
+                    paint = images_1_1.value;
+                    image = void 0;
+                    if (!paint.objId) return [3 /*break*/, 4];
+                    pending_1 = decoded.get(paint.objId);
+                    if (!pending_1) {
+                        pending_1 = pdfImageObject(page, paint.objId);
+                        decoded.set(paint.objId, pending_1);
+                    }
+                    return [4 /*yield*/, pending_1];
+                case 3:
+                    image = _c.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    image = paint.inline;
+                    _c.label = 5;
+                case 5:
+                    if (!image)
+                        return [3 /*break*/, 10];
+                    _a = paint.toCad, a = _a.a, b = _a.b, c = _a.c, d = _a.d, e = _a.e, f = _a.f;
+                    raster = void 0;
+                    _c.label = 6;
+                case 6:
+                    _c.trys.push([6, 8, , 9]);
+                    return [4 /*yield*/, acapPdfRasterizeImage(image, {
+                            a: a * scale,
+                            b: b * scale,
+                            c: c * scale,
+                            d: d * scale,
+                            e: insertionPoint.x + e * scale,
+                            f: insertionPoint.y + f * scale
+                        })];
+                case 7:
+                    raster = _c.sent();
+                    return [3 /*break*/, 9];
+                case 8:
+                    err_2 = _c.sent();
+                    log.warn('[PdfImport] Skipped an image that could not be drawn:', err_2);
+                    return [3 /*break*/, 10];
+                case 9:
+                    if (!raster)
+                        return [3 /*break*/, 10];
+                    fileName = uniqueImageFileName(db);
+                    imageDef = new AcDbRasterImageDef();
+                    imageDef.sourceFileName = fileName;
+                    imageDef.imageSize = new AcGePoint2d(raster.pixelWidth, raster.pixelHeight);
+                    imageDef.isLoaded = true;
+                    db.objects.imageDefinition.setAt(fileName, imageDef);
+                    entity = new AcDbRasterImage();
+                    entity.position = new AcGePoint3d(raster.box.x, raster.box.y, 0);
+                    entity.width = raster.box.width;
+                    entity.height = raster.box.height;
+                    entity.imageSize = new AcGePoint2d(raster.pixelWidth, raster.pixelHeight);
+                    entity.image = raster.png;
+                    entity.imageDefId = imageDef.objectId;
+                    if (paint.layerName)
+                        entity.layer = paint.layerName;
+                    result.push(entity);
+                    _c.label = 10;
+                case 10:
+                    images_1_1 = images_1.next();
+                    return [3 /*break*/, 2];
+                case 11: return [3 /*break*/, 14];
+                case 12:
+                    e_9_1 = _c.sent();
+                    e_9 = { error: e_9_1 };
+                    return [3 /*break*/, 14];
+                case 13:
+                    try {
+                        if (images_1_1 && !images_1_1.done && (_b = images_1.return)) _b.call(images_1);
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                    return [7 /*endfinally*/];
+                case 14: return [2 /*return*/, result];
+            }
+        });
+    });
+}
+/** Waits for PDF.js to deliver a decoded image object. */
+function pdfImageObject(page, objId) {
+    var store = objId.startsWith('g_') ? page.commonObjs : page.objs;
+    return new Promise(function (resolve) {
+        var timer = setTimeout(function () {
+            log.warn("[PdfImport] Timed out waiting for image ".concat(objId, "."));
+            resolve(undefined);
+        }, PDF_IMAGE_TIMEOUT_MS);
+        try {
+            store.get(objId, function (data) {
+                clearTimeout(timer);
+                resolve((data !== null && data !== void 0 ? data : undefined));
+            });
+        }
+        catch (err) {
+            clearTimeout(timer);
+            log.warn("[PdfImport] Image ".concat(objId, " is not available:"), err);
+            resolve(undefined);
+        }
+    });
+}
+/** First `PDF_IMAGE_<n>.png` not used by an image definition. */
+function uniqueImageFileName(db) {
+    var index = 1;
+    while (db.objects.imageDefinition.has("".concat(PDF_IMAGE_PREFIX).concat(index, ".png"))) {
+        index++;
+    }
+    return "".concat(PDF_IMAGE_PREFIX).concat(index, ".png");
+}
+/**
+ * Sets each text's width factor so it spans its PDF advance width in the
+ * font the viewer will actually draw it with (usually a substitute for the
+ * PDF font). Texts whose glyphs cannot be measured keep the PDF factor.
+ */
+function fitTextWidths(db, texts, scale) {
+    return __awaiter(this, void 0, void 0, function () {
+        var styleTable, fontsOf, fontNames, texts_2, texts_2_1, entity, _a, font, bigFont, err_3, texts_3, texts_3_1, _b, entity, run, _c, font, bigFont, natural;
+        var e_10, _d, e_11, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    styleTable = db.tables.textStyleTable;
+                    fontsOf = function (entity) {
+                        var _a, _b;
+                        var style = styleTable.resolveAt(entity.styleName || db.textstyle);
+                        return {
+                            font: (_a = style === null || style === void 0 ? void 0 : style.textStyle.font) !== null && _a !== void 0 ? _a : '',
+                            bigFont: (_b = style === null || style === void 0 ? void 0 : style.textStyle.bigFont) !== null && _b !== void 0 ? _b : ''
+                        };
+                    };
+                    fontNames = new Set();
+                    try {
+                        for (texts_2 = __values(texts), texts_2_1 = texts_2.next(); !texts_2_1.done; texts_2_1 = texts_2.next()) {
+                            entity = texts_2_1.value.entity;
+                            _a = fontsOf(entity), font = _a.font, bigFont = _a.bigFont;
+                            if (font)
+                                fontNames.add(font);
+                            if (bigFont)
+                                fontNames.add(bigFont);
+                        }
+                    }
+                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                    finally {
+                        try {
+                            if (texts_2_1 && !texts_2_1.done && (_d = texts_2.return)) _d.call(texts_2);
+                        }
+                        finally { if (e_10) throw e_10.error; }
+                    }
+                    _f.label = 1;
+                case 1:
+                    _f.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, AcApFontUtil.prepareTextMeasurement(__spreadArray([], __read(fontNames), false))];
+                case 2:
+                    _f.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    err_3 = _f.sent();
+                    // Without fonts there is nothing to measure against; keep PDF factors.
+                    log.warn('[PdfImport] Could not load fonts to fit text widths:', err_3);
+                    return [2 /*return*/];
+                case 4:
+                    try {
+                        for (texts_3 = __values(texts), texts_3_1 = texts_3.next(); !texts_3_1.done; texts_3_1 = texts_3.next()) {
+                            _b = texts_3_1.value, entity = _b.entity, run = _b.run;
+                            if (run.width === undefined)
+                                continue;
+                            _c = fontsOf(entity), font = _c.font, bigFont = _c.bigFont;
+                            natural = AcApFontUtil.measureTextWidth(entity.textString, font, entity.height, bigFont);
+                            entity.widthFactor = acapPdfFitWidthFactor(entity.widthFactor, run.width * scale, natural);
+                        }
+                    }
+                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    finally {
+                        try {
+                            if (texts_3_1 && !texts_3_1.done && (_e = texts_3.return)) _e.call(texts_3);
+                        }
+                        finally { if (e_11) throw e_11.error; }
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/** Creates the CAD entity for a recognized shape. */
+/**
+ * Distance (paper millimeters, before import scaling) within which a stroke
+ * counts as lying on a recognized hatch line. PDF writers round coordinates
+ * to about 0.01 pt (0.0035 mm), so this leaves ample headroom while staying
+ * far below any real hatch spacing.
+ */
+var PDF_HATCH_TOLERANCE_MM = 0.05;
+function createPatternHatch(db, found) {
+    var loops = found.boundary
+        .map(function (shape) { return acapPdfShapeToLoop(shape); })
+        .filter(function (loop) { return !!loop; });
+    var hatch = acapPdfCreatePatternHatch(db, loops, found.pattern, found.definitionLines);
+    if (!hatch)
+        return undefined;
+    if (found.layerName)
+        hatch.layer = found.layerName;
+    applyPdfColor(hatch, found.color);
+    return hatch;
+}
+function shapeToEntity(shape) {
+    switch (shape.kind) {
+        case 'line':
+            return new AcDbLine(new AcGePoint3d(shape.start.x, shape.start.y, 0), new AcGePoint3d(shape.end.x, shape.end.y, 0));
+        case 'circle':
+            return new AcDbCircle(new AcGePoint3d(shape.center.x, shape.center.y, 0), shape.radius);
+        case 'arc':
+            return new AcDbArc(new AcGePoint3d(shape.center.x, shape.center.y, 0), shape.radius, shape.startAngle, shape.endAngle);
+        case 'ellipse': {
+            var major = Math.hypot(shape.majorAxis.x, shape.majorAxis.y);
+            if (!(major > 0))
+                return null;
+            return new AcDbEllipse(new AcGePoint3d(shape.center.x, shape.center.y, 0), AcGeVector3d.Z_AXIS, new AcGeVector3d(shape.majorAxis.x, shape.majorAxis.y, 0), major, major * shape.radiusRatio, shape.startAngle, shape.endAngle);
+        }
+        case 'polyline': {
+            if (shape.vertices.length < 2)
+                return null;
+            var poly_1 = new AcDbPolyline();
+            shape.vertices.forEach(function (v, i) {
+                return poly_1.addVertexAt(i, new AcGePoint2d(v.x, v.y), v.bulge);
+            });
+            poly_1.closed = shape.closed;
+            return poly_1;
+        }
+        case 'spline':
+            try {
+                return new AcDbSpline(shape.controlPoints.map(function (p) { return new AcGePoint3d(p.x, p.y, 0); }), shape.knots);
+            }
+            catch (err) {
+                log.warn('[PdfImport] Skipped invalid spline:', err);
+                return null;
+            }
+    }
+}
+/** Standard AutoCAD line weights in 1/100 mm. */
+var STANDARD_LINE_WEIGHTS = [
+    0, 5, 9, 13, 15, 18, 20, 25, 30, 35, 40, 50, 53, 60, 70, 80, 90, 100, 106,
+    120, 140, 158, 200, 211
+];
+/** Maps a stroke width in millimeters to the nearest standard line weight. */
+function nearestLineWeight(widthMm) {
+    var e_12, _a;
+    var hundredths = widthMm * 100;
+    var best = STANDARD_LINE_WEIGHTS[0];
+    try {
+        for (var STANDARD_LINE_WEIGHTS_1 = __values(STANDARD_LINE_WEIGHTS), STANDARD_LINE_WEIGHTS_1_1 = STANDARD_LINE_WEIGHTS_1.next(); !STANDARD_LINE_WEIGHTS_1_1.done; STANDARD_LINE_WEIGHTS_1_1 = STANDARD_LINE_WEIGHTS_1.next()) {
+            var weight = STANDARD_LINE_WEIGHTS_1_1.value;
+            if (Math.abs(weight - hundredths) < Math.abs(best - hundredths)) {
+                best = weight;
+            }
+        }
+    }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (STANDARD_LINE_WEIGHTS_1_1 && !STANDARD_LINE_WEIGHTS_1_1.done && (_a = STANDARD_LINE_WEIGHTS_1.return)) _a.call(STANDARD_LINE_WEIGHTS_1);
+        }
+        finally { if (e_12) throw e_12.error; }
+    }
+    return best;
+}
+/** PDF font name for a `setFont` resource id, when PDF.js loaded it. */
+function pdfFontName(page, fontId) {
+    try {
+        if (!page.commonObjs.has(fontId))
+            return undefined;
+        var font = page.commonObjs.get(fontId);
+        return typeof (font === null || font === void 0 ? void 0 : font.name) === 'string' && font.name ? font.name : undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/** Name prefix for blocks recovered from repeated Form XObjects. */
+var PDF_FORM_BLOCK_PREFIX = 'PDF_FORM_';
+/** First `<prefix><n>` block name not used in the drawing. */
+function uniqueBlockName(context, prefix) {
+    var blockTable = context.doc.database.tables.blockTable;
+    var index = 1;
+    while (blockTable.has("".concat(prefix).concat(index)))
+        index++;
+    return "".concat(prefix).concat(index);
+}
 function applyPdfColor(entity, color) {
     if (!color)
         return;
+    if (color === PDF_IMPORT_FOREGROUND_COLOR) {
+        entity.color = new AcCmColor().setForeground();
+        return;
+    }
     var match = /^#([0-9a-fA-F]{6})$/.exec(color);
     if (!match)
         return;