apexify.js 5.1.1 → 5.2.0

package/lib/Canvas/utils/Custom/advancedLines.ts

@@ -1,387 +0,0 @@
-import { SKRSContext2D, Image, loadImage } from '@napi-rs/canvas';
-import path from 'path';
-import fs from 'fs';
-
-/**
- * Draws an arrow at the end of a line
- * @param ctx - Canvas 2D context
- * @param x - Arrow tip X
- * @param y - Arrow tip Y
- * @param angle - Arrow angle in radians
- * @param size - Arrow size
- * @param style - Arrow style
- * @param color - Arrow color
- */
-export function drawArrow(
-  ctx: SKRSContext2D,
-  x: number,
-  y: number,
-  angle: number,
-  size: number,
-  style: 'filled' | 'outline',
-  color: string
-): void {
-  ctx.save();
-  ctx.translate(x, y);
-  ctx.rotate(angle);
-  
-  const arrowHeadLength = size;
-  const arrowHeadWidth = size * 0.6;
-  
-  ctx.beginPath();
-  ctx.moveTo(0, 0);
-  ctx.lineTo(-arrowHeadLength, -arrowHeadWidth);
-  ctx.lineTo(-arrowHeadLength * 0.7, 0);
-  ctx.lineTo(-arrowHeadLength, arrowHeadWidth);
-  ctx.closePath();
-  
-  if (style === 'filled') {
-    ctx.fillStyle = color;
-    ctx.fill();
-  } else {
-    ctx.strokeStyle = color;
-    ctx.lineWidth = 2;
-    ctx.stroke();
-  }
-  
-  ctx.restore();
-}
-
-/**
- * Draws a marker on a path
- * @param ctx - Canvas 2D context
- * @param x - Marker X position
- * @param y - Marker Y position
- * @param shape - Marker shape
- * @param size - Marker size
- * @param color - Marker color
- */
-export function drawMarker(
-  ctx: SKRSContext2D,
-  x: number,
-  y: number,
-  shape: 'circle' | 'square' | 'diamond' | 'arrow',
-  size: number,
-  color: string
-): void {
-  ctx.save();
-  ctx.fillStyle = color;
-  ctx.translate(x, y);
-  
-  switch (shape) {
-    case 'circle':
-      ctx.beginPath();
-      ctx.arc(0, 0, size / 2, 0, Math.PI * 2);
-      ctx.fill();
-      break;
-      
-    case 'square':
-      ctx.fillRect(-size / 2, -size / 2, size, size);
-      break;
-      
-    case 'diamond':
-      ctx.beginPath();
-      ctx.moveTo(0, -size / 2);
-      ctx.lineTo(size / 2, 0);
-      ctx.lineTo(0, size / 2);
-      ctx.lineTo(-size / 2, 0);
-      ctx.closePath();
-      ctx.fill();
-      break;
-      
-    case 'arrow':
-      ctx.beginPath();
-      ctx.moveTo(0, -size / 2);
-      ctx.lineTo(size / 2, size / 2);
-      ctx.lineTo(-size / 2, size / 2);
-      ctx.closePath();
-      ctx.fill();
-      break;
-  }
-  
-  ctx.restore();
-}
-
-/**
- * Creates a smooth path from points using Cardinal Spline (graph-like smoothness)
- * @param ctx - Canvas 2D context
- * @param points - Array of points
- * @param tension - Smoothness (0-1, default 0.5, lower = smoother)
- * @param closed - Whether path is closed
- */
-export function createSmoothPath(
-  ctx: SKRSContext2D,
-  points: Array<{ x: number; y: number }>,
-  tension: number = 0.5,
-  closed: boolean = false
-): void {
-  if (points.length < 2) return;
-  
-  // Enable anti-aliasing for smoother rendering
-  ctx.imageSmoothingEnabled = true;
-  ctx.imageSmoothingQuality = 'high';
-  
-  ctx.beginPath();
-  ctx.moveTo(points[0].x, points[0].y);
-  
-  if (points.length === 2) {
-    ctx.lineTo(points[1].x, points[1].y);
-    return;
-  }
-  
-  // Cardinal spline - produces graph-like smooth curves
-  // Ultra-high resolution for maximum smoothness (like professional graphing libraries)
-  const segmentsPerCurve = 50; // Increased to 50 for ultra-smooth curves
-  
-  for (let i = 0; i < points.length - 1; i++) {
-    const p0 = i > 0 ? points[i - 1] : (closed ? points[points.length - 1] : points[i]);
-    const p1 = points[i];
-    const p2 = points[i + 1];
-    const p3 = i < points.length - 2 ? points[i + 2] : (closed ? points[0] : p2);
-    
-    // Cardinal spline control points (optimized for maximum smoothness)
-    const t = (1 - tension) * 0.5; // Convert tension to cardinal spline parameter
-    
-    const cp1x = p1.x + t * (p2.x - p0.x);
-    const cp1y = p1.y + t * (p2.y - p0.y);
-    const cp2x = p2.x - t * (p3.x - p1.x);
-    const cp2y = p2.y - t * (p3.y - p1.y);
-    
-    // Draw ultra-smooth curve with many segments for graph-like quality
-    for (let s = 0; s <= segmentsPerCurve; s++) {
-      const t = s / segmentsPerCurve;
-      const point = cubicBezier(p1, { x: cp1x, y: cp1y }, { x: cp2x, y: cp2y }, p2, t);
-      
-      if (s === 0 && i === 0) {
-        ctx.moveTo(point.x, point.y);
-      } else {
-        ctx.lineTo(point.x, point.y);
-      }
-    }
-  }
-  
-  if (closed) {
-    ctx.closePath();
-  }
-}
-
-/**
- * Cubic Bezier interpolation helper
- */
-function cubicBezier(
-  p0: { x: number; y: number },
-  p1: { x: number; y: number },
-  p2: { x: number; y: number },
-  p3: { x: number; y: number },
-  t: number
-): { x: number; y: number } {
-  const mt = 1 - t;
-  const mt2 = mt * mt;
-  const mt3 = mt2 * mt;
-  const t2 = t * t;
-  const t3 = t2 * t;
-  
-  return {
-    x: mt3 * p0.x + 3 * mt2 * t * p1.x + 3 * mt * t2 * p2.x + t3 * p3.x,
-    y: mt3 * p0.y + 3 * mt2 * t * p1.y + 3 * mt * t2 * p2.y + t3 * p3.y
-  };
-}
-
-/**
- * Creates a Catmull-Rom spline path (ultra-smooth, passes through all points - best for graphs)
- * @param ctx - Canvas 2D context
- * @param points - Array of points
- * @param tension - Tension (0-1, default 0.5, lower = tighter curves)
- * @param closed - Whether path is closed
- */
-export function createCatmullRomPath(
-  ctx: SKRSContext2D,
-  points: Array<{ x: number; y: number }>,
-  tension: number = 0.5,
-  closed: boolean = false
-): void {
-  if (points.length < 2) return;
-  
-  // Enable anti-aliasing for smoother rendering
-  ctx.imageSmoothingEnabled = true;
-  ctx.imageSmoothingQuality = 'high';
-  
-  ctx.beginPath();
-  ctx.moveTo(points[0].x, points[0].y);
-  
-  if (points.length === 2) {
-    ctx.lineTo(points[1].x, points[1].y);
-    return;
-  }
-  
-  const segments = closed ? points.length : points.length - 1;
-  const segmentsPerCurve = 60; // Ultra-high resolution for maximum smoothness (graph quality)
-  
-  for (let i = 0; i < segments; i++) {
-    const p0 = closed && i === 0 ? points[points.length - 1] : (i > 0 ? points[i - 1] : points[i]);
-    const p1 = points[i];
-    const p2 = points[(i + 1) % points.length];
-    const p3 = closed && i === segments - 1 ? points[0] : (i < points.length - 2 ? points[i + 2] : p2);
-    
-    // Draw ultra-smooth curve with maximum resolution for graph-like quality
-    for (let s = 0; s <= segmentsPerCurve; s++) {
-      const t = s / segmentsPerCurve;
-      const point = catmullRom(p0, p1, p2, p3, t, tension);
-      
-      if (s === 0 && i === 0) {
-        ctx.moveTo(point.x, point.y);
-      } else {
-        ctx.lineTo(point.x, point.y);
-      }
-    }
-  }
-  
-  if (closed) {
-    ctx.closePath();
-  }
-}
-
-/**
- * Catmull-Rom spline interpolation (corrected formula)
- * This creates curves that pass through all control points
- */
-function catmullRom(
-  p0: { x: number; y: number },
-  p1: { x: number; y: number },
-  p2: { x: number; y: number },
-  p3: { x: number; y: number },
-  t: number,
-  tension: number
-): { x: number; y: number } {
-  const t2 = t * t;
-  const t3 = t2 * t;
-  
-  // Proper Catmull-Rom spline formula with tension
-  // Tension typically ranges from 0 (tight) to 1 (loose)
-  const s = (1 - tension) * 0.5;
-  
-  const x = (2 * p1.x) +
-    s * ((-p0.x + p2.x) * t +
-         (2 * p0.x - 5 * p1.x + 4 * p2.x - p3.x) * t2 +
-         (-p0.x + 3 * p1.x - 3 * p2.x + p3.x) * t3);
-  
-  const y = (2 * p1.y) +
-    s * ((-p0.y + p2.y) * t +
-         (2 * p0.y - 5 * p1.y + 4 * p2.y - p3.y) * t2 +
-         (-p0.y + 3 * p1.y - 3 * p2.y + p3.y) * t3);
-  
-  return { x: x * 0.5, y: y * 0.5 };
-}
-
-/**
- * Applies line pattern
- * @param ctx - Canvas 2D context
- * @param pattern - Pattern configuration
- */
-export function applyLinePattern(
-  ctx: SKRSContext2D,
-  pattern: {
-    type: 'dots' | 'dashes' | 'custom';
-    segments?: number[];
-    offset?: number;
-  }
-): void {
-  switch (pattern.type) {
-    case 'dots':
-      ctx.setLineDash([2, 4]);
-      break;
-      
-    case 'dashes':
-      ctx.setLineDash([10, 5]);
-      break;
-      
-    case 'custom':
-      if (pattern.segments && pattern.segments.length > 0) {
-        ctx.setLineDash(pattern.segments);
-      }
-      break;
-  }
-  
-  if (pattern.offset !== undefined) {
-    ctx.lineDashOffset = pattern.offset;
-  }
-}
-
-/**
- * Applies texture to line
- * @param ctx - Canvas 2D context
- * @param textureSource - Texture image source
- * @param lineWidth - Line width
- * @param lineLength - Approximate line length
- */
-export async function applyLineTexture(
-  ctx: SKRSContext2D,
-  textureSource: string | Buffer,
-  lineWidth: number,
-  lineLength: number
-): Promise<void> {
-  try {
-    let textureImage: Image;
-    if (Buffer.isBuffer(textureSource)) {
-      textureImage = await loadImage(textureSource);
-    } else if (textureSource.startsWith('http')) {
-      textureImage = await loadImage(textureSource);
-    } else {
-      const texturePath = path.join(process.cwd(), textureSource);
-      textureImage = await loadImage(fs.readFileSync(texturePath));
-    }
-    
-    // Create pattern from texture
-    const pattern = ctx.createPattern(textureImage, 'repeat');
-    if (pattern) {
-      ctx.strokeStyle = pattern;
-    }
-  } catch (error) {
-    console.error('Error applying line texture:', error);
-    // Fallback to current stroke style
-  }
-}
-
-/**
- * Gets points along a path for marker placement
- * @param points - Path points
- * @param position - Position along path (0-1)
- */
-export function getPointOnLinePath(
-  points: Array<{ x: number; y: number }>,
-  position: number
-): { x: number; y: number } {
-  if (points.length < 2) return points[0] || { x: 0, y: 0 };
-  
-  // Calculate total path length
-  let totalLength = 0;
-  const segmentLengths: number[] = [];
-  
-  for (let i = 0; i < points.length - 1; i++) {
-    const dx = points[i + 1].x - points[i].x;
-    const dy = points[i + 1].y - points[i].y;
-    const length = Math.sqrt(dx * dx + dy * dy);
-    segmentLengths.push(length);
-    totalLength += length;
-  }
-  
-  // Find target position
-  const targetLength = totalLength * Math.max(0, Math.min(1, position));
-  let currentLength = 0;
-  
-  for (let i = 0; i < segmentLengths.length; i++) {
-    if (currentLength + segmentLengths[i] >= targetLength) {
-      const segmentT = (targetLength - currentLength) / segmentLengths[i];
-      const dx = points[i + 1].x - points[i].x;
-      const dy = points[i + 1].y - points[i].y;
-      return {
-        x: points[i].x + dx * segmentT,
-        y: points[i].y + dy * segmentT
-      };
-    }
-    currentLength += segmentLengths[i];
-  }
-  
-  return points[points.length - 1];
-}
-

