js-draw 1.7.2 → 1.9.0

package/dist/cjs/tools/PanZoom.js

@@ -71,12 +71,19 @@ class PanZoom extends BaseTool_1.default {
         this.editor = editor;
         this.mode = mode;
         this.transform = null;
+        // Constants
+        // initialRotationSnapAngle is larger than afterRotationStartSnapAngle to
+        // make it more difficult to start rotating (and easier to continue rotating).
+        this.initialRotationSnapAngle = 0.22; // radians
+        this.afterRotationStartSnapAngle = 0.07; // radians
+        this.pinchZoomStartThreshold = 1.08; // scale factor
         this.lastPointerDownTimestamp = 0;
         this.initialTouchAngle = 0;
         this.initialViewportRotation = 0;
         // Set to `true` only when scaling has started (if two fingers are down and have moved
         // far enough).
         this.isScaling = false;
+        this.isRotating = false;
         this.inertialScroller = null;
         this.velocity = null;
     }
@@ -118,6 +125,9 @@ class PanZoom extends BaseTool_1.default {
             this.initialTouchAngle = angle;
             this.initialViewportRotation = this.editor.viewport.getRotationAngle();
             this.isScaling = false;
+            // We're initially rotated if `initialViewportRotation` isn't near a multiple of pi/2.
+            // In other words, if sin(2 initialViewportRotation) is near zero.
+            this.isRotating = Math.abs(Math.sin(this.initialViewportRotation * 2)) > 1e-3;
             handlingGesture = true;
         }
         else if (pointers.length === 1 && ((this.mode & PanZoomMode.OneFingerTouchGestures && allAreTouch)
@@ -174,7 +184,9 @@ class PanZoom extends BaseTool_1.default {
         const roundedFullRotation = Math.round(fullRotation / snapToMultipleOf) * snapToMultipleOf;
         // The maximum angle for which we snap the given angle to a multiple of
         // `snapToMultipleOf`.
-        const maxSnapAngle = 0.07;
+        // Use a smaller snap angle if already rotated (to avoid pinch zoom gestures from
+        // starting rotation).
+        const maxSnapAngle = this.isRotating ? this.afterRotationStartSnapAngle : this.initialRotationSnapAngle;
         // Snap the rotation
         if (Math.abs(fullRotation - roundedFullRotation) < maxSnapAngle) {
             fullRotation = roundedFullRotation;
@@ -197,6 +209,11 @@ class PanZoom extends BaseTool_1.default {
         else {
             deltaRotation = this.toSnappedRotationDelta(angle);
         }
+        // If any rotation, make a note of this (affects rotation snap
+        // angles).
+        if (Math.abs(deltaRotation) > 1e-8) {
+            this.isRotating = true;
+        }
         this.updateVelocity(screenCenter);
         let scaleFactor = 1;
         if (this.isScaling) {
@@ -205,7 +222,9 @@ class PanZoom extends BaseTool_1.default {
         else {
             const initialScaleFactor = dist / this.startDist;
             // Only start scaling if scaling done so far exceeds some threshold.
-            if (initialScaleFactor > 1.05 || initialScaleFactor < 0.95) {
+            const upperBound = this.pinchZoomStartThreshold;
+            const lowerBound = 1 / this.pinchZoomStartThreshold;
+            if (initialScaleFactor > upperBound || initialScaleFactor < lowerBound) {
                 scaleFactor = initialScaleFactor;
                 this.isScaling = true;
             }

package/dist/cjs/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
-    number: '1.7.2',
+    number: '1.9.0',
 };

package/dist/mjs/EventDispatcher.mjs

@@ -1,4 +1,5 @@
-// Code shared with Joplin (js-draw was originally intended to be part of Joplin).
+// Code shared with Joplin (from when it was MIT licensed)
+// (js-draw was originally intended to be part of Joplin).
 /**
  * Handles notifying listeners of events.
  *

package/dist/mjs/SVGLoader.d.ts

@@ -18,7 +18,7 @@ export declare enum SVGLoaderLoadMethod {
 export interface SVGLoaderOptions {
     sanitize?: boolean;
     disableUnknownObjectWarnings?: boolean;
-    loadMethod?: 'iframe' | 'domparser';
+    loadMethod?: SVGLoaderLoadMethod;
 }
 export default class SVGLoader implements ImageLoader {
     private source;

package/dist/mjs/SVGLoader.mjs

@@ -6,6 +6,7 @@ import  SVGGlobalAttributesObject  from './components/SVGGlobalAttributesObject.
 import  TextComponent, { TextTransformMode }  from './components/TextComponent.mjs';
 import  UnknownSVGObject  from './components/UnknownSVGObject.mjs';
 import  { pathToRenderable }  from './rendering/RenderablePathSpec.mjs';
+import  { renderedStylesheetId }  from './rendering/renderers/SVGRenderer.mjs';
 // Size of a loaded image if no size is specified.
 export const defaultSVGViewRect = new Rect2(0, 0, 500, 500);
 // Key to retrieve unrecognised attributes from an AbstractComponent
@@ -475,7 +476,13 @@ export default class SVGLoader {
                 this.updateSVGAttrs(node);
                 break;
             case 'style':
-                await this.addUnknownNode(node);
+                // Keeping unnecessary style sheets can cause the browser to keep all
+                // SVG elements *referenced* by the style sheet in some browsers.
+                //
+                // Only keep the style sheet if it won't be discarded on save.
+                if (node.getAttribute('id') !== renderedStylesheetId) {
+                    await this.addUnknownNode(node);
+                }
                 break;
             default:
                 if (!this.disableUnknownObjectWarnings) {
@@ -518,6 +525,7 @@ export default class SVGLoader {
             this.onDetermineExportRect?.(defaultSVGViewRect);
         }
         this.onFinish?.();
+        this.onFinish = null;
     }
     /**
      * Create an `SVGLoader` from the content of an SVG image. SVGs are loaded within a sandboxed
@@ -529,7 +537,7 @@ export default class SVGLoader {
      * @param options - if `true` or `false`, treated as the `sanitize` option -- don't store unknown attributes.
      */
     static fromString(text, options = false) {
-        const domParserLoad = typeof options !== 'boolean' && options?.loadMethod === 'domparser';
+        const domParserLoad = typeof options !== 'boolean' && options?.loadMethod === SVGLoaderLoadMethod.DOMParser;
         const { svgElem, cleanUp } = (() => {
             // If the user requested an iframe load (the default) try to load with an iframe.
             // There are some cases (e.g. in a sandboxed iframe) where this doesn't work.
@@ -577,6 +585,7 @@ export default class SVGLoader {
                     const cleanUp = () => {
                         svgElem.remove();
                         sandbox.remove();
+                        sandbox.src = '';
                     };
                     return { svgElem, cleanUp };
                 }

package/dist/mjs/Viewport.d.ts

@@ -56,6 +56,8 @@ export declare class Viewport {
     /**
      * @returns the angle of the canvas in radians.
      * This is the angle by which the canvas is rotated relative to the screen.
+     *
+     * Returns an angle in the range $[-\pi, \pi]$ (the same range as {@link Vec3.angle}).
      */
     getRotationAngle(): number;
     /**

package/dist/mjs/Viewport.mjs

@@ -114,6 +114,8 @@ export class Viewport {
     /**
      * @returns the angle of the canvas in radians.
      * This is the angle by which the canvas is rotated relative to the screen.
+     *
+     * Returns an angle in the range $[-\pi, \pi]$ (the same range as {@link Vec3.angle}).
      */
     getRotationAngle() {
         return this.transform.transformVec3(Vec3.unitX).angle();

package/dist/mjs/components/AbstractComponent.d.ts

@@ -77,6 +77,15 @@ export default abstract class AbstractComponent {
      * {@link EditorImage}.
      */
     getSizingMode(): ComponentSizingMode;
+    /**
+     * **Optimization**
+     *
+     * Should return `true` if this component covers the entire `visibleRect`
+     * and would prevent anything below this component from being visible.
+     *
+     * Should return `false` otherwise.
+     */
+    occludesEverythingBelowWhenRenderedInRect(_visibleRect: Rect2): boolean;
     /** Called when this component is added to the given image. */
     onAddToImage(_image: EditorImage): void;
     onRemoveFromImage(): void;

package/dist/mjs/components/AbstractComponent.mjs

@@ -102,6 +102,17 @@ class AbstractComponent {
     getSizingMode() {
         return ComponentSizingMode.BoundingBox;
     }
+    /**
+     * **Optimization**
+     *
+     * Should return `true` if this component covers the entire `visibleRect`
+     * and would prevent anything below this component from being visible.
+     *
+     * Should return `false` otherwise.
+     */
+    occludesEverythingBelowWhenRenderedInRect(_visibleRect) {
+        return false;
+    }
     /** Called when this component is added to the given image. */
     onAddToImage(_image) { }
     onRemoveFromImage() { }

package/dist/mjs/components/Stroke.d.ts

@@ -49,6 +49,9 @@ export default class Stroke extends AbstractComponent implements RestyleableComp
     forceStyle(style: ComponentStyle, editor: Editor | null): void;
     intersects(line: LineSegment2): boolean;
     intersectsRect(rect: Rect2): boolean;
+    private simplifiedPath;
+    private computeSimplifiedPathFor;
+    occludesEverythingBelowWhenRenderedInRect(rect: Rect2): boolean;
     render(canvas: AbstractRenderer, visibleRect?: Rect2): void;
     getProportionalRenderingTime(): number;
     private bboxForPart;

package/dist/mjs/components/Stroke.mjs

@@ -2,7 +2,7 @@ import { Path, Rect2 } from '@js-draw/math';
 import  { styleFromJSON, styleToJSON }  from '../rendering/RenderingStyle.mjs';
 import  AbstractComponent  from './AbstractComponent.mjs';
 import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
-import  { pathFromRenderable, pathToRenderable }  from '../rendering/RenderablePathSpec.mjs';
+import  { pathFromRenderable, pathToRenderable, simplifyPathToFullScreenOrEmpty }  from '../rendering/RenderablePathSpec.mjs';
 /**
  * Represents an {@link AbstractComponent} made up of one or more {@link Path}s.
  *
@@ -41,6 +41,9 @@ export default class Stroke extends AbstractComponent {
         // @internal
         // eslint-disable-next-line @typescript-eslint/prefer-as-const
         this.isRestylableComponent = true;
+        // A simplification of the path for a given visibleRect. Intended
+        // to help check for occlusion.
+        this.simplifiedPath = null;
         this.approximateRenderingTime = 0;
         this.parts = [];
         for (const section of parts) {
@@ -166,9 +169,60 @@ export default class Stroke extends AbstractComponent {
         }
         return super.intersectsRect(rect);
     }
+    computeSimplifiedPathFor(visibleRect) {
+        const simplifiedParts = [];
+        let occludes = false;
+        let skipSimplification = false;
+        for (const part of this.parts) {
+            if (skipSimplification
+                // Simplification currently only works for stroked paths
+                || !part.style.stroke
+                // One of the main purposes of this is to check for occlusion.
+                // We can't occlude things if the stroke is partially transparent.
+                || part.style.stroke.color.a < 0.99) {
+                simplifiedParts.push(part);
+                continue;
+            }
+            const mapping = simplifyPathToFullScreenOrEmpty(part, visibleRect);
+            if (mapping) {
+                simplifiedParts.push(mapping.path);
+                if (mapping.fullScreen) {
+                    occludes = true;
+                    skipSimplification = true;
+                }
+            }
+            else {
+                simplifiedParts.push(part);
+            }
+        }
+        return {
+            forVisibleRect: visibleRect,
+            parts: simplifiedParts,
+            occludes,
+        };
+    }
+    occludesEverythingBelowWhenRenderedInRect(rect) {
+        // Can't occlude if doesn't contain.
+        if (!this.getBBox().containsRect(rect)) {
+            return false;
+        }
+        if (!this.simplifiedPath || !this.simplifiedPath.forVisibleRect.eq(rect)) {
+            this.simplifiedPath = this.computeSimplifiedPathFor(rect);
+        }
+        return this.simplifiedPath.occludes;
+    }
     render(canvas, visibleRect) {
         canvas.startObject(this.getBBox());
-        for (const part of this.parts) {
+        // Can we use a cached simplified path for faster rendering?
+        let parts = this.parts;
+        if (visibleRect && this.simplifiedPath?.forVisibleRect?.containsRect(visibleRect)) {
+            parts = this.simplifiedPath.parts;
+        }
+        else {
+            // Save memory
+            this.simplifiedPath = null;
+        }
+        for (const part of parts) {
             const bbox = this.bboxForPart(part.path.bbox, part.style);
             if (visibleRect) {
                 if (!bbox.intersects(visibleRect)) {

package/dist/mjs/image/EditorImage.d.ts

@@ -123,8 +123,28 @@ export default class EditorImage {
      */
     private setExportRectDirectly;
     private onExportViewportChanged;
+    /**
+     * @internal
+     *
+     * Enables debug mode for **all** `EditorImage`s.
+     *
+     * **Only use for debugging**.
+     *
+     * @internal
+     */
+    setDebugMode(newDebugMode: boolean): void;
     private static SetImportExportRectCommand;
 }
+/**
+ * Determines the first index in `sortedLeaves` that needs to be rendered
+ * (based on occlusion -- everything before that index can be skipped and
+ * produce a visually-equivalent image).
+ *
+ * Does nothing if visibleRect is not provided
+ *
+ * @internal
+ */
+export declare const computeFirstIndexToRender: (sortedLeaves: Array<ImageNode>, visibleRect?: Rect2) => number;
 type TooSmallToRenderCheck = (rect: Rect2) => boolean;
 /**
  * Part of the Editor's image. Does not handle fullscreen/invisible components.

package/dist/mjs/image/EditorImage.mjs

@@ -19,7 +19,7 @@ export var EditorImageEventType;
     EditorImageEventType[EditorImageEventType["ExportViewportChanged"] = 0] = "ExportViewportChanged";
     EditorImageEventType[EditorImageEventType["AutoresizeModeChanged"] = 1] = "AutoresizeModeChanged";
 })(EditorImageEventType || (EditorImageEventType = {}));
-const debugMode = false;
+let debugMode = false;
 // Handles lookup/storage of elements in the image
 class EditorImage {
     // @internal
@@ -271,6 +271,18 @@ class EditorImage {
             });
         }
     }
+    /**
+     * @internal
+     *
+     * Enables debug mode for **all** `EditorImage`s.
+     *
+     * **Only use for debugging**.
+     *
+     * @internal
+     */
+    setDebugMode(newDebugMode) {
+        debugMode = newDebugMode;
+    }
 }
 _a = EditorImage;
 // A Command that can access private [EditorImage] functionality
@@ -410,6 +422,30 @@ EditorImage.SetImportExportRectCommand = (_c = class extends SerializableCommand
     })(),
     _c);
 export default EditorImage;
+/**
+ * Determines the first index in `sortedLeaves` that needs to be rendered
+ * (based on occlusion -- everything before that index can be skipped and
+ * produce a visually-equivalent image).
+ *
+ * Does nothing if visibleRect is not provided
+ *
+ * @internal
+ */
+export const computeFirstIndexToRender = (sortedLeaves, visibleRect) => {
+    let startIndex = 0;
+    if (visibleRect) {
+        for (let i = sortedLeaves.length - 1; i >= 1; i--) {
+            if (
+            // Check for occlusion
+            sortedLeaves[i].getBBox().containsRect(visibleRect)
+                && sortedLeaves[i].getContent()?.occludesEverythingBelowWhenRenderedInRect(visibleRect)) {
+                startIndex = i;
+                break;
+            }
+        }
+    }
+    return startIndex;
+};
 /**
  * Part of the Editor's image. Does not handle fullscreen/invisible components.
  * @internal
@@ -663,12 +699,20 @@ export class ImageNode {
             leaves = this.getLeaves();
         }
         sortLeavesByZIndex(leaves);
-        for (const leaf of leaves) {
+        // If some components hide others (and we're permitted to simplify,
+        // which is true in the case of visibleRect being defined), then only
+        // draw the non-hidden components:
+        const startIndex = computeFirstIndexToRender(leaves);
+        for (let i = startIndex; i < leaves.length; i++) {
+            const leaf = leaves[i];
             // Leaves by definition have content
             leaf.getContent().render(renderer, visibleRect);
         }
         // Show debug information
         if (debugMode && visibleRect) {
+            if (startIndex !== 0) {
+                console.log('EditorImage: skipped ', startIndex, 'nodes due to occlusion');
+            }
             this.renderDebugBoundingBoxes(renderer, visibleRect);
         }
     }

package/dist/mjs/rendering/Display.d.ts

@@ -26,6 +26,7 @@ export default class Display {
     private textRenderer;
     private textRerenderOutput;
     private cache;
+    private devicePixelRatio;
     private resizeSurfacesCallback?;
     private flattenCallback?;
     /** @internal */
@@ -46,6 +47,14 @@ export default class Display {
     getColorAt: (_screenPos: Point2) => Color4 | null;
     private initializeCanvasRendering;
     private initializeTextRendering;
+    /**
+     * Sets the device-pixel-ratio.
+     *
+     * Intended for debugging. Users do not need to call this manually.
+     *
+     * @internal
+     */
+    setDevicePixelRatio(dpr: number): Promise<void> | undefined;
     /**
      * Rerenders the text-based display.
      * The text-based display is intended for screen readers and can be navigated to by pressing `tab`.

package/dist/mjs/rendering/Display.mjs

@@ -28,6 +28,7 @@ export default class Display {
         this.editor = editor;
         this.parent = parent;
         this.textRerenderOutput = null;
+        this.devicePixelRatio = window.devicePixelRatio ?? 1;
         /**
          * @returns the color at the given point on the dry ink renderer, or `null` if `screenPos`
          * 	is not on the display.
@@ -112,16 +113,29 @@ export default class Display {
             this.parent.appendChild(wetInkCanvas);
         }
         this.resizeSurfacesCallback = () => {
+            const expectedWidth = (canvas) => {
+                return Math.ceil(canvas.clientWidth * this.devicePixelRatio);
+            };
+            const expectedHeight = (canvas) => {
+                return Math.ceil(canvas.clientHeight * this.devicePixelRatio);
+            };
             const hasSizeMismatch = (canvas) => {
-                return canvas.clientHeight !== canvas.height || canvas.clientWidth !== canvas.width;
+                return expectedHeight(canvas) !== canvas.height || expectedWidth(canvas) !== canvas.width;
             };
             // Ensure that the drawing surfaces sizes match the
             // canvas' sizes to prevent stretching.
             if (hasSizeMismatch(dryInkCanvas) || hasSizeMismatch(wetInkCanvas)) {
-                dryInkCanvas.width = dryInkCanvas.clientWidth;
-                dryInkCanvas.height = dryInkCanvas.clientHeight;
-                wetInkCanvas.width = wetInkCanvas.clientWidth;
-                wetInkCanvas.height = wetInkCanvas.clientHeight;
+                dryInkCanvas.width = expectedWidth(dryInkCanvas);
+                dryInkCanvas.height = expectedHeight(dryInkCanvas);
+                wetInkCanvas.width = expectedWidth(wetInkCanvas);
+                wetInkCanvas.height = expectedHeight(wetInkCanvas);
+                // Ensure correct drawing operations on high-resolution screens.
+                // See
+                // https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Optimizing_canvas#scaling_for_high_resolution_displays
+                wetInkCtx.resetTransform();
+                dryInkCtx.resetTransform();
+                dryInkCtx.scale(this.devicePixelRatio, this.devicePixelRatio);
+                wetInkCtx.scale(this.devicePixelRatio, this.devicePixelRatio);
                 this.editor.notifier.dispatch(EditorEventType.DisplayResized, {
                     kind: EditorEventType.DisplayResized,
                     newSize: Vec2.of(this.width, this.height),
@@ -130,7 +144,10 @@ export default class Display {
         };
         this.resizeSurfacesCallback();
         this.flattenCallback = () => {
+            dryInkCtx.save();
+            dryInkCtx.resetTransform();
             dryInkCtx.drawImage(wetInkCanvas, 0, 0);
+            dryInkCtx.restore();
         };
         this.getColorAt = (screenPos) => {
             const pixel = dryInkCtx.getImageData(screenPos.x, screenPos.y, 1, 1);
@@ -156,6 +173,23 @@ export default class Display {
         textRendererOutputContainer.replaceChildren(rerenderButton, this.textRerenderOutput);
         this.editor.createHTMLOverlay(textRendererOutputContainer);
     }
+    /**
+     * Sets the device-pixel-ratio.
+     *
+     * Intended for debugging. Users do not need to call this manually.
+     *
+     * @internal
+     */
+    setDevicePixelRatio(dpr) {
+        const minDpr = 0.001;
+        const maxDpr = 10;
+        if (isFinite(dpr) && dpr >= minDpr && dpr <= maxDpr && dpr !== this.devicePixelRatio) {
+            this.devicePixelRatio = dpr;
+            this.resizeSurfacesCallback?.();
+            return this.editor.queueRerender();
+        }
+        return undefined;
+    }
     /**
      * Rerenders the text-based display.
      * The text-based display is intended for screen readers and can be navigated to by pressing `tab`.

package/dist/mjs/rendering/RenderablePathSpec.d.ts

@@ -6,11 +6,29 @@ interface RenderablePathSpec {
     style: RenderingStyle;
     path?: Path;
 }
+interface RenderablePathSpecWithPath extends RenderablePathSpec {
+    path: Path;
+}
 /** Converts a renderable path (a path with a `startPoint`, `commands`, and `style`). */
 export declare const pathFromRenderable: (renderable: RenderablePathSpec) => Path;
-export declare const pathToRenderable: (path: Path, style: RenderingStyle) => RenderablePathSpec;
+export declare const pathToRenderable: (path: Path, style: RenderingStyle) => RenderablePathSpecWithPath;
+interface RectangleSimplificationResult {
+    rectangle: Rect2;
+    path: RenderablePathSpecWithPath;
+    fullScreen: boolean;
+}
+/**
+ * Tries to simplify the given path to a fullscreen rectangle.
+ * Returns `null` on failure.
+ *
+ * @internal
+ */
+export declare const simplifyPathToFullScreenOrEmpty: (renderablePath: RenderablePathSpec, visibleRect: Rect2, options?: {
+    fastCheck: boolean;
+    expensiveCheck: boolean;
+}) => RectangleSimplificationResult | null;
 /**
  * @returns a Path that, when rendered, looks roughly equivalent to the given path.
  */
-export declare const visualEquivalent: (renderablePath: RenderablePathSpec, visibleRect: Rect2) => RenderablePathSpec;
+export declare const visualEquivalent: (renderablePath: RenderablePathSpec, visibleRect: Rect2) => RenderablePathSpecWithPath;
 export default RenderablePathSpec;

package/dist/mjs/rendering/RenderablePathSpec.mjs

@@ -1,4 +1,4 @@
-import { Mat33, Path, PathCommandType } from '@js-draw/math';
+import { Color4, Mat33, Path, PathCommandType, Rect2 } from '@js-draw/math';
 /** Converts a renderable path (a path with a `startPoint`, `commands`, and `style`). */
 export const pathFromRenderable = (renderable) => {
     if (renderable.path) {
@@ -15,33 +15,89 @@ export const pathToRenderable = (path, style) => {
     };
 };
 /**
- * @returns a Path that, when rendered, looks roughly equivalent to the given path.
+ * Fills the optional `path` field in `RenderablePathSpec`
+ * with `path` if not already filled
  */
-export const visualEquivalent = (renderablePath, visibleRect) => {
+const pathIncluded = (renderablePath, path) => {
+    if (renderablePath.path) {
+        return renderablePath;
+    }
+    return {
+        ...renderablePath,
+        path,
+    };
+};
+/**
+ * Tries to simplify the given path to a fullscreen rectangle.
+ * Returns `null` on failure.
+ *
+ * @internal
+ */
+export const simplifyPathToFullScreenOrEmpty = (renderablePath, visibleRect, options = { fastCheck: true, expensiveCheck: true }) => {
     const path = pathFromRenderable(renderablePath);
     const strokeWidth = renderablePath.style.stroke?.width ?? 0;
     const onlyStroked = strokeWidth > 0 && renderablePath.style.fill.a === 0;
     const styledPathBBox = path.bbox.grownBy(strokeWidth);
     // Are we close enough to the path that it fills the entire screen?
-    if (onlyStroked
-        && renderablePath.style.stroke
+    const isOnlyStrokedAndCouldFillScreen = (onlyStroked
         && strokeWidth > visibleRect.maxDimension
-        && styledPathBBox.containsRect(visibleRect)) {
+        && styledPathBBox.containsRect(visibleRect));
+    if (options.fastCheck && isOnlyStrokedAndCouldFillScreen && renderablePath.style.stroke) {
         const strokeRadius = strokeWidth / 2;
+        // Are we completely within the stroke?
         // Do a fast, but with many false negatives, check.
         for (const point of path.startEndPoints()) {
             // If within the strokeRadius of any point
             if (visibleRect.isWithinRadiusOf(strokeRadius, point)) {
-                return pathToRenderable(Path.fromRect(visibleRect), { fill: renderablePath.style.stroke.color });
+                return {
+                    rectangle: visibleRect,
+                    path: pathToRenderable(Path.fromRect(visibleRect), { fill: renderablePath.style.stroke.color }),
+                    fullScreen: true,
+                };
             }
         }
     }
+    // Try filtering again, but with slightly more expensive checks
+    if (options.expensiveCheck &&
+        isOnlyStrokedAndCouldFillScreen && renderablePath.style.stroke
+        && strokeWidth > visibleRect.maxDimension * 3) {
+        const signedDist = path.signedDistance(visibleRect.center, strokeWidth / 2);
+        const margin = strokeWidth / 6;
+        if (signedDist < -visibleRect.maxDimension / 2 - margin) {
+            return {
+                path: pathToRenderable(Path.fromRect(visibleRect), { fill: renderablePath.style.stroke.color }),
+                rectangle: visibleRect,
+                fullScreen: true,
+            };
+        }
+        else if (signedDist > visibleRect.maxDimension / 2 + margin) {
+            return {
+                path: pathToRenderable(Path.empty, { fill: Color4.transparent }),
+                rectangle: Rect2.empty,
+                fullScreen: false,
+            };
+        }
+    }
+    return null;
+};
+/**
+ * @returns a Path that, when rendered, looks roughly equivalent to the given path.
+ */
+export const visualEquivalent = (renderablePath, visibleRect) => {
+    const path = pathFromRenderable(renderablePath);
+    const strokeWidth = renderablePath.style.stroke?.width ?? 0;
+    const onlyStroked = strokeWidth > 0 && renderablePath.style.fill.a === 0;
+    const styledPathBBox = path.bbox.grownBy(strokeWidth);
+    let rectangleSimplification = simplifyPathToFullScreenOrEmpty(renderablePath, visibleRect, { fastCheck: true, expensiveCheck: false, });
+    if (rectangleSimplification) {
+        return rectangleSimplification.path;
+    }
     // Scale the expanded rect --- the visual equivalent is only close for huge strokes.
     const expandedRect = visibleRect.grownBy(strokeWidth)
         .transformedBoundingBox(Mat33.scaling2D(4, visibleRect.center));
     // TODO: Handle simplifying very small paths.
     if (expandedRect.containsRect(styledPathBBox)) {
-        return renderablePath;
+        return pathIncluded(renderablePath, path);
     }
     const parts = [];
     let startPoint = path.startPoint;
@@ -76,5 +132,11 @@ export const visualEquivalent = (renderablePath, visibleRect) => {
         }
         startPoint = endPoint;
     }
-    return pathToRenderable(new Path(path.startPoint, parts), renderablePath.style);
+    const newPath = new Path(path.startPoint, parts);
+    const newStyle = renderablePath.style;
+    rectangleSimplification = simplifyPathToFullScreenOrEmpty(renderablePath, visibleRect, { fastCheck: false, expensiveCheck: true, });
+    if (rectangleSimplification) {
+        return rectangleSimplification.path;
+    }
+    return pathToRenderable(newPath, newStyle);
 };

package/dist/mjs/rendering/caching/CacheRecord.mjs

@@ -47,8 +47,10 @@ export default class CacheRecord {
         return transform;
     }
     setRenderingRegion(drawTo) {
-        this.renderer.setTransform(
-        // Invert to map objects instead of the viewport
-        this.getTransform(drawTo));
+        const transform = this.getTransform(drawTo);
+        this.renderer.setTransform(transform);
+        // The visible region may be slightly larger than where we're actually drawing
+        // to (because of rounding).
+        this.renderer.overrideVisibleRect(drawTo.grownBy(1 / transform.getScaleFactor()));
     }
 }