html2canvas-pro 2.4.5 → 2.5.0

package/dist/lib/render/canvas/border-image-renderer.js

@@ -1,153 +0,0 @@
-"use strict";
-/**
- * Border Image Renderer
- *
- * Renders CSS border-image using 9-slice scaling.
- * The source image is divided into 9 regions (4 corners, 4 edges, 1 center)
- * based on border-image-slice values, then each region is drawn to the
- * corresponding area of the element's border box.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BorderImageRenderer = void 0;
-const border_image_repeat_1 = require("../../css/property-descriptors/border-image-repeat");
-class BorderImageRenderer {
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    renderBorderImage(bounds, image, slice, repeat, borderTopWidth, borderRightWidth, borderBottomWidth, borderLeftWidth) {
-        const imgW = image.naturalWidth || image.width;
-        const imgH = image.naturalHeight || image.height;
-        if (imgW <= 0 || imgH <= 0) {
-            return;
-        }
-        // Calculate source slice positions in image pixel space
-        const sT = Math.min(slice.unit === 'percent' ? (slice.top / 100) * imgH : Math.min(slice.top, imgH), imgH);
-        const sR = Math.min(slice.unit === 'percent' ? (slice.right / 100) * imgW : Math.min(slice.right, imgW), imgW);
-        const sB = Math.min(slice.unit === 'percent' ? (slice.bottom / 100) * imgH : Math.min(slice.bottom, imgH), imgH);
-        const sL = Math.min(slice.unit === 'percent' ? (slice.left / 100) * imgW : Math.min(slice.left, imgW), imgW);
-        const { left, top, width, height } = bounds;
-        if (width <= 0 || height <= 0) {
-            return;
-        }
-        // Clamp border widths to available box dimensions
-        const dT = Math.min(borderTopWidth, height);
-        const dR = Math.min(borderRightWidth, width);
-        const dB = Math.min(borderBottomWidth, height - dT);
-        const dL = Math.min(borderLeftWidth, width - dR);
-        // Draw corners
-        this.drawRegion(image, 0, 0, sL, sT, left, top, dL, dT);
-        this.drawRegion(image, imgW - sR, 0, sR, sT, left + width - dR, top, dR, dT);
-        this.drawRegion(image, imgW - sR, imgH - sB, sR, sB, left + width - dR, top + height - dB, dR, dB);
-        this.drawRegion(image, 0, imgH - sB, sL, sB, left, top + height - dB, dL, dB);
-        // Draw edges
-        const edges = [
-            {
-                sx: sL,
-                sy: 0,
-                sw: imgW - sL - sR,
-                sh: sT,
-                dx: left + dL,
-                dy: top,
-                dw: width - dL - dR,
-                dh: dT,
-                repeat: repeat.horizontal
-            },
-            {
-                sx: imgW - sR,
-                sy: sT,
-                sw: sR,
-                sh: imgH - sT - sB,
-                dx: left + width - dR,
-                dy: top + dT,
-                dw: dR,
-                dh: height - dT - dB,
-                repeat: repeat.vertical
-            },
-            {
-                sx: sL,
-                sy: imgH - sB,
-                sw: imgW - sL - sR,
-                sh: sB,
-                dx: left + dL,
-                dy: top + height - dB,
-                dw: width - dL - dR,
-                dh: dB,
-                repeat: repeat.horizontal
-            },
-            {
-                sx: 0,
-                sy: sT,
-                sw: sL,
-                sh: imgH - sT - sB,
-                dx: left,
-                dy: top + dT,
-                dw: dL,
-                dh: height - dT - dB,
-                repeat: repeat.vertical
-            }
-        ];
-        for (const edge of edges) {
-            if (edge.sw <= 0 || edge.sh <= 0 || edge.dw <= 0 || edge.dh <= 0)
-                continue;
-            const isHorizontal = edge.dw >= edge.dh;
-            if (edge.repeat === border_image_repeat_1.BORDER_IMAGE_REPEAT.STRETCH) {
-                this.ctx.drawImage(image, edge.sx, edge.sy, edge.sw, edge.sh, edge.dx, edge.dy, edge.dw, edge.dh);
-            }
-            else if (edge.repeat === border_image_repeat_1.BORDER_IMAGE_REPEAT.REPEAT || edge.repeat === border_image_repeat_1.BORDER_IMAGE_REPEAT.ROUND) {
-                this.drawRepeatedEdge(image, edge, isHorizontal, edge.repeat === border_image_repeat_1.BORDER_IMAGE_REPEAT.ROUND);
-            }
-        }
-        // Draw center if fill is specified
-        if (slice.fill) {
-            const cx = sL;
-            const cy = sT;
-            const cw = imgW - sL - sR;
-            const ch = imgH - sT - sB;
-            const tcx = left + dL;
-            const tcy = top + dT;
-            const tcw = width - dL - dR;
-            const tch = height - dT - dB;
-            this.drawRegion(image, cx, cy, cw, ch, tcx, tcy, tcw, tch);
-        }
-    }
-    drawRegion(image, sx, sy, sw, sh, dx, dy, dw, dh) {
-        if (sw > 0 && sh > 0 && dw > 0 && dh > 0) {
-            this.ctx.drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh);
-        }
-    }
-    drawRepeatedEdge(image, edge, isHorizontal, round) {
-        const srcLength = isHorizontal ? edge.sw : edge.sh;
-        const tgLength = isHorizontal ? edge.dw : edge.dh;
-        if (srcLength <= 0 || tgLength <= 0)
-            return;
-        let tileSize;
-        let tileCount;
-        if (round) {
-            tileCount = Math.max(1, Math.round(tgLength / srcLength));
-            tileSize = tgLength / tileCount;
-        }
-        else {
-            tileSize = srcLength;
-            tileCount = Math.ceil(tgLength / tileSize);
-        }
-        this.ctx.save();
-        this.ctx.beginPath();
-        this.ctx.rect(edge.dx, edge.dy, edge.dw, edge.dh);
-        this.ctx.clip();
-        for (let i = 0; i < tileCount; i++) {
-            const offset = i * tileSize;
-            const remaining = tgLength - offset;
-            const clampedSize = Math.min(tileSize, remaining);
-            if (clampedSize <= 0)
-                break;
-            if (isHorizontal) {
-                this.ctx.drawImage(image, edge.sx, edge.sy, edge.sw, edge.sh, edge.dx + offset, edge.dy, clampedSize, edge.dh);
-            }
-            else {
-                this.ctx.drawImage(image, edge.sx, edge.sy, edge.sw, edge.sh, edge.dx, edge.dy + offset, edge.dw, clampedSize);
-            }
-        }
-        this.ctx.restore();
-    }
-}
-exports.BorderImageRenderer = BorderImageRenderer;

package/dist/lib/render/canvas/border-renderer.js

@@ -1,184 +0,0 @@
-"use strict";
-/**
- * Border Renderer
- *
- * Handles rendering of element borders including:
- * - Solid borders
- * - Double borders
- * - Dashed borders
- * - Dotted borders
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BorderRenderer = void 0;
-const color_utilities_1 = require("../../css/types/color-utilities");
-const border_1 = require("../border");
-const bezier_curve_1 = require("../bezier-curve");
-const vector_1 = require("../vector");
-/**
- * Border Renderer
- *
- * Specialized renderer for element borders.
- * Extracted from CanvasRenderer to improve code organization and maintainability.
- */
-class BorderRenderer {
-    constructor(deps, pathCallbacks) {
-        this.ctx = deps.ctx;
-        this.pathCallbacks = pathCallbacks;
-    }
-    /**
-     * Render a solid border
-     *
-     * @param color - Border color
-     * @param side - Border side (0=top, 1=right, 2=bottom, 3=left)
-     * @param curvePoints - Border curve points
-     */
-    async renderSolidBorder(color, side, curvePoints) {
-        this.pathCallbacks.path((0, border_1.parsePathForBorder)(curvePoints, side));
-        this.ctx.fillStyle = (0, color_utilities_1.asString)(color);
-        this.ctx.fill();
-    }
-    /**
-     * Render a double border
-     * Falls back to solid border if width is too small
-     *
-     * @param color - Border color
-     * @param width - Border width
-     * @param side - Border side (0=top, 1=right, 2=bottom, 3=left)
-     * @param curvePoints - Border curve points
-     */
-    async renderDoubleBorder(color, width, side, curvePoints) {
-        if (width < 3) {
-            await this.renderSolidBorder(color, side, curvePoints);
-            return;
-        }
-        const outerPaths = (0, border_1.parsePathForBorderDoubleOuter)(curvePoints, side);
-        this.pathCallbacks.path(outerPaths);
-        this.ctx.fillStyle = (0, color_utilities_1.asString)(color);
-        this.ctx.fill();
-        const innerPaths = (0, border_1.parsePathForBorderDoubleInner)(curvePoints, side);
-        this.pathCallbacks.path(innerPaths);
-        this.ctx.fill();
-    }
-    /**
-     * Render a dashed or dotted border
-     *
-     * @param color - Border color
-     * @param width - Border width
-     * @param side - Border side (0=top, 1=right, 2=bottom, 3=left)
-     * @param curvePoints - Border curve points
-     * @param style - Border style (DASHED or DOTTED)
-     */
-    async renderDashedDottedBorder(color, width, side, curvePoints, style) {
-        this.ctx.save();
-        const strokePaths = (0, border_1.parsePathForBorderStroke)(curvePoints, side);
-        const boxPaths = (0, border_1.parsePathForBorder)(curvePoints, side);
-        if (style === 2 /* BORDER_STYLE.DASHED */) {
-            this.pathCallbacks.path(boxPaths);
-            this.ctx.clip();
-        }
-        // Extract start and end coordinates
-        let startX, startY, endX, endY;
-        if ((0, bezier_curve_1.isBezierCurve)(boxPaths[0])) {
-            startX = boxPaths[0].start.x;
-            startY = boxPaths[0].start.y;
-        }
-        else {
-            startX = boxPaths[0].x;
-            startY = boxPaths[0].y;
-        }
-        if ((0, bezier_curve_1.isBezierCurve)(boxPaths[1])) {
-            endX = boxPaths[1].end.x;
-            endY = boxPaths[1].end.y;
-        }
-        else {
-            endX = boxPaths[1].x;
-            endY = boxPaths[1].y;
-        }
-        // Calculate border length
-        let length;
-        if (side === 0 || side === 2) {
-            length = Math.abs(startX - endX);
-        }
-        else {
-            length = Math.abs(startY - endY);
-        }
-        this.ctx.beginPath();
-        if (style === 3 /* BORDER_STYLE.DOTTED */) {
-            this.pathCallbacks.formatPath(strokePaths);
-        }
-        else {
-            this.pathCallbacks.formatPath(boxPaths.slice(0, 2));
-        }
-        // Calculate dash and space lengths
-        let dashLength = width < 3 ? width * 3 : width * 2;
-        let spaceLength = width < 3 ? width * 2 : width;
-        if (style === 3 /* BORDER_STYLE.DOTTED */) {
-            dashLength = width;
-            spaceLength = width;
-        }
-        // Adjust dash pattern for border length
-        let useLineDash = true;
-        if (length <= dashLength * 2) {
-            useLineDash = false;
-        }
-        else if (length <= dashLength * 2 + spaceLength) {
-            const multiplier = length / (2 * dashLength + spaceLength);
-            dashLength *= multiplier;
-            spaceLength *= multiplier;
-        }
-        else {
-            const numberOfDashes = Math.floor((length + spaceLength) / (dashLength + spaceLength));
-            const minSpace = (length - numberOfDashes * dashLength) / (numberOfDashes - 1);
-            const maxSpace = (length - (numberOfDashes + 1) * dashLength) / numberOfDashes;
-            spaceLength =
-                maxSpace <= 0 || Math.abs(spaceLength - minSpace) < Math.abs(spaceLength - maxSpace)
-                    ? minSpace
-                    : maxSpace;
-        }
-        // Apply line dash pattern
-        if (useLineDash) {
-            if (style === 3 /* BORDER_STYLE.DOTTED */) {
-                this.ctx.setLineDash([0, dashLength + spaceLength]);
-            }
-            else {
-                this.ctx.setLineDash([dashLength, spaceLength]);
-            }
-        }
-        // Set line style and stroke
-        if (style === 3 /* BORDER_STYLE.DOTTED */) {
-            this.ctx.lineCap = 'round';
-            this.ctx.lineWidth = width;
-        }
-        else {
-            this.ctx.lineWidth = width * 2 + 1.1;
-        }
-        this.ctx.strokeStyle = (0, color_utilities_1.asString)(color);
-        this.ctx.stroke();
-        this.ctx.setLineDash([]);
-        // Fill dashed round edge gaps
-        if (style === 2 /* BORDER_STYLE.DASHED */) {
-            if ((0, bezier_curve_1.isBezierCurve)(boxPaths[0])) {
-                const path1 = boxPaths[3];
-                const path2 = boxPaths[0];
-                this.ctx.beginPath();
-                this.pathCallbacks.formatPath([
-                    new vector_1.Vector(path1.end.x, path1.end.y),
-                    new vector_1.Vector(path2.start.x, path2.start.y)
-                ]);
-                this.ctx.stroke();
-            }
-            if ((0, bezier_curve_1.isBezierCurve)(boxPaths[1])) {
-                const path1 = boxPaths[1];
-                const path2 = boxPaths[2];
-                this.ctx.beginPath();
-                this.pathCallbacks.formatPath([
-                    new vector_1.Vector(path1.end.x, path1.end.y),
-                    new vector_1.Vector(path2.start.x, path2.start.y)
-                ]);
-                this.ctx.stroke();
-            }
-        }
-        this.ctx.restore();
-    }
-}
-exports.BorderRenderer = BorderRenderer;