package/lib/Canvas/utils/Custom/customLines.ts

@@ -1,206 +0,0 @@
-import { SKRSContext2D } from '@napi-rs/canvas';
-import { createGradientFill } from "../Image/imageProperties";
-import { CustomOptions } from "../types";
-import { drawArrow, drawMarker, createSmoothPath, createCatmullRomPath, applyLinePattern, applyLineTexture, getPointOnLinePath } from "./advancedLines";
-
-
-export async function customLines(ctx: SKRSContext2D, options: CustomOptions[]): Promise<void> {
-    // Enable high-quality anti-aliasing for ultra-smooth lines (graph quality)
-    ctx.imageSmoothingEnabled = true;
-    ctx.imageSmoothingQuality = 'high';
-    
-    let previousEndCoordinates: { x: number; y: number } | null = null;
-    let currentStyle: CustomOptions['lineStyle'] | null = null;
-    let inSingleLineSequence = false;
-
-    for (let i = 0; i < options.length; i++) {
-        const customOption = options[i];
-        const { startCoordinates, endCoordinates, lineStyle, path, arrow, markers } = customOption;
-        const isSingleLine = lineStyle?.singleLine;
-        
-        // Collect all points for path rendering
-        const allPoints: Array<{ x: number; y: number }> = [];
-        if (i === 0 || !isSingleLine) {
-            allPoints.push(startCoordinates);
-        }
-        allPoints.push(endCoordinates);
-
-        if (isSingleLine && !inSingleLineSequence) {
-            currentStyle = lineStyle;
-            inSingleLineSequence = true;
-            ctx.beginPath();
-            ctx.moveTo(startCoordinates.x, startCoordinates.y);
-        }
-
-        if (!isSingleLine && inSingleLineSequence) {
-            ctx.stroke();
-            if (currentStyle) {
-              applyStroke(ctx, currentStyle, startCoordinates, endCoordinates);
-            }
-            inSingleLineSequence = false;
-            currentStyle = null;
-        }
-
-        const start = inSingleLineSequence && previousEndCoordinates
-            ? previousEndCoordinates
-            : startCoordinates;
-
-        if (!inSingleLineSequence) {
-            ctx.beginPath();
-            ctx.moveTo(start.x, start.y);
-        }
-
-        // Apply path smoothing if specified
-        if (path && allPoints.length >= 2) {
-            ctx.beginPath();
-            if (path.type === 'smooth') {
-                createSmoothPath(ctx, allPoints, path.tension ?? 0.5, path.closed ?? false);
-            } else if (path.type === 'catmull-rom') {
-                createCatmullRomPath(ctx, allPoints, path.tension ?? 0.5, path.closed ?? false);
-            } else if (path.type === 'bezier' && allPoints.length >= 4) {
-                ctx.moveTo(allPoints[0].x, allPoints[0].y);
-                for (let j = 1; j < allPoints.length - 2; j += 3) {
-                    if (j + 2 < allPoints.length) {
-                        ctx.bezierCurveTo(
-                            allPoints[j].x, allPoints[j].y,
-                            allPoints[j + 1].x, allPoints[j + 1].y,
-                            allPoints[j + 2].x, allPoints[j + 2].y
-                        );
-                    }
-                }
-            } else {
-                ctx.lineTo(endCoordinates.x, endCoordinates.y);
-            }
-        } else {
-            ctx.lineTo(endCoordinates.x, endCoordinates.y);
-        }
-
-        const appliedStyle = inSingleLineSequence ? currentStyle : lineStyle;
-        ctx.lineWidth = appliedStyle?.width || 1;
-
-        if (appliedStyle?.gradient) {
-            ctx.strokeStyle = createGradientFill(ctx, appliedStyle.gradient, { x: start.x, y: start.y, w: endCoordinates.x - start.x, h: endCoordinates.y - start.y });
-        } else {
-            ctx.strokeStyle = appliedStyle?.color || 'black';
-        }
-
-        ctx.lineJoin = appliedStyle?.lineJoin || 'miter';
-        ctx.lineCap = appliedStyle?.lineCap || 'butt';
-
-        // Apply line patterns
-        if (appliedStyle?.pattern) {
-            applyLinePattern(ctx, appliedStyle.pattern);
-        } else if (appliedStyle?.lineDash) {
-            ctx.setLineDash(appliedStyle.lineDash.dashArray || []);
-            ctx.lineDashOffset = appliedStyle.lineDash.offset || 0;
-        } else {
-            ctx.setLineDash([]);
-        }
-
-        // Apply line texture if specified
-        if (appliedStyle?.texture) {
-            await applyLineTexture(ctx, appliedStyle.texture, appliedStyle.width || 1, 
-                Math.sqrt(Math.pow(endCoordinates.x - start.x, 2) + Math.pow(endCoordinates.y - start.y, 2)));
-        }
-
-        if (typeof appliedStyle?.lineRadius === 'number' && appliedStyle.lineRadius > 0) {
-            const radius = appliedStyle.lineRadius;
-            const dx = endCoordinates.x - start.x;
-            const dy = endCoordinates.y - start.y;
-            const angle = Math.atan2(dy, dx);
-
-            ctx.lineCap = "round";
-            ctx.stroke();
-
-            ctx.beginPath();
-            ctx.arc(start.x, start.y, radius, angle + Math.PI / 2, angle - Math.PI / 2, true);
-            ctx.arc(endCoordinates.x, endCoordinates.y, radius, angle - Math.PI / 2, angle + Math.PI / 2, false);
-            ctx.fill();
-        } 
-        
-        else if (appliedStyle?.lineRadius === 'circular') {
-            const dx = endCoordinates.x - start.x;
-            const dy = endCoordinates.y - start.y;
-            const length = Math.sqrt(dx * dx + dy * dy);
-
-            ctx.beginPath();
-            ctx.arcTo(start.x, start.y, endCoordinates.x, endCoordinates.y, length / 2);
-            ctx.arcTo(endCoordinates.x, endCoordinates.y, start.x, start.y, length / 2);
-            ctx.closePath();
-            ctx.stroke();
-        }
-
-        if (!inSingleLineSequence || i === options.length - 1) {
-            ctx.stroke();
-            if (appliedStyle) {
-              applyStroke(ctx, appliedStyle, startCoordinates, endCoordinates);
-            }
-        }
-
-        // Draw arrows if specified
-        if (arrow) {
-            const dx = endCoordinates.x - start.x;
-            const dy = endCoordinates.y - start.y;
-            const angle = Math.atan2(dy, dx);
-            const arrowColor = arrow.color || appliedStyle?.color || 'black';
-            const arrowSize = arrow.size || 10;
-            
-            if (arrow.start) {
-                drawArrow(ctx, start.x, start.y, angle + Math.PI, arrowSize, arrow.style || 'filled', arrowColor);
-            }
-            if (arrow.end) {
-                drawArrow(ctx, endCoordinates.x, endCoordinates.y, angle, arrowSize, arrow.style || 'filled', arrowColor);
-            }
-        }
-
-        // Draw markers if specified
-        if (markers && markers.length > 0) {
-            const linePoints = [start, endCoordinates];
-            for (const marker of markers) {
-                const point = getPointOnLinePath(linePoints, marker.position);
-                drawMarker(ctx, point.x, point.y, marker.shape, marker.size, marker.color);
-            }
-        }
-
-        previousEndCoordinates = endCoordinates;
-
-        if (!isSingleLine) {
-            currentStyle = null;
-            inSingleLineSequence = false;
-        }
-    }
-}
-
-function applyStroke(ctx: SKRSContext2D, style: CustomOptions['lineStyle'] | undefined, start: { x: number; y: number }, end: { x: number; y: number }): void {
-    if (!style || !style.stroke) {
-      return;
-    }
-    
-    if (style.stroke) {
-        const { color, width, gradient, lineRadius, lineCap } = style.stroke;
-        const prevStrokeStyle = ctx.strokeStyle;
-        const prevLineWidth = ctx.lineWidth;
-        const prevLineCap = ctx.lineCap;
-
-        if (gradient) {
-            ctx.strokeStyle = createGradientFill(ctx, gradient, { x: start.x, y: start.y, w: end.x - start.x, h: end.y - start.y });
-        } else {
-            ctx.strokeStyle = color || prevStrokeStyle;
-        }
-
-        ctx.lineWidth = width || prevLineWidth;
-        ctx.lineCap = lineCap || prevLineCap; 
-        ctx.stroke();
-
-        if (typeof lineRadius === 'number' && lineRadius > 0) {
-            ctx.beginPath();
-            ctx.arc(start.x, start.y, lineRadius, 0, Math.PI * 2);
-            ctx.arc(end.x, end.y, lineRadius, 0, Math.PI * 2);
-            ctx.fill();
-        }
-
-        ctx.strokeStyle = prevStrokeStyle;
-        ctx.lineWidth = prevLineWidth;
-        ctx.lineCap = prevLineCap;
-    }
-}

