@polotno/pdf-import 0.0.1

package/lib/image-encoder.js

@@ -0,0 +1,181 @@
+// Encode pdfjs-dist image data to base64 data URIs
+// pdfjs gives us raw pixel data (Uint8ClampedArray) with width/height/kind
+function uint8ArrayToBase64(bytes) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('base64');
+    }
+    // Browser fallback
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+export function imageDataToDataUri(data, width, height, kind) {
+    // kind: 1 = grayscale, 2 = RGB, 3 = RGBA
+    // Convert to RGBA if needed, then encode as PNG
+    let rgba;
+    if (kind === 3) {
+        // Already RGBA
+        rgba = new Uint8Array(data);
+    }
+    else if (kind === 2) {
+        // RGB -> RGBA
+        rgba = new Uint8Array(width * height * 4);
+        for (let i = 0; i < width * height; i++) {
+            rgba[i * 4] = data[i * 3];
+            rgba[i * 4 + 1] = data[i * 3 + 1];
+            rgba[i * 4 + 2] = data[i * 3 + 2];
+            rgba[i * 4 + 3] = 255;
+        }
+    }
+    else if (kind === 1) {
+        // Grayscale -> RGBA
+        rgba = new Uint8Array(width * height * 4);
+        for (let i = 0; i < width * height; i++) {
+            rgba[i * 4] = data[i];
+            rgba[i * 4 + 1] = data[i];
+            rgba[i * 4 + 2] = data[i];
+            rgba[i * 4 + 3] = 255;
+        }
+    }
+    else {
+        // Unknown kind, try as RGBA
+        rgba = new Uint8Array(data);
+    }
+    const png = encodePng(rgba, width, height);
+    const b64 = uint8ArrayToBase64(png);
+    return `data:image/png;base64,${b64}`;
+}
+// Minimal PNG encoder (uncompressed)
+function encodePng(rgba, width, height) {
+    // PNG signature
+    const signature = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+    // IHDR chunk
+    const ihdr = new Uint8Array(13);
+    const ihdrView = new DataView(ihdr.buffer);
+    ihdrView.setUint32(0, width);
+    ihdrView.setUint32(4, height);
+    ihdr[8] = 8; // bit depth
+    ihdr[9] = 6; // color type: RGBA
+    ihdr[10] = 0; // compression
+    ihdr[11] = 0; // filter
+    ihdr[12] = 0; // interlace
+    const ihdrChunk = makeChunk('IHDR', ihdr);
+    // IDAT: we use zlib stored blocks (no compression)
+    // Each row: filter byte (0) + RGBA pixels
+    const rowSize = 1 + width * 4;
+    const rawData = new Uint8Array(height * rowSize);
+    for (let y = 0; y < height; y++) {
+        rawData[y * rowSize] = 0; // filter: none
+        rawData.set(rgba.subarray(y * width * 4, (y + 1) * width * 4), y * rowSize + 1);
+    }
+    // Wrap in zlib format (stored blocks)
+    const zlibData = deflateStored(rawData);
+    const idatChunk = makeChunk('IDAT', zlibData);
+    // IEND
+    const iendChunk = makeChunk('IEND', new Uint8Array(0));
+    // Concatenate
+    const total = signature.length +
+        ihdrChunk.length +
+        idatChunk.length +
+        iendChunk.length;
+    const result = new Uint8Array(total);
+    let offset = 0;
+    result.set(signature, offset);
+    offset += signature.length;
+    result.set(ihdrChunk, offset);
+    offset += ihdrChunk.length;
+    result.set(idatChunk, offset);
+    offset += idatChunk.length;
+    result.set(iendChunk, offset);
+    return result;
+}
+function makeChunk(type, data) {
+    const chunk = new Uint8Array(4 + 4 + data.length + 4);
+    const view = new DataView(chunk.buffer);
+    // Length
+    view.setUint32(0, data.length);
+    // Type
+    for (let i = 0; i < 4; i++) {
+        chunk[4 + i] = type.charCodeAt(i);
+    }
+    // Data
+    chunk.set(data, 8);
+    // CRC
+    const crcData = chunk.subarray(4, 8 + data.length);
+    view.setUint32(8 + data.length, crc32(crcData));
+    return chunk;
+}
+function deflateStored(data) {
+    // zlib header (no compression) + stored deflate blocks + adler32
+    const maxBlockSize = 65535;
+    const numBlocks = Math.ceil(data.length / maxBlockSize) || 1;
+    // Calculate total size: zlib header (2) + blocks + adler32 (4)
+    let totalSize = 2 + 4; // header + adler32
+    for (let i = 0; i < numBlocks; i++) {
+        const blockStart = i * maxBlockSize;
+        const blockLen = Math.min(maxBlockSize, data.length - blockStart);
+        totalSize += 5 + blockLen; // 5 byte block header + data
+    }
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    // zlib header: CMF=0x78 (deflate, window=32768), FLG=0x01 (no dict, check)
+    result[offset++] = 0x78;
+    result[offset++] = 0x01;
+    // Stored blocks
+    for (let i = 0; i < numBlocks; i++) {
+        const blockStart = i * maxBlockSize;
+        const blockLen = Math.min(maxBlockSize, data.length - blockStart);
+        const isLast = i === numBlocks - 1;
+        result[offset++] = isLast ? 1 : 0; // BFINAL
+        result[offset++] = blockLen & 0xff;
+        result[offset++] = (blockLen >> 8) & 0xff;
+        result[offset++] = ~blockLen & 0xff;
+        result[offset++] = (~blockLen >> 8) & 0xff;
+        result.set(data.subarray(blockStart, blockStart + blockLen), offset);
+        offset += blockLen;
+    }
+    // Adler32
+    const adler = adler32(data);
+    result[offset++] = (adler >> 24) & 0xff;
+    result[offset++] = (adler >> 16) & 0xff;
+    result[offset++] = (adler >> 8) & 0xff;
+    result[offset++] = adler & 0xff;
+    return result;
+}
+function adler32(data) {
+    let a = 1, b = 0;
+    for (let i = 0; i < data.length; i++) {
+        a = (a + data[i]) % 65521;
+        b = (b + a) % 65521;
+    }
+    return ((b << 16) | a) >>> 0;
+}
+// CRC32 lookup table
+const crcTable = [];
+for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+        if (c & 1) {
+            c = 0xedb88320 ^ (c >>> 1);
+        }
+        else {
+            c = c >>> 1;
+        }
+    }
+    crcTable[n] = c;
+}
+function crc32(data) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc = crcTable[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+// For already-encoded images from pdfjs (JPEG etc)
+export function imageBytesToDataUri(data, mimeType) {
+    const b64 = uint8ArrayToBase64(data);
+    return `data:${mimeType};base64,${b64}`;
+}
+//# sourceMappingURL=image-encoder.js.map

package/lib/index.d.ts

@@ -0,0 +1,97 @@
+export interface PolotnoTextElement {
+    type: 'text';
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    opacity: number;
+    visible: boolean;
+    selectable: boolean;
+    removable: boolean;
+    text: string;
+    fontSize: number;
+    fontFamily: string;
+    fontWeight: string;
+    fontStyle: string;
+    fill: string;
+    align: string;
+    lineHeight: number;
+    letterSpacing: number;
+    name: string;
+    placeholder: string;
+}
+export interface PolotnoImageElement {
+    type: 'image';
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    opacity: number;
+    visible: boolean;
+    selectable: boolean;
+    removable: boolean;
+    src: string;
+    cropX: number;
+    cropY: number;
+    cropWidth: number;
+    cropHeight: number;
+    clipSrc: string;
+    name: string;
+}
+export interface PolotnoSvgElement {
+    type: 'svg';
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    opacity: number;
+    src: string;
+    clipSrc?: string;
+    name: string;
+}
+export interface PolotnoLineElement {
+    type: 'line';
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    rotation: number;
+    dash?: number[];
+    opacity?: number;
+    name?: string;
+}
+export type PolotnoElement = PolotnoTextElement | PolotnoImageElement | PolotnoSvgElement | PolotnoLineElement;
+export interface PolotnoFont {
+    fontFamily: string;
+    url?: string | null;
+    styles?: Record<string, unknown>[] | null;
+}
+export interface PolotnoPage {
+    id: string;
+    children: PolotnoElement[];
+    width?: number | null;
+    height?: number | null;
+    background: string;
+}
+export interface PolotnoJson {
+    width: number;
+    height: number;
+    fonts: PolotnoFont[];
+    pages: PolotnoPage[];
+    unit: string;
+    dpi: number;
+}
+export type FontStrategy = 'embed' | 'googleFontsMatch';
+export declare function pdfToJson({ pdf, fontStrategy, }: {
+    pdf: ArrayBuffer | Uint8Array;
+    fontStrategy?: FontStrategy;
+}): Promise<PolotnoJson>;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1 @@
+import{getDocument as x,GlobalWorkerOptions as m}from"pdfjs-dist/legacy/build/pdf.mjs";import{parsePage as I}from"./page-parser.js";import{FontRegistry as R}from"./font-registry.js";import{buildJpegIndex as S}from"./pdf-image-extractor.js";let k=0;function A(){return`el_${Date.now()}_${++k}`}async function j({pdf:e,fontStrategy:w="embed"}){typeof window<"u"&&!m.workerSrc&&(m.workerSrc=new URL("pdfjs-dist/legacy/build/pdf.worker.mjs",import.meta.url).toString());const s=new Uint8Array(e instanceof ArrayBuffer?e:e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength)),l=S(s),r=await x({data:s,useSystemFonts:!0,disableFontFace:!0,fontExtraProperties:!0}).promise,i=new R;let c=612,g=792;const f=await r.getPage(1),u=f.getViewport({scale:1});c=u.width,g=u.height;const d=3,n=new Array(r.numPages);for(let o=0;o<r.numPages;o+=d){const y=Math.min(o+d,r.numPages),p=[];for(let t=o;t<y;t++)p.push((async()=>{const a=t===0?f:await r.getPage(t+1),{parsedPage:P}=await I({page:a,pageIdx:t,fontRegistry:i,generateId:A,jpegIndex:l});return{parsedPage:P,pageIdx:t}})());const b=await Promise.all(p);for(const{parsedPage:t,pageIdx:a}of b)n[a]=t}await r.destroy();const h=i.finalize(w,n);return{width:c,height:g,fonts:h,pages:n,unit:"px",dpi:72}}export{j as pdfToJson};

