js-draw 0.18.1 → 0.18.2

package/dist/cjs/src/rendering/renderers/AbstractRenderer.js

@@ -0,0 +1,170 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Path_1 = __importStar(require("../../math/Path"));
+const Vec2_1 = require("../../math/Vec2");
+const RenderingStyle_1 = require("../RenderingStyle");
+class AbstractRenderer {
+    constructor(viewport) {
+        this.viewport = viewport;
+        // If null, this' transformation is linked to the Viewport
+        this.selfTransform = null;
+        this.transformStack = [];
+        this.objectLevel = 0;
+        this.currentPaths = null;
+    }
+    // this.canvasToScreen, etc. should be used instead of the corresponding
+    // methods on Viewport.
+    getViewport() { return this.viewport; }
+    setDraftMode(_draftMode) { }
+    flushPath() {
+        if (!this.currentPaths) {
+            return;
+        }
+        let lastStyle = null;
+        for (const path of this.currentPaths) {
+            const { startPoint, commands, style } = path;
+            if (!lastStyle || !(0, RenderingStyle_1.stylesEqual)(lastStyle, style)) {
+                if (lastStyle) {
+                    this.endPath(lastStyle);
+                }
+                this.beginPath(startPoint);
+                lastStyle = style;
+            }
+            else {
+                this.moveTo(startPoint);
+            }
+            for (const command of commands) {
+                if (command.kind === Path_1.PathCommandType.LineTo) {
+                    this.lineTo(command.point);
+                }
+                else if (command.kind === Path_1.PathCommandType.MoveTo) {
+                    this.moveTo(command.point);
+                }
+                else if (command.kind === Path_1.PathCommandType.CubicBezierTo) {
+                    this.traceCubicBezierCurve(command.controlPoint1, command.controlPoint2, command.endPoint);
+                }
+                else if (command.kind === Path_1.PathCommandType.QuadraticBezierTo) {
+                    this.traceQuadraticBezierCurve(command.controlPoint, command.endPoint);
+                }
+            }
+        }
+        if (lastStyle) {
+            this.endPath(lastStyle);
+        }
+    }
+    drawPath(path) {
+        // If we're being called outside of an object,
+        // we can't delay rendering
+        if (this.objectLevel === 0) {
+            this.currentPaths = [path];
+            this.flushPath();
+            this.currentPaths = null;
+        }
+        else {
+            // Otherwise, don't render paths all at once. This prevents faint lines between
+            // segments of the same stroke from being visible.
+            this.currentPaths.push(path);
+        }
+    }
+    // Strokes a rectangle. Boundary lines have width [lineWidth] and are filled with [lineFill].
+    // This is equivalent to `drawPath(Path.fromRect(...).toRenderable(...))`.
+    drawRect(rect, lineWidth, lineFill) {
+        const path = Path_1.default.fromRect(rect, lineWidth);
+        this.drawPath(path.toRenderable(lineFill));
+    }
+    // Fills a rectangle.
+    fillRect(rect, fill) {
+        const path = Path_1.default.fromRect(rect);
+        this.drawPath(path.toRenderable({ fill }));
+    }
+    // Note the start of an object with the given bounding box.
+    // Renderers are not required to support [clip]
+    startObject(_boundingBox, _clip) {
+        this.currentPaths = [];
+        this.objectLevel++;
+    }
+    /**
+     * Notes the end of an object.
+     * @param _loaderData - a map from strings to JSON-ifyable objects
+     * and contains properties attached to the object by whatever loader loaded the image. This
+     * is used to preserve attributes not supported by js-draw when loading/saving an image.
+     * Renderers may ignore this.
+     *
+     * @param _objectTags - a list of labels (e.g. `className`s) to be attached to the object.
+     * Renderers may ignore this.
+     */
+    endObject(_loaderData, _objectTags) {
+        // Render the paths all at once
+        this.flushPath();
+        this.currentPaths = null;
+        this.objectLevel--;
+        if (this.objectLevel < 0) {
+            throw new Error('More objects have ended than have been started (negative object nesting level)!');
+        }
+    }
+    getNestingLevel() {
+        return this.objectLevel;
+    }
+    // Returns true iff other can be rendered onto this without data loss.
+    canRenderFromWithoutDataLoss(_other) {
+        return false;
+    }
+    // MUST throw if other and this are not of the same base class.
+    renderFromOtherOfSameType(_renderTo, other) {
+        throw new Error(`Unable to render from ${other}: Not implemented`);
+    }
+    // Set a transformation to apply to things before rendering,
+    // replacing the viewport's transform.
+    setTransform(transform) {
+        this.selfTransform = transform;
+    }
+    pushTransform(transform) {
+        this.transformStack.push(this.selfTransform);
+        this.setTransform(this.getCanvasToScreenTransform().rightMul(transform));
+    }
+    popTransform() {
+        var _a;
+        if (this.transformStack.length === 0) {
+            throw new Error('Unable to pop more transforms than have been pushed!');
+        }
+        this.setTransform((_a = this.transformStack.pop()) !== null && _a !== void 0 ? _a : null);
+    }
+    // Get the matrix that transforms a vector on the canvas to a vector on this'
+    // rendering target.
+    getCanvasToScreenTransform() {
+        if (this.selfTransform) {
+            return this.selfTransform;
+        }
+        return this.viewport.canvasToScreenTransform;
+    }
+    canvasToScreen(vec) {
+        return this.getCanvasToScreenTransform().transformVec2(vec);
+    }
+    getSizeOfCanvasPixelOnScreen() {
+        return this.getCanvasToScreenTransform().transformVec3(Vec2_1.Vec2.unitX).length();
+    }
+}
+exports.default = AbstractRenderer;