package/lib/Canvas/utils/General/batchOperations.ts

@@ -1,103 +0,0 @@
-import { ApexPainter } from '../../ApexPainter';
-import { BatchOperation, ChainOperation, CanvasConfig, ImageProperties, TextProperties } from '../types';
-
-/**
- * Processes multiple operations in parallel
- * @param painter - ApexPainter instance
- * @param operations - Array of operations to process
- * @returns Array of result buffers
- */
-export async function batchOperations(
-  painter: ApexPainter,
-  operations: BatchOperation[]
-): Promise<Buffer[]> {
-  if (!operations || operations.length === 0) {
-    throw new Error('batch: operations array is required');
-  }
-
-  const promises = operations.map(async (op) => {
-    try {
-      switch (op.type) {
-        case 'canvas':
-          const canvasResult = await painter.createCanvas(op.config as CanvasConfig);
-          return canvasResult.buffer;
-          
-        case 'image':
-          // For image operations, we need a base canvas
-          const baseCanvas = await painter.createCanvas({ width: 800, height: 600 });
-          return await painter.createImage(op.config as ImageProperties | ImageProperties[], baseCanvas);
-          
-        case 'text':
-          // For text operations, we need a base canvas
-          const textBaseCanvas = await painter.createCanvas({ width: 800, height: 600 });
-          return await painter.createText(op.config as TextProperties | TextProperties[], textBaseCanvas);
-          
-        case 'chart':
-          return await painter.createChart(op.config, { chartType: 'bar', chartNumber: 1 });
-          
-        default:
-          throw new Error(`batch: Unknown operation type: ${op.type}`);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      throw new Error(`batch: Failed to process ${op.type} operation: ${errorMessage}`);
-    }
-  });
-
-  return Promise.all(promises);
-}
-
-/**
- * Chains multiple operations sequentially
- * @param painter - ApexPainter instance
- * @param operations - Array of operations to chain
- * @returns Final result buffer
- */
-export async function chainOperations(
-  painter: ApexPainter,
-  operations: ChainOperation[]
-): Promise<Buffer> {
-  if (!operations || operations.length === 0) {
-    throw new Error('chain: operations array is required');
-  }
-
-  let currentBuffer: Buffer | undefined;
-
-  for (const op of operations) {
-    try {
-      const method = (painter as any)[op.method];
-      if (typeof method !== 'function') {
-        throw new Error(`chain: Method "${op.method}" does not exist on ApexPainter`);
-      }
-
-      // Prepare arguments - replace 'current' with current buffer
-      const args = op.args.map(arg => {
-        if (arg === 'current' || (typeof arg === 'object' && arg !== null && (arg as any).__isCurrentBuffer)) {
-          return currentBuffer;
-        }
-        return arg;
-      });
-
-      const result = await method.apply(painter, args);
-
-      // Update current buffer
-      if (Buffer.isBuffer(result)) {
-        currentBuffer = result;
-      } else if (result && typeof result === 'object' && 'buffer' in result) {
-        currentBuffer = (result as any).buffer;
-      } else {
-        throw new Error(`chain: Operation "${op.method}" did not return a buffer`);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      throw new Error(`chain: Failed to execute "${op.method}": ${errorMessage}`);
-    }
-  }
-
-  if (!currentBuffer) {
-    throw new Error('chain: No buffer was produced from operations');
-  }
-
-  return currentBuffer;
-}
-