@guildai/cli 0.7.1 → 0.8.1

package/dist/lib/svg-renderer.js

@@ -1,858 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * SVG to Braille Canvas Renderer
- *
- * Renders SVG paths to terminal using braille characters.
- * Each braille character represents a 2x4 pixel grid.
- *
- * Braille dot positions:
- * ┌───┬───┐
- * │ 1 │ 4 │
- * │ 2 │ 5 │
- * │ 3 │ 6 │
- * │ 7 │ 8 │
- * └───┴───┘
- */
-import { SVGPathData } from 'svg-pathdata';
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-// ESM equivalent of __dirname
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// Braille Unicode block starts at U+2800
-const BRAILLE_BASE = 0x2800;
-// Dot bit positions in the braille character
-// Left column: bits 0,1,2,6 (positions 1,2,3,7)
-// Right column: bits 3,4,5,7 (positions 4,5,6,8)
-const DOT_BITS = [
-    [0x01, 0x08], // Row 0: dots 1,4
-    [0x02, 0x10], // Row 1: dots 2,5
-    [0x04, 0x20], // Row 2: dots 3,6
-    [0x40, 0x80], // Row 3: dots 7,8
-];
-/**
- * Create an identity transform matrix
- */
-function identityMatrix() {
-    return { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
-}
-/**
- * Multiply two transform matrices
- */
-function multiplyMatrices(m1, m2) {
-    return {
-        a: m1.a * m2.a + m1.c * m2.b,
-        b: m1.b * m2.a + m1.d * m2.b,
-        c: m1.a * m2.c + m1.c * m2.d,
-        d: m1.b * m2.c + m1.d * m2.d,
-        e: m1.a * m2.e + m1.c * m2.f + m1.e,
-        f: m1.b * m2.e + m1.d * m2.f + m1.f,
-    };
-}
-/**
- * Apply transform matrix to a point
- */
-export function transformPoint(x, y, m) {
-    return [m.a * x + m.c * y + m.e, m.b * x + m.d * y + m.f];
-}
-/**
- * Parse SVG transform string into a matrix
- * Handles: translate, scale, rotate, matrix
- */
-function parseTransform(transform) {
-    let result = identityMatrix();
-    // Match each transform function
-    const regex = /(translate|scale|rotate|matrix)\s*\(([^)]+)\)/gi;
-    let match;
-    while ((match = regex.exec(transform)) !== null) {
-        const type = match[1].toLowerCase();
-        const args = match[2]
-            .split(/[\s,]+/)
-            .filter((s) => s.length > 0)
-            .map(Number);
-        let m;
-        switch (type) {
-            case 'translate':
-                m = { a: 1, b: 0, c: 0, d: 1, e: args[0] || 0, f: args[1] || 0 };
-                break;
-            case 'scale':
-                m = { a: args[0] || 1, b: 0, c: 0, d: args[1] ?? args[0] ?? 1, e: 0, f: 0 };
-                break;
-            case 'rotate': {
-                const angle = ((args[0] || 0) * Math.PI) / 180;
-                const cos = Math.cos(angle);
-                const sin = Math.sin(angle);
-                m = { a: cos, b: sin, c: -sin, d: cos, e: 0, f: 0 };
-                break;
-            }
-            case 'matrix':
-                m = {
-                    a: args[0] || 1,
-                    b: args[1] || 0,
-                    c: args[2] || 0,
-                    d: args[3] || 1,
-                    e: args[4] || 0,
-                    f: args[5] || 0,
-                };
-                break;
-            default:
-                continue;
-        }
-        result = multiplyMatrices(result, m);
-    }
-    return result;
-}
-/**
- * Create an empty braille canvas
- */
-export function createCanvas(widthChars, heightChars) {
-    const pixelWidth = widthChars * 2;
-    const pixelHeight = heightChars * 4;
-    const pixels = [];
-    for (let y = 0; y < pixelHeight; y++) {
-        pixels.push(new Array(pixelWidth).fill(false));
-    }
-    return { width: widthChars, height: heightChars, pixels };
-}
-/**
- * Set a pixel in the canvas
- */
-export function setPixel(canvas, x, y, value = true) {
-    const px = Math.floor(x);
-    const py = Math.floor(y);
-    if (px >= 0 && px < canvas.width * 2 && py >= 0 && py < canvas.height * 4) {
-        canvas.pixels[py][px] = value;
-    }
-}
-/**
- * Draw a line using Bresenham's algorithm
- */
-export function drawLine(canvas, x0, y0, x1, y1) {
-    x0 = Math.round(x0);
-    y0 = Math.round(y0);
-    x1 = Math.round(x1);
-    y1 = Math.round(y1);
-    const dx = Math.abs(x1 - x0);
-    const dy = Math.abs(y1 - y0);
-    const sx = x0 < x1 ? 1 : -1;
-    const sy = y0 < y1 ? 1 : -1;
-    let err = dx - dy;
-    let x = x0;
-    let y = y0;
-    while (true) {
-        setPixel(canvas, x, y);
-        if (x === x1 && y === y1)
-            break;
-        const e2 = 2 * err;
-        if (e2 > -dy) {
-            err -= dy;
-            x += sx;
-        }
-        if (e2 < dx) {
-            err += dx;
-            y += sy;
-        }
-    }
-}
-/**
- * Draw a cubic bezier curve
- */
-export function drawCubicBezier(canvas, x0, y0, x1, y1, x2, y2, x3, y3, steps = 20) {
-    let lastX = x0;
-    let lastY = y0;
-    for (let i = 1; i <= steps; i++) {
-        const t = i / steps;
-        const mt = 1 - t;
-        const mt2 = mt * mt;
-        const mt3 = mt2 * mt;
-        const t2 = t * t;
-        const t3 = t2 * t;
-        const x = mt3 * x0 + 3 * mt2 * t * x1 + 3 * mt * t2 * x2 + t3 * x3;
-        const y = mt3 * y0 + 3 * mt2 * t * y1 + 3 * mt * t2 * y2 + t3 * y3;
-        drawLine(canvas, lastX, lastY, x, y);
-        lastX = x;
-        lastY = y;
-    }
-}
-/**
- * Draw a quadratic bezier curve
- */
-export function drawQuadraticBezier(canvas, x0, y0, x1, y1, x2, y2, steps = 20) {
-    let lastX = x0;
-    let lastY = y0;
-    for (let i = 1; i <= steps; i++) {
-        const t = i / steps;
-        const mt = 1 - t;
-        const mt2 = mt * mt;
-        const t2 = t * t;
-        const x = mt2 * x0 + 2 * mt * t * x1 + t2 * x2;
-        const y = mt2 * y0 + 2 * mt * t * y1 + t2 * y2;
-        drawLine(canvas, lastX, lastY, x, y);
-        lastX = x;
-        lastY = y;
-    }
-}
-/**
- * Fill a closed path using scanline algorithm
- */
-export function fillPath(canvas, points, density = 1.0) {
-    if (points.length < 3)
-        return;
-    // Find bounding box
-    let minY = Infinity;
-    let maxY = -Infinity;
-    for (const [, y] of points) {
-        minY = Math.min(minY, y);
-        maxY = Math.max(maxY, y);
-    }
-    minY = Math.max(0, Math.floor(minY));
-    maxY = Math.min(canvas.height * 4 - 1, Math.ceil(maxY));
-    // Scanline fill
-    for (let y = minY; y <= maxY; y++) {
-        const intersections = [];
-        // Find intersections with all edges
-        for (let i = 0; i < points.length; i++) {
-            const [x1, y1] = points[i];
-            const [x2, y2] = points[(i + 1) % points.length];
-            if ((y1 <= y && y2 > y) || (y2 <= y && y1 > y)) {
-                const x = x1 + ((y - y1) / (y2 - y1)) * (x2 - x1);
-                intersections.push(x);
-            }
-        }
-        // Sort and fill between pairs
-        intersections.sort((a, b) => a - b);
-        for (let i = 0; i < intersections.length; i += 2) {
-            if (i + 1 < intersections.length) {
-                const startX = Math.max(0, Math.floor(intersections[i]));
-                const endX = Math.min(canvas.width * 2 - 1, Math.ceil(intersections[i + 1]));
-                // Apply density-based sparse sampling
-                if (density >= 1.0) {
-                    // Full density - render every pixel
-                    for (let x = startX; x <= endX; x++) {
-                        setPixel(canvas, x, y);
-                    }
-                }
-                else {
-                    // Sparse sampling using ordered dithering (Bayer-style pattern)
-                    // This creates a more uniform distribution than random sampling
-                    // and preserves detail better than simple checkerboard
-                    for (let x = startX; x <= endX; x++) {
-                        // 2x2 Bayer matrix pattern for ordered dithering
-                        // Values: 0.0, 0.5, 0.75, 0.25 in a 2x2 pattern
-                        const bx = x % 2;
-                        const by = y % 2;
-                        let threshold;
-                        if (bx === 0 && by === 0)
-                            threshold = 0.0;
-                        else if (bx === 1 && by === 0)
-                            threshold = 0.5;
-                        else if (bx === 0 && by === 1)
-                            threshold = 0.75;
-                        else
-                            threshold = 0.25;
-                        // Render pixel if density is higher than threshold
-                        // density=1.0 renders all (all thresholds < 1.0)
-                        // density=0.75 renders 75% (thresholds 0.0, 0.5, 0.25 < 0.75)
-                        // density=0.5 renders 50% (thresholds 0.0, 0.25 < 0.5)
-                        if (density > threshold) {
-                            setPixel(canvas, x, y);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-/**
- * Extract clipPath rectangles from SVG defs
- * Lottie mask animations become clipPaths with path geometry
- * We extract their bounding rectangles for clipping
- */
-function extractClipPaths(svgContent) {
-    const clipPaths = new Map();
-    // Find all clipPath definitions
-    const clipPathRegex = /<clipPath id="([^"]+)"[^>]*>([\s\S]*?)<\/clipPath>/g;
-    let match;
-    while ((match = clipPathRegex.exec(svgContent)) !== null) {
-        const id = match[1];
-        const content = match[2];
-        // Extract path data
-        const pathMatch = content.match(/d="([^"]+)"/);
-        if (pathMatch) {
-            const d = pathMatch[1];
-            // Extract all coordinates from the path data
-            // Match patterns like: 123.45 or -123.45
-            const coords = [];
-            const coordRegex = /-?\d+(?:\.\d+)?/g;
-            let coordMatch;
-            while ((coordMatch = coordRegex.exec(d)) !== null) {
-                coords.push(parseFloat(coordMatch[0]));
-            }
-            if (coords.length >= 4) {
-                // Get bounding box from all coordinates
-                const xCoords = coords.filter((_, i) => i % 2 === 0); // Even indices are X
-                const yCoords = coords.filter((_, i) => i % 2 === 1); // Odd indices are Y
-                clipPaths.set(id, {
-                    minX: Math.min(...xCoords),
-                    minY: Math.min(...yCoords),
-                    maxX: Math.max(...xCoords),
-                    maxY: Math.max(...yCoords),
-                });
-            }
-        }
-    }
-    return clipPaths;
-}
-/**
- * Parse SVG hierarchically to match each path with its correct transform chain
- */
-export function parseHierarchicalPaths(svgContent) {
-    const paths = [];
-    const transformStack = [identityMatrix()];
-    const visibilityStack = [true]; // Track visibility state
-    // Extract all clipPath rectangles
-    const clipPathRects = extractClipPaths(svgContent);
-    // Track current clipPath (stack for nested groups)
-    const clipPathStack = [undefined];
-    // Track if we're inside <defs> to skip those paths
-    let inDefs = false;
-    // Use regex to find all <defs>, </defs>, <g>, </g>, and <path> tags in order
-    const tagRegex = /<(\/?)(?:defs|g|path)([^>]*)>/g;
-    let match;
-    while ((match = tagRegex.exec(svgContent)) !== null) {
-        const isClosing = match[1] === '/';
-        const fullTag = match[0];
-        let tagName = 'unknown';
-        if (fullTag.startsWith('<defs'))
-            tagName = 'defs';
-        else if (fullTag.startsWith('</defs'))
-            tagName = 'defs';
-        else if (fullTag.startsWith('<g'))
-            tagName = 'g';
-        else if (fullTag.startsWith('</g'))
-            tagName = 'g';
-        else if (fullTag.startsWith('<path'))
-            tagName = 'path';
-        const attributes = match[2];
-        // Track <defs> sections
-        if (tagName === 'defs') {
-            inDefs = !isClosing;
-            continue;
-        }
-        // Skip everything inside <defs>
-        if (inDefs)
-            continue;
-        if (tagName === 'g' && !isClosing) {
-            // Opening <g> tag - check visibility and transform
-            const hasDisplayNone = attributes.includes('display: none');
-            // Check for opacity="0" which also hides elements
-            const opacityMatch = attributes.match(/opacity="([^"]+)"/);
-            const hasZeroOpacity = opacityMatch && parseFloat(opacityMatch[1]) === 0;
-            const isVisible = !hasDisplayNone && !hasZeroOpacity;
-            const currentVisibility = visibilityStack[visibilityStack.length - 1];
-            // Group is visible only if parent is visible AND this group isn't hidden
-            visibilityStack.push(currentVisibility && isVisible);
-            // Check for clip-path attribute
-            const clipPathMatch = attributes.match(/clip-path="url\(#([^)]+)\)"/);
-            let groupClipRect;
-            if (clipPathMatch) {
-                const clipPathId = clipPathMatch[1];
-                groupClipRect = clipPathRects.get(clipPathId);
-            }
-            // Inherit parent's clipRect if we don't have our own
-            if (!groupClipRect) {
-                groupClipRect = clipPathStack[clipPathStack.length - 1];
-            }
-            clipPathStack.push(groupClipRect);
-            // Extract transform and push onto stack
-            const transformMatch = attributes.match(/transform="([^"]+)"/);
-            if (transformMatch) {
-                const transform = parseTransform(transformMatch[1]);
-                const currentTransform = transformStack[transformStack.length - 1];
-                const newTransform = multiplyMatrices(currentTransform, transform);
-                transformStack.push(newTransform);
-            }
-            else {
-                // No transform attribute - duplicate current transform
-                transformStack.push(transformStack[transformStack.length - 1]);
-            }
-        }
-        else if (tagName === 'g' && isClosing) {
-            // Closing </g> tag - pop from stacks
-            if (transformStack.length > 1) {
-                transformStack.pop();
-                visibilityStack.pop();
-                clipPathStack.pop();
-            }
-        }
-        else if (tagName === 'path') {
-            // <path> tag - only record if currently visible
-            const currentlyVisible = visibilityStack[visibilityStack.length - 1];
-            if (currentlyVisible) {
-                const pathDataMatch = attributes.match(/d="([^"]+)"/);
-                if (pathDataMatch) {
-                    // Extract fill color
-                    const fillMatch = attributes.match(/fill="([^"]+)"/);
-                    paths.push({
-                        pathData: pathDataMatch[1],
-                        transform: transformStack[transformStack.length - 1],
-                        clipRect: clipPathStack[clipPathStack.length - 1],
-                        fill: fillMatch ? fillMatch[1] : undefined,
-                    });
-                }
-            }
-        }
-    }
-    return paths;
-}
-/**
- * Parse SVG content and extract path points with transforms applied
- */
-export function extractPathPoints(svgContent, targetWidth, targetHeight, rotation = 0, autoFit = false, explicitBounds) {
-    // Extract viewBox
-    const viewBoxMatch = svgContent.match(/viewBox="([^"]+)"/);
-    let viewBoxX = 0;
-    let viewBoxY = 0;
-    let viewBoxWidth = 100;
-    let viewBoxHeight = 100;
-    if (viewBoxMatch) {
-        const parts = viewBoxMatch[1].split(/\s+/).map(Number);
-        viewBoxX = parts[0] || 0;
-        viewBoxY = parts[1] || 0;
-        viewBoxWidth = parts[2] || 100;
-        viewBoxHeight = parts[3] || 100;
-    }
-    // Parse SVG hierarchically to get paths with their correct transforms
-    const parsedPaths = parseHierarchicalPaths(svgContent);
-    const pixelWidth = targetWidth * 2;
-    const pixelHeight = targetHeight * 4;
-    // Determine bounds to use (explicit > autoFit > viewBox)
-    let boundsMinX;
-    let boundsMinY;
-    let boundsMaxX;
-    let boundsMaxY;
-    if (explicitBounds) {
-        // Use explicit bounds provided by caller
-        boundsMinX = explicitBounds.minX;
-        boundsMinY = explicitBounds.minY;
-        boundsMaxX = explicitBounds.maxX;
-        boundsMaxY = explicitBounds.maxY;
-    }
-    else if (autoFit) {
-        // Calculate bounds from actual path content WITH CORRECT TRANSFORMS
-        boundsMinX = viewBoxX;
-        boundsMinY = viewBoxY;
-        boundsMaxX = viewBoxX + viewBoxWidth;
-        boundsMaxY = viewBoxY + viewBoxHeight;
-        let hasPoints = false;
-        for (const parsedPath of parsedPaths) {
-            try {
-                const pathData = new SVGPathData(parsedPath.pathData).toAbs();
-                const commands = pathData.commands;
-                for (const cmd of commands) {
-                    // Check all coordinate types
-                    const coords = [];
-                    if ('x' in cmd && 'y' in cmd) {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        coords.push([cmd.x, cmd.y]);
-                    }
-                    if ('x1' in cmd && 'y1' in cmd) {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        coords.push([cmd.x1, cmd.y1]);
-                    }
-                    if ('x2' in cmd && 'y2' in cmd) {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        coords.push([cmd.x2, cmd.y2]);
-                    }
-                    // Apply THIS path's specific transform (not all transforms!)
-                    for (const [x, y] of coords) {
-                        const [tx, ty] = transformPoint(x, y, parsedPath.transform);
-                        if (!hasPoints) {
-                            boundsMinX = boundsMaxX = tx;
-                            boundsMinY = boundsMaxY = ty;
-                            hasPoints = true;
-                        }
-                        else {
-                            boundsMinX = Math.min(boundsMinX, tx);
-                            boundsMinY = Math.min(boundsMinY, ty);
-                            boundsMaxX = Math.max(boundsMaxX, tx);
-                            boundsMaxY = Math.max(boundsMaxY, ty);
-                        }
-                    }
-                }
-            }
-            catch {
-                // Skip invalid paths
-            }
-        }
-    }
-    else {
-        // Use viewBox bounds
-        boundsMinX = viewBoxX;
-        boundsMinY = viewBoxY;
-        boundsMaxX = viewBoxX + viewBoxWidth;
-        boundsMaxY = viewBoxY + viewBoxHeight;
-    }
-    // Calculate dimensions based on bounds
-    const boundsWidth = boundsMaxX - boundsMinX;
-    const boundsHeight = boundsMaxY - boundsMinY;
-    // Calculate scale to fit into target pixel dimensions
-    const scaleX = pixelWidth / boundsWidth;
-    const scaleY = pixelHeight / boundsHeight;
-    const scale = Math.min(scaleX, scaleY) * 0.9;
-    // Center offset (accounting for bounds offset)
-    const offsetX = (pixelWidth - boundsWidth * scale) / 2 - boundsMinX * scale;
-    const offsetY = (pixelHeight - boundsHeight * scale) / 2 - boundsMinY * scale;
-    // Apply rotation if specified (rotate around center of bounds)
-    let rotationTransform = identityMatrix();
-    if (rotation !== 0) {
-        const angle = (rotation * Math.PI) / 180;
-        const cos = Math.cos(angle);
-        const sin = Math.sin(angle);
-        const centerX = (boundsMinX + boundsMaxX) / 2;
-        const centerY = (boundsMinY + boundsMaxY) / 2;
-        // Translate to origin, rotate, translate back
-        rotationTransform = multiplyMatrices({ a: 1, b: 0, c: 0, d: 1, e: centerX, f: centerY }, multiplyMatrices({ a: cos, b: sin, c: -sin, d: cos, e: 0, f: 0 }, { a: 1, b: 0, c: 0, d: 1, e: -centerX, f: -centerY }));
-    }
-    // Viewport transform: rotation -> scale to fit -> center
-    const viewportTransform = multiplyMatrices({ a: scale, b: 0, c: 0, d: scale, e: offsetX, f: offsetY }, rotationTransform);
-    // Render each path with its individual transform chain
-    const allPaths = [];
-    // SVG viewBox bounds for clipping (lottie uses clip-path to enforce this)
-    const clipMinX = viewBoxX;
-    const clipMinY = viewBoxY;
-    const clipMaxX = viewBoxX + viewBoxWidth;
-    const clipMaxY = viewBoxY + viewBoxHeight;
-    for (const parsedPath of parsedPaths) {
-        try {
-            // Skip white fills (these are used for negative space in logos)
-            // Check for common white color formats: "#ffffff", "#fff", "rgb(255,255,255)", "white"
-            const fill = parsedPath.fill?.toLowerCase();
-            if (fill === '#ffffff' ||
-                fill === '#fff' ||
-                fill === 'rgb(255,255,255)' ||
-                fill === 'white' ||
-                fill === 'rgba(255,255,255,1)') {
-                continue; // Skip white fills
-            }
-            const pathData = new SVGPathData(parsedPath.pathData).toAbs();
-            // First, check if this path is within the viewBox clip bounds
-            // Apply the path's transform to check bounds before viewport scaling
-            let pathBoundsMinX = Infinity;
-            let pathBoundsMinY = Infinity;
-            let pathBoundsMaxX = -Infinity;
-            let pathBoundsMaxY = -Infinity;
-            pathData.commands.forEach((cmd) => {
-                if ('x' in cmd && 'y' in cmd) {
-                    const [tx, ty] = transformPoint(
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    cmd.x, 
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    cmd.y, parsedPath.transform);
-                    pathBoundsMinX = Math.min(pathBoundsMinX, tx);
-                    pathBoundsMinY = Math.min(pathBoundsMinY, ty);
-                    pathBoundsMaxX = Math.max(pathBoundsMaxX, tx);
-                    pathBoundsMaxY = Math.max(pathBoundsMaxY, ty);
-                }
-            });
-            // Skip paths that are completely outside the clip bounds
-            if (pathBoundsMaxX < clipMinX ||
-                pathBoundsMinX > clipMaxX ||
-                pathBoundsMaxY < clipMinY ||
-                pathBoundsMinY > clipMaxY) {
-                continue; // Path is completely clipped out
-            }
-            // Final transform: path's SVG transform -> viewport transform
-            const finalTransform = multiplyMatrices(viewportTransform, parsedPath.transform);
-            const commands = pathData.commands;
-            const pathPoints = [];
-            let currentX = 0;
-            let currentY = 0;
-            let startX = 0;
-            let startY = 0;
-            for (const cmd of commands) {
-                switch (cmd.type) {
-                    case SVGPathData.MOVE_TO: {
-                        const [tx, ty] = transformPoint(cmd.x, cmd.y, finalTransform);
-                        currentX = tx;
-                        currentY = ty;
-                        startX = tx;
-                        startY = ty;
-                        pathPoints.push([tx, ty]);
-                        break;
-                    }
-                    case SVGPathData.LINE_TO: {
-                        const [tx, ty] = transformPoint(cmd.x, cmd.y, finalTransform);
-                        // Add intermediate points for better rendering
-                        const steps = Math.max(1, Math.ceil(Math.hypot(tx - currentX, ty - currentY) / 2));
-                        for (let i = 1; i <= steps; i++) {
-                            const t = i / steps;
-                            pathPoints.push([
-                                currentX + (tx - currentX) * t,
-                                currentY + (ty - currentY) * t,
-                            ]);
-                        }
-                        currentX = tx;
-                        currentY = ty;
-                        break;
-                    }
-                    case SVGPathData.HORIZ_LINE_TO: {
-                        const [tx] = transformPoint(cmd.x, currentY / finalTransform.d, finalTransform);
-                        const steps = Math.max(1, Math.ceil(Math.abs(tx - currentX) / 2));
-                        for (let i = 1; i <= steps; i++) {
-                            const t = i / steps;
-                            pathPoints.push([currentX + (tx - currentX) * t, currentY]);
-                        }
-                        currentX = tx;
-                        break;
-                    }
-                    case SVGPathData.VERT_LINE_TO: {
-                        const [, ty] = transformPoint(currentX / finalTransform.a, cmd.y, finalTransform);
-                        const steps = Math.max(1, Math.ceil(Math.abs(ty - currentY) / 2));
-                        for (let i = 1; i <= steps; i++) {
-                            const t = i / steps;
-                            pathPoints.push([currentX, currentY + (ty - currentY) * t]);
-                        }
-                        currentY = ty;
-                        break;
-                    }
-                    case SVGPathData.CURVE_TO: {
-                        const [x1t, y1t] = transformPoint(cmd.x1, cmd.y1, finalTransform);
-                        const [x2t, y2t] = transformPoint(cmd.x2, cmd.y2, finalTransform);
-                        const [xt, yt] = transformPoint(cmd.x, cmd.y, finalTransform);
-                        // Sample bezier curve
-                        const steps = 20;
-                        for (let i = 1; i <= steps; i++) {
-                            const t = i / steps;
-                            const mt = 1 - t;
-                            const mt2 = mt * mt;
-                            const mt3 = mt2 * mt;
-                            const t2 = t * t;
-                            const t3 = t2 * t;
-                            const x = mt3 * currentX + 3 * mt2 * t * x1t + 3 * mt * t2 * x2t + t3 * xt;
-                            const y = mt3 * currentY + 3 * mt2 * t * y1t + 3 * mt * t2 * y2t + t3 * yt;
-                            pathPoints.push([x, y]);
-                        }
-                        currentX = xt;
-                        currentY = yt;
-                        break;
-                    }
-                    case SVGPathData.SMOOTH_CURVE_TO: {
-                        const [x2t, y2t] = transformPoint(cmd.x2, cmd.y2, finalTransform);
-                        const [xt, yt] = transformPoint(cmd.x, cmd.y, finalTransform);
-                        const steps = 20;
-                        for (let i = 1; i <= steps; i++) {
-                            const t = i / steps;
-                            const mt = 1 - t;
-                            const mt2 = mt * mt;
-                            const mt3 = mt2 * mt;
-                            const t2 = t * t;
-                            const t3 = t2 * t;
-                            const x = mt3 * currentX + 3 * mt2 * t * currentX + 3 * mt * t2 * x2t + t3 * xt;
-                            const y = mt3 * currentY + 3 * mt2 * t * currentY + 3 * mt * t2 * y2t + t3 * yt;
-                            pathPoints.push([x, y]);
-                        }
-                        currentX = xt;
-                        currentY = yt;
-                        break;
-                    }
-                    case SVGPathData.QUAD_TO: {
-                        const [x1t, y1t] = transformPoint(cmd.x1, cmd.y1, finalTransform);
-                        const [xt, yt] = transformPoint(cmd.x, cmd.y, finalTransform);
-                        const steps = 20;
-                        for (let i = 1; i <= steps; i++) {
-                            const t = i / steps;
-                            const mt = 1 - t;
-                            const mt2 = mt * mt;
-                            const t2 = t * t;
-                            const x = mt2 * currentX + 2 * mt * t * x1t + t2 * xt;
-                            const y = mt2 * currentY + 2 * mt * t * y1t + t2 * yt;
-                            pathPoints.push([x, y]);
-                        }
-                        currentX = xt;
-                        currentY = yt;
-                        break;
-                    }
-                    case SVGPathData.CLOSE_PATH:
-                        // Add line back to start
-                        const steps = Math.max(1, Math.ceil(Math.hypot(startX - currentX, startY - currentY) / 2));
-                        for (let i = 1; i <= steps; i++) {
-                            const t = i / steps;
-                            pathPoints.push([
-                                currentX + (startX - currentX) * t,
-                                currentY + (startY - currentY) * t,
-                            ]);
-                        }
-                        currentX = startX;
-                        currentY = startY;
-                        break;
-                }
-            }
-            // Apply clipRect filtering if this path has a mask
-            if (parsedPath.clipRect && pathPoints.length > 0) {
-                const clip = parsedPath.clipRect;
-                // Transform clip bounds to pixel space (once per path, not per point)
-                const [clipMinX, clipMinY] = transformPoint(clip.minX, clip.minY, viewportTransform);
-                const [clipMaxX, clipMaxY] = transformPoint(clip.maxX, clip.maxY, viewportTransform);
-                // Normalize bounds in case transform flipped them
-                const pixelClipMinX = Math.min(clipMinX, clipMaxX);
-                const pixelClipMaxX = Math.max(clipMinX, clipMaxX);
-                const pixelClipMinY = Math.min(clipMinY, clipMaxY);
-                const pixelClipMaxY = Math.max(clipMinY, clipMaxY);
-                // Filter points to only those within clip rectangle
-                const clippedPoints = pathPoints.filter(([x, y]) => {
-                    return (x >= pixelClipMinX &&
-                        x <= pixelClipMaxX &&
-                        y >= pixelClipMinY &&
-                        y <= pixelClipMaxY);
-                });
-                if (clippedPoints.length > 0) {
-                    allPaths.push(clippedPoints);
-                }
-            }
-            else if (pathPoints.length > 0) {
-                // No clipping needed
-                allPaths.push(pathPoints);
-            }
-        }
-        catch {
-            // Skip invalid paths
-        }
-    }
-    return allPaths;
-}
-/**
- * Render SVG content to a braille canvas
- */
-export function renderSVGToCanvas(svgContent, options = {}) {
-    const targetWidth = options.width || 20;
-    const targetHeight = options.height || 10;
-    const canvas = createCanvas(targetWidth, targetHeight);
-    const allPaths = extractPathPoints(svgContent, targetWidth, targetHeight, options.rotation || 0, options.autoFit || false, options.explicitBounds);
-    // Draw all paths
-    for (const pathPoints of allPaths) {
-        // Draw edges (stroke) if requested
-        if (options.stroke !== false) {
-            for (let i = 0; i < pathPoints.length - 1; i++) {
-                drawLine(canvas, pathPoints[i][0], pathPoints[i][1], pathPoints[i + 1][0], pathPoints[i + 1][1]);
-            }
-        }
-        // Fill if requested
-        if (options.fill !== false && pathPoints.length > 2) {
-            fillPath(canvas, pathPoints, options.fillDensity || 1.0);
-        }
-    }
-    // Invert pixels if requested
-    if (options.invert) {
-        for (let y = 0; y < canvas.pixels.length; y++) {
-            for (let x = 0; x < canvas.pixels[y].length; x++) {
-                canvas.pixels[y][x] = !canvas.pixels[y][x];
-            }
-        }
-    }
-    return canvas;
-}
-/**
- * Convert braille canvas to string array
- */
-export function canvasToStrings(canvas) {
-    const lines = [];
-    for (let charY = 0; charY < canvas.height; charY++) {
-        let line = '';
-        for (let charX = 0; charX < canvas.width; charX++) {
-            let code = BRAILLE_BASE;
-            // Each braille character is 2x4 pixels
-            for (let dy = 0; dy < 4; dy++) {
-                for (let dx = 0; dx < 2; dx++) {
-                    const px = charX * 2 + dx;
-                    const py = charY * 4 + dy;
-                    if (canvas.pixels[py]?.[px]) {
-                        code += DOT_BITS[dy][dx];
-                    }
-                }
-            }
-            line += String.fromCharCode(code);
-        }
-        lines.push(line);
-    }
-    return lines;
-}
-/**
- * Render SVG content string to braille strings
- */
-export function renderSVGContent(content, options = {}) {
-    const canvas = renderSVGToCanvas(content, options);
-    return canvasToStrings(canvas);
-}
-/**
- * Load and render the Guild logo from local assets
- */
-export function renderGuildLogo(widthChars = 20, heightChars = 10, invert = true, rotation = 0) {
-    const content = loadLogoSVG();
-    if (!content) {
-        // Fallback: return empty lines if logo not found
-        return Array(heightChars).fill('⠀'.repeat(widthChars));
-    }
-    return renderSVGContent(content, {
-        width: widthChars,
-        height: heightChars,
-        fill: true,
-        invert,
-        rotation,
-    });
-}
-/**
- * Get raw path points for animation purposes
- * Returns points in pixel coordinate space for the given dimensions
- */
-export function getLogoPathPoints(widthChars = 20, heightChars = 10) {
-    const content = loadLogoSVG();
-    if (!content) {
-        return [];
-    }
-    return extractPathPoints(content, widthChars, heightChars);
-}
-/**
- * Get pixel positions from rendered logo (useful for inverted logos)
- * Returns array of [x, y] pixel coordinates that are "on" in the rendered logo
- */
-export function getLogoPixelPositions(widthChars = 20, heightChars = 10, invert = true) {
-    const content = loadLogoSVG();
-    if (!content) {
-        return [];
-    }
-    const canvas = renderSVGToCanvas(content, {
-        width: widthChars,
-        height: heightChars,
-        fill: true,
-        invert,
-    });
-    const positions = [];
-    for (let y = 0; y < canvas.pixels.length; y++) {
-        for (let x = 0; x < canvas.pixels[y].length; x++) {
-            if (canvas.pixels[y][x]) {
-                positions.push([x, y]);
-            }
-        }
-    }
-    return positions;
-}
-/**
- * Load the Guild logo SVG from local assets
- */
-function loadLogoSVG() {
-    // Primary: CLI's own copy in assets directory
-    const possiblePaths = [
-        path.resolve(__dirname, '../assets/logo.svg'), // From dist/lib/
-        path.resolve(__dirname, '../../src/assets/logo.svg'), // Dev fallback
-    ];
-    for (const logoPath of possiblePaths) {
-        if (fs.existsSync(logoPath)) {
-            return fs.readFileSync(logoPath, 'utf-8');
-        }
-    }
-    return null;
-}
-//# sourceMappingURL=svg-renderer.js.map