package/dist/cjs/src/rendering/renderers/CanvasRenderer.d.ts

@@ -0,0 +1,63 @@
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Vec3 from '../../math/Vec3';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage, RenderablePathSpec } from './AbstractRenderer';
+/**
+ * Renders onto a `CanvasRenderingContext2D`.
+ *
+ * @example
+ * ```ts
+ * const editor = new Editor(document.body);
+ *
+ * const canvas = document.createElement('canvas');
+ * const ctx = canvas.getContext('2d');
+ *
+ * // Ensure that the canvas can fit the entire rendering
+ * const viewport = editor.image.getImportExportViewport();
+ * canvas.width = viewport.getScreenRectSize().x;
+ * canvas.height = viewport.getScreenRectSize().y;
+ *
+ * // Render editor.image onto the renderer
+ * const renderer = new CanvasRenderer(ctx, viewport);
+ * editor.image.render(renderer, viewport);
+ * ```
+ */
+export default class CanvasRenderer extends AbstractRenderer {
+    private ctx;
+    private ignoreObjectsAboveLevel;
+    private ignoringObject;
+    private currentObjectBBox;
+    private minSquareCurveApproxDist;
+    private minRenderSizeAnyDimen;
+    private minRenderSizeBothDimens;
+    /**
+     * Creates a new `CanvasRenderer` that renders to the given rendering context.
+     * The `viewport` is used to determine the translation/rotation/scaling of the content
+     * to draw.
+     */
+    constructor(ctx: CanvasRenderingContext2D, viewport: Viewport);
+    private transformBy;
+    canRenderFromWithoutDataLoss(other: AbstractRenderer): boolean;
+    renderFromOtherOfSameType(transformBy: Mat33, other: AbstractRenderer): void;
+    setDraftMode(draftMode: boolean): void;
+    displaySize(): Vec2;
+    clear(): void;
+    protected beginPath(startPoint: Point2): void;
+    protected endPath(style: RenderingStyle): void;
+    protected lineTo(point: Point2): void;
+    protected moveTo(point: Point2): void;
+    protected traceCubicBezierCurve(p1: Point2, p2: Point2, p3: Point2): void;
+    protected traceQuadraticBezierCurve(controlPoint: Vec3, endPoint: Vec3): void;
+    drawPath(path: RenderablePathSpec): void;
+    drawText(text: string, transform: Mat33, style: TextStyle): void;
+    drawImage(image: RenderableImage): void;
+    private clipLevels;
+    startObject(boundingBox: Rect2, clip?: boolean): void;
+    endObject(): void;
+    drawPoints(...points: Point2[]): void;
+    isTooSmallToRender(rect: Rect2): boolean;
+}