package/dist/lib/render/canvas/box-shadow-geometry.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.spreadShadowPath = exports.shadowRadius = void 0;
-const bezier_curve_1 = require("../bezier-curve");
-const vector_1 = require("../vector");
-// CSS Backgrounds 3, 6.1.1: growing a small corner needs the cubic adjustment
-// to approach a square continuously as the original radius approaches zero.
-const shadowRadius = (radius, spread) => {
-    const delta = spread > radius ? spread * (1 + Math.pow(radius / spread - 1, 3)) : spread;
-    return Math.max(0, radius + delta);
-};
-exports.shadowRadius = shadowRadius;
-// Input is the four clockwise border/padding corner segments from BoundCurves.
-// Translation alone preserves the old radii and turns a spread circle into a
-// rounded square. Resize each quarter ellipse around its box corner instead.
-const spreadShadowPath = (paths, spread) => {
-    if (spread === 0)
-        return paths;
-    const corners = paths.map((point, index) => {
-        if (!(0, bezier_curve_1.isBezierCurve)(point))
-            return { x: point.x, y: point.y, rx: 0, ry: 0 };
-        return {
-            x: index % 2 === 0 ? point.start.x : point.end.x,
-            y: index % 2 === 0 ? point.end.y : point.start.y,
-            rx: Math.abs(point.end.x - point.start.x),
-            ry: Math.abs(point.end.y - point.start.y)
-        };
-    });
-    const width = corners[1].x - corners[0].x + 2 * spread;
-    const height = corners[3].y - corners[0].y + 2 * spread;
-    if (width <= 0 || height <= 0)
-        return [];
-    const radii = corners.map((c) => ({ x: (0, exports.shadowRadius)(c.rx, spread), y: (0, exports.shadowRadius)(c.ry, spread) }));
-    const ratio = (size, sum) => (sum > 0 ? size / sum : 1);
-    const factor = Math.min(1, ratio(width, radii[0].x + radii[1].x), ratio(width, radii[3].x + radii[2].x), ratio(height, radii[0].y + radii[3].y), ratio(height, radii[1].y + radii[2].y));
-    return paths.map((point, index) => {
-        const corner = corners[index];
-        const x = corner.x + (index === 1 || index === 2 ? spread : -spread);
-        const y = corner.y + (index >= 2 ? spread : -spread);
-        if (!(0, bezier_curve_1.isBezierCurve)(point))
-            return new vector_1.Vector(x, y);
-        const rx = radii[index].x * factor;
-        const ry = radii[index].y * factor;
-        if (!rx || !ry)
-            return new vector_1.Vector(x, y);
-        const sx = rx / corner.rx;
-        const sy = ry / corner.ry;
-        const resize = (v) => new vector_1.Vector(x + (v.x - corner.x) * sx, y + (v.y - corner.y) * sy);
-        return new bezier_curve_1.BezierCurve(resize(point.start), resize(point.startControl), resize(point.endControl), resize(point.end));
-    });
-};
-exports.spreadShadowPath = spreadShadowPath;

