@polotno/pdf-export 0.1.38 → 0.1.40

package/lib/pdf-import/text-analysis.js

@@ -1,186 +0,0 @@
-import { extractPosition, extractRotation, pdfToPolotnoX, pdfToPolotnoY, pdfColorToHex, } from './coordinate-transform.js';
-import { mapFont } from './font-mapper.js';
-/**
- * Sort text items by position (top-to-bottom, left-to-right)
- */
-export function sortTextItems(items, pageHeight) {
-    return items.sort((a, b) => {
-        const posA = extractPosition(a.transform);
-        const posB = extractPosition(b.transform);
-        // Convert PDF Y (bottom-origin) to top-origin for comparison
-        const yA = pageHeight - posA.y;
-        const yB = pageHeight - posB.y;
-        // Same line threshold (5 pixels)
-        const lineThreshold = 5;
-        if (Math.abs(yA - yB) < lineThreshold) {
-            // Same line, sort by X (left to right)
-            return posA.x - posB.x;
-        }
-        // Different lines, sort by Y (top to bottom)
-        return yA - yB;
-    });
-}
-/**
- * Check if two text items should be in the same block based on proximity and font
- */
-function shouldMerge(item1, item2, pageHeight, options) {
-    const pos1 = extractPosition(item1.transform);
-    const pos2 = extractPosition(item2.transform);
-    // Get thresholds from options
-    const verticalThreshold = item1.fontSize; // options.textClusterThreshold?.vertical ?? 20;
-    const horizontalThreshold = options.textClusterThreshold?.horizontal ?? 10;
-    // Convert PDF Y to top-origin
-    const y1 = pageHeight - pos1.y;
-    const y2 = pageHeight - pos2.y;
-    // Check vertical distance
-    const verticalDistance = Math.abs(y1 - y2);
-    if (verticalDistance > verticalThreshold) {
-        return false;
-    }
-    // Check horizontal distance (for same line)
-    const horizontalDistance = Math.abs(pos2.x - (pos1.x + item1.width));
-    if (verticalDistance < 5 && horizontalDistance > horizontalThreshold) {
-        return false;
-    }
-    // Check font consistency
-    if (item1.fontName !== item2.fontName) {
-        return false;
-    }
-    // Check font size consistency (within 1pt tolerance)
-    if (Math.abs((item1.fontSize || 0) - (item2.fontSize || 0)) > 1) {
-        return false;
-    }
-    return true;
-}
-/**
- * Cluster text items into text blocks
- */
-export function clusterTextItems(items, pageHeight, pageWidth, options) {
-    if (items.length === 0) {
-        return [];
-    }
-    // Sort items first
-    const sortedItems = sortTextItems(items, pageHeight);
-    // Filter out items that are too small
-    const minSize = options.minTextBlockSize ?? 8;
-    const filteredItems = sortedItems.filter(item => (item.fontSize || 0) >= minSize);
-    if (filteredItems.length === 0) {
-        return [];
-    }
-    const blocks = [];
-    let currentBlock = [filteredItems[0]];
-    for (let i = 1; i < filteredItems.length; i++) {
-        const prevItem = filteredItems[i - 1];
-        const currentItem = filteredItems[i];
-        if (shouldMerge(prevItem, currentItem, pageHeight, options)) {
-            // Add to current block
-            currentBlock.push(currentItem);
-        }
-        else {
-            // Finalize current block and start new one
-            if (currentBlock.length > 0) {
-                blocks.push(createTextBlock(currentBlock, pageHeight, options));
-            }
-            currentBlock = [currentItem];
-        }
-    }
-    // Don't forget the last block
-    if (currentBlock.length > 0) {
-        blocks.push(createTextBlock(currentBlock, pageHeight, options));
-    }
-    return blocks;
-}
-/**
- * Create a text block from a cluster of text items
- */
-function createTextBlock(items, pageHeight, options) {
-    // Combine text with proper spacing
-    let text = '';
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        text += item.str;
-        // Add space if needed (not at end, and next item doesn't start with space)
-        if (i < items.length - 1) {
-            const nextItem = items[i + 1];
-            const pos = extractPosition(item.transform);
-            const nextPos = extractPosition(nextItem.transform);
-            // Check if items are on same line
-            const y = pageHeight - pos.y;
-            const nextY = pageHeight - nextPos.y;
-            if (Math.abs(y - nextY) < 5) {
-                // Same line - add space if there's a gap
-                const gap = nextPos.x - (pos.x + item.width);
-                if (gap > 2 && !nextItem.str.startsWith(' ') && !item.str.endsWith(' ')) {
-                    text += ' ';
-                }
-            }
-            else {
-                // Different line - add newline
-                if (!text.endsWith('\n')) {
-                    text += '\n';
-                }
-            }
-        }
-    }
-    // Calculate bounding box
-    const positions = items.map(item => extractPosition(item.transform));
-    const minX = Math.min(...positions.map(p => p.x));
-    const maxX = Math.max(...items.map((item, i) => positions[i].x + item.width));
-    const minY = Math.min(...positions.map(p => p.y));
-    const maxY = Math.max(...items.map((item, i) => positions[i].y + item.height));
-    const width = maxX - minX;
-    const height = maxY - minY;
-    // Use first item for font properties
-    const firstItem = items[0];
-    const fontSize = firstItem.fontSize || 12;
-    const rotation = extractRotation(firstItem.transform);
-    // Map font
-    const mappedFont = mapFont(firstItem.fontName, options.fontMapping);
-    // Extract color
-    const color = pdfColorToHex(firstItem.color || [0, 0, 0]);
-    // Transform coordinates
-    const x = pdfToPolotnoX(minX);
-    const y = pdfToPolotnoY(minY, height, pageHeight);
-    return {
-        text,
-        x,
-        y,
-        width,
-        height,
-        fontName: mappedFont.family,
-        fontSize,
-        fontWeight: mappedFont.weight,
-        fontStyle: mappedFont.style,
-        color,
-        rotation,
-        align: 'left', // Default to left alignment
-    };
-}
-/**
- * Detect text alignment based on position within page
- */
-export function detectAlignment(block, pageWidth) {
-    const blockCenter = block.x + block.width / 2;
-    const pageCenter = pageWidth / 2;
-    // Check if block is centered (within 10% of page width)
-    const centerThreshold = pageWidth * 0.1;
-    if (Math.abs(blockCenter - pageCenter) < centerThreshold) {
-        return 'center';
-    }
-    // Check if block is right-aligned (within 10% of right edge)
-    const rightEdge = pageWidth;
-    if (Math.abs(block.x + block.width - rightEdge) < centerThreshold) {
-        return 'right';
-    }
-    // Default to left
-    return 'left';
-}
-/**
- * Apply alignment detection to all blocks
- */
-export function applyAlignmentDetection(blocks, pageWidth) {
-    return blocks.map(block => ({
-        ...block,
-        align: detectAlignment(block, pageWidth),
-    }));
-}

