@mlightcad/cad-pdf-plugin 1.7.3 → 1.7.4

package/lib/AcApPdfImportConvertor.js

@@ -1,14 +1,3 @@
-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) {
@@ -45,17 +34,6 @@ 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 __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;
@@ -72,13 +50,42 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-import { AcDbLine, AcDbPolyline, AcGePoint2d, AcGePoint3d, log } from '@mlightcad/data-model';
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { AcApDocManager, AcApI18n, AcEdCorsorType } from '@mlightcad/cad-simple-viewer';
+import { AcCmColor, AcDbLine, AcDbPolyline, AcDbText, AcGePoint2d, AcGePoint3d, log } from '@mlightcad/data-model';
 import * as pdfjsLib from 'pdfjs-dist';
-pdfjsLib.GlobalWorkerOptions.workerSrc = '';
-/** 1 PDF point in mm (1 pt = 1/72 inch = 25.4/72 mm) */
-var PT_TO_MM = 25.4 / 72;
-/** Bezier approximation resolution (line segments per curve) */
-var BEZIER_STEPS = 8;
+import { allocatePdfFallbackLayerName, collectPdfOcgLayers, normalizeCadLayerKey, pdfOperatorListHasOptionalContent } from './pdfOptionalContent';
+import { extractPdfImportSubpaths } from './pdfVectorImport';
+/**
+ * PDF.js worker shipped beside this module.
+ *
+ * Vite rewrites `new URL(..., import.meta.url)` and emits `pdf.worker.mjs`.
+ * App builds that rebundle this package pick that file up from the package
+ * `dist` and emit it into their own assets. PDF.js 5 rejects an empty
+ * `workerSrc`, and a `?url` import would keep the URL from the library build
+ * instead of the app chunk that actually loads it.
+ */
+var PDF_WORKER_URL = new URL('../node_modules/pdfjs-dist/build/pdf.worker.mjs', import.meta.url);
+pdfjsLib.GlobalWorkerOptions.workerSrc = PDF_WORKER_URL.href;
 /**
  * Converts a PDF file into CAD entities appended to the current document's
  * model space.
@@ -89,235 +96,240 @@ var AcApPdfImportConvertor = /** @class */ (function () {
     /**
      * Prompts the user to pick a PDF file and imports vector geometry.
      *
+     * Returns without database edits when the picker 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) {
-        var _this = this;
-        var input = document.createElement('input');
-        input.type = 'file';
-        input.accept = '.pdf';
-        input.style.display = 'none';
-        document.body.appendChild(input);
-        input.addEventListener('change', function () { return __awaiter(_this, void 0, void 0, function () {
+        return __awaiter(this, void 0, void 0, function () {
             var file, buffer;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        file = (_a = input.files) === null || _a === void 0 ? void 0 : _a[0];
-                        document.body.removeChild(input);
+                        _a.trys.push([0, , 4, 5]);
+                        return [4 /*yield*/, this.pickPdfFile()];
+                    case 1:
+                        file = _a.sent();
                         if (!file)
                             return [2 /*return*/];
                         return [4 /*yield*/, file.arrayBuffer()];
-                    case 1:
-                        buffer = _b.sent();
-                        return [4 /*yield*/, this.convert(context, buffer)];
                     case 2:
-                        _b.sent();
-                        return [2 /*return*/];
+                        buffer = _a.sent();
+                        return [4 /*yield*/, this.convert(context, buffer)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        // Chrome drops an SVG data-URI cursor after the native file dialog.
+                        restoreViewCursor(context);
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
                 }
             });
-        }); });
-        input.click();
+        });
     };
     /**
-     * Converts the first page of a PDF ArrayBuffer into CAD entities.
-     * @param context - Application context for the target document
-     * @param data - Raw PDF bytes
-     * @param pageNumber - 1-based page number (default: 1)
+     * Opens the browser file picker.
+     *
+     * 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
+     * inside its write transaction.
      */