package/dist/cjs/src/rendering/renderers/CanvasRenderer.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Color4_1 = __importDefault(require("../../Color4"));
+const TextComponent_1 = __importDefault(require("../../components/TextComponent"));
+const Path_1 = __importDefault(require("../../math/Path"));
+const Vec2_1 = require("../../math/Vec2");
+const AbstractRenderer_1 = __importDefault(require("./AbstractRenderer"));
+/**
+ * Renders onto a `CanvasRenderingContext2D`.
+ *
+ * @example
+ * ```ts
+ * const editor = new Editor(document.body);
+ *
+ * const canvas = document.createElement('canvas');
+ * const ctx = canvas.getContext('2d');
+ *
+ * // Ensure that the canvas can fit the entire rendering
+ * const viewport = editor.image.getImportExportViewport();
+ * canvas.width = viewport.getScreenRectSize().x;
+ * canvas.height = viewport.getScreenRectSize().y;
+ *
+ * // Render editor.image onto the renderer
+ * const renderer = new CanvasRenderer(ctx, viewport);
+ * editor.image.render(renderer, viewport);
+ * ```
+ */
+class CanvasRenderer extends AbstractRenderer_1.default {
+    /**
+     * Creates a new `CanvasRenderer` that renders to the given rendering context.
+     * The `viewport` is used to determine the translation/rotation/scaling of the content
+     * to draw.
+     */
+    constructor(ctx, viewport) {
+        super(viewport);
+        this.ctx = ctx;
+        this.ignoreObjectsAboveLevel = null;
+        this.ignoringObject = false;
+        this.currentObjectBBox = null;
+        this.clipLevels = [];
+        this.setDraftMode(false);
+    }
+    transformBy(transformBy) {
+        // From MDN, transform(a,b,c,d,e,f)
+        // takes input such that
+        // ⎡ a c e ⎤
+        // ⎢ b d f ⎥ transforms content drawn to [ctx].
+        // ⎣ 0 0 1 ⎦
+        this.ctx.transform(transformBy.a1, transformBy.b1, // a, b
+        transformBy.a2, transformBy.b2, // c, d
+        transformBy.a3, transformBy.b3);
+    }
+    canRenderFromWithoutDataLoss(other) {
+        return other instanceof CanvasRenderer;
+    }
+    renderFromOtherOfSameType(transformBy, other) {
+        if (!(other instanceof CanvasRenderer)) {
+            throw new Error(`${other} cannot be rendered onto ${this}`);
+        }
+        transformBy = this.getCanvasToScreenTransform().rightMul(transformBy);
+        this.ctx.save();
+        this.transformBy(transformBy);
+        this.ctx.drawImage(other.ctx.canvas, 0, 0);
+        this.ctx.restore();
+    }
+    // Set parameters for lower/higher quality rendering
+    setDraftMode(draftMode) {
+        if (draftMode) {
+            this.minSquareCurveApproxDist = 9;
+            this.minRenderSizeBothDimens = 2;
+            this.minRenderSizeAnyDimen = 0.5;
+        }
+        else {
+            this.minSquareCurveApproxDist = 0.5;
+            this.minRenderSizeBothDimens = 0.2;
+            this.minRenderSizeAnyDimen = 1e-6;
+        }
+    }
+    displaySize() {
+        return Vec2_1.Vec2.of(this.ctx.canvas.clientWidth, this.ctx.canvas.clientHeight);
+    }
+    clear() {
+        this.ctx.clearRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
+    }
+    beginPath(startPoint) {
+        startPoint = this.canvasToScreen(startPoint);
+        this.ctx.beginPath();
+        this.ctx.moveTo(startPoint.x, startPoint.y);
+    }
+    endPath(style) {
+        this.ctx.fillStyle = style.fill.toHexString();
+        this.ctx.fill();
+        if (style.stroke) {
+            this.ctx.strokeStyle = style.stroke.color.toHexString();
+            this.ctx.lineWidth = this.getSizeOfCanvasPixelOnScreen() * style.stroke.width;
+            this.ctx.lineCap = 'round';
+            this.ctx.lineJoin = 'round';
+            this.ctx.stroke();
+        }
+        this.ctx.closePath();
+    }
+    lineTo(point) {
+        point = this.canvasToScreen(point);
+        this.ctx.lineTo(point.x, point.y);
+    }
+    moveTo(point) {
+        point = this.canvasToScreen(point);
+        this.ctx.moveTo(point.x, point.y);
+    }
+    traceCubicBezierCurve(p1, p2, p3) {
+        p1 = this.canvasToScreen(p1);
+        p2 = this.canvasToScreen(p2);
+        p3 = this.canvasToScreen(p3);
+        // Approximate the curve if small enough.
+        const delta1 = p2.minus(p1);
+        const delta2 = p3.minus(p2);
+        if (delta1.magnitudeSquared() < this.minSquareCurveApproxDist
+            && delta2.magnitudeSquared() < this.minSquareCurveApproxDist) {
+            this.ctx.lineTo(p3.x, p3.y);
+        }
+        else {
+            this.ctx.bezierCurveTo(p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
+        }
+    }
+    traceQuadraticBezierCurve(controlPoint, endPoint) {
+        controlPoint = this.canvasToScreen(controlPoint);
+        endPoint = this.canvasToScreen(endPoint);
+        // Approximate the curve with a line if small enough
+        const delta = controlPoint.minus(endPoint);
+        if (delta.magnitudeSquared() < this.minSquareCurveApproxDist) {
+            this.ctx.lineTo(endPoint.x, endPoint.y);
+        }
+        else {
+            this.ctx.quadraticCurveTo(controlPoint.x, controlPoint.y, endPoint.x, endPoint.y);
+        }
+    }
+    drawPath(path) {
+        var _a;
+        if (this.ignoringObject) {
+            return;
+        }
+        // If part of a huge object, it might be worth trimming the path
+        if ((_a = this.currentObjectBBox) === null || _a === void 0 ? void 0 : _a.containsRect(this.getViewport().visibleRect)) {
+            // Try to trim/remove parts of the path outside of the bounding box.
+            path = Path_1.default.visualEquivalent(path, this.getViewport().visibleRect);
+        }
+        super.drawPath(path);
+    }
+    drawText(text, transform, style) {
+        this.ctx.save();
+        transform = this.getCanvasToScreenTransform().rightMul(transform);
+        this.transformBy(transform);
+        TextComponent_1.default.applyTextStyles(this.ctx, style);
+        if (style.renderingStyle.fill.a !== 0) {
+            this.ctx.fillStyle = style.renderingStyle.fill.toHexString();
+            this.ctx.fillText(text, 0, 0);
+        }
+        if (style.renderingStyle.stroke) {
+            this.ctx.strokeStyle = style.renderingStyle.stroke.color.toHexString();
+            this.ctx.lineWidth = style.renderingStyle.stroke.width;
+            this.ctx.strokeText(text, 0, 0);
+        }
+        this.ctx.restore();
+    }
+    drawImage(image) {
+        this.ctx.save();
+        const transform = this.getCanvasToScreenTransform().rightMul(image.transform);
+        this.transformBy(transform);
+        this.ctx.drawImage(image.image, 0, 0);
+        this.ctx.restore();
+    }
+    startObject(boundingBox, clip) {
+        if (this.isTooSmallToRender(boundingBox)) {
+            this.ignoreObjectsAboveLevel = this.getNestingLevel();
+            this.ignoringObject = true;
+        }
+        super.startObject(boundingBox);
+        this.currentObjectBBox = boundingBox;
+        if (!this.ignoringObject && clip) {
+            this.clipLevels.push(this.objectLevel);
+            this.ctx.save();
+            this.ctx.beginPath();
+            for (const corner of boundingBox.corners) {
+                const screenCorner = this.canvasToScreen(corner);
+                this.ctx.lineTo(screenCorner.x, screenCorner.y);
+            }
+            this.ctx.clip();
+        }
+    }
+    endObject() {
+        if (!this.ignoringObject && this.clipLevels.length > 0) {
+            if (this.clipLevels[this.clipLevels.length - 1] === this.objectLevel) {
+                this.ctx.restore();
+                this.clipLevels.pop();
+            }
+        }
+        this.currentObjectBBox = null;
+        super.endObject();
+        // If exiting an object with a too-small-to-draw bounding box,
+        if (this.ignoreObjectsAboveLevel !== null && this.getNestingLevel() <= this.ignoreObjectsAboveLevel) {
+            this.ignoreObjectsAboveLevel = null;
+            this.ignoringObject = false;
+        }
+    }
+    // @internal
+    drawPoints(...points) {
+        const pointRadius = 10;
+        for (let i = 0; i < points.length; i++) {
+            const point = this.canvasToScreen(points[i]);
+            this.ctx.beginPath();
+            this.ctx.arc(point.x, point.y, pointRadius, 0, Math.PI * 2);
+            this.ctx.fillStyle = Color4_1.default.ofRGBA(0.5 + Math.sin(i) / 2, 1.0, 0.5 + Math.cos(i * 0.2) / 4, 0.5).toHexString();
+            this.ctx.fill();
+            this.ctx.stroke();
+            this.ctx.closePath();
+            this.ctx.textAlign = 'center';
+            this.ctx.textBaseline = 'middle';
+            this.ctx.fillStyle = 'black';
+            this.ctx.fillText(`${i}`, point.x, point.y, pointRadius * 2);
+        }
+    }
+    // @internal
+    isTooSmallToRender(rect) {
+        // Should we ignore all objects within this object's bbox?
+        const diagonal = this.getCanvasToScreenTransform().transformVec3(rect.size);
+        const bothDimenMinSize = this.minRenderSizeBothDimens;
+        const bothTooSmall = Math.abs(diagonal.x) < bothDimenMinSize && Math.abs(diagonal.y) < bothDimenMinSize;
+        const anyDimenMinSize = this.minRenderSizeAnyDimen;
+        const anyTooSmall = Math.abs(diagonal.x) < anyDimenMinSize || Math.abs(diagonal.y) < anyDimenMinSize;
+        return bothTooSmall || anyTooSmall;
+    }
+}
+exports.default = CanvasRenderer;

package/dist/cjs/src/rendering/renderers/DummyRenderer.d.ts

@@ -0,0 +1,35 @@
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Vec3 from '../../math/Vec3';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage } from './AbstractRenderer';
+export default class DummyRenderer extends AbstractRenderer {
+    clearedCount: number;
+    renderedPathCount: number;
+    lastFillStyle: RenderingStyle | null;
+    lastPoint: Point2 | null;
+    objectNestingLevel: number;
+    lastText: string | null;
+    lastImage: RenderableImage | null;
+    pointBuffer: Point2[];
+    constructor(viewport: Viewport);
+    displaySize(): Vec2;
+    clear(): void;
+    protected beginPath(startPoint: Vec3): void;
+    protected endPath(style: RenderingStyle): void;
+    protected lineTo(point: Vec3): void;
+    protected moveTo(point: Point2): void;
+    protected traceCubicBezierCurve(p1: Vec3, p2: Vec3, p3: Vec3): void;
+    protected traceQuadraticBezierCurve(controlPoint: Vec3, endPoint: Vec3): void;
+    drawPoints(..._points: Vec3[]): void;
+    drawText(text: string, _transform: Mat33, _style: TextStyle): void;
+    drawImage(image: RenderableImage): void;
+    startObject(boundingBox: Rect2, _clip: boolean): void;
+    endObject(): void;
+    isTooSmallToRender(_rect: Rect2): boolean;
+    canRenderFromWithoutDataLoss(other: AbstractRenderer): boolean;
+    renderFromOtherOfSameType(transform: Mat33, other: AbstractRenderer): void;
+}