package/lib/pdf-import/types.d.ts

@@ -1,101 +0,0 @@
-/**
- * Options for PDF to JSON conversion
- */
-export interface PDFImportOptions {
-    pageNumbers?: number[];
-    imageMode?: 'dataURL' | 'upload';
-    imageUploadFn?: (buffer: Buffer, mimeType: string) => Promise<string>;
-    fontMapping?: Record<string, string>;
-    minTextBlockSize?: number;
-    textClusterThreshold?: {
-        vertical?: number;
-        horizontal?: number;
-    };
-    outputUnit?: 'px' | 'cm' | 'in';
-    dpi?: number;
-}
-/**
- * Raw text item extracted from PDF with position and font metadata
- */
-export interface PDFTextItem {
-    str: string;
-    transform: number[];
-    width: number;
-    height: number;
-    fontName: string;
-    fontSize?: number;
-    hasEOL?: boolean;
-    dir?: string;
-    color?: number[];
-}
-/**
- * Clustered text block representing a semantic unit
- */
-export interface TextBlock {
-    text: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    fontName: string;
-    fontSize: number;
-    fontWeight: string;
-    fontStyle: string;
-    color: string;
-    rotation: number;
-    align?: string;
-}
-/**
- * Raw image object extracted from PDF
- */
-export interface PDFImageObject {
-    buffer: Buffer;
-    mimeType: string;
-    width: number;
-    height: number;
-    transform: number[];
-}
-/**
- * Polotno image element ready for JSON
- */
-export interface ImageBlock {
-    src: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rotation: number;
-}
-/**
- * Parsed font information from PDF font name
- */
-export interface ParsedFont {
-    family: string;
-    weight: string;
-    style: string;
-}
-/**
- * Coordinate transformation context
- */
-export interface CoordinateContext {
-    pageHeight: number;
-    pageWidth: number;
-    rotation?: number;
-}
-/**
- * PDF page metadata
- */
-export interface PDFPageMetadata {
-    pageNumber: number;
-    width: number;
-    height: number;
-    rotate?: number;
-}
-/**
- * Result of PDF parsing for one page
- */
-export interface ParsedPage {
-    metadata: PDFPageMetadata;
-    textItems: PDFTextItem[];
-    images: PDFImageObject[];
-}