+    AcApPdfImportConvertor.prototype.pickPdfFile = function () {
+        return new Promise(function (resolve) {
+            var input = document.createElement('input');
+            input.type = 'file';
+            input.accept = '.pdf,application/pdf';
+            input.style.display = 'none';
+            document.body.appendChild(input);
+            var settled = false;
+            var focusFallbackTimer;
+            var finish = function (file) {
+                if (settled)
+                    return;
+                settled = true;
+                window.removeEventListener('focus', onWindowFocus);
+                if (focusFallbackTimer !== undefined) {
+                    clearTimeout(focusFallbackTimer);
+                }
+                input.remove();
+                resolve(file);
+            };
+            var onWindowFocus = function () {
+                // `change` can arrive just after focus. Wait before treating an empty
+                // selection as a cancel.
+                focusFallbackTimer = window.setTimeout(function () {
+                    var _a;
+                    finish((_a = input.files) === null || _a === void 0 ? void 0 : _a[0]);
+                }, 500);
+            };
+            input.addEventListener('change', function () { var _a; return finish((_a = input.files) === null || _a === void 0 ? void 0 : _a[0]); }, {
+                once: true
+            });
+            input.addEventListener('cancel', function () { return finish(); }, { once: true });
+            input.click();
+            // Attach after click so the focus event from opening the dialog is not
+            // treated as a dismiss.
+            window.setTimeout(function () {
+                if (!settled) {
+                    window.addEventListener('focus', onWindowFocus);
+                }
+            }, 0);
+        });
+    };
     AcApPdfImportConvertor.prototype.convert = function (context_1, data_1) {
         return __awaiter(this, arguments, void 0, function (context, data, pageNumber) {
-            var pdf, page, viewport, pageHeight, operatorList, entities, modelSpace, entities_1, entities_1_1, entity, err_1;
-            var e_1, _a;
+            var _this = this;
             if (pageNumber === void 0) { pageNumber = 1; }
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            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 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcApPdfImportConvertor.prototype.importPage = function (context, data, pageNumber) {
+        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) {
                     case 0:
-                        _b.trys.push([0, 4, , 5]);
+                        _h.trys.push([0, 5, , 6]);
                         return [4 /*yield*/, pdfjsLib.getDocument({ data: data }).promise];
                     case 1:
-                        pdf = _b.sent();
+                        pdf = _h.sent();
                         return [4 /*yield*/, pdf.getPage(pageNumber)];
                     case 2:
-                        page = _b.sent();
+                        page = _h.sent();
                         viewport = page.getViewport({ scale: 1 });
-                        pageHeight = viewport.height;
                         return [4 /*yield*/, page.getOperatorList()];
                     case 3:
-                        operatorList = _b.sent();
-                        entities = this.extractEntities(operatorList, pageHeight);
-                        if (entities.length === 0) {
-                            log.warn('[PdfImport] No vector paths found in PDF page.');
-                            return [2 /*return*/];
-                        }
-                        modelSpace = context.doc.database.tables.blockTable.modelSpace;
+                        operatorList = _h.sent();
+                        return [4 /*yield*/, pdf.getOptionalContentConfig({
+                                intent: 'display'
+                            })];
+                    case 4:
+                        optionalContentConfig = (_h.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();
                         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);
+                            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);
                             }
                         }
                         catch (e_1_1) { e_1 = { error: e_1_1 }; }
                         finally {
                             try {
-                                if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
+                                if (subpaths_1_1 && !subpaths_1_1.done && (_d = subpaths_1.return)) _d.call(subpaths_1);
                             }
                             finally { if (e_1) throw e_1.error; }
                         }
-                        log.info("[PdfImport] Imported ".concat(entities.length, " entities from PDF."));
-                        return [3 /*break*/, 5];
-                    case 4:
-                        err_1 = _b.sent();
-                        log.error('[PdfImport] Failed to import PDF:', err_1);
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    AcApPdfImportConvertor.prototype.extractEntities = function (opList, pageHeight) {
-        var e_2, _a, e_3, _b, e_4, _c;
-        var _this = this;
-        var OPS = pdfjsLib.OPS;
-        var fnArray = opList.fnArray, argsArray = opList.argsArray;
-        var result = [];
-        var subpaths = [];
-        var current = [];
-        var curX = 0;
-        var curY = 0;
-        var flush = function () {
-            if (current.length > 1)
-                subpaths.push(current);
-            current = [];
-        };
-        var commit = function () {
-            var e_5, _a;
-            flush();
-            try {
-                for (var subpaths_1 = __values(subpaths), subpaths_1_1 = subpaths_1.next(); !subpaths_1_1.done; subpaths_1_1 = subpaths_1.next()) {
-                    var sp = subpaths_1_1.value;
-                    var entity = _this.subpathToEntity(sp);
-                    if (entity)
-                        result.push(entity);
-                }
-            }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (subpaths_1_1 && !subpaths_1_1.done && (_a = subpaths_1.return)) _a.call(subpaths_1);
-                }
-                finally { if (e_5) throw e_5.error; }
-            }
-            subpaths = [];
-        };
-        var tx = function (x, _y) { return x * PT_TO_MM; };
-        var ty = function (_x, y) { return (pageHeight - y) * PT_TO_MM; };
-        for (var i = 0; i < fnArray.length; i++) {
-            var fn = fnArray[i];
-            var args = argsArray[i];
-            switch (fn) {
-                case OPS.moveTo: {
-                    flush();
-                    curX = args[0];
-                    curY = args[1];
-                    current = [{ x: tx(curX, curY), y: ty(curX, curY) }];
-                    break;
-                }
-                case OPS.lineTo: {
-                    curX = args[0];
-                    curY = args[1];
-                    current.push({ x: tx(curX, curY), y: ty(curX, curY) });
-                    break;
-                }
-                case OPS.curveTo: {
-                    var _d = __read(args, 6), x1 = _d[0], y1 = _d[1], x2 = _d[2], y2 = _d[3], x3 = _d[4], y3 = _d[5];
-                    var pts = cubicBezier({ x: curX, y: curY }, { x: x1, y: y1 }, { x: x2, y: y2 }, { x: x3, y: y3 }, BEZIER_STEPS);
-                    try {
-                        for (var pts_1 = (e_2 = void 0, __values(pts)), pts_1_1 = pts_1.next(); !pts_1_1.done; pts_1_1 = pts_1.next()) {
-                            var p = pts_1_1.value;
-                            current.push({ x: tx(p.x, p.y), y: ty(p.x, p.y) });
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
                         try {
-                            if (pts_1_1 && !pts_1_1.done && (_a = pts_1.return)) _a.call(pts_1);
+                            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);
+                                }
+                                entity = this.textToEntity(textRun);
+                                if (entity)
+                                    entities.push(entity);
+                            }
                         }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                    curX = x3;
-                    curY = y3;
-                    break;
-                }
-                case OPS.curveTo2: {
-                    var _e = __read(args, 4), x2 = _e[0], y2 = _e[1], x3 = _e[2], y3 = _e[3];
-                    var pts = cubicBezier({ x: curX, y: curY }, { x: curX, y: curY }, { x: x2, y: y2 }, { x: x3, y: y3 }, BEZIER_STEPS);
-                    try {
-                        for (var pts_2 = (e_3 = void 0, __values(pts)), pts_2_1 = pts_2.next(); !pts_2_1.done; pts_2_1 = pts_2.next()) {
-                            var p = pts_2_1.value;
-                            current.push({ x: tx(p.x, p.y), y: ty(p.x, p.y) });
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (texts_1_1 && !texts_1_1.done && (_e = texts_1.return)) _e.call(texts_1);
+                            }
+                            finally { if (e_2) throw e_2.error; }
                         }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
+                        if (entities.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
+                            : [];
+                        existedKeys = new Set(existed.map(normalizeCadLayerKey));
                         try {
-                            if (pts_2_1 && !pts_2_1.done && (_b = pts_2.return)) _b.call(pts_2);
+                            for (_b = __values(ocgLayers.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                layerInfo = _c.value;
+                                if (!usedLayerNames.has(layerInfo.layerName))
+                                    continue;
+                                if (existedKeys.has(normalizeCadLayerKey(layerInfo.layerName)))
+                                    continue;
+                                if (layerInfo.visible)
+                                    continue;
+                                layerService.setLayerOn(layerInfo.layerName, false);
+                            }
                         }
-                        finally { if (e_3) throw e_3.error; }
-                    }
-                    curX = x3;
-                    curY = y3;
-                    break;
-                }
-                case OPS.curveTo3: {
-                    var _f = __read(args, 4), x1 = _f[0], y1 = _f[1], x3 = _f[2], y3 = _f[3];
-                    var pts = cubicBezier({ x: curX, y: curY }, { x: x1, y: y1 }, { x: x3, y: y3 }, { x: x3, y: y3 }, BEZIER_STEPS);
-                    try {
-                        for (var pts_3 = (e_4 = void 0, __values(pts)), pts_3_1 = pts_3.next(); !pts_3_1.done; pts_3_1 = pts_3.next()) {
-                            var p = pts_3_1.value;
-                            current.push({ x: tx(p.x, p.y), y: ty(p.x, p.y) });
+                        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; }
                         }
-                    }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                    finally {
+                        modelSpace = context.doc.database.tables.blockTable.modelSpace;
                         try {
-                            if (pts_3_1 && !pts_3_1.done && (_c = pts_3.return)) _c.call(pts_3);
+                            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);
+                            }
                         }
-                        finally { if (e_4) throw e_4.error; }
-                    }
-                    curX = x3;
-                    curY = y3;
-                    break;
-                }
-                case OPS.closePath: {
-                    if (current.length > 0 && subpaths.length === 0) {
-                        current.push(__assign({}, current[0]));
-                    }
-                    flush();
-                    break;
-                }
-                case OPS.stroke:
-                case OPS.fill:
-                case OPS.eoFill:
-                case OPS.fillStroke:
-                case OPS.eoFillStroke:
-                case OPS.endPath: {
-                    commit();
-                    break;
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (entities_1_1 && !entities_1_1.done && (_g = entities_1.return)) _g.call(entities_1);
+                            }
+                            finally { if (e_4) throw e_4.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();
+                        log.error('[PdfImport] Failed to import PDF:', err_1);
+                        throw err_1;
+                    case 6: return [2 /*return*/];
                 }
