@polotno/pdf-import 0.0.1

package/lib/operator-list.js

@@ -0,0 +1,528 @@
+import { OPS } from 'pdfjs-dist/legacy/build/pdf.mjs';
+import { argsToMatrix, isTextShowOp, isVisualOrderOp, multiplyMatrices, } from './operator-list-helpers.js';
+// pdfjs setFillRGBColor/setStrokeRGBColor args are Uint8ClampedArray 0-255
+function argsToHex(args) {
+    const r = Math.round(args[0]);
+    const g = Math.round(args[1]);
+    const b = Math.round(args[2]);
+    return ('#' +
+        (r & 0xff).toString(16).toUpperCase().padStart(2, '0') +
+        (g & 0xff).toString(16).toUpperCase().padStart(2, '0') +
+        (b & 0xff).toString(16).toUpperCase().padStart(2, '0'));
+}
+function grayToHex(args) {
+    const v = Math.round(args[0]);
+    const h = (v & 0xff).toString(16).toUpperCase().padStart(2, '0');
+    return '#' + h + h + h;
+}
+function cmykToHex(args) {
+    // CMYK args are 0-1 floats in pdfjs
+    const c = args[0] / 255, m = args[1] / 255, y = args[2] / 255, k = args[3] / 255;
+    const r = Math.round(255 * (1 - c) * (1 - k));
+    const g = Math.round(255 * (1 - m) * (1 - k));
+    const b = Math.round(255 * (1 - y) * (1 - k));
+    return ('#' +
+        (r & 0xff).toString(16).toUpperCase().padStart(2, '0') +
+        (g & 0xff).toString(16).toUpperCase().padStart(2, '0') +
+        (b & 0xff).toString(16).toUpperCase().padStart(2, '0'));
+}
+function argsToRgbFloat(args) {
+    return [args[0] / 255, args[1] / 255, args[2] / 255];
+}
+function grayToRgbFloat(args) {
+    const v = args[0] / 255;
+    return [v, v, v];
+}
+function cmykToRgbFloat(args) {
+    const c = args[0] / 255, m = args[1] / 255, y = args[2] / 255, k = args[3] / 255;
+    return [(1 - c) * (1 - k), (1 - m) * (1 - k), (1 - y) * (1 - k)];
+}
+export function extractTextColors(ops) {
+    const result = new Map();
+    let currentFillColor = '#000000';
+    let currentFontName = '';
+    for (let i = 0; i < ops.fnArray.length; i++) {
+        const fn = ops.fnArray[i];
+        const args = ops.argsArray[i];
+        if (fn === OPS.setFillRGBColor) {
+            currentFillColor = argsToHex(args);
+        }
+        else if (fn === OPS.setFillGray) {
+            currentFillColor = grayToHex(args);
+        }
+        else if (fn === OPS.setFillCMYKColor) {
+            currentFillColor = cmykToHex(args);
+        }
+        else if (fn === OPS.setFont) {
+            currentFontName = args[0];
+        }
+        else if (fn === OPS.showText || fn === OPS.showSpacedText) {
+            if (currentFontName) {
+                result.set(currentFontName, currentFillColor);
+            }
+        }
+    }
+    return result;
+}
+export function extractTextPositionColors(ops, pageHeight) {
+    const result = [];
+    const fontRefs = new Set();
+    let currentFillColor = '#000000';
+    let currentFontName = '';
+    let currentFontSize = 12;
+    let elementOrder = 0;
+    // Track CTM stack for proper position computation
+    let ctm = [1, 0, 0, 1, 0, 0];
+    const ctmStack = [];
+    // Track text matrix for position
+    let tmX = 0;
+    let tmY = 0;
+    for (let i = 0; i < ops.fnArray.length; i++) {
+        const fn = ops.fnArray[i];
+        const args = ops.argsArray[i];
+        if (fn === OPS.save) {
+            ctmStack.push({ ctm: [...ctm], fill: currentFillColor });
+        }
+        else if (fn === OPS.restore) {
+            const state = ctmStack.pop();
+            if (state) {
+                ctm = state.ctm;
+                currentFillColor = state.fill;
+            }
+        }
+        else if (fn === OPS.transform) {
+            ctm = multiplyMatrices(argsToMatrix(args), ctm);
+        }
+        else if (fn === OPS.setFillRGBColor) {
+            currentFillColor = argsToHex(args);
+        }
+        else if (fn === OPS.setFillGray) {
+            currentFillColor = grayToHex(args);
+        }
+        else if (fn === OPS.setFillCMYKColor) {
+            currentFillColor = cmykToHex(args);
+        }
+        else if (fn === OPS.setFont) {
+            currentFontName = args[0];
+            currentFontSize = args[1];
+            fontRefs.add(currentFontName);
+        }
+        else if (fn === OPS.beginText) {
+            // BT resets the text matrix to identity; without this reset,
+            // moveText (Td) values accumulate across BT/ET blocks.
+            tmX = 0;
+            tmY = 0;
+        }
+        else if (fn === OPS.setTextMatrix) {
+            tmX = args[4];
+            tmY = args[5];
+        }
+        else if (fn === OPS.moveText) {
+            tmX += args[0];
+            tmY += args[1];
+        }
+        else if (isTextShowOp(fn)) {
+            // Transform text matrix position through CTM to get page coordinates
+            const px = ctm[0] * tmX + ctm[2] * tmY + ctm[4];
+            const py = ctm[1] * tmX + ctm[3] * tmY + ctm[5];
+            result.push({
+                x: px,
+                y: pageHeight - py,
+                color: currentFillColor,
+                fontName: currentFontName,
+                fontSize: currentFontSize,
+                orderIndex: elementOrder++,
+            });
+        }
+        else if (isVisualOrderOp(fn)) {
+            // Count non-text visual ops to keep orderIndex in sync with extractDrawingsAndImages
+            elementOrder++;
+        }
+    }
+    result.fontRefs = fontRefs;
+    return result;
+}
+export function extractDrawingsAndImages(ops, pageHeight) {
+    const drawings = [];
+    const imageRefs = [];
+    let elementOrder = 0;
+    let fillColor = [0, 0, 0];
+    let strokeColor = [0, 0, 0];
+    let fillGradient = null;
+    // Track shading references from TilingPattern fills for later resolution
+    let pendingShadingNames = null;
+    let pendingShadingMatrix = null;
+    let strokeWidth = 1;
+    let opacity = 1.0;
+    // CTM stack for tracking transforms
+    let ctm = [1, 0, 0, 1, 0, 0];
+    // Track current clip path for images
+    let currentClipPath = null;
+    let currentClipRect = null;
+    const ctmStack = [];
+    // Track soft mask groups — drawings inside smask groups are mask definitions, not visible
+    let smaskDepth = 0;
+    // Accumulated path data
+    let pathItems = [];
+    let pathMinX = Infinity, pathMinY = Infinity, pathMaxX = -Infinity, pathMaxY = -Infinity;
+    let curX = 0, curY = 0;
+    function transformPoint(x, y) {
+        const tx = ctm[0] * x + ctm[2] * y + ctm[4];
+        const ty = ctm[1] * x + ctm[3] * y + ctm[5];
+        return [tx, pageHeight - ty];
+    }
+    function expandBounds(x, y) {
+        if (x < pathMinX)
+            pathMinX = x;
+        if (y < pathMinY)
+            pathMinY = y;
+        if (x > pathMaxX)
+            pathMaxX = x;
+        if (y > pathMaxY)
+            pathMaxY = y;
+    }
+    function resetPath() {
+        pathItems = [];
+        pathMinX = Infinity;
+        pathMinY = Infinity;
+        pathMaxX = -Infinity;
+        pathMaxY = -Infinity;
+    }
+    for (let i = 0; i < ops.fnArray.length; i++) {
+        const fn = ops.fnArray[i];
+        const args = ops.argsArray[i];
+        if (fn === OPS.save) {
+            ctmStack.push({
+                ctm: [...ctm],
+                fill: fillColor ? [...fillColor] : null,
+                stroke: strokeColor
+                    ? [...strokeColor]
+                    : null,
+                fillGradient,
+                strokeWidth,
+                opacity,
+                clipPath: currentClipPath,
+                clipRect: currentClipRect,
+            });
+        }
+        else if (fn === OPS.restore) {
+            const state = ctmStack.pop();
+            if (state) {
+                ctm = state.ctm;
+                fillColor = state.fill;
+                strokeColor = state.stroke;
+                fillGradient = state.fillGradient;
+                strokeWidth = state.strokeWidth;
+                opacity = state.opacity;
+                currentClipPath = state.clipPath;
+                currentClipRect = state.clipRect;
+            }
+        }
+        else if (fn === OPS.transform) {
+            ctm = multiplyMatrices(argsToMatrix(args), ctm);
+        }
+        else if (fn === OPS.setFillRGBColor) {
+            fillColor = argsToRgbFloat(args);
+            fillGradient = null;
+            pendingShadingNames = null;
+        }
+        else if (fn === OPS.setFillGray) {
+            fillColor = grayToRgbFloat(args);
+            fillGradient = null;
+            pendingShadingNames = null;
+        }
+        else if (fn === OPS.setFillCMYKColor) {
+            fillColor = cmykToRgbFloat(args);
+            fillGradient = null;
+            pendingShadingNames = null;
+        }
+        else if (fn === OPS.setFillColorN) {
+            // Pattern/gradient fill — extract shading info from TilingPattern
+            if (args && args[0] === 'TilingPattern') {
+                const patternOps = args[2]; // embedded operator list
+                if (patternOps && patternOps.argsArray) {
+                    // Find shading references in the pattern's operator list
+                    const names = [];
+                    let matrix = null;
+                    for (const pArgs of patternOps.argsArray) {
+                        if (Array.isArray(pArgs) && pArgs[0] === 'Shading' && typeof pArgs[1] === 'string') {
+                            if (!names.includes(pArgs[1]))
+                                names.push(pArgs[1]);
+                            if (!matrix && Array.isArray(pArgs[2])) {
+                                matrix = pArgs[2];
+                            }
+                        }
+                    }
+                    if (names.length > 0) {
+                        pendingShadingNames = names;
+                        pendingShadingMatrix = matrix;
+                    }
+                }
+                // Set fill to null — gradient will be resolved later
+                fillColor = null;
+                fillGradient = null;
+            }
+        }
+        else if (fn === OPS.setStrokeRGBColor) {
+            strokeColor = argsToRgbFloat(args);
+        }
+        else if (fn === OPS.setStrokeGray) {
+            strokeColor = grayToRgbFloat(args);
+        }
+        else if (fn === OPS.setStrokeCMYKColor) {
+            strokeColor = cmykToRgbFloat(args);
+        }
+        else if (fn === OPS.setGState) {
+            // setGState args is an array of [key, value] pairs
+            const pairs = args[0];
+            if (Array.isArray(pairs)) {
+                for (const [key, value] of pairs) {
+                    if (key === 'ca') {
+                        // ca = fill opacity (0-1)
+                        opacity = value;
+                    }
+                }
+            }
+        }
+        else if (fn === OPS.setLineWidth) {
+            strokeWidth = args[0];
+        }
+        else if (fn === OPS.constructPath) {
+            // args[0] = array of sub-ops, args[1] = flat array of coordinates
+            const subOps = args[0];
+            const coords = args[1];
+            let ci = 0;
+            for (const subOp of subOps) {
+                if (subOp === OPS.moveTo) {
+                    const [tx, ty] = transformPoint(coords[ci], coords[ci + 1]);
+                    ci += 2;
+                    pathItems.push({ kind: 'm', x: tx, y: ty });
+                    expandBounds(tx, ty);
+                    curX = tx;
+                    curY = ty;
+                }
+                else if (subOp === OPS.lineTo) {
+                    const [tx, ty] = transformPoint(coords[ci], coords[ci + 1]);
+                    ci += 2;
+                    pathItems.push({ kind: 'l', x1: curX, y1: curY, x2: tx, y2: ty });
+                    expandBounds(tx, ty);
+                    curX = tx;
+                    curY = ty;
+                }
+                else if (subOp === OPS.curveTo) {
+                    const [cpx1, cpy1] = transformPoint(coords[ci], coords[ci + 1]);
+                    const [cpx2, cpy2] = transformPoint(coords[ci + 2], coords[ci + 3]);
+                    const [tx, ty] = transformPoint(coords[ci + 4], coords[ci + 5]);
+                    ci += 6;
+                    pathItems.push({
+                        kind: 'c',
+                        x1: curX,
+                        y1: curY,
+                        cpx1,
+                        cpy1,
+                        cpx2,
+                        cpy2,
+                        x2: tx,
+                        y2: ty,
+                    });
+                    expandBounds(cpx1, cpy1);
+                    expandBounds(cpx2, cpy2);
+                    expandBounds(tx, ty);
+                    curX = tx;
+                    curY = ty;
+                }
+                else if (subOp === OPS.curveTo2) {
+                    // curveTo2: current point as first control point
+                    const [cpx2, cpy2] = transformPoint(coords[ci], coords[ci + 1]);
+                    const [tx, ty] = transformPoint(coords[ci + 2], coords[ci + 3]);
+                    ci += 4;
+                    pathItems.push({
+                        kind: 'c',
+                        x1: curX,
+                        y1: curY,
+                        cpx1: curX,
+                        cpy1: curY,
+                        cpx2,
+                        cpy2,
+                        x2: tx,
+                        y2: ty,
+                    });
+                    expandBounds(cpx2, cpy2);
+                    expandBounds(tx, ty);
+                    curX = tx;
+                    curY = ty;
+                }
+                else if (subOp === OPS.curveTo3) {
+                    // curveTo3: endpoint as last control point
+                    const [cpx1, cpy1] = transformPoint(coords[ci], coords[ci + 1]);
+                    const [tx, ty] = transformPoint(coords[ci + 2], coords[ci + 3]);
+                    ci += 4;
+                    pathItems.push({
+                        kind: 'c',
+                        x1: curX,
+                        y1: curY,
+                        cpx1,
+                        cpy1,
+                        cpx2: tx,
+                        cpy2: ty,
+                        x2: tx,
+                        y2: ty,
+                    });
+                    expandBounds(cpx1, cpy1);
+                    expandBounds(tx, ty);
+                    curX = tx;
+                    curY = ty;
+                }
+                else if (subOp === OPS.rectangle) {
+                    const rx = coords[ci], ry = coords[ci + 1], rw = coords[ci + 2], rh = coords[ci + 3];
+                    ci += 4;
+                    const [tx0, ty0] = transformPoint(rx, ry);
+                    const [tx1, ty1] = transformPoint(rx + rw, ry);
+                    const [tx2, ty2] = transformPoint(rx + rw, ry + rh);
+                    const [tx3, ty3] = transformPoint(rx, ry + rh);
+                    // Use the min/max of transformed corners
+                    const minX = Math.min(tx0, tx1, tx2, tx3);
+                    const minY = Math.min(ty0, ty1, ty2, ty3);
+                    const maxX = Math.max(tx0, tx1, tx2, tx3);
+                    const maxY = Math.max(ty0, ty1, ty2, ty3);
+                    pathItems.push({
+                        kind: 're',
+                        x: minX,
+                        y: minY,
+                        w: maxX - minX,
+                        h: maxY - minY,
+                    });
+                    expandBounds(minX, minY);
+                    expandBounds(maxX, maxY);
+                    curX = minX;
+                    curY = minY;
+                }
+                else if (subOp === OPS.closePath) {
+                    // close subpath - no coords consumed
+                }
+            }
+        }
+        else if (fn === OPS.fill ||
+            fn === OPS.eoFill ||
+            fn === OPS.fillStroke ||
+            fn === OPS.eoFillStroke) {
+            // Always increment order to stay in sync with extractTextPositionColors
+            const order = elementOrder++;
+            if (smaskDepth > 0) {
+                // Inside soft mask group — skip, this is a mask definition not a visible drawing
+                resetPath();
+            }
+            else if (pathItems.length > 0 && pathMinX < Infinity) {
+                const hasFill = fn === OPS.fill ||
+                    fn === OPS.eoFill ||
+                    fn === OPS.fillStroke ||
+                    fn === OPS.eoFillStroke;
+                const hasStroke = fn === OPS.fillStroke || fn === OPS.eoFillStroke;
+                // Scale stroke width by CTM scale factor (path coords are already transformed)
+                const ctmScale = Math.sqrt(ctm[0] * ctm[0] + ctm[1] * ctm[1]);
+                const scaledStrokeWidth = strokeWidth * ctmScale;
+                drawings.push({
+                    rect: [pathMinX, pathMinY, pathMaxX, pathMaxY],
+                    fill: hasFill && fillColor ? [...fillColor] : null,
+                    stroke: hasStroke && strokeColor
+                        ? [...strokeColor]
+                        : null,
+                    strokeWidth: scaledStrokeWidth,
+                    items: [...pathItems],
+                    opacity,
+                    evenOdd: fn === OPS.eoFill || fn === OPS.eoFillStroke,
+                    closePath: true,
+                    orderIndex: order,
+                    gradient: fillGradient,
+                    clipPath: currentClipPath,
+                    clipRect: currentClipRect,
+                    _shadingNames: pendingShadingNames,
+                    _shadingMatrix: pendingShadingMatrix,
+                });
+            }
+            resetPath();
+        }
+        else if (fn === OPS.stroke) {
+            // Always increment order to stay in sync with extractTextPositionColors
+            const order = elementOrder++;
+            if (smaskDepth > 0) {
+                resetPath();
+            }
+            else if (pathItems.length > 0 && pathMinX < Infinity) {
+                // Scale stroke width by CTM scale factor (path coords are already transformed)
+                const ctmScale = Math.sqrt(ctm[0] * ctm[0] + ctm[1] * ctm[1]);
+                const scaledStrokeWidth = strokeWidth * ctmScale;
+                drawings.push({
+                    rect: [pathMinX, pathMinY, pathMaxX, pathMaxY],
+                    fill: null,
+                    stroke: strokeColor
+                        ? [...strokeColor]
+                        : null,
+                    strokeWidth: scaledStrokeWidth,
+                    items: [...pathItems],
+                    opacity,
+                    evenOdd: false,
+                    closePath: false,
+                    orderIndex: order,
+                    gradient: null,
+                    clipPath: currentClipPath,
+                    clipRect: currentClipRect,
+                });
+            }
+            resetPath();
+        }
+        else if (fn === OPS.clip || fn === OPS.eoClip) {
+            // Capture current path as clip path for subsequent image painting
+            if (pathItems.length > 0 && pathMinX < Infinity) {
+                // Only set clip if we don't already have a non-rectangular one
+                // (PDF clips are intersected; a rectangle inside a circle still shows the circle)
+                const isSimpleRect = pathItems.length === 1 && pathItems[0].kind === 're';
+                if (!currentClipPath || !isSimpleRect) {
+                    currentClipPath = [...pathItems];
+                    currentClipRect = [pathMinX, pathMinY, pathMaxX, pathMaxY];
+                }
+            }
+            // Don't reset path — endPath will do that
+        }
+        else if (fn === OPS.endPath) {
+            resetPath();
+        }
+        else if (fn === OPS.beginGroup) {
+            // Check if this group has a soft mask (smask) — content inside is mask definition
+            const groupInfo = args[0];
+            if (groupInfo && groupInfo.smask) {
+                smaskDepth++;
+            }
+        }
+        else if (fn === OPS.endGroup) {
+            if (smaskDepth > 0) {
+                smaskDepth--;
+            }
+        }
+        else if (fn === OPS.paintImageXObject) {
+            // args[0] = image name, args[1] = width, args[2] = height
+            const name = args[0];
+            // Image is painted in a 1x1 unit square transformed by CTM.
+            // Unit square corners: (0,0)=BL, (1,0)=BR, (1,1)=TR, (0,1)=TL in image space
+            // (Y is flipped in image space, so (0,1) is top-left)
+            const tl = transformPoint(0, 1);
+            const tr = transformPoint(1, 1);
+            const bl = transformPoint(0, 0);
+            // Width/height from edge lengths of the transformed parallelogram
+            const w = Math.sqrt((tr[0] - tl[0]) ** 2 + (tr[1] - tl[1]) ** 2);
+            const h = Math.sqrt((bl[0] - tl[0]) ** 2 + (bl[1] - tl[1]) ** 2);
+            // Rotation: angle of the top edge from horizontal (degrees, clockwise)
+            const rotation = Math.atan2(tr[1] - tl[1], tr[0] - tl[0]) * 180 / Math.PI;
+            // Position: top-left corner in screen space (polotno rotates around top-left)
+            const x = tl[0];
+            const y = tl[1];
+            imageRefs.push({ name, x, y, width: w, height: h, rotation, clipPath: currentClipPath, clipRect: currentClipRect, orderIndex: elementOrder++ });
+        }
+        else if (isTextShowOp(fn)) {
+            // Count text ops to keep orderIndex in sync with extractTextPositionColors
+            elementOrder++;
+        }
+    }
+    return { drawings, imageRefs };
+}
+//# sourceMappingURL=operator-list.js.map

package/lib/page-parser.d.ts

@@ -0,0 +1,18 @@
+import { FontRegistry } from './font-registry.js';
+import { type RawImageStream } from './pdf-image-extractor.js';
+import type { PolotnoPage } from './index.js';
+interface ParsePageOptions {
+    page: any;
+    pageIdx: number;
+    fontRegistry: FontRegistry;
+    generateId: () => string;
+    jpegIndex: Map<number, RawImageStream>;
+}
+interface ParsePageResult {
+    parsedPage: PolotnoPage;
+    pageWidth: number;
+    pageHeight: number;
+}
+export declare function parsePage({ page, pageIdx, fontRegistry, generateId, jpegIndex, }: ParsePageOptions): Promise<ParsePageResult>;
+export {};
+//# sourceMappingURL=page-parser.d.ts.map