package/lib/pdf-import/types.js

@@ -1 +0,0 @@
-export {};

package/lib/scripts/compare-json.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/scripts/compare-json.js

@@ -1,141 +0,0 @@
-import fs from 'fs';
-function compareImages(original, converted, index) {
-    const differences = [];
-    // Compare position
-    const xDiff = Math.abs(original.x - converted.x);
-    const yDiff = Math.abs(original.y - converted.y);
-    if (xDiff > 1) {
-        differences.push(`  X: ${original.x.toFixed(2)} → ${converted.x.toFixed(2)} (Δ ${(converted.x - original.x).toFixed(2)})`);
-    }
-    if (yDiff > 1) {
-        differences.push(`  Y: ${original.y.toFixed(2)} → ${converted.y.toFixed(2)} (Δ ${(converted.y - original.y).toFixed(2)})`);
-    }
-    // Compare dimensions
-    const widthDiff = Math.abs(original.width - converted.width);
-    const heightDiff = Math.abs(original.height - converted.height);
-    if (widthDiff > 1) {
-        differences.push(`  Width: ${original.width.toFixed(2)} → ${converted.width.toFixed(2)} (Δ ${(converted.width - original.width).toFixed(2)})`);
-    }
-    if (heightDiff > 1) {
-        differences.push(`  Height: ${original.height.toFixed(2)} → ${converted.height.toFixed(2)} (Δ ${(converted.height - original.height).toFixed(2)})`);
-    }
-    // Compare rotation
-    const origRotation = original.rotation || 0;
-    const convRotation = converted.rotation || 0;
-    if (Math.abs(origRotation - convRotation) > 0.1) {
-        differences.push(`  Rotation: ${origRotation} → ${convRotation}`);
-    }
-    return differences;
-}
-function compareJSON(originalPath, convertedPath) {
-    console.log('='.repeat(80));
-    console.log('PDF Import Comparison Tool');
-    console.log('='.repeat(80));
-    console.log();
-    // Read JSON files
-    const original = JSON.parse(fs.readFileSync(originalPath, 'utf-8'));
-    const converted = JSON.parse(fs.readFileSync(convertedPath, 'utf-8'));
-    // Compare document dimensions
-    console.log('📄 Document Dimensions:');
-    console.log(`  Original:  ${original.width.toFixed(2)} x ${original.height.toFixed(2)}`);
-    console.log(`  Converted: ${converted.width.toFixed(2)} x ${converted.height.toFixed(2)}`);
-    const dimMatch = Math.abs(original.width - converted.width) < 1 &&
-        Math.abs(original.height - converted.height) < 1;
-    console.log(`  Status: ${dimMatch ? '✅ Match' : '❌ Mismatch'}`);
-    console.log();
-    // Compare page count
-    console.log('📑 Page Count:');
-    console.log(`  Original:  ${original.pages.length}`);
-    console.log(`  Converted: ${converted.pages.length}`);
-    console.log(`  Status: ${original.pages.length === converted.pages.length ? '✅ Match' : '❌ Mismatch'}`);
-    console.log();
-    // Compare each page
-    const maxPages = Math.max(original.pages.length, converted.pages.length);
-    for (let pageIdx = 0; pageIdx < maxPages; pageIdx++) {
-        console.log(`${'─'.repeat(80)}`);
-        console.log(`Page ${pageIdx + 1}:`);
-        console.log(`${'─'.repeat(80)}`);
-        const origPage = original.pages[pageIdx];
-        const convPage = converted.pages[pageIdx];
-        if (!origPage || !convPage) {
-            console.log('❌ Page missing in one of the documents');
-            console.log();
-            continue;
-        }
-        // Filter to only image elements for comparison
-        const origImages = origPage.children.filter(el => el.type === 'image');
-        const convImages = convPage.children.filter(el => el.type === 'image');
-        console.log();
-        console.log(`🖼️  Image Elements:`);
-        console.log(`  Original:  ${origImages.length} images`);
-        console.log(`  Converted: ${convImages.length} images`);
-        console.log();
-        // Compare each image
-        const maxImages = Math.max(origImages.length, convImages.length);
-        for (let imgIdx = 0; imgIdx < maxImages; imgIdx++) {
-            const origImg = origImages[imgIdx];
-            const convImg = convImages[imgIdx];
-            console.log(`  Image ${imgIdx + 1}:`);
-            if (!origImg) {
-                console.log('    ❌ Missing in original');
-                console.log();
-                continue;
-            }
-            if (!convImg) {
-                console.log('    ❌ Missing in converted');
-                console.log();
-                continue;
-            }
-            // Show original values
-            console.log(`    Original:  x=${origImg.x.toFixed(2)}, y=${origImg.y.toFixed(2)}, w=${origImg.width.toFixed(2)}, h=${origImg.height.toFixed(2)}`);
-            console.log(`    Converted: x=${convImg.x.toFixed(2)}, y=${convImg.y.toFixed(2)}, w=${convImg.width.toFixed(2)}, h=${convImg.height.toFixed(2)}`);
-            // Compare and show differences
-            const differences = compareImages(origImg, convImg, imgIdx);
-            if (differences.length === 0) {
-                console.log('    ✅ Perfect match');
-            }
-            else {
-                console.log('    ❌ Differences:');
-                differences.forEach(diff => console.log(`    ${diff}`));
-            }
-            console.log();
-        }
-        // Compare text elements
-        const origTexts = origPage.children.filter(el => el.type === 'text');
-        const convTexts = convPage.children.filter(el => el.type === 'text');
-        if (origTexts.length > 0 || convTexts.length > 0) {
-            console.log(`📝 Text Elements:`);
-            console.log(`  Original:  ${origTexts.length} text elements`);
-            console.log(`  Converted: ${convTexts.length} text elements`);
-            console.log();
-        }
-        // Show other element types
-        const origOther = origPage.children.filter(el => el.type !== 'image' && el.type !== 'text');
-        const convOther = convPage.children.filter(el => el.type !== 'image' && el.type !== 'text');
-        if (origOther.length > 0 || convOther.length > 0) {
-            console.log(`🔧 Other Elements:`);
-            console.log(`  Original:  ${origOther.length} elements`);
-            console.log(`  Converted: ${convOther.length} elements`);
-            console.log();
-        }
-    }
-    console.log('='.repeat(80));
-}
-// CLI usage
-const args = process.argv.slice(2);
-if (args.length < 2) {
-    console.log('Usage: npm run compare-json <original.json> <converted.json>');
-    console.log('Example: npm run compare-json tests/files/pdf-img-design.json tests/files/pdf-img-converted.json');
-    process.exit(1);
-}
-const [originalPath, convertedPath] = args;
-// Check files exist
-if (!fs.existsSync(originalPath)) {
-    console.error(`Error: Original file not found: ${originalPath}`);
-    process.exit(1);
-}
-if (!fs.existsSync(convertedPath)) {
-    console.error(`Error: Converted file not found: ${convertedPath}`);
-    process.exit(1);
-}
-compareJSON(originalPath, convertedPath);