-            }
-        }
-        commit();
-        return result;
+            });
+        });
     };
-    AcApPdfImportConvertor.prototype.subpathToEntity = function (pts) {
+    AcApPdfImportConvertor.prototype.subpathToEntity = function (pts, layerName, color) {
         if (pts.length < 2)
             return null;
         if (pts.length === 2) {
-            return new AcDbLine(new AcGePoint3d(pts[0].x, pts[0].y, 0), new AcGePoint3d(pts[1].x, pts[1].y, 0));
+            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));
         }
@@ -330,34 +342,50 @@ var AcApPdfImportConvertor = /** @class */ (function () {
         }
         return poly;
     };
+    AcApPdfImportConvertor.prototype.textToEntity = function (run) {
+        if (!run.text || run.height <= 0)
+            return null;
+        var text = new AcDbText();
+        text.textString = run.text;
+        text.position = new AcGePoint3d(run.position.x, run.position.y, 0);
+        text.height = run.height;
+        text.rotation = run.rotation;
+        if (Number.isFinite(run.widthFactor) && run.widthFactor > 0) {
+            text.widthFactor = run.widthFactor;
+        }
+        if (run.layerName) {
+            text.layer = run.layerName;
+        }
+        applyPdfColor(text, run.color);
+        return text;
+    };
     return AcApPdfImportConvertor;
 }());
 export { AcApPdfImportConvertor };
