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

package/lib/pdfVectorImport.js

@@ -43,11 +43,140 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { 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;
+/**
+ * Sentinel colour: CAD ACI 7 (AutoCAD “foreground” / auto-contrast).
+ *
+ * Renders white on a dark CAD canvas and black on a light one.
+ */
+export var PDF_IMPORT_FOREGROUND_COLOR = 'foreground';
+/**
+ * Channel ceiling for near-black ink. All RGB components must be below this
+ * so CAD primaries (`#0000ff`, …) are not treated as paper black. High
+ * enough for the "rich black" design tools emit after CMYK conversion
+ * (e.g. `#2c2e35`), which is unreadable on a dark CAD canvas.
+ */
+var PDF_PAPER_BLACK_CHANNEL = 64;
+/**
+ * Channel floor for near-white ink (dark-paper drawings).
+ */
+var PDF_PAPER_WHITE_CHANNEL = 208;
+function parseCssRgb(color) {
+    if (!color || !/^#[0-9a-fA-F]{6}$/.test(color))
+        return undefined;
+    var value = Number.parseInt(color.slice(1), 16);
+    return {
+        r: (value >> 16) & 255,
+        g: (value >> 8) & 255,
+        b: value & 255
+    };
+}
+/** True when every channel is near black (paper ink on white PDF). */
+export function isPdfNearBlackColor(color) {
+    var rgb = parseCssRgb(color);
+    if (!rgb)
+        return false;
+    return (rgb.r < PDF_PAPER_BLACK_CHANNEL &&
+        rgb.g < PDF_PAPER_BLACK_CHANNEL &&
+        rgb.b < PDF_PAPER_BLACK_CHANNEL);
+}
+/** True when every channel is near white (paper ink on dark PDF). */
+export function isPdfNearWhiteColor(color) {
+    var rgb = parseCssRgb(color);
+    if (!rgb)
+        return false;
+    return (rgb.r > PDF_PAPER_WHITE_CHANNEL &&
+        rgb.g > PDF_PAPER_WHITE_CHANNEL &&
+        rgb.b > PDF_PAPER_WHITE_CHANNEL);
+}
+/**
+ * Infers PDF paper tone from painted colours.
+ *
+ * Dark paper is rare; bias toward light so white fills on a normal CAD PDF
+ * do not leave near-black linework unmapped (and invisible on a dark canvas).
+ * Only classify as dark when near-white ink dominates and near-black is absent.
+ */
+export function detectPdfImportPaperTone(colors) {
+    var e_1, _a;
+    var nearBlack = 0;
+    var nearWhite = 0;
+    try {
+        for (var colors_1 = __values(colors), colors_1_1 = colors_1.next(); !colors_1_1.done; colors_1_1 = colors_1.next()) {
+            var color = colors_1_1.value;
+            if (isPdfNearBlackColor(color))
+                nearBlack++;
+            else if (isPdfNearWhiteColor(color))
+                nearWhite++;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (colors_1_1 && !colors_1_1.done && (_a = colors_1.return)) _a.call(colors_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (nearBlack === 0 && nearWhite >= 8)
+        return 'dark';
+    return 'light';
+}
+/**
+ * Maps PDF contrast ink to ACI 7 (`foreground`) based on paper tone.
+ *
+ * - Light paper + near-black → {@link PDF_IMPORT_FOREGROUND_COLOR}
+ * - Dark paper + near-white → {@link PDF_IMPORT_FOREGROUND_COLOR}
+ * - Other colours kept as lowercase `#rrggbb`
+ */
+export function remapPdfImportColor(color, paperTone) {
+    if (paperTone === void 0) { paperTone = 'light'; }
+    if (!color)
+        return color;
+    if (color === PDF_IMPORT_FOREGROUND_COLOR)
+        return color;
+    if (!parseCssRgb(color))
+        return color;
+    if (paperTone === 'light' && isPdfNearBlackColor(color)) {
+        return PDF_IMPORT_FOREGROUND_COLOR;
+    }
+    if (paperTone === 'dark' && isPdfNearWhiteColor(color)) {
+        return PDF_IMPORT_FOREGROUND_COLOR;
+    }
+    return color.toLowerCase();
+}
+/**
+ * Applies contrast-ink remapping to an extracted page.
+ *
+ * When `paperTone` is `'auto'`, tone is detected from the raw colours first.
+ */
+export function applyPdfImportContrastColors(content, options) {
+    var _a;
+    var enabled = (options === null || options === void 0 ? void 0 : options.remapContrastInk) !== false && (options === null || options === void 0 ? void 0 : options.remapDarkColors) !== false;
+    if (!enabled)
+        return content;
+    var requested = (_a = options === null || options === void 0 ? void 0 : options.paperTone) !== null && _a !== void 0 ? _a : 'auto';
+    var tone = requested === 'auto'
+        ? detectPdfImportPaperTone(__spreadArray(__spreadArray([], __read(content.subpaths.map(function (s) { return s.color; })), false), __read(content.texts.map(function (t) { return t.color; })), false))
+        : requested;
+    return {
+        subpaths: content.subpaths.map(function (subpath) { return (__assign(__assign(__assign({}, subpath), { color: remapPdfImportColor(subpath.color, tone) }), (subpath.fillColor
+            ? { fillColor: remapPdfImportColor(subpath.fillColor, tone) }
+            : {}))); }),
+        texts: content.texts.map(function (text) { return (__assign(__assign({}, text), { color: remapPdfImportColor(text.color, tone) })); })
+    };
+}
 /**
  * Converts one page operator list into model-space subpaths.
  *
@@ -59,12 +188,15 @@ var BEZIER_STEPS = 8;
  * @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;
+export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallbackLayerName, options) {
+    var e_2, _a;
+    var _b, _c;
     var fnArray = opList.fnArray, argsArray = opList.argsArray;
     var subpathResult = [];
+    var formInstances = [];
+    var currentFormInstance;
     var textResult = [];
+    var imageResult = [];
     // 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.
@@ -75,24 +207,76 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
     var DRAW_CLOSE_PATH = 4;
     var subpaths = [];
     var current = [];
+    var currentSegments = [];
     var currentPathLayerName = fallbackLayerName;
     var activeLayerName = fallbackLayerName;
+    // True while inside an OCG that starts hidden. Viewers draw nested optional
+    // content only when every enclosing group is ON, so an inner ON group (e.g.
+    // a frozen INSERT's children on their own layers) must not pull geometry
+    // out of the hidden outer layer.
+    var activeLayerHidden = false;
     var markedContentLayerStack = [];
     var curX = 0;
     var curY = 0;
+    // Start of the current subpath in user space: `h` returns the current
+    // point there, so a following `l` without `m` starts from it.
+    var startX = 0;
+    var startY = 0;
     var ctm = [1, 0, 0, 1, 0, 0];
     var fillColor = '#000000';
     var strokeColor = '#000000';
+    var lineWidth = 1;
+    var dashArray = [];
+    // Innermost clip in effect (graphics state) and whether `W` is pending.
+    var clipId;
+    var pendingClip = false;
+    var clipPaths = [];
     // 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 fontId;
     var textHScale = 1;
     var textRise = 0;
     var leading = 0;
     var charSpacing = 0;
     var wordSpacing = 0;
     var textRenderingMode = 0;
+    var snapshotGraphicsState = function () { return ({
+        ctm: cloneMatrix(ctm),
+        fillColor: fillColor,
+        strokeColor: strokeColor,
+        lineWidth: lineWidth,
+        dashArray: dashArray,
+        clipId: clipId,
+        fontSize: fontSize,
+        fontId: fontId,
+        textHScale: textHScale,
+        textRise: textRise,
+        leading: leading,
+        charSpacing: charSpacing,
+        wordSpacing: wordSpacing,
+        textRenderingMode: textRenderingMode
+    }); };
+    var restoreGraphicsState = function (restored) {
+        ctm = restored.ctm;
+        fillColor = restored.fillColor;
+        strokeColor = restored.strokeColor;
+        lineWidth = restored.lineWidth;
+        dashArray = restored.dashArray;
+        clipId = restored.clipId;
+        fontSize = restored.fontSize;
+        fontId = restored.fontId;
+        textHScale = restored.textHScale;
+        textRise = restored.textRise;
+        leading = restored.leading;
+        charSpacing = restored.charSpacing;
+        wordSpacing = restored.wordSpacing;
+        textRenderingMode = restored.textRenderingMode;
+    };
+    // q/Q stack — separate from Form XObject Begin/End so unbalanced save/restore
+    // inside a form cannot pop the form entry (or vice versa).
     var graphicsStack = [];
+    var formStack = [];
     var textMatrix = [1, 0, 0, 1, 0, 0];
     var textLineMatrix = [1, 0, 0, 1, 0, 0];
     var textX = 0;
@@ -119,38 +303,163 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
     }); };
     var flush = function () {
         if (current.length > 1) {
-            subpaths.push({
+            var subpath = {
                 points: current,
+                segments: currentSegments,
                 layerName: currentPathLayerName
-            });
+            };
+            if (currentFormInstance !== undefined) {
+                subpath.formInstance = currentFormInstance;
+            }
+            if (clipId !== undefined)
+                subpath.clipPath = clipId;
+            subpaths.push(subpath);
         }
         current = [];
+        currentSegments = [];
         currentPathLayerName = activeLayerName;
     };
-    var commit = function (color) {
-        var e_2, _a;
-        if (color === void 0) { color = strokeColor; }
-        flush();
+    var samePoint = function (a, b) {
+        return a.x === b.x && a.y === b.y;
+    };
+    var closeOpenSubpaths = function () {
+        var e_3, _a;
+        var _b;
+        // PDF fill/eoFill implicitly close each open subpath; pdf.js does not
+        // always emit DrawOPS.closePath for plain fill paints.
+        if (current.length > 0) {
+            var first = current[0];
+            var last = current[current.length - 1];
+            if (!samePoint(first, last)) {
+                current.push(__assign({}, first));
+                currentSegments.push({ kind: 'line', p0: last, p1: __assign({}, first) });
+            }
+            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 }));
+                var pts = subpath.points;
+                if (pts.length < 2)
+                    continue;
+                var first = pts[0];
+                var last = pts[pts.length - 1];
+                if (!samePoint(first, last)) {
+                    pts.push(__assign({}, first));
+                    (_b = subpath.segments) === null || _b === void 0 ? void 0 : _b.push({ kind: 'line', p0: last, p1: __assign({}, first) });
+                }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_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; }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    var paintCount = 0;
+    var commit = function (color, filled, stroked) {
+        var e_4, _a;
+        if (color === void 0) { color = strokeColor; }
+        if (filled === void 0) { filled = false; }
+        if (stroked === void 0) { stroked = !filled; }
+        flush();
+        var width = stroked ? strokeWidthMm() : 0;
+        var dashes = stroked ? dashPatternMm() : undefined;
+        var group = paintCount++;
+        try {
+            for (var subpaths_2 = __values(subpaths), subpaths_2_1 = subpaths_2.next(); !subpaths_2_1.done; subpaths_2_1 = subpaths_2.next()) {
+                var subpath = subpaths_2_1.value;
+                var result = __assign(__assign({}, subpath), { color: color });
+                if (filled) {
+                    result.filled = true;
+                    result.fillColor = fillColor;
+                    result.paintGroup = group;
+                    if (stroked)
+                        result.stroked = true;
+                }
+                if (width > 0)
+                    result.lineWidth = width;
+                if (dashes)
+                    result.dashPattern = dashes;
+                subpathResult.push(result);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (subpaths_2_1 && !subpaths_2_1.done && (_a = subpaths_2.return)) _a.call(subpaths_2);
+            }
+            finally { if (e_4) throw e_4.error; }
         }
         subpaths = [];
     };
+    // Dash lengths are in user space like the line width. PDF repeats an odd
+    // array to even length ([3] means 3 on, 3 off). All-zero arrays are solid.
+    var dashPatternMm = function () {
+        if (dashArray.length === 0 || dashArray.every(function (v) { return !(v > 0); })) {
+            return undefined;
+        }
+        var scale = Math.sqrt(Math.abs(ctm[0] * ctm[3] - ctm[1] * ctm[2])) * PDF_PT_TO_MM;
+        var even = dashArray.length % 2 === 0 ? dashArray : __spreadArray(__spreadArray([], __read(dashArray), false), __read(dashArray), false);
+        return even.map(function (v) { return Math.max(0, v) * scale; });
+    };
+    // PDF line width is in user space; the CTM scales it to page points. Use
+    // the geometric mean of the axis scales, which is exact for similarity
+    // transforms and a reasonable average for skewed ones.
+    var strokeWidthMm = function () {
+        if (!(lineWidth > 0))
+            return 0;
+        var scale = Math.sqrt(Math.abs(ctm[0] * ctm[3] - ctm[1] * ctm[2]));
+        return lineWidth * scale * PDF_PT_TO_MM;
+    };
+    var isStrokePaint = function (paintOp) {
+        return paintOp === ops.stroke ||
+            paintOp === ops.closeStroke ||
+            paintOp === ops.fillStroke ||
+            paintOp === ops.eoFillStroke ||
+            paintOp === ops.closeFillStroke ||
+            paintOp === ops.closeEOFillStroke;
+    };
+    var isFillPaint = function (paintOp) {
+        return paintOp === ops.fill ||
+            paintOp === ops.eoFill ||
+            paintOp === ops.fillStroke ||
+            paintOp === ops.eoFillStroke ||
+            paintOp === ops.closeFillStroke ||
+            paintOp === ops.closeEOFillStroke ||
+            (ops.rawFillPath !== undefined && paintOp === ops.rawFillPath);
+    };
     var paintColor = function (paintOp) {
-        return paintOp === ops.fill || paintOp === ops.eoFill ? fillColor : strokeColor;
+        if (paintOp === ops.fill ||
+            paintOp === ops.eoFill ||
+            (ops.rawFillPath !== undefined && paintOp === ops.rawFillPath)) {
+            return fillColor;
+        }
+        return strokeColor;
+    };
+    // `W` / `W*` make the path of the next paint operator the clip.
+    var captureClip = function () {
+        if (!pendingClip)
+            return;
+        pendingClip = false;
+        flush();
+        var loops = subpaths
+            .map(function (subpath) {
+            var pts = subpath.points;
+            var closed = pts.length > 1 && samePoint(pts[0], pts[pts.length - 1]);
+            return closed ? pts.slice(0, -1) : __spreadArray([], __read(pts), false);
+        })
+            .filter(function (loop) { return loop.length >= 3; });
+        if (loops.length === 0)
+            return;
+        clipPaths.push(loops);
+        clipId = clipPaths.length - 1;
     };
     var discard = function () {
         current = [];
+        currentSegments = [];
         subpaths = [];
         currentPathLayerName = activeLayerName;
     };
@@ -164,20 +473,35 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
     };
     var tx = function (x, y) { return pagePointToCadPoint(x, y).x; };
     var ty = function (x, y) { return pagePointToCadPoint(x, y).y; };
+    var lastCadPoint = function () {
+        return current.length > 0
+            ? current[current.length - 1]
+            : pagePointToCadPoint(curX, curY);
+    };
     var moveTo = function (x, y) {
         flush();
         curX = x;
         curY = y;
+        startX = x;
+        startY = y;
         currentPathLayerName = activeLayerName;
         current = [{ x: tx(x, y), y: ty(x, y) }];
     };
     var lineTo = function (x, y) {
+        var p0 = lastCadPoint();
+        if (current.length === 0)
+            current.push(p0);
         curX = x;
         curY = y;
-        current.push({ x: tx(x, y), y: ty(x, y) });
+        var p1 = pagePointToCadPoint(x, y);
+        current.push(p1);
+        currentSegments.push({ kind: 'line', p0: p0, p1: p1 });
     };
     var curveTo = function (x1, y1, x2, y2, x3, y3) {
-        var e_3, _a;
+        var e_5, _a;
+        var p0 = lastCadPoint();
+        if (current.length === 0)
+            current.push(p0);
         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()) {
@@ -185,17 +509,33 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
                 current.push({ x: tx(point.x, point.y), y: ty(point.x, point.y) });
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_5_1) { e_5 = { error: e_5_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; }
+            finally { if (e_5) throw e_5.error; }
         }
+        // Reuse the last sampled point as p3 so segments and points share the
+        // exact same end coordinate.
+        currentSegments.push({
+            kind: 'cubic',
+            p0: p0,
+            p1: pagePointToCadPoint(x1, y1),
+            p2: pagePointToCadPoint(x2, y2),
+            p3: current[current.length - 1]
+        });
         curX = x3;
         curY = y3;
     };
     var quadraticCurveTo = function (x1, y1, x2, y2) {
+        var p0 = lastCadPoint();
+        if (current.length === 0)
+            current.push(p0);
+        // Degree elevation: a quadratic is the cubic with controls 2/3 of the way
+        // from each end point toward the single quadratic control.
+        var c1 = pagePointToCadPoint(curX + (2 / 3) * (x1 - curX), curY + (2 / 3) * (y1 - curY));
+        var c2 = pagePointToCadPoint(x2 + (2 / 3) * (x1 - x2), y2 + (2 / 3) * (y1 - y2));
         for (var step = 1; step <= BEZIER_STEPS; step++) {
             var t = step / BEZIER_STEPS;
             var mt = 1 - t;
@@ -203,13 +543,27 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
             var y = mt * mt * curY + 2 * mt * t * y1 + t * t * y2;
             current.push({ x: tx(x, y), y: ty(x, y) });
         }
+        currentSegments.push({
+            kind: 'cubic',
+            p0: p0,
+            p1: c1,
+            p2: c2,
+            p3: current[current.length - 1]
+        });
         curX = x2;
         curY = y2;
     };
     var closePath = function () {
         if (current.length > 0) {
-            current.push(__assign({}, current[0]));
+            var first = current[0];
+            var last = current[current.length - 1];
+            current.push(__assign({}, first));
+            if (!samePoint(first, last)) {
+                currentSegments.push({ kind: 'line', p0: last, p1: __assign({}, first) });
+            }
         }
+        curX = startX;
+        curY = startY;
         flush();
     };
     var rectangle = function (x, y, width, height) {
@@ -246,7 +600,8 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
                     closePath();
                     break;
                 default:
-                    // Avoid consuming coordinates with an unknown DrawOPS value.
+                    // Unknown DrawOPS — stop this stream so we do not desync
+                    // coordinates, but keep geometry already collected for paint.
                     return;
             }
         }
@@ -278,6 +633,7 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
                     curveTo(curX, curY, take(), take(), take(), take());
                     break;
                 case ops.curveTo3: {
+                    // PDF "y": second control coincides with the end point (x3, y3).
                     var x1 = take();
                     var y1 = take();
                     var x3 = take();
@@ -296,22 +652,36 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
         }
     };
     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;
+        captureClip();
+        if (paintOp === ops.endPath) {
+            // PDF "n" ends the current path without painting it, commonly after
+            // clipping. Do not create CAD entities from those paths.
+            discard();
+            return;
+        }
+        if (paintOp === ops.stroke ||
+            paintOp === ops.closeStroke ||
+            paintOp === ops.fill ||
+            paintOp === ops.eoFill ||
+            paintOp === ops.fillStroke ||
+            paintOp === ops.eoFillStroke ||
+            paintOp === ops.closeFillStroke ||
+            paintOp === ops.closeEOFillStroke ||
+            (ops.rawFillPath !== undefined && paintOp === ops.rawFillPath)) {
+            if (isFillPaint(paintOp)) {
+                closeOpenSubpaths();
+            }
+            else if (paintOp === ops.closeStroke ||
+                paintOp === ops.closeFillStroke ||
+                paintOp === ops.closeEOFillStroke) {
+                closePath();
+            }
+            commit(paintColor(paintOp), isFillPaint(paintOp), isStrokePaint(paintOp));
+        }
+        else {
+            // Unrecognized paint op — drop the path rather than inventing a stroke
+            // at EOF via a trailing commit.
+            discard();
         }
     };
     for (var i = 0; i < fnArray.length; i++) {
@@ -319,34 +689,18 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
         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
-            });
+            graphicsStack.push(snapshotGraphicsState());
             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;
-            }
+            if (restored)
+                restoreGraphicsState(restored);
+            continue;
+        }
+        if ((ops.clip !== undefined && fn === ops.clip) ||
+            (ops.eoClip !== undefined && fn === ops.eoClip)) {
+            pendingClip = true;
             continue;
         }
         if (fn === ops.setFillRGBColor) {
@@ -355,6 +709,19 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
                 fillColor = color;
             continue;
         }
+        if (ops.setDash !== undefined && fn === ops.setDash) {
+            var list = asNumberList(rawArgs[0]);
+            dashArray = list
+                ? Array.from(list, Number).filter(function (v) { return Number.isFinite(v); })
+                : [];
+            continue;
+        }
+        if (ops.setLineWidth !== undefined && fn === ops.setLineWidth) {
+            var value_1 = Number(rawArgs[0]);
+            if (Number.isFinite(value_1) && value_1 >= 0)
+                lineWidth = value_1;
+            continue;
+        }
         if (fn === ops.setStrokeRGBColor) {
             var color = readCssColor(rawArgs[0]);
             if (color)
@@ -375,6 +742,8 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
             var size = Number(rawArgs[1]);
             if (Number.isFinite(size))
                 fontSize = size;
+            if (typeof rawArgs[0] === 'string')
+                fontId = rawArgs[0];
             continue;
         }
         if (fn === ops.setTextMatrix) {
@@ -402,39 +771,39 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
             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;
+                leading = value_2;
             continue;
         }
-        if (fn === ops.setWordSpacing) {
+        if (fn === ops.setCharSpacing) {
             var value_3 = Number(rawArgs[0]);
             if (Number.isFinite(value_3))
-                wordSpacing = value_3;
+                charSpacing = value_3;
             continue;
         }
-        if (fn === ops.setHScale) {
+        if (fn === ops.setWordSpacing) {
             var value_4 = Number(rawArgs[0]);
             if (Number.isFinite(value_4))
-                textHScale = value_4 / 100;
+                wordSpacing = value_4;
             continue;
         }
-        if (fn === ops.setTextRise) {
+        if (fn === ops.setHScale) {
             var value_5 = Number(rawArgs[0]);
             if (Number.isFinite(value_5))
-                textRise = value_5;
+                textHScale = value_5 / 100;
             continue;
         }
-        if (fn === ops.setTextRenderingMode) {
+        if (fn === ops.setTextRise) {
             var value_6 = Number(rawArgs[0]);
             if (Number.isFinite(value_6))
-                textRenderingMode = value_6;
+                textRise = value_6;
+            continue;
+        }
+        if (fn === ops.setTextRenderingMode) {
+            var value_7 = Number(rawArgs[0]);
+            if (Number.isFinite(value_7))
+                textRenderingMode = value_7;
             continue;
         }
         if (fn === ops.showText) {
@@ -456,14 +825,25 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
             continue;
         }
         if (fn === ops.beginMarkedContent) {
-            markedContentLayerStack.push(activeLayerName);
+            markedContentLayerStack.push({
+                layerName: activeLayerName,
+                hidden: activeLayerHidden
+            });
             continue;
         }
         if (fn === ops.beginMarkedContentProps) {
-            markedContentLayerStack.push(activeLayerName);
+            markedContentLayerStack.push({
+                layerName: activeLayerName,
+                hidden: activeLayerHidden
+            });
+            if (activeLayerHidden) {
+                continue;
+            }
             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;
+                var ocgLayer = ocgLayers.get(target.id);
+                activeLayerName = (_b = ocgLayer === null || ocgLayer === void 0 ? void 0 : ocgLayer.layerName) !== null && _b !== void 0 ? _b : fallbackLayerName;
+                activeLayerHidden = !!ocgLayer && ocgLayer.visible === false;
             }
             else if (target.kind === 'fallback') {
                 activeLayerName = fallbackLayerName;
@@ -471,7 +851,75 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
             continue;
         }
         if (fn === ops.endMarkedContent) {
-            activeLayerName = (_d = markedContentLayerStack.pop()) !== null && _d !== void 0 ? _d : fallbackLayerName;
+            var outer = markedContentLayerStack.pop();
+            activeLayerName = outer ? outer.layerName : fallbackLayerName;
+            activeLayerHidden = (_c = outer === null || outer === void 0 ? void 0 : outer.hidden) !== null && _c !== void 0 ? _c : false;
+            continue;
+        }
+        if ((ops.paintImageXObject !== undefined && fn === ops.paintImageXObject) ||
+            (ops.paintInlineImageXObject !== undefined &&
+                fn === ops.paintInlineImageXObject)) {
+            var o = pagePointToCadPoint(0, 0);
+            var ux = pagePointToCadPoint(1, 0);
+            var uy = pagePointToCadPoint(0, 1);
+            var image = {
+                toCad: {
+                    a: ux.x - o.x,
+                    b: ux.y - o.y,
+                    c: uy.x - o.x,
+                    d: uy.y - o.y,
+                    e: o.x,
+                    f: o.y
+                },
+                layerName: activeLayerName
+            };
+            if (fn === ops.paintImageXObject) {
+                if (typeof rawArgs[0] !== 'string')
+                    continue;
+                image.objId = rawArgs[0];
+            }
+            else {
+                if (!rawArgs[0])
+                    continue;
+                image.inline = rawArgs[0];
+            }
+            imageResult.push(image);
+            continue;
+        }
+        if (ops.paintFormXObjectBegin !== undefined &&
+            fn === ops.paintFormXObjectBegin) {
+            formStack.push(snapshotGraphicsState());
+            var matrix = readMatrix(rawArgs);
+            if (matrix) {
+                ctm = multiplyMatrix(ctm, matrix);
+            }
+            if (formStack.length === 1) {
+                // Sample the form-space → model-space map; both the CTM and the
+                // viewport transform are affine.
+                var o = pagePointToCadPoint(0, 0);
+                var ux = pagePointToCadPoint(1, 0);
+                var uy = pagePointToCadPoint(0, 1);
+                formInstances.push({
+                    toCad: {
+                        a: ux.x - o.x,
+                        b: ux.y - o.y,
+                        c: uy.x - o.x,
+                        d: uy.y - o.y,
+                        e: o.x,
+                        f: o.y
+                    }
+                });
+                currentFormInstance = formInstances.length - 1;
+            }
+            continue;
+        }
+        if (ops.paintFormXObjectEnd !== undefined &&
+            fn === ops.paintFormXObjectEnd) {
+            var restored = formStack.pop();
+            if (restored)
+                restoreGraphicsState(restored);
+            if (formStack.length === 0)
+                currentFormInstance = undefined;
             continue;
         }
         switch (fn) {
@@ -487,19 +935,19 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
                 // [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()) {
+                        for (var second_1 = (e_2 = 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 }; }
+                    catch (e_2_1) { e_2 = { error: e_2_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; }
+                        finally { if (e_2) throw e_2.error; }
                     }
                 }
                 else if (isArrayLikePathData(second)) {
@@ -529,6 +977,7 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
                 break;
             }
             case ops.curveTo3: {
+                // PDF "y": second control coincides with the end point.
                 var args = rawArgs;
                 curveTo(args[0], args[1], args[2], args[3], args[2], args[3]);
                 break;
@@ -544,27 +993,47 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
             case ops.closeStroke:
             case ops.closeFillStroke:
             case ops.closeEOFillStroke:
+                captureClip();
                 closePath();
-                commit(paintColor(fn));
+                if (isFillPaint(fn)) {
+                    closeOpenSubpaths();
+                }
+                commit(paintColor(fn), isFillPaint(fn), isStrokePaint(fn));
                 break;
             case ops.stroke:
+                captureClip();
+                commit(paintColor(fn));
+                break;
             case ops.fill:
             case ops.eoFill:
             case ops.fillStroke:
             case ops.eoFillStroke:
-                commit(paintColor(fn));
+                captureClip();
+                closeOpenSubpaths();
+                commit(paintColor(fn), true, isStrokePaint(fn));
                 break;
             case ops.endPath:
+                captureClip();
                 discard();
                 break;
         }
     }
-    commit();
-    return { subpaths: subpathResult, texts: textResult };
+    // Drop any path that never received a paint operator.
+    discard();
+    var content = applyPdfImportContrastColors({ subpaths: subpathResult, texts: textResult }, options);
+    if (formInstances.length > 0)
+        content.formInstances = formInstances;
+    if (clipPaths.length > 0)
+        content.clipPaths = clipPaths;
+    if (imageResult.length > 0)
+        content.images = imageResult;
+    return content;
     // Hoisted so the operator loop above can call them.
     function moveTextLine(tx, ty) {
+        // Td offsets are in text space: Tlm' = [1 0 0 1 tx ty] × Tlm (row form),
+        // so the shift applies before Tlm and is scaled by the font matrix.
         var shift = [1, 0, 0, 1, tx, ty];
-        textLineMatrix = multiplyMatrix(shift, textLineMatrix);
+        textLineMatrix = multiplyMatrix(textLineMatrix, shift);
         textMatrix = cloneMatrix(textLineMatrix);
         textX = 0;
         textY = 0;
@@ -604,16 +1073,9 @@ export function extractPdfImportSubpaths(opList, ops, viewport, ocgLayers, fallb
             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;
+            var end = textPointToCad(textX + advance * textHScale, textY + textRise);
             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
-                });
+                textResult.push(__assign({ text: text, position: origin_1, width: Math.hypot(end.x - origin_1.x, end.y - origin_1.y), height: height, rotation: Math.atan2(dy, dx), widthFactor: widthFactor, layerName: activeLayerName, color: (textRenderingMode & 3) === 1 ? strokeColor : fillColor }, (fontId !== undefined ? { fontId: fontId } : {})));
             }
         }
         textX += advance * textHScale;
@@ -641,9 +1103,15 @@ function readCssColor(value) {
     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)
+    // Text matrix ops pass six numbers (or one Float32Array). Form XObject
+    // begin passes `[matrix, bbox]`, so prefer a nested 6-vector when present.
+    var nested = asNumberList(rawArgs[0]);
+    var source = nested && nested.length >= 6
+        ? nested
+        : rawArgs.length >= 6
+            ? rawArgs
+            : undefined;
+    if (!source || source.length < 6)
         return undefined;
     return [
         Number(source[0]),