package/lib/spot-colors.d.ts

@@ -1,38 +0,0 @@
-export interface SpotColorDefinition {
-    name?: string;
-    cmyk?: number[];
-}
-export interface SpotColorConfig {
-    [color: string]: SpotColorDefinition;
-}
-/**
- * Normalize color to a consistent format for matching using Konva's color parser
- * This ensures consistency with how Polotno/Konva handles colors
- * @param color - Color in any format (string or [r, g, b, a] array)
- * @returns Normalized color string in rgba format
- */
-export declare function normalizeColor(color: string | number[]): string | null;
-/**
- * Get spot color definition for a given color
- * @param color - Color to check
- * @param spotColorConfig - Spot color configuration
- * @returns Spot color definition or null
- */
-export declare function getSpotColorForColor(color: string, spotColorConfig: SpotColorConfig): SpotColorDefinition | null;
-/**
- * Register a spot color using PDFKit's built-in addSpotColor method
- * @param doc - PDFKit document
- * @param spotName - Name of the spot color
- * @param spotColorDef - Spot color definition with CMYK fallback
- * @returns Reference to the registered spot color
- */
-export declare function registerSpotColor(doc: any, spotName: string, spotColorDef: SpotColorDefinition): {
-    name: string;
-    cmyk: number[];
-};
-/**
- * Enable spot color support on a PDFDocument by intercepting color methods
- * @param doc - PDFKit document
- * @param spotColorConfig - Spot color configuration mapping
- */
-export declare function enableSpotColorSupport(doc: any, spotColorConfig: SpotColorConfig): void;