package/dist/cjs/src/rendering/renderers/DummyRenderer.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Vec2_1 = require("../../math/Vec2");
+const AbstractRenderer_1 = __importDefault(require("./AbstractRenderer"));
+// Renderer that outputs almost nothing. Useful for automated tests.
+class DummyRenderer extends AbstractRenderer_1.default {
+    constructor(viewport) {
+        super(viewport);
+        // Variables that track the state of what's been rendered
+        this.clearedCount = 0;
+        this.renderedPathCount = 0;
+        this.lastFillStyle = null;
+        this.lastPoint = null;
+        this.objectNestingLevel = 0;
+        this.lastText = null;
+        this.lastImage = null;
+        // List of points drawn since the last clear.
+        this.pointBuffer = [];
+    }
+    displaySize() {
+        // Do we have a stored viewport size?
+        const viewportSize = this.getViewport().getScreenRectSize();
+        // Don't use a 0x0 viewport — DummyRenderer is often used
+        // for tests that run without a display, so pretend we have a
+        // reasonable-sized display.
+        if (viewportSize.x === 0 || viewportSize.y === 0) {
+            return Vec2_1.Vec2.of(640, 480);
+        }
+        return viewportSize;
+    }
+    clear() {
+        this.clearedCount++;
+        this.renderedPathCount = 0;
+        this.pointBuffer = [];
+        this.lastText = null;
+        this.lastImage = null;
+        // Ensure all objects finished rendering
+        if (this.objectNestingLevel > 0) {
+            throw new Error(`Within an object while clearing! Nesting level: ${this.objectNestingLevel}`);
+        }
+    }
+    beginPath(startPoint) {
+        this.lastPoint = startPoint;
+        this.pointBuffer.push(startPoint);
+    }
+    endPath(style) {
+        this.renderedPathCount++;
+        this.lastFillStyle = style;
+    }
+    lineTo(point) {
+        point = this.canvasToScreen(point);
+        this.lastPoint = point;
+        this.pointBuffer.push(point);
+    }
+    moveTo(point) {
+        point = this.canvasToScreen(point);
+        this.lastPoint = point;
+        this.pointBuffer.push(point);
+    }
+    traceCubicBezierCurve(p1, p2, p3) {
+        p1 = this.canvasToScreen(p1);
+        p2 = this.canvasToScreen(p2);
+        p3 = this.canvasToScreen(p3);
+        this.lastPoint = p3;
+        this.pointBuffer.push(p1, p2, p3);
+    }
+    traceQuadraticBezierCurve(controlPoint, endPoint) {
+        controlPoint = this.canvasToScreen(controlPoint);
+        endPoint = this.canvasToScreen(endPoint);
+        this.lastPoint = endPoint;
+        this.pointBuffer.push(controlPoint, endPoint);
+    }
+    drawPoints(..._points) {
+        // drawPoints is intended for debugging.
+        // As such, it is unlikely to be the target of automated tests.
+    }
+    drawText(text, _transform, _style) {
+        this.lastText = text;
+    }
+    drawImage(image) {
+        this.lastImage = image;
+    }
+    startObject(boundingBox, _clip) {
+        super.startObject(boundingBox);
+        this.objectNestingLevel += 1;
+    }
+    endObject() {
+        super.endObject();
+        this.objectNestingLevel -= 1;
+    }
+    isTooSmallToRender(_rect) {
+        return false;
+    }
+    canRenderFromWithoutDataLoss(other) {
+        return other instanceof DummyRenderer;
+    }
+    renderFromOtherOfSameType(transform, other) {
+        if (!(other instanceof DummyRenderer)) {
+            throw new Error(`${other} cannot be rendered onto ${this}`);
+        }
+        this.renderedPathCount += other.renderedPathCount;
+        this.lastFillStyle = other.lastFillStyle;
+        this.lastPoint = other.lastPoint;
+        this.pointBuffer.push(...other.pointBuffer.map(point => {
+            return transform.transformVec2(point);
+        }));
+    }
+}
+exports.default = DummyRenderer;