package/dist/lib/render/canvas/box-shadow-painter.js

@@ -1,194 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paintBoxShadow = void 0;
-const color_utilities_1 = require("../../css/types/color-utilities");
-const constants_1 = require("../../core/constants");
-const bound_curves_1 = require("../bound-curves");
-const box_sizing_1 = require("../box-sizing");
-const path_1 = require("../path");
-const canvas_path_1 = require("./canvas-path");
-const filter_surface_1 = require("./filter-surface");
-const surface_bounds_1 = require("./surface-bounds");
-const box_shadow_geometry_1 = require("./box-shadow-geometry");
-const box_shadow_transform_1 = require("./box-shadow-transform");
-// Separate closed subpaths plus even-odd filling avoid reversing only the order
-// of corner Beziers, which does not reverse the curves themselves.
-const complement = (ctx, rect, hole) => {
-    ctx.beginPath();
-    ctx.rect(rect.left, rect.top, rect.width, rect.height);
-    if (hole.length) {
-        (0, canvas_path_1.formatCanvasPath)(ctx, hole);
-        ctx.closePath();
-    }
-};
-const insetHole = (paint, shadow) => {
-    const spread = shadow.spread.number;
-    const box = (0, box_sizing_1.paddingBox)(paint.container);
-    if (box.width - 2 * spread <= 0 || box.height - 2 * spread <= 0)
-        return [];
-    return (0, box_shadow_geometry_1.spreadShadowPath)((0, bound_curves_1.calculatePaddingBoxPath)(paint.curves), -spread);
-};
-// Rasterize in local coordinates, blur once, and then let the destination CTM
-// transform the complete shadow. This also preserves anisotropic/sheared blur.
-const paintShadowSurface = async (ctx, paint, shadow, options, budget, space) => {
-    const padding = (0, box_sizing_1.paddingBox)(paint.container);
-    const blur = shadow.blur.number / 2;
-    const margin = Math.ceil(3 * blur) + 2;
-    const spread = shadow.spread.number;
-    const area = shadow.inset
-        ? padding
-        : paint.container.bounds.add(shadow.offsetX.number - spread, shadow.offsetY.number - spread, 2 * spread, 2 * spread);
-    const bounds = (0, surface_bounds_1.cropSurface)(area.add(-margin, -margin, 2 * margin, 2 * margin), space.viewport, margin, space.scale);
-    if (!bounds.width || !bounds.height)
-        return true;
-    const width = Math.ceil(bounds.width * space.scale);
-    const height = Math.ceil(bounds.height * space.scale);
-    const reserved = (0, surface_bounds_1.reserveSurface)(budget, width, height);
-    if (!reserved)
-        return false;
-    let source;
-    let filtered;
-    try {
-        source = ctx.canvas.ownerDocument.createElement('canvas');
-        source.width = width;
-        source.height = height;
-        const sourceCtx = source.getContext('2d');
-        if (!sourceCtx)
-            return false;
-        sourceCtx.scale(space.scale, space.scale);
-        sourceCtx.translate(-bounds.left, -bounds.top);
-        const silhouette = shadow.inset
-            ? insetHole(paint, shadow)
-            : (0, box_shadow_geometry_1.spreadShadowPath)((0, bound_curves_1.calculateBorderBoxPath)(paint.curves), spread);
-        const path = (0, path_1.transformPath)(silhouette, shadow.offsetX.number, shadow.offsetY.number, 0, 0);
-        if (shadow.inset)
-            complement(sourceCtx, bounds, path);
-        else
-            (0, canvas_path_1.createCanvasPath)(sourceCtx, path);
-        sourceCtx.fillStyle = (0, color_utilities_1.asString)(shadow.color);
-        sourceCtx.fill(shadow.inset ? 'evenodd' : 'nonzero');
-        filtered = await (0, filter_surface_1.renderFilterSurface)(source, { blur }, 1, space.scale, options.signal);
-        ctx.save();
-        try {
-            if (shadow.inset) {
-                (0, canvas_path_1.createCanvasPath)(ctx, (0, bound_curves_1.calculatePaddingBoxPath)(paint.curves));
-                ctx.clip();
-            }
-            else {
-                complement(ctx, space.viewport, (0, bound_curves_1.calculateBorderBoxPath)(paint.curves));
-                ctx.clip('evenodd');
-            }
-            ctx.drawImage(filtered, bounds.left, bounds.top, filtered.width / space.scale, filtered.height / space.scale);
-        }
-        finally {
-            ctx.restore();
-        }
-        return true;
-    }
-    catch (error) {
-        if (!(error instanceof filter_surface_1.FilterSurfaceError))
-            throw error;
-        return false;
-    }
-    finally {
-        if (filtered && filtered !== source)
-            (0, filter_surface_1.releaseSurface)(filtered);
-        if (source)
-            (0, filter_surface_1.releaseSurface)(source);
-        budget.pixels -= reserved;
-    }
-};
-const paintBoxShadow = async (ctx, paint, shadow, options, budget) => {
-    if (options.signal?.aborted)
-        throw new DOMException('The operation was aborted.', 'AbortError');
-    if ((0, color_utilities_1.isTransparent)(shadow.color))
-        return;
-    const spread = shadow.spread.number;
-    if (!shadow.inset &&
-        (paint.container.bounds.width + 2 * spread <= 0 || paint.container.bounds.height + 2 * spread <= 0))
-        return;
-    // getTransform includes capture scale, CSS transforms and their origins.
-    // Without it the CTM is unknown: approximate it with the capture transform
-    // and only ever move the mask relative to the real CTM (see below).
-    const knownTransform = typeof ctx.getTransform === 'function';
-    const matrix = knownTransform
-        ? ctx.getTransform()
-        : {
-            a: options.scale,
-            b: 0,
-            c: 0,
-            d: options.scale,
-            e: -options.x * options.scale,
-            f: -options.y * options.scale
-        };
-    const space = (0, box_shadow_transform_1.shadowSpace)(matrix, ctx.canvas.width, ctx.canvas.height);
-    // Singular transforms have zero painted area; never attempt to invert them.
-    if (!space)
-        return;
-    const { viewport } = space;
-    if (shadow.blur.number > 0 &&
-        (shadow.inset || !space.uniform) &&
-        (await paintShadowSurface(ctx, paint, shadow, options, budget, space)))
-        return;
-    const padding = (0, box_sizing_1.paddingBox)(paint.container);
-    ctx.save();
-    try {
-        if (shadow.inset && shadow.blur.number === 0) {
-            (0, canvas_path_1.createCanvasPath)(ctx, (0, bound_curves_1.calculatePaddingBoxPath)(paint.curves));
-            ctx.clip();
-            complement(ctx, padding, (0, path_1.transformPath)(insetHole(paint, shadow), shadow.offsetX.number, shadow.offsetY.number, 0, 0));
-            ctx.fillStyle = (0, color_utilities_1.asString)(shadow.color);
-            ctx.fill('evenodd');
-            return;
-        }
-        const margin = Math.ceil(shadow.blur.number * 2 +
-            Math.abs(spread) +
-            Math.abs(shadow.offsetX.number) +
-            Math.abs(shadow.offsetY.number)) + 2;
-        // Displace in OUTPUT pixels, not along a CSS axis. A rotated or reflected
-        // local x axis need not point off the left edge of the output bitmap.
-        const sourceBounds = shadow.inset
-            ? padding.add(-margin, -margin, 2 * margin, 2 * margin)
-            : paint.container.bounds.add(-spread, -spread, 2 * spread, 2 * spread);
-        const { a, b, c, d, e, f } = matrix;
-        const right = sourceBounds.left + sourceBounds.width;
-        const bottom = sourceBounds.top + sourceBounds.height;
-        const maxX = Math.max(a * sourceBounds.left + c * sourceBounds.top + e, a * right + c * sourceBounds.top + e, a * right + c * bottom + e, a * sourceBounds.left + c * bottom + e);
-        const displacement = Math.max(constants_1.SHADOW_MASK_OFFSET, maxX + margin * space.scale + 2);
-        if (shadow.inset) {
-            (0, canvas_path_1.createCanvasPath)(ctx, (0, bound_curves_1.calculatePaddingBoxPath)(paint.curves));
-            ctx.clip();
-        }
-        else {
-            complement(ctx, viewport, (0, bound_curves_1.calculateBorderBoxPath)(paint.curves));
-            ctx.clip('evenodd');
-        }
-        // Current paths retain their device coordinates across transform changes.
-        // setTransform with an approximate matrix would discard CSS transforms
-        // on the real CTM, so the legacy path translates relative to it instead.
-        if (knownTransform)
-            ctx.setTransform(a, b, c, d, e - displacement, f);
-        else
-            ctx.translate(-displacement / a, 0);
-        if (shadow.inset)
-            complement(ctx, sourceBounds, insetHole(paint, shadow));
-        else
-            (0, canvas_path_1.createCanvasPath)(ctx, (0, box_shadow_geometry_1.spreadShadowPath)((0, bound_curves_1.calculateBorderBoxPath)(paint.curves), spread));
-        if (knownTransform)
-            ctx.setTransform(a, b, c, d, e, f);
-        else
-            ctx.translate(displacement / a, 0);
-        ctx.shadowOffsetX = displacement + a * shadow.offsetX.number + c * shadow.offsetY.number;
-        ctx.shadowOffsetY = b * shadow.offsetX.number + d * shadow.offsetY.number;
-        // Allocation/filter-failure fallback remains bounded-memory. Its blur is
-        // isotropic under nonuniform transforms, but positioning stays correct.
-        ctx.shadowBlur = shadow.blur.number * space.scale;
-        ctx.shadowColor = (0, color_utilities_1.asString)(shadow.color);
-        ctx.fillStyle = 'rgb(0, 0, 0)';
-        ctx.fill(shadow.inset ? 'evenodd' : 'nonzero');
-    }
-    finally {
-        ctx.restore();
-    }
-};
-exports.paintBoxShadow = paintBoxShadow;