package/lib/spot-colors.js

@@ -1,141 +0,0 @@
-import { Util } from 'konva/lib/Util.js';
-/**
- * Normalize color to a consistent format for matching using Konva's color parser
- * This ensures consistency with how Polotno/Konva handles colors
- * @param color - Color in any format (string or [r, g, b, a] array)
- * @returns Normalized color string in rgba format
- */
-export function normalizeColor(color) {
-    if (!color) {
-        return null;
-    }
-    try {
-        // Handle array format [r, g, b, a]
-        if (Array.isArray(color)) {
-            const r = Math.round(color[0]);
-            const g = Math.round(color[1]);
-            const b = Math.round(color[2]);
-            const a = color[3] !== undefined ? color[3] : 1;
-            return `rgba(${r},${g},${b},${a})`;
-        }
-        // Handle string format
-        if (typeof color !== 'string') {
-            return null;
-        }
-        // Use Konva's colorToRGBA for consistent color parsing
-        const rgba = Util.colorToRGBA(color);
-        if (!rgba) {
-            return null;
-        }
-        // Konva returns {r, g, b, a} object
-        // Normalize to rgba string format
-        return `rgba(${rgba.r},${rgba.g},${rgba.b},${rgba.a})`;
-    }
-    catch (error) {
-        return null;
-    }
-}
-/**
- * Get spot color definition for a given color
- * @param color - Color to check
- * @param spotColorConfig - Spot color configuration
- * @returns Spot color definition or null
- */
-export function getSpotColorForColor(color, spotColorConfig) {
-    if (!spotColorConfig || !color) {
-        return null;
-    }
-    const normalizedColor = normalizeColor(color);
-    if (!normalizedColor) {
-        return null;
-    }
-    // Check direct match first
-    if (spotColorConfig[color]) {
-        return spotColorConfig[color];
-    }
-    // Check normalized match
-    if (spotColorConfig[normalizedColor]) {
-        return spotColorConfig[normalizedColor];
-    }
-    // Check all configured colors with normalization
-    for (const [configColor, definition] of Object.entries(spotColorConfig)) {
-        const normalizedConfigColor = normalizeColor(configColor);
-        if (normalizedConfigColor === normalizedColor) {
-            return definition;
-        }
-    }
-    return null;
-}
-/**
- * Register a spot color using PDFKit's built-in addSpotColor method
- * @param doc - PDFKit document
- * @param spotName - Name of the spot color
- * @param spotColorDef - Spot color definition with CMYK fallback
- * @returns Reference to the registered spot color
- */
-export function registerSpotColor(doc, spotName, spotColorDef) {
-    const { cmyk = [0, 0, 0, 1] } = spotColorDef;
-    // Convert CMYK from 0-1 range to 0-100 percentage range for PDFKit
-    const c = Math.max(0, Math.min(100, cmyk[0] * 100));
-    const m = Math.max(0, Math.min(100, cmyk[1] * 100));
-    const y = Math.max(0, Math.min(100, cmyk[2] * 100));
-    const k = Math.max(0, Math.min(100, cmyk[3] * 100));
-    // Sanitize spot color name for PDF (no spaces or special characters)
-    const sanitizedName = spotName.replace(/[^a-zA-Z0-9-_]/g, '_');
-    // Use PDFKit's built-in spot color support
-    doc.addSpotColor(sanitizedName, c, m, y, k);
-    return {
-        name: sanitizedName,
-        cmyk: [c / 100, m / 100, y / 100, k / 100], // Store in 0-1 range
-    };
-}
-/**
- * Enable spot color support on a PDFDocument by intercepting color methods
- * @param doc - PDFKit document
- * @param spotColorConfig - Spot color configuration mapping
- */
-export function enableSpotColorSupport(doc, spotColorConfig) {
-    if (!spotColorConfig || Object.keys(spotColorConfig).length === 0) {
-        return;
-    }
-    // Store configuration and registered spot colors on the document
-    doc._spotColors = new Map();
-    doc._spotColorConfig = spotColorConfig;
-    // Register all spot colors using PDFKit's built-in addSpotColor method
-    for (const [color, definition] of Object.entries(spotColorConfig)) {
-        const spotName = definition.name || `Spot_${color}`;
-        const registered = registerSpotColor(doc, spotName, definition);
-        // Cache the registered color definition
-        const normalizedColor = normalizeColor(color);
-        doc._spotColors.set(normalizedColor, registered);
-        doc._spotColors.set(color, registered); // Also store original format
-    }
-    // Intercept fillColor method to automatically use spot colors
-    const originalFillColor = doc.fillColor.bind(doc);
-    doc.fillColor = function (color, opacity) {
-        const spotColorDef = getSpotColorForColor(color, spotColorConfig);
-        if (spotColorDef) {
-            const normalizedColor = normalizeColor(color);
-            const registered = doc._spotColors.get(normalizedColor) || doc._spotColors.get(color);
-            if (registered) {
-                // Use PDFKit's fillColor with the spot color name directly
-                return originalFillColor(registered.name, opacity);
-            }
-        }
-        return originalFillColor(color, opacity);
-    };
-    // Intercept strokeColor method to automatically use spot colors
-    const originalStrokeColor = doc.strokeColor.bind(doc);
-    doc.strokeColor = function (color, opacity) {
-        const spotColorDef = getSpotColorForColor(color, spotColorConfig);
-        if (spotColorDef) {
-            const normalizedColor = normalizeColor(color);
-            const registered = doc._spotColors.get(normalizedColor) || doc._spotColors.get(color);
-            if (registered) {
-                // Use PDFKit's strokeColor with the spot color name directly
-                return originalStrokeColor(registered.name, opacity);
-            }
-        }
-        return originalStrokeColor(color, opacity);
-    };
-}