package/lib/operator-list-helpers.d.ts

@@ -0,0 +1,6 @@
+export type Matrix = [number, number, number, number, number, number];
+export declare function argsToMatrix(args: any): Matrix;
+export declare function multiplyMatrices(m1: Matrix, m2: Matrix): Matrix;
+export declare function isTextShowOp(fn: number): boolean;
+export declare function isVisualOrderOp(fn: number): boolean;
+//# sourceMappingURL=operator-list-helpers.d.ts.map

package/lib/operator-list-helpers.js

@@ -0,0 +1,26 @@
+import { OPS } from 'pdfjs-dist/legacy/build/pdf.mjs';
+export function argsToMatrix(args) {
+    return [args[0], args[1], args[2], args[3], args[4], args[5]];
+}
+export function multiplyMatrices(m1, m2) {
+    return [
+        m1[0] * m2[0] + m1[1] * m2[2],
+        m1[0] * m2[1] + m1[1] * m2[3],
+        m1[2] * m2[0] + m1[3] * m2[2],
+        m1[2] * m2[1] + m1[3] * m2[3],
+        m1[4] * m2[0] + m1[5] * m2[2] + m2[4],
+        m1[4] * m2[1] + m1[5] * m2[3] + m2[5],
+    ];
+}
+export function isTextShowOp(fn) {
+    return fn === OPS.showText || fn === OPS.showSpacedText;
+}
+export function isVisualOrderOp(fn) {
+    return (fn === OPS.fill ||
+        fn === OPS.stroke ||
+        fn === OPS.fillStroke ||
+        fn === OPS.eoFill ||
+        fn === OPS.eoFillStroke ||
+        fn === OPS.paintImageXObject);
+}
+//# sourceMappingURL=operator-list-helpers.js.map

