@polotno/pdf-export 0.1.37 → 0.1.39

package/lib/compare-render.js

@@ -1,185 +0,0 @@
-/*
-Compare PDFs produced by polotno-node vs this library for a subset of samples.
-
-Usage examples:
-  node lib/compare-render.js --limit 10
-  node lib/compare-render.js --glob "2021-03-*"
-  node lib/compare-render.js --start 0 --end 50
-
-Outputs:
-  - builds PDFs under `comparisons/<sample>/polotno-node.pdf` and `comparisons/<sample>/current.pdf`
-  - writes a simple byte-size diff report to `comparisons/report.json`
-*/
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import { promisify } from 'util';
-import { createInstance } from 'polotno-node';
-import { pdfToPng } from 'pdf-to-png-converter';
-import pixelmatch from 'pixelmatch';
-import { PNG } from 'pngjs';
-import { jsonToPDF } from './index.js';
-const readFile = promisify(fs.readFile);
-const writeFile = promisify(fs.writeFile);
-const mkdir = promisify(fs.mkdir);
-const access = promisify(fs.access);
-const readdir = promisify(fs.readdir);
-const SAMPLES_DIR = path.resolve('./samples');
-const OUTPUT_DIR = path.resolve('./comparisons');
-function parseArgs() {
-    const args = process.argv.slice(2);
-    const result = {};
-    for (let i = 0; i < args.length; i += 1) {
-        const a = args[i];
-        if (a === '--limit')
-            result.limit = Number(args[++i]);
-        else if (a === '--start')
-            result.start = Number(args[++i]);
-        else if (a === '--end')
-            result.end = Number(args[++i]);
-        else if (a === '--glob')
-            result.glob = String(args[++i]);
-    }
-    return result;
-}
-async function tryEnsureDir(dir) {
-    try {
-        await access(dir, fs.constants.F_OK);
-    }
-    catch {
-        await mkdir(dir, { recursive: true });
-    }
-}
-function sha256(buf) {
-    return crypto.createHash('sha256').update(buf).digest('hex');
-}
-async function loadPolotnoJson(filePath) {
-    const buf = await readFile(filePath, 'utf8');
-    return JSON.parse(buf);
-}
-let polotnoInstance = null;
-async function getPolotnoInstance() {
-    if (polotnoInstance)
-        return polotnoInstance;
-    const key = process.env.POLOTNO_API_KEY || process.env.POLOTNO_API_TOKEN || '';
-    polotnoInstance = await createInstance({ key });
-    return polotnoInstance;
-}
-async function renderWithPolotnoNode(json, outPath) {
-    const instance = await getPolotnoInstance();
-    const base64 = await instance.jsonToPDFBase64(json, {
-        pixelRatio: 4,
-    });
-    await writeFile(outPath, Buffer.from(base64, 'base64'));
-}
-async function renderWithCurrent(json, outPath) {
-    await jsonToPDF(json, outPath, {});
-}
-function pickSampleDirs(allDirs, { start = 0, end, limit, glob }) {
-    let list = allDirs.filter((d) => !d.startsWith('.'));
-    if (glob) {
-        const re = new RegExp('^' + glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$');
-        list = list.filter((d) => re.test(d));
-    }
-    if (typeof start === 'number' && typeof end === 'number' && end > start) {
-        list = list.slice(start, end);
-    }
-    if (typeof limit === 'number' && limit > 0) {
-        list = list.slice(0, limit);
-    }
-    return list;
-}
-async function run() {
-    const args = parseArgs();
-    await tryEnsureDir(OUTPUT_DIR);
-    const all = await readdir(SAMPLES_DIR, { withFileTypes: true });
-    const sampleDirs = pickSampleDirs(all.filter((d) => d.isDirectory()).map((d) => d.name), args);
-    const report = [];
-    for (const dir of sampleDirs) {
-        const samplePath = path.join(SAMPLES_DIR, dir);
-        const jsonFiles = (await readdir(samplePath)).filter((f) => f.endsWith('.json') && f !== 'meta.json');
-        if (jsonFiles.length === 0)
-            continue;
-        const designPath = path.join(samplePath, jsonFiles[0]);
-        const json = await loadPolotnoJson(designPath);
-        const outDir = path.join(OUTPUT_DIR, dir);
-        await tryEnsureDir(outDir);
-        const polotnoOut = path.join(outDir, 'polotno-node.pdf');
-        const currentOut = path.join(outDir, 'current.pdf');
-        if (!fs.existsSync(polotnoOut)) {
-            // Render both
-            try {
-                await renderWithPolotnoNode(json, polotnoOut);
-            }
-            catch (e) {
-                await writeFile(path.join(outDir, 'error-polotno.txt'), String(e?.stack || e?.message || e));
-                continue;
-            }
-        }
-        try {
-            await renderWithCurrent(json, currentOut);
-        }
-        catch (e) {
-            await writeFile(path.join(outDir, 'error-current.txt'), String(e?.stack || e?.message || e));
-            continue;
-        }
-        // Rasterize first page of each PDF to PNG (via pdf-to-png-converter)
-        try {
-            const [imgA] = await pdfToPng(polotnoOut, { disableFontFace: true, viewportScale: 2, pagesToProcess: [1] });
-            const [imgB] = await pdfToPng(currentOut, { disableFontFace: true, viewportScale: 2, pagesToProcess: [1] });
-            const pngA = imgA.content;
-            const pngB = imgB.content;
-            const pngAPath = path.join(outDir, 'polotno-node.png');
-            const pngBPath = path.join(outDir, 'current.png');
-            await writeFile(pngAPath, pngA);
-            await writeFile(pngBPath, pngB);
-            // Visual diff with pixelmatch
-            const imgAParsed = PNG.sync.read(pngA);
-            const imgBParsed = PNG.sync.read(pngB);
-            const width = Math.min(imgAParsed.width, imgBParsed.width);
-            const height = Math.min(imgAParsed.height, imgBParsed.height);
-            const cropA = new PNG({ width, height });
-            const cropB = new PNG({ width, height });
-            PNG.bitblt(imgAParsed, cropA, 0, 0, width, height, 0, 0);
-            PNG.bitblt(imgBParsed, cropB, 0, 0, width, height, 0, 0);
-            const diff = new PNG({ width, height });
-            const numDiff = pixelmatch(cropA.data, cropB.data, diff.data, width, height, {
-                threshold: 0.1,
-                includeAA: true,
-            });
-            const diffPath = path.join(outDir, 'diff.png');
-            await writeFile(diffPath, PNG.sync.write(diff));
-            const a = await readFile(polotnoOut);
-            const b = await readFile(currentOut);
-            const item = {
-                sample: dir,
-                polotnoBytes: a.length,
-                currentBytes: b.length,
-                bytesDiff: Math.abs(a.length - b.length),
-                polotnoSha256: sha256(a),
-                currentSha256: sha256(b),
-                identical: numDiff === 0,
-                diffPixels: numDiff,
-                imageWidth: width,
-                imageHeight: height,
-            };
-            report.push(item);
-            await writeFile(path.join(outDir, 'summary.json'), JSON.stringify(item, null, 2));
-            console.log(`${dir}: diffPixels=${numDiff} sizeA=${item.polotnoBytes} sizeB=${item.currentBytes}`);
-        }
-        catch (e) {
-            await writeFile(path.join(outDir, 'error-diff.txt'), String(e?.stack || e?.message || e));
-        }
-    }
-    await writeFile(path.join(OUTPUT_DIR, 'report.json'), JSON.stringify(report, null, 2));
-    console.log(`Done. Compared ${report.length} samples. Report: ${path.join(OUTPUT_DIR, 'report.json')}`);
-    // Close polotno-node instance to allow process to exit
-    if (polotnoInstance) {
-        await polotnoInstance.close();
-        polotnoInstance = null;
-    }
-}
-run().catch((err) => {
-    console.error(err);
-    process.exitCode = 1;
-});

package/lib/core/index.d.ts

@@ -1,26 +0,0 @@
-import { SpotColorConfig } from '../spot-colors.js';
-export interface PolotnoJSON {
-    width: number;
-    height: number;
-    fonts: Array<{
-        fontFamily: string;
-        url: string;
-    }>;
-    pages: Array<{
-        background?: string;
-        children: any[];
-    }>;
-}
-export interface RenderAttrs {
-    pdfx1a?: boolean;
-    validate?: boolean;
-    metadata?: {
-        title?: string;
-        author?: string;
-        application?: string;
-        producer?: string;
-    };
-    spotColors?: SpotColorConfig;
-    textVerticalResizeEnabled?: boolean;
-}
-export declare function jsonToPDF(json: PolotnoJSON, pdfFileName?: string, attrs?: RenderAttrs): Promise<Blob | Uint8Array | undefined>;

package/lib/core/index.js

@@ -1,87 +0,0 @@
-import { srcToBuffer, parseColor } from '../utils.js';
-import { renderImage } from '../image.js';
-import { loadFontIfNeeded, renderText } from '../text.js';
-import { renderFigure } from '../figure.js';
-import { renderGroup } from '../group.js';
-import { lineToPDF } from '../line.js';
-import { renderSVG } from '../svg-render.js';
-import { enableSpotColorSupport } from '../spot-colors.js';
-import { getPlatformAdapter } from '../platform/adapter.js';
-async function renderElement({ doc, element, fonts, attrs, cache, }) {
-    if ((element.visible !== undefined && !element.visible) ||
-        (element.showInExport !== undefined && !element.showInExport)) {
-        return;
-    }
-    doc.save();
-    if (element.type !== 'group') {
-        doc.translate(element.x, element.y);
-        doc.rotate(element.rotation);
-    }
-    if (element.opacity !== undefined) {
-        doc.opacity(element.opacity);
-    }
-    if (element.type === 'group') {
-        await renderGroup(doc, element, renderElement, fonts, attrs, cache);
-    }
-    else if (element.type === 'text') {
-        await loadFontIfNeeded(doc, element, fonts);
-        await renderText(doc, element, fonts, attrs);
-    }
-    else if (element.type === 'line') {
-        lineToPDF(doc, element);
-    }
-    else if (element.type === 'image') {
-        await renderImage(doc, element, cache);
-    }
-    else if (element.type === 'svg') {
-        await renderSVG(doc, element, cache);
-    }
-    else if (element.type === 'figure') {
-        renderFigure(doc, element);
-    }
-    doc.restore();
-}
-export async function jsonToPDF(json, pdfFileName, attrs = {}) {
-    const fonts = {};
-    const cache = {
-        images: new Map(),
-        buffers: new Map(),
-        processedImages: new Map(),
-    };
-    const adapter = getPlatformAdapter();
-    const { doc, finalize } = adapter.createPDFContext({
-        size: [json.width, json.height],
-        autoFirstPage: false,
-    });
-    if (attrs.spotColors) {
-        enableSpotColorSupport(doc, attrs.spotColors);
-    }
-    for (const font of json.fonts) {
-        await adapter.registerFont(doc, font.fontFamily, await srcToBuffer(font.url, cache));
-        fonts[font.fontFamily] = true;
-    }
-    for (const page of json.pages) {
-        doc.addPage();
-        if (page.background) {
-            const isURL = page.background.indexOf('http') >= 0 ||
-                page.background.indexOf('.png') >= 0 ||
-                page.background.indexOf('.jpg') >= 0;
-            if (isURL) {
-                const mime = cache.buffers.get(`mime:${page.background}`);
-                await adapter.embedImage(doc, await srcToBuffer(page.background, cache), 0, 0, {
-                    cover: [json.width, json.height],
-                    align: 'center',
-                }, mime);
-            }
-            else {
-                doc.rect(0, 0, json.width, json.height);
-                doc.fill(parseColor(page.background).hex);
-            }
-        }
-        for (const element of page.children) {
-            await renderElement({ doc, element, fonts, attrs, cache });
-        }
-    }
-    doc.end();
-    return finalize({ fileName: pdfFileName, attrs });
-}

package/lib/figure.d.ts

@@ -1,10 +0,0 @@
-export interface FigureElement {
-    fill?: string;
-    stroke?: string;
-    strokeWidth: number;
-    opacity: number;
-    width: number;
-    height: number;
-    [key: string]: any;
-}
-export declare function renderFigure(doc: any, element: FigureElement): void;

package/lib/figure.js

@@ -1,54 +0,0 @@
-import { parseColor } from './utils.js';
-import { figureToSvg } from 'polotno/utils/figure-to-svg';
-export function renderFigure(doc, element) {
-    const svgStr = figureToSvg({
-        ...element,
-        fill: (() => {
-            if (!element.fill)
-                return 'transparent';
-            const color = parseColor(element.fill);
-            if (!color || !color.rgba)
-                return element.fill;
-            let oldOpacity = color.rgba[3] || 1;
-            // Normalize opacity to 0-1 range if it's greater than 1
-            if (oldOpacity > 1) {
-                oldOpacity = oldOpacity / 100;
-            }
-            const rgba = color.rgba
-                .slice(0, 3)
-                .concat(oldOpacity * element.opacity)
-                .join(',');
-            return `rgba(${rgba})`;
-        })(),
-        stroke: (() => {
-            if (!element.stroke || element.strokeWidth === 0)
-                return 'none';
-            const color = parseColor(element.stroke);
-            if (!color || !color.rgba)
-                return element.stroke;
-            let oldOpacity = color.rgba[3] || 1;
-            // Normalize opacity to 0-1 range if it's greater than 1
-            if (oldOpacity > 1) {
-                oldOpacity = oldOpacity / 100;
-            }
-            const rgba = color.rgba
-                .slice(0, 3)
-                .concat(oldOpacity * element.opacity)
-                .join(',');
-            return `rgba(${rgba})`;
-        })(),
-    });
-    doc.addSVG(svgStr, 0, 0, {
-        preserveAspectRatio: 'xMinYMin meet',
-        width: element.width,
-        height: element.height,
-        opacity: element.opacity,
-        colorCallback: (colors) => {
-            if (!colors) {
-                return colors;
-            }
-            const [color, opacity] = colors;
-            return [color, opacity * element.opacity];
-        },
-    });
-}

package/lib/filters.d.ts

@@ -1,2 +0,0 @@
-import { Filter } from "konva/lib/Node";
-export declare const elementFilterToKonva: Record<string, (intensity: number) => Filter>;

package/lib/filters.js

@@ -1,163 +0,0 @@
-export const elementFilterToKonva = {
-    warm: (intensity) => (imageData) => {
-        const data = imageData.data; // Access pixel data
-        // Intensity should be in 0-1 range from the model
-        intensity = Math.max(0, Math.min(1, intensity));
-        for (let i = 0; i < data.length; i += 4) {
-            // Increase red and green values for a warm effect
-            data[i] = Math.min(data[i] + 30 * intensity, 255); // Red channel
-            data[i + 1] = Math.min(data[i + 1] + 15 * intensity, 255); // Green channel
-            // Leave blue unchanged for a warm tone
-        }
-        return imageData;
-    },
-    cold: (intensity) => (imageData) => {
-        const data = imageData.data; // Access pixel data
-        // Intensity should be in 0-1 range from the model
-        intensity = Math.max(0, Math.min(1, intensity));
-        for (let i = 0; i < data.length; i += 4) {
-            // Adjust red, green, and blue channels
-            data[i] = Math.min(data[i] - 15 * intensity, 255); // Reduce red
-            data[i + 1] = Math.min(data[i + 1] - 10 * intensity, 255); // Slightly reduce green
-            data[i + 2] = Math.min(data[i + 2] + 15 * intensity, 255); // Boost blue
-        }
-        return imageData;
-    },
-    natural: (intensity) => (imageData) => {
-        const data = imageData.data; // Access pixel data
-        // Intensity should be in 0-1 range from the model
-        intensity = Math.max(0, Math.min(1, intensity));
-        for (let i = 0; i < data.length; i += 4) {
-            // Adjust each channel (R, G, B)
-            data[i] = Math.min(data[i] * (1 + 0.1 * intensity), 255); // Enhance red
-            data[i + 1] = Math.min(data[i + 1] * (1 + 0.1 * intensity), 255); // Enhance green
-            data[i + 2] = Math.min(data[i + 2] * (1 + 0.1 * intensity), 255); // Enhance blue
-            // Increase contrast based on intensity
-            const average = (data[i] + data[i + 1] + data[i + 2]) / 3;
-            data[i] = Math.min((data[i] - average) * (1 + 0.2 * intensity) + average, 255);
-            data[i + 1] = Math.min((data[i + 1] - average) * (1 + 0.2 * intensity) + average, 255);
-            data[i + 2] = Math.min((data[i + 2] - average) * (1 + 0.2 * intensity) + average, 255);
-        }
-        return imageData;
-    },
-    temperature: (intensity) => (imageData) => {
-        const data = imageData.data;
-        // Intensity should be in -1 to 1 range from the model
-        intensity = Math.max(-1, Math.min(1, intensity));
-        for (let i = 0; i < data.length; i += 4) {
-            const r = data[i];
-            const g = data[i + 1];
-            const b = data[i + 2];
-            // Adjust red and blue channels based on temperature
-            // Warmer = more red, less blue
-            // Colder = more blue, less red
-            data[i] = Math.min(Math.max(r + 15 * intensity, 0), 255); // Red channel
-            data[i + 2] = Math.min(Math.max(b - 15 * intensity, 0), 255); // Blue channel
-            // Optionally: slight tweak to green for balance (optional)
-            // data[i + 1] = Math.min(Math.max(g + 10 * intensity, 0), 255);
-        }
-        return imageData;
-    },
-    contrast: (intensity) => (imageData) => {
-        const data = imageData.data;
-        // Intensity should be in -1 to 1 range from the model
-        intensity = Math.max(-1, Math.min(1, intensity));
-        // Convert intensity to a contrast factor
-        // Scale from -1,1 to -100,100 for the formula
-        const scaledIntensity = intensity * 100;
-        const factor = (259 * (scaledIntensity + 255)) / (255 * (259 - scaledIntensity));
-        for (let i = 0; i < data.length; i += 4) {
-            // Apply contrast formula to R, G, B channels
-            data[i] = Math.min(Math.max(factor * (data[i] - 128) + 128, 0), 255); // Red
-            data[i + 1] = Math.min(Math.max(factor * (data[i + 1] - 128) + 128, 0), 255); // Green
-            data[i + 2] = Math.min(Math.max(factor * (data[i + 2] - 128) + 128, 0), 255); // Blue
-        }
-        return imageData;
-    },
-    shadows: (intensity) => (imageData) => {
-        const data = imageData.data;
-        // Intensity should be in -1 to 1 range from the model
-        intensity = Math.max(-1, Math.min(1, intensity));
-        for (let i = 0; i < data.length; i += 4) {
-            // Compute brightness as average of R, G, B
-            const brightness = (data[i] + data[i + 1] + data[i + 2]) / 3;
-            // Only affect pixels in shadow range (brightness < 128)
-            if (brightness < 128) {
-                const factor = 1 + intensity * (1 - brightness / 128) * 2; // More adjustment for darker pixels
-                data[i] = Math.min(Math.max(data[i] * factor, 0), 255); // Red
-                data[i + 1] = Math.min(Math.max(data[i + 1] * factor, 0), 255); // Green
-                data[i + 2] = Math.min(Math.max(data[i + 2] * factor, 0), 255); // Blue
-            }
-        }
-        return imageData;
-    },
-    white: (intensity) => (imageData) => {
-        const data = imageData.data;
-        // Intensity should be in -1 to 1 range from the model
-        intensity = Math.max(-1, Math.min(1, intensity));
-        for (let i = 0; i < data.length; i += 4) {
-            const r = data[i];
-            const g = data[i + 1];
-            const b = data[i + 2];
-            const brightness = (r + g + b) / 3;
-            if (brightness > 128) {
-                const factor = 1 + intensity * ((brightness - 128) / 127); // stronger effect on brighter pixels
-                data[i] = Math.min(Math.max(r * factor, 0), 255);
-                data[i + 1] = Math.min(Math.max(g * factor, 0), 255);
-                data[i + 2] = Math.min(Math.max(b * factor, 0), 255);
-            }
-        }
-        return imageData;
-    },
-    black: (intensity) => (imageData) => {
-        const data = imageData.data;
-        // Intensity should be in -1 to 1 range from the model
-        intensity = Math.max(-1, Math.min(1, intensity));
-        for (let i = 0; i < data.length; i += 4) {
-            const r = data[i];
-            const g = data[i + 1];
-            const b = data[i + 2];
-            const brightness = (r + g + b) / 3;
-            if (brightness < 128) {
-                const factor = 1 + intensity * ((128 - brightness) / 128); // stronger effect on darker pixels
-                data[i] = Math.min(Math.max(r * factor, 0), 255);
-                data[i + 1] = Math.min(Math.max(g * factor, 0), 255);
-                data[i + 2] = Math.min(Math.max(b * factor, 0), 255);
-            }
-        }
-        return imageData;
-    },
-    vibrance: (intensity) => (imageData) => {
-        const data = imageData.data;
-        // Intensity should be in -1 to 1 range from the model
-        intensity = Math.max(-1, Math.min(1, intensity));
-        for (let i = 0; i < data.length; i += 4) {
-            const r = data[i];
-            const g = data[i + 1];
-            const b = data[i + 2];
-            const max = Math.max(r, g, b);
-            const avg = (r + g + b) / 3;
-            const saturation = max === 0 ? 0 : (max - avg) / max;
-            const factor = intensity < 0 ? (1 - saturation) * intensity * 1.5 : intensity * 0.5;
-            data[i] = Math.min(Math.max(r - (max - r) * factor, 0), 255);
-            data[i + 1] = Math.min(Math.max(g - (max - g) * factor, 0), 255);
-            data[i + 2] = Math.min(Math.max(b - (max - b) * factor, 0), 255);
-        }
-        return imageData;
-    },
-    saturation: (intensity) => (imageData) => {
-        const data = imageData.data;
-        // Intensity should be in -1 to 1 range from the model
-        intensity = Math.max(-1, Math.min(1, intensity));
-        for (let i = 0; i < data.length; i += 4) {
-            const r = data[i];
-            const g = data[i + 1];
-            const b = data[i + 2];
-            const gray = 0.2126 * r + 0.7152 * g + 0.0722 * b;
-            data[i] = Math.min(Math.max(gray + (r - gray) * (1 + intensity), 0), 255);
-            data[i + 1] = Math.min(Math.max(gray + (g - gray) * (1 + intensity), 0), 255);
-            data[i + 2] = Math.min(Math.max(gray + (b - gray) * (1 + intensity), 0), 255);
-        }
-        return imageData;
-    },
-};

package/lib/ghostscript.d.ts

@@ -1,21 +0,0 @@
-export interface PDFXMetadata {
-    title?: string;
-    author?: string;
-    application?: string;
-    producer?: string;
-}
-export interface ConversionOptions {
-    metadata?: PDFXMetadata;
-}
-/**
- * Convert PDF to PDF/X-1a using GhostScript
- * @param inputPath - Path to input PDF
- * @param outputPath - Path to output PDF/X-1a file
- * @param options - Conversion options
- */
-export declare function convertToPDFX1a(inputPath: string, outputPath: string, options?: ConversionOptions): Promise<void>;
-/**
- * Validate if PDF is PDF/X-1a compliant
- * @param pdfPath - Path to PDF file
- */
-export declare function validatePDFX1a(pdfPath: string): Promise<boolean>;

package/lib/ghostscript.js

@@ -1,132 +0,0 @@
-import { spawn } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-/**
- * Convert PDF to PDF/X-1a using GhostScript
- * @param inputPath - Path to input PDF
- * @param outputPath - Path to output PDF/X-1a file
- * @param options - Conversion options
- */
-export async function convertToPDFX1a(inputPath, outputPath, options = {}) {
-    return new Promise((resolve, reject) => {
-        // PDF/X-1a conversion parameters with stroke preservation
-        const args = [
-            '-dNOPAUSE',
-            '-dBATCH',
-            '-dSAFER',
-            '-sDEVICE=pdfwrite',
-            '-dCompatibilityLevel=1.3',
-            '-dPDFX=true',
-            '-dColorConversionStrategy=/CMYK',
-            '-dProcessColorModel=/DeviceCMYK',
-            '-dUseCIEColor=true',
-            '-sColorConversionStrategy=CMYK',
-            '-sProcessColorModel=DeviceCMYK',
-            '-dOverrideICC=true',
-            // Preserve text rendering modes and strokes
-            '-dPreserveAnnots=true',
-            '-dPreserveCopyPage=true',
-            '-dPreserveDeviceN=true', // IMPORTANT: Preserves spot/separation colors
-            '-dDoThumbnails=false',
-            '-dDetectDuplicateImages=true', // Enable duplicate image detection
-            '-dCompressFonts=true', // Enable font compression
-            '-dSubsetFonts=true', // Subset fonts to reduce size
-            '-dEmbedAllFonts=true',
-            // Better handling of text rendering modes
-            '-dPDFSETTINGS=/prepress',
-            `-sOutputFile=${outputPath}`,
-            inputPath,
-        ];
-        // Add custom metadata if provided
-        if (options.metadata) {
-            // Create temporary PostScript file with metadata
-            const psMetadata = createMetadataPS(options.metadata);
-            const tempPSFile = path.join(path.dirname(outputPath), 'metadata.ps');
-            fs.writeFileSync(tempPSFile, psMetadata);
-            args.splice(-1, 0, tempPSFile); // Insert before input file
-        }
-        const gs = spawn('gs', args);
-        let stderr = '';
-        gs.stderr.on('data', (data) => {
-            stderr += data.toString();
-        });
-        gs.on('close', (code) => {
-            // Clean up temp metadata file
-            if (options.metadata) {
-                const tempPSFile = path.join(path.dirname(outputPath), 'metadata.ps');
-                if (fs.existsSync(tempPSFile)) {
-                    fs.unlinkSync(tempPSFile);
-                }
-            }
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`GhostScript failed with code ${code}: ${stderr}`));
-            }
-        });
-        gs.on('error', (error) => {
-            reject(new Error(`Failed to start GhostScript: ${error.message}`));
-        });
-    });
-}
-/**
- * Create PostScript metadata for PDF/X-1a
- * @param metadata - Metadata object
- * @returns PostScript code
- */
-function createMetadataPS(metadata) {
-    const { title = 'Cover Creator Export', author = 'KDP Cover Creator', application = 'KDP CoverCreator', producer = 'Polotno PDF Export', } = metadata;
-    return `
-%!PS
-% PDF/X-1a Metadata
-[/Title (${title})
- /Author (${author})
- /Creator (${application})
- /Producer (${producer})
- /CreationDate (D:${new Date().toISOString().replace(/[-:]/g, '').slice(0, 14)})
- /ModDate (D:${new Date().toISOString().replace(/[-:]/g, '').slice(0, 14)})
- /DOCINFO pdfmark
-
-% Output Intent for PDF/X-1a
-[/OutputIntent
- /GTS_PDFX
- /Info (PDF/X-1a Output Intent)
- /OutputConditionIdentifier (CGATS TR 001)
- /RegistryName (http://www.color.org)
- /PDFX pdfmark
-`;
-}
-/**
- * Validate if PDF is PDF/X-1a compliant
- * @param pdfPath - Path to PDF file
- */
-export async function validatePDFX1a(pdfPath) {
-    return new Promise((resolve, reject) => {
-        const args = [
-            '-dNOPAUSE',
-            '-dBATCH',
-            '-sDEVICE=nullpage',
-            '-dPDFX=true',
-            pdfPath,
-        ];
-        const gs = spawn('gs', args);
-        let stderr = '';
-        gs.stderr.on('data', (data) => {
-            stderr += data.toString();
-        });
-        gs.on('close', (code) => {
-            if (code === 0 &&
-                !stderr.includes('Error') &&
-                !stderr.includes('Warning')) {
-                resolve(true);
-            }
-            else {
-                resolve(false);
-            }
-        });
-        gs.on('error', (error) => {
-            reject(new Error(`Failed to validate PDF: ${error.message}`));
-        });
-    });
-}