package/lib/svg-render.d.ts

@@ -1,9 +0,0 @@
-import { ImageCache } from './utils.js';
-export interface SVGElement {
-    src: string;
-    width: number;
-    height: number;
-    opacity: number;
-    colorsReplace: Record<string, string>;
-}
-export declare function renderSVG(doc: any, element: SVGElement, cache?: ImageCache | null): Promise<void>;

package/lib/svg-render.js

@@ -1,63 +0,0 @@
-import * as svg from './svg.js';
-import { Util } from 'konva/lib/Util.js';
-export async function renderSVG(doc, element, cache = null) {
-    const str = await svg.urlToString(element.src, cache);
-    const replaceEntries = Object.entries(element.colorsReplace || {});
-    doc.addSVG(str, 0, 0, {
-        // Use 'none' to allow stretching to exact dimensions, 'xMinYMin meet' to preserve aspect ratio
-        preserveAspectRatio: 'none',
-        width: element.width,
-        height: element.height,
-        opacity: element.opacity,
-        colorCallback: (colors) => {
-            if (!colors) {
-                return colors;
-            }
-            const [rgb, opacity] = colors;
-            let colorString = null;
-            if (Array.isArray(rgb) && rgb.length === 3) {
-                colorString = `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`;
-            }
-            else if (typeof rgb === 'string') {
-                colorString = rgb;
-            }
-            let nextColorString = colorString;
-            if (replaceEntries.length && colorString) {
-                for (const [from, to] of replaceEntries) {
-                    if (svg.sameColors(from, colorString)) {
-                        nextColorString = to;
-                        break;
-                    }
-                }
-            }
-            let nextColorArray = rgb;
-            let finalOpacity = opacity * element.opacity;
-            if (nextColorString != null) {
-                const rgbaObject = Util.colorToRGBA(nextColorString);
-                if (rgbaObject) {
-                    nextColorArray = [
-                        Math.round(rgbaObject.r),
-                        Math.round(rgbaObject.g),
-                        Math.round(rgbaObject.b),
-                    ];
-                    // Handle alpha channel from the color string
-                    if (rgbaObject.a !== undefined) {
-                        finalOpacity = rgbaObject.a * opacity * element.opacity;
-                    }
-                }
-            }
-            if (!Array.isArray(nextColorArray) &&
-                typeof nextColorArray === 'string') {
-                const rgbObject = Util.getRGB(nextColorArray);
-                if (rgbObject) {
-                    nextColorArray = [
-                        Math.round(rgbObject.r),
-                        Math.round(rgbObject.g),
-                        Math.round(rgbObject.b),
-                    ];
-                }
-            }
-            return [nextColorArray, finalOpacity];
-        },
-    });
-}