package/dist/cjs/src/rendering/renderers/SVGRenderer.d.ts

@@ -0,0 +1,57 @@
+import { LoadSaveDataTable } from '../../components/AbstractComponent';
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage, RenderablePathSpec } from './AbstractRenderer';
+export declare const renderedStylesheetId = "js-draw-style-sheet";
+/**
+ * Renders onto an `SVGElement`.
+ *
+ * @see {@link Editor.toSVG}
+ */
+export default class SVGRenderer extends AbstractRenderer {
+    private elem;
+    private sanitize;
+    private lastPathStyle;
+    private lastPathString;
+    private objectElems;
+    private overwrittenAttrs;
+    /**
+     * Creates a renderer that renders onto `elem`. If `sanitize`, don't render potentially untrusted data.
+     *
+     * `viewport` is used to determine the translation/rotation/scaling/output size of the rendered
+     * data.
+     */
+    constructor(elem: SVGSVGElement, viewport: Viewport, sanitize?: boolean);
+    private addStyleSheet;
+    setRootSVGAttribute(name: string, value: string | null): void;
+    displaySize(): Vec2;
+    clear(): void;
+    private addPathToSVG;
+    drawPath(pathSpec: RenderablePathSpec): void;
+    private transformFrom;
+    private textContainer;
+    private textContainerTransform;
+    private textParentStyle;
+    drawText(text: string, transform: Mat33, style: TextStyle): void;
+    drawImage(image: RenderableImage): void;
+    startObject(boundingBox: Rect2): void;
+    endObject(loaderData?: LoadSaveDataTable, elemClassNames?: string[]): void;
+    private unimplementedMessage;
+    protected beginPath(_startPoint: Point2): void;
+    protected endPath(_style: RenderingStyle): void;
+    protected lineTo(_point: Point2): void;
+    protected moveTo(_point: Point2): void;
+    protected traceCubicBezierCurve(_controlPoint1: Point2, _controlPoint2: Point2, _endPoint: Point2): void;
+    protected traceQuadraticBezierCurve(_controlPoint: Point2, _endPoint: Point2): void;
+    drawPoints(...points: Point2[]): void;
+    drawSVGElem(elem: SVGElement): void;
+    isTooSmallToRender(_rect: Rect2): boolean;
+    static fromViewport(viewport: Viewport, sanitize?: boolean): {
+        element: SVGSVGElement;
+        renderer: SVGRenderer;
+    };
+}