-/**
- * Approximates a cubic Bézier curve as a polyline.
- *
- * @param p0 - Start point
- * @param p1 - First control point
- * @param p2 - Second control point
- * @param p3 - End point
- * @param steps - Number of line segments to generate
- * @returns Sampled points along the curve (excluding `p0`)
- */
-function cubicBezier(p0, p1, p2, p3, steps) {
-    var pts = [];
-    for (var i = 1; i <= steps; i++) {
-        var t = i / steps;
-        var mt = 1 - t;
-        var x = mt * mt * mt * p0.x +
-            3 * mt * mt * t * p1.x +
-            3 * mt * t * t * p2.x +
-            t * t * t * p3.x;
-        var y = mt * mt * mt * p0.y +
-            3 * mt * mt * t * p1.y +
-            3 * mt * t * t * p2.y +
-            t * t * t * p3.y;
-        pts.push({ x: x, y: y });
-    }
-    return pts;
+function applyPdfColor(entity, color) {
+    if (!color)
+        return;
+    var match = /^#([0-9a-fA-F]{6})$/.exec(color);
+    if (!match)
+        return;
+    var value = Number.parseInt(match[1], 16);
+    entity.color = new AcCmColor().setRGB((value >> 16) & 255, (value >> 8) & 255, value & 255);
+}
+function restoreViewCursor(context) {
+    var _a;
+    var view = context.view;
+    if (!view)
+        return;
+    var cursor = (_a = view.editor.currentCursor) !== null && _a !== void 0 ? _a : AcEdCorsorType.Crosshair;
+    var canvas = view.canvas;
+    var apply = function () {
+        canvas.style.cursor = 'default';
+        view.editor.setCursor(cursor);
+    };
+    apply();
+    window.requestAnimationFrame(apply);
+}
+function databaseLayerNames(context) {
+    return __spreadArray([], __read(context.doc.database.tables.layerTable.newIterator()), false).map(function (layer) { return layer.name; });
 }
 //# sourceMappingURL=AcApPdfImportConvertor.js.map