package/dist/lib/render/canvas/box-shadow-transform.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shadowSpace = void 0;
-const bounds_1 = require("../../css/layout/bounds");
-// Map the output bitmap back into the current user space. Capture x/y are not
-// in this space once CSS transforms (including ancestor transforms) are active.
-// An AABB of all four inverse-transformed corners is conservative under rotation.
-const shadowSpace = (matrix, width, height) => {
-    const { a, b, c, d, e, f } = matrix;
-    if (![a, b, c, d, e, f, width, height].every(Number.isFinite))
-        return null;
-    const determinant = a * d - b * c;
-    if (!Number.isFinite(determinant) || determinant === 0)
-        return null;
-    const inversePoint = (x, y) => ({
-        x: (d * (x - e) - c * (y - f)) / determinant,
-        y: (-b * (x - e) + a * (y - f)) / determinant
-    });
-    const corners = [inversePoint(0, 0), inversePoint(width, 0), inversePoint(width, height), inversePoint(0, height)];
-    if (!corners.every((point) => Number.isFinite(point.x) && Number.isFinite(point.y)))
-        return null;
-    const left = Math.min(...corners.map((point) => point.x));
-    const top = Math.min(...corners.map((point) => point.y));
-    const right = Math.max(...corners.map((point) => point.x));
-    const bottom = Math.max(...corners.map((point) => point.y));
-    // Largest singular value: enough local raster resolution for either output
-    // axis. A scalar Canvas shadow blur is exact only for similarity transforms.
-    const xx = a * a + b * b;
-    const yy = c * c + d * d;
-    const xy = a * c + b * d;
-    const scale = Math.sqrt((xx + yy + Math.hypot(xx - yy, 2 * xy)) / 2);
-    if (!Number.isFinite(scale) || scale <= 0)
-        return null;
-    const tolerance = 1e-10 * Math.max(xx, yy);
-    return {
-        matrix,
-        viewport: new bounds_1.Bounds(left, top, right - left, bottom - top),
-        scale,
-        uniform: Math.abs(xx - yy) <= tolerance && Math.abs(xy) <= tolerance
-    };
-};
-exports.shadowSpace = shadowSpace;

package/dist/lib/render/canvas/canvas-path.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCanvasPath = exports.formatCanvasPath = void 0;
-const bezier_curve_1 = require("../bezier-curve");
-const formatCanvasPath = (ctx, paths) => {
-    paths.forEach((point, index) => {
-        const start = (0, bezier_curve_1.isBezierCurve)(point) ? point.start : point;
-        if (index === 0) {
-            ctx.moveTo(start.x, start.y);
-        }
-        else {
-            ctx.lineTo(start.x, start.y);
-        }
-        if ((0, bezier_curve_1.isBezierCurve)(point)) {
-            ctx.bezierCurveTo(point.startControl.x, point.startControl.y, point.endControl.x, point.endControl.y, point.end.x, point.end.y);
-        }
-    });
-};
-exports.formatCanvasPath = formatCanvasPath;
-const createCanvasPath = (ctx, paths) => {
-    ctx.beginPath();
-    (0, exports.formatCanvasPath)(ctx, paths);
-    ctx.closePath();
-};
-exports.createCanvasPath = createCanvasPath;