package/lib/operator-list.d.ts

@@ -0,0 +1,99 @@
+export interface TextColorEntry {
+    fontName: string;
+    fillColor: string;
+}
+export declare function extractTextColors(ops: {
+    fnArray: number[];
+    argsArray: any[];
+}): Map<string, string>;
+export interface PositionColor {
+    x: number;
+    y: number;
+    color: string;
+    fontName: string;
+    fontSize: number;
+    orderIndex: number;
+}
+export declare function extractTextPositionColors(ops: {
+    fnArray: number[];
+    argsArray: any[];
+}, pageHeight: number): PositionColor[] & {
+    fontRefs?: Set<string>;
+};
+export interface GradientInfo {
+    type: 'linear' | 'radial';
+    stops: {
+        offset: number;
+        color: string;
+    }[];
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+    cx?: number;
+    cy?: number;
+    r0?: number;
+    r1?: number;
+}
+export interface ExtractedDrawing {
+    rect: [number, number, number, number];
+    fill: [number, number, number] | null;
+    stroke: [number, number, number] | null;
+    strokeWidth: number;
+    items: DrawingItem[];
+    opacity: number;
+    evenOdd: boolean;
+    closePath: boolean;
+    orderIndex: number;
+    gradient: GradientInfo | null;
+    clipPath: DrawingItem[] | null;
+    clipRect: [number, number, number, number] | null;
+    _shadingNames?: string[] | null;
+    _shadingMatrix?: [number, number, number, number, number, number] | null;
+}
+export type DrawingItem = {
+    kind: 're';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+} | {
+    kind: 'm';
+    x: number;
+    y: number;
+} | {
+    kind: 'l';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+} | {
+    kind: 'c';
+    x1: number;
+    y1: number;
+    cpx1: number;
+    cpy1: number;
+    cpx2: number;
+    cpy2: number;
+    x2: number;
+    y2: number;
+};
+export interface ExtractedImageRef {
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    clipPath: DrawingItem[] | null;
+    clipRect: [number, number, number, number] | null;
+    orderIndex: number;
+}
+export declare function extractDrawingsAndImages(ops: {
+    fnArray: number[];
+    argsArray: any[];
+}, pageHeight: number): {
+    drawings: ExtractedDrawing[];
+    imageRefs: ExtractedImageRef[];
+};
+//# sourceMappingURL=operator-list.d.ts.map