@mlightcad/cad-pdf-plugin 1.7.3 → 1.7.5

package/lib/pdfVectorImport.js

@@ -0,0 +1,680 @@
+/**
+ * PDF operator-list → CAD polyline conversion, without pdfjs-dist.
+ *
+ * PDF.js numeric op codes are passed in so unit tests can exercise packed
+ * `constructPath` streams, CTM save/restore, and layer assignment without
+ * loading the PDF worker.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { getPdfMarkedContentTarget } from './pdfOptionalContent';
+/** 1 PDF point in mm (1 pt = 1/72 inch = 25.4/72 mm) */
+export var PDF_PT_TO_MM = 25.4 / 72;
+/** Bezier approximation resolution (line segments per curve) */
+var BEZIER_STEPS = 8;
+/**
+ * Converts one page operator list into model-space subpaths.
+ *
+ * Coordinates are mapped through the content-stream CTM and then the PDF.js
+ * viewport. PDF.js bakes a pure translation `q cm ... Q` into `constructPath`
+ * and removes that `transform` op, so this function applies only the
+ * transforms that remain in the operator list.
+ *
+ * @param fallbackLayerName - Layer for geometry outside a single OCG. Omit it
+ * for PDFs with no optional content so entities stay on the current layer.
+ */
+export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallbackLayerName) {
+    var e_1, _a;
+    var _b, _c, _d;
+    var fnArray = opList.fnArray, argsArray = opList.argsArray;
+    var subpathResult = [];
+    var textResult = [];
+    // PDF.js 5.x normally packs path construction into OPS.constructPath.
+    // The packed stream uses DrawOPS values from PDF.js shared/util:
+    // moveTo=0, lineTo=1, curveTo=2, quadraticCurveTo=3, closePath=4.
+    var DRAW_MOVE_TO = 0;
+    var DRAW_LINE_TO = 1;
+    var DRAW_CURVE_TO = 2;
+    var DRAW_QUADRATIC_CURVE_TO = 3;
+    var DRAW_CLOSE_PATH = 4;
+    var subpaths = [];
+    var current = [];
+    var currentPathLayerName = fallbackLayerName;
+    var activeLayerName = fallbackLayerName;
+    var markedContentLayerStack = [];
+    var curX = 0;
+    var curY = 0;
+    var ctm = [1, 0, 0, 1, 0, 0];
+    var fillColor = '#000000';
+    var strokeColor = '#000000';
+    // Text state parameters (Tf/Tc/Tw/Tz/TL/Tr/Ts) are graphics-state fields and
+    // must round-trip with q/Q. Tm/Tlm and the text cursor are not.
+    var fontSize = 0;
+    var textHScale = 1;
+    var textRise = 0;
+    var leading = 0;
+    var charSpacing = 0;
+    var wordSpacing = 0;
+    var textRenderingMode = 0;
+    var graphicsStack = [];
+    var textMatrix = [1, 0, 0, 1, 0, 0];
+    var textLineMatrix = [1, 0, 0, 1, 0, 0];
+    var textX = 0;
+    var textY = 0;
+    var cloneMatrix = function (matrix) { return [
+        matrix[0],
+        matrix[1],
+        matrix[2],
+        matrix[3],
+        matrix[4],
+        matrix[5]
+    ]; };
+    var multiplyMatrix = function (left, right) { return [
+        left[0] * right[0] + left[2] * right[1],
+        left[1] * right[0] + left[3] * right[1],
+        left[0] * right[2] + left[2] * right[3],
+        left[1] * right[2] + left[3] * right[3],
+        left[0] * right[4] + left[2] * right[5] + left[4],
+        left[1] * right[4] + left[3] * right[5] + left[5]
+    ]; };
+    var transformPoint = function (x, y) { return ({
+        x: ctm[0] * x + ctm[2] * y + ctm[4],
+        y: ctm[1] * x + ctm[3] * y + ctm[5]
+    }); };
+    var flush = function () {
+        if (current.length > 1) {
+            subpaths.push({
+                points: current,
+                layerName: currentPathLayerName
+            });
+        }
+        current = [];
+        currentPathLayerName = activeLayerName;
+    };
+    var commit = function (color) {
+        var e_2, _a;
+        if (color === void 0) { color = strokeColor; }
+        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 subpath = subpaths_1_1.value;
+                subpathResult.push(__assign(__assign({}, subpath), { color: color }));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (subpaths_1_1 && !subpaths_1_1.done && (_a = subpaths_1.return)) _a.call(subpaths_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        subpaths = [];
+    };
+    var paintColor = function (paintOp) {
+        return paintOp === ops.fill || paintOp === ops.eoFill ? fillColor : strokeColor;
+    };
+    var discard = function () {
+        current = [];
+        subpaths = [];
+        currentPathLayerName = activeLayerName;
+    };
+    var pagePointToCadPoint = function (x, y) {
+        var transformed = transformPoint(x, y);
+        var _a = __read(viewport.convertToViewportPoint(transformed.x, transformed.y), 2), viewportX = _a[0], viewportY = _a[1];
+        return {
+            x: viewportX * PDF_PT_TO_MM,
+            y: (viewport.height - viewportY) * PDF_PT_TO_MM
+        };
+    };
+    var tx = function (x, y) { return pagePointToCadPoint(x, y).x; };
+    var ty = function (x, y) { return pagePointToCadPoint(x, y).y; };
+    var moveTo = function (x, y) {
+        flush();
+        curX = x;
+        curY = y;
+        currentPathLayerName = activeLayerName;
+        current = [{ x: tx(x, y), y: ty(x, y) }];
+    };
+    var lineTo = function (x, y) {
+        curX = x;
+        curY = y;
+        current.push({ x: tx(x, y), y: ty(x, y) });
+    };
+    var curveTo = function (x1, y1, x2, y2, x3, y3) {
+        var e_3, _a;
+        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 = __values(pts), pts_1_1 = pts_1.next(); !pts_1_1.done; pts_1_1 = pts_1.next()) {
+                var point = pts_1_1.value;
+                current.push({ x: tx(point.x, point.y), y: ty(point.x, point.y) });
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (pts_1_1 && !pts_1_1.done && (_a = pts_1.return)) _a.call(pts_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        curX = x3;
+        curY = y3;
+    };
+    var quadraticCurveTo = function (x1, y1, x2, y2) {
+        for (var step = 1; step <= BEZIER_STEPS; step++) {
+            var t = step / BEZIER_STEPS;
+            var mt = 1 - t;
+            var x = mt * mt * curX + 2 * mt * t * x1 + t * t * x2;
+            var y = mt * mt * curY + 2 * mt * t * y1 + t * t * y2;
+            current.push({ x: tx(x, y), y: ty(x, y) });
+        }
+        curX = x2;
+        curY = y2;
+    };
+    var closePath = function () {
+        if (current.length > 0) {
+            current.push(__assign({}, current[0]));
+        }
+        flush();
+    };
+    var rectangle = function (x, y, width, height) {
+        moveTo(x, y);
+        lineTo(x + width, y);
+        lineTo(x + width, y + height);
+        lineTo(x, y + height);
+        closePath();
+    };
+    var isArrayLikePathData = function (value) {
+        return Array.isArray(value) || ArrayBuffer.isView(value);
+    };
+    var processPackedPathStream = function (stream) {
+        if (stream.length === 0 || stream[0] == null)
+            return;
+        var index = 0;
+        var take = function () { return Number(stream[index++]); };
+        while (index < stream.length) {
+            var pathOp = Number(stream[index++]);
+            switch (pathOp) {
+                case DRAW_MOVE_TO:
+                    moveTo(take(), take());
+                    break;
+                case DRAW_LINE_TO:
+                    lineTo(take(), take());
+                    break;
+                case DRAW_CURVE_TO:
+                    curveTo(take(), take(), take(), take(), take(), take());
+                    break;
+                case DRAW_QUADRATIC_CURVE_TO:
+                    quadraticCurveTo(take(), take(), take(), take());
+                    break;
+                case DRAW_CLOSE_PATH:
+                    closePath();
+                    break;
+                default:
+                    // Avoid consuming coordinates with an unknown DrawOPS value.
+                    return;
+            }
+        }
+    };
+    // Compatibility with older operator-list shapes where path operation codes
+    // and coordinates were delivered as separate arrays.
+    var processSplitPathStream = function (pathOps, pathArgs) {
+        var argIndex = 0;
+        var take = function () { return Number(pathArgs[argIndex++]); };
+        for (var i = 0; i < pathOps.length; i++) {
+            var pathOp = Number(pathOps[i]);
+            switch (pathOp) {
+                case DRAW_MOVE_TO:
+                case ops.moveTo:
+                    moveTo(take(), take());
+                    break;
+                case DRAW_LINE_TO:
+                case ops.lineTo:
+                    lineTo(take(), take());
+                    break;
+                case DRAW_CURVE_TO:
+                case ops.curveTo:
+                    curveTo(take(), take(), take(), take(), take(), take());
+                    break;
+                case DRAW_QUADRATIC_CURVE_TO:
+                    quadraticCurveTo(take(), take(), take(), take());
+                    break;
+                case ops.curveTo2:
+                    curveTo(curX, curY, take(), take(), take(), take());
+                    break;
+                case ops.curveTo3: {
+                    var x1 = take();
+                    var y1 = take();
+                    var x3 = take();
+                    var y3 = take();
+                    curveTo(x1, y1, x3, y3, x3, y3);
+                    break;
+                }
+                case ops.rectangle:
+                    rectangle(take(), take(), take(), take());
+                    break;
+                case DRAW_CLOSE_PATH:
+                case ops.closePath:
+                    closePath();
+                    break;
+            }
+        }
+    };
+    var finishConstructPath = function (paintOp) {
+        switch (paintOp) {
+            case ops.stroke:
+            case ops.closeStroke:
+            case ops.fill:
+            case ops.eoFill:
+            case ops.fillStroke:
+            case ops.eoFillStroke:
+            case ops.closeFillStroke:
+            case ops.closeEOFillStroke:
+                commit(paintColor(paintOp));
+                break;
+            case ops.endPath:
+                // PDF "n" ends the current path without painting it, commonly after
+                // clipping. Do not create CAD entities from those paths.
+                discard();
+                break;
+        }
+    };
+    for (var i = 0; i < fnArray.length; i++) {
+        var fn = fnArray[i];
+        var value = argsArray[i];
+        var rawArgs = Array.isArray(value) ? value : [];
+        if (fn === ops.save) {
+            graphicsStack.push({
+                ctm: cloneMatrix(ctm),
+                fillColor: fillColor,
+                strokeColor: strokeColor,
+                fontSize: fontSize,
+                textHScale: textHScale,
+                textRise: textRise,
+                leading: leading,
+                charSpacing: charSpacing,
+                wordSpacing: wordSpacing,
+                textRenderingMode: textRenderingMode
+            });
+            continue;
+        }
+        if (fn === ops.restore) {
+            var restored = graphicsStack.pop();
+            if (restored) {
+                ctm = restored.ctm;
+                fillColor = restored.fillColor;
+                strokeColor = restored.strokeColor;
+                fontSize = restored.fontSize;
+                textHScale = restored.textHScale;
+                textRise = restored.textRise;
+                leading = restored.leading;
+                charSpacing = restored.charSpacing;
+                wordSpacing = restored.wordSpacing;
+                textRenderingMode = restored.textRenderingMode;
+            }
+            continue;
+        }
+        if (fn === ops.setFillRGBColor) {
+            var color = readCssColor(rawArgs[0]);
+            if (color)
+                fillColor = color;
+            continue;
+        }
+        if (fn === ops.setStrokeRGBColor) {
+            var color = readCssColor(rawArgs[0]);
+            if (color)
+                strokeColor = color;
+            continue;
+        }
+        if (fn === ops.beginText) {
+            textMatrix = [1, 0, 0, 1, 0, 0];
+            textLineMatrix = [1, 0, 0, 1, 0, 0];
+            textX = 0;
+            textY = 0;
+            continue;
+        }
+        if (fn === ops.endText) {
+            continue;
+        }
+        if (fn === ops.setFont) {
+            var size = Number(rawArgs[1]);
+            if (Number.isFinite(size))
+                fontSize = size;
+            continue;
+        }
+        if (fn === ops.setTextMatrix) {
+            var matrix = readMatrix(rawArgs);
+            if (matrix) {
+                textMatrix = matrix;
+                textLineMatrix = cloneMatrix(matrix);
+                textX = 0;
+                textY = 0;
+            }
+            continue;
+        }
+        if (fn === ops.moveText) {
+            moveTextLine(Number(rawArgs[0]), Number(rawArgs[1]));
+            continue;
+        }
+        if (fn === ops.setLeadingMoveText) {
+            var ty_1 = Number(rawArgs[1]);
+            leading = -ty_1;
+            moveTextLine(Number(rawArgs[0]), ty_1);
+            continue;
+        }
+        if (fn === ops.nextLine) {
+            moveTextLine(0, -leading);
+            continue;
+        }
+        if (fn === ops.setLeading) {
+            var value_1 = Number(rawArgs[0]);
+            if (Number.isFinite(value_1))
+                leading = value_1;
+            continue;
+        }
+        if (fn === ops.setCharSpacing) {
+            var value_2 = Number(rawArgs[0]);
+            if (Number.isFinite(value_2))
+                charSpacing = value_2;
+            continue;
+        }
+        if (fn === ops.setWordSpacing) {
+            var value_3 = Number(rawArgs[0]);
+            if (Number.isFinite(value_3))
+                wordSpacing = value_3;
+            continue;
+        }
+        if (fn === ops.setHScale) {
+            var value_4 = Number(rawArgs[0]);
+            if (Number.isFinite(value_4))
+                textHScale = value_4 / 100;
+            continue;
+        }
+        if (fn === ops.setTextRise) {
+            var value_5 = Number(rawArgs[0]);
+            if (Number.isFinite(value_5))
+                textRise = value_5;
+            continue;
+        }
+        if (fn === ops.setTextRenderingMode) {
+            var value_6 = Number(rawArgs[0]);
+            if (Number.isFinite(value_6))
+                textRenderingMode = value_6;
+            continue;
+        }
+        if (fn === ops.showText) {
+            showGlyphs(rawArgs[0]);
+            continue;
+        }
+        if (fn === ops.transform) {
+            if (rawArgs.length >= 6) {
+                var next = [
+                    Number(rawArgs[0]),
+                    Number(rawArgs[1]),
+                    Number(rawArgs[2]),
+                    Number(rawArgs[3]),
+                    Number(rawArgs[4]),
+                    Number(rawArgs[5])
+                ];
+                ctm = multiplyMatrix(ctm, next);
+            }
+            continue;
+        }
+        if (fn === ops.beginMarkedContent) {
+            markedContentLayerStack.push(activeLayerName);
+            continue;
+        }
+        if (fn === ops.beginMarkedContentProps) {
+            markedContentLayerStack.push(activeLayerName);
+            var target = getPdfMarkedContentTarget(rawArgs);
+            if (target.kind === 'ocg') {
+                activeLayerName = (_c = (_b = ocgLayers.get(target.id)) === null || _b === void 0 ? void 0 : _b.layerName) !== null && _c !== void 0 ? _c : fallbackLayerName;
+            }
+            else if (target.kind === 'fallback') {
+                activeLayerName = fallbackLayerName;
+            }
+            continue;
+        }
+        if (fn === ops.endMarkedContent) {
+            activeLayerName = (_d = markedContentLayerStack.pop()) !== null && _d !== void 0 ? _d : fallbackLayerName;
+            continue;
+        }
+        switch (fn) {
+            case ops.constructPath: {
+                var first = rawArgs[0];
+                var second = rawArgs[1];
+                if (isArrayLikePathData(first) && isArrayLikePathData(second)) {
+                    processSplitPathStream(first, second);
+                    break;
+                }
+                var paintOp = Number(first);
+                // PDF.js 5.x shape:
+                // [paintOp, [Float32Array(DrawOPS + coordinates)], minMax]
+                if (Array.isArray(second)) {
+                    try {
+                        for (var second_1 = (e_1 = void 0, __values(second)), second_1_1 = second_1.next(); !second_1_1.done; second_1_1 = second_1.next()) {
+                            var stream = second_1_1.value;
+                            if (!isArrayLikePathData(stream))
+                                continue;
+                            processPackedPathStream(stream);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (second_1_1 && !second_1_1.done && (_a = second_1.return)) _a.call(second_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                else if (isArrayLikePathData(second)) {
+                    processPackedPathStream(second);
+                }
+                finishConstructPath(paintOp);
+                break;
+            }
+            case ops.moveTo: {
+                var args = rawArgs;
+                moveTo(args[0], args[1]);
+                break;
+            }
+            case ops.lineTo: {
+                var args = rawArgs;
+                lineTo(args[0], args[1]);
+                break;
+            }
+            case ops.curveTo: {
+                var args = rawArgs;
+                curveTo(args[0], args[1], args[2], args[3], args[4], args[5]);
+                break;
+            }
+            case ops.curveTo2: {
+                var args = rawArgs;
+                curveTo(curX, curY, args[0], args[1], args[2], args[3]);
+                break;
+            }
+            case ops.curveTo3: {
+                var args = rawArgs;
+                curveTo(args[0], args[1], args[2], args[3], args[2], args[3]);
+                break;
+            }
+            case ops.rectangle: {
+                var args = rawArgs;
+                rectangle(args[0], args[1], args[2], args[3]);
+                break;
+            }
+            case ops.closePath:
+                closePath();
+                break;
+            case ops.closeStroke:
+            case ops.closeFillStroke:
+            case ops.closeEOFillStroke:
+                closePath();
+                commit(paintColor(fn));
+                break;
+            case ops.stroke:
+            case ops.fill:
+            case ops.eoFill:
+            case ops.fillStroke:
+            case ops.eoFillStroke:
+                commit(paintColor(fn));
+                break;
+            case ops.endPath:
+                discard();
+                break;
+        }
+    }
+    commit();
+    return { subpaths: subpathResult, texts: textResult };
+    // Hoisted so the operator loop above can call them.
+    function moveTextLine(tx, ty) {
+        var shift = [1, 0, 0, 1, tx, ty];
+        textLineMatrix = multiplyMatrix(shift, textLineMatrix);
+        textMatrix = cloneMatrix(textLineMatrix);
+        textX = 0;
+        textY = 0;
+    }
+    function showGlyphs(glyphs) {
+        var list = asNumberList(glyphs);
+        if (!list)
+            return;
+        var text = '';
+        var advance = 0;
+        var widthAdvanceScale = fontSize * 0.001;
+        for (var index = 0; index < list.length; index++) {
+            var glyph = list[index];
+            if (typeof glyph === 'number') {
+                // TJ spacing is in thousandths of a unit; a positive value moves left.
+                advance += (-glyph * fontSize) / 1000;
+                continue;
+            }
+            if (!glyph || typeof glyph !== 'object')
+                continue;
+            var record = glyph;
+            var unicode = typeof record.unicode === 'string' ? record.unicode : '';
+            var fontChar = typeof record.fontChar === 'string' ? record.fontChar : '';
+            text += unicode || fontChar;
+            var width = typeof record.width === 'number' ? record.width : 0;
+            var spacing = (record.isSpace ? wordSpacing : 0) + charSpacing;
+            advance += width * widthAdvanceScale + spacing;
+        }
+        text = text.split('\u0000').join('');
+        var paints = (textRenderingMode & 3) !== 3;
+        if (paints && fontSize !== 0 && text.length > 0) {
+            var origin_1 = textPointToCad(textX, textY + textRise);
+            var alongX = textPointToCad(textX + textHScale, textY + textRise);
+            var alongY = textPointToCad(textX, textY + textRise + fontSize);
+            var dx = alongX.x - origin_1.x;
+            var dy = alongX.y - origin_1.y;
+            var height = Math.hypot(alongY.x - origin_1.x, alongY.y - origin_1.y);
+            var unitY = fontSize > 0 ? height / fontSize : 0;
+            var widthFactor = unitY > 1e-9 ? Math.hypot(dx, dy) / unitY : textHScale;
+            if (height > 1e-9) {
+                textResult.push({
+                    text: text,
+                    position: origin_1,
+                    height: height,
+                    rotation: Math.atan2(dy, dx),
+                    widthFactor: widthFactor,
+                    layerName: activeLayerName,
+                    color: (textRenderingMode & 3) === 1 ? strokeColor : fillColor
+                });
+            }
+        }
+        textX += advance * textHScale;
+    }
+    function textPointToCad(x, y) {
+        var userX = textMatrix[0] * x + textMatrix[2] * y + textMatrix[4];
+        var userY = textMatrix[1] * x + textMatrix[3] * y + textMatrix[5];
+        return pagePointToCadPoint(userX, userY);
+    }
+}
+/**
+ * Approximates a cubic Bezier 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 readCssColor(value) {
+    if (typeof value === 'string' && /^#[0-9a-fA-F]{6}$/.test(value)) {
+        return value.toLowerCase();
+    }
+    return undefined;
+}
+function readMatrix(rawArgs) {
+    var nested = rawArgs.length === 1 ? asNumberList(rawArgs[0]) : undefined;
+    var source = nested && nested.length >= 6 ? nested : rawArgs;
+    if (source.length < 6)
+        return undefined;
+    return [
+        Number(source[0]),
+        Number(source[1]),
+        Number(source[2]),
+        Number(source[3]),
+        Number(source[4]),
+        Number(source[5])
+    ];
+}
+function asNumberList(value) {
+    if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+        return value;
+    }
+    return undefined;
+}
+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;
+}
+//# sourceMappingURL=pdfVectorImport.js.map