js-draw 0.0.5 → 0.0.8

package/dist/src/Editor.js

@@ -23,7 +23,6 @@ import SVGLoader from './SVGLoader';
 import Pointer from './Pointer';
 import Mat33 from './geometry/Mat33';
 import { defaultEditorLocalization } from './localization';
-;
 export class Editor {
     constructor(parent, settings = {}) {
         var _a, _b;
@@ -132,6 +131,14 @@ export class Editor {
             var _a, _b;
             const pointer = Pointer.ofEvent(evt, (_b = (_a = pointers[evt.pointerId]) === null || _a === void 0 ? void 0 : _a.down) !== null && _b !== void 0 ? _b : false, this.viewport);
             if (pointer.down) {
+                const prevData = pointers[pointer.id];
+                if (prevData) {
+                    const distanceMoved = pointer.screenPos.minus(prevData.screenPos).magnitude();
+                    // If the pointer moved less than two pixels, don't send a new event.
+                    if (distanceMoved < 2) {
+                        return;
+                    }
+                }
                 pointers[pointer.id] = pointer;
                 if (this.toolController.dispatchInputEvent({
                     kind: InputEvtType.PointerMoveEvt,
@@ -324,6 +331,7 @@ export class Editor {
         result.setAttribute('viewBox', `${rect.x} ${rect.y} ${rect.w} ${rect.h}`);
         result.setAttribute('width', `${rect.w}`);
         result.setAttribute('height', `${rect.h}`);
+        console.log('res', result);
         // Ensure the image can be identified as an SVG if downloaded.
         // See https://jwatt.org/svg/authoring/
         result.setAttribute('version', '1.1');

package/dist/src/EditorImage.d.ts

@@ -15,8 +15,8 @@ export default class EditorImage {
     getElementsIntersectingRegion(region: Rect2): AbstractComponent[];
     static AddElementCommand: {
         new (element: AbstractComponent, applyByFlattening?: boolean): {
-            readonly "__#1@#element": AbstractComponent;
-            "__#1@#applyByFlattening": boolean;
+            readonly "__#2@#element": AbstractComponent;
+            "__#2@#applyByFlattening": boolean;
             apply(editor: Editor): void;
             unapply(editor: Editor): void;
             description(localization: EditorLocalization): string;

package/dist/src/SVGLoader.d.ts

@@ -15,7 +15,9 @@ export default class SVGLoader implements ImageLoader {
     private addPath;
     private addUnknownNode;
     private updateViewBox;
+    private updateSVGAttrs;
     private visit;
+    private getSourceAttrs;
     start(onAddComponent: ComponentAddedListener, onProgress: OnProgressListener): Promise<Rect2>;
     static fromString(text: string): SVGLoader;
 }

package/dist/src/SVGLoader.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Color4 from './Color4';
 import Stroke from './components/Stroke';
+import SVGGlobalAttributesObject from './components/SVGGlobalAttributesObject';
 import UnknownSVGObject from './components/UnknownSVGObject';
 import Path from './geometry/Path';
 import Rect2 from './geometry/Rect2';
@@ -65,7 +66,9 @@ export default class SVGLoader {
         const parts = pathData.split('M');
         let isFirst = true;
         for (const part of parts) {
-            if (part !== '') {
+            // Skip effective no-ops -- moveTos without additional commands.
+            const isNoOpMoveTo = /^[0-9., \t\n]+$/.exec(part);
+            if (part !== '' && !isNoOpMoveTo) {
                 // We split the path by moveTo commands, so add the 'M' back in
                 // if it was present.
                 const current = !isFirst ? `M${part}` : part;
@@ -111,6 +114,10 @@ export default class SVGLoader {
         }
         this.rootViewBox = new Rect2(x, y, width, height);
     }
+    updateSVGAttrs(node) {
+        var _a;
+        (_a = this.onAddComponent) === null || _a === void 0 ? void 0 : _a.call(this, new SVGGlobalAttributesObject(this.getSourceAttrs(node)));
+    }
     visit(node) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -124,6 +131,7 @@ export default class SVGLoader {
                     break;
                 case 'svg':
                     this.updateViewBox(node);
+                    this.updateSVGAttrs(node);
                     break;
                 default:
                     console.warn('Unknown SVG element,', node);
@@ -140,6 +148,12 @@ export default class SVGLoader {
             yield ((_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, this.processedCount, this.totalToProcess));
         });
     }
+    // Get SVG element attributes (e.g. xlink=...)
+    getSourceAttrs(node) {
+        return node.getAttributeNames().map(attr => {
+            return [attr, node.getAttribute(attr)];
+        });
+    }
     start(onAddComponent, onProgress) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {

package/dist/src/UndoRedoHistory.d.ts

@@ -13,5 +13,7 @@ declare class UndoRedoHistory {
     push(command: Command, apply?: boolean): void;
     undo(): void;
     redo(): void;
+    get undoStackSize(): number;
+    get redoStackSize(): number;
 }
 export default UndoRedoHistory;

package/dist/src/Viewport.d.ts

@@ -10,7 +10,7 @@ export declare class Viewport {
     private notifier;
     static ViewportTransform: {
         new (transform: Mat33): {
-            readonly "__#2@#inverseTransform": Mat33;
+            readonly "__#1@#inverseTransform": Mat33;
             readonly transform: Mat33;
             apply(editor: Editor): void;
             unapply(editor: Editor): void;

package/dist/src/components/SVGGlobalAttributesObject.d.ts

@@ -0,0 +1,15 @@
+import LineSegment2 from '../geometry/LineSegment2';
+import Mat33 from '../geometry/Mat33';
+import Rect2 from '../geometry/Rect2';
+import AbstractRenderer from '../rendering/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+export default class SVGGlobalAttributesObject extends AbstractComponent {
+    private readonly attrs;
+    protected contentBBox: Rect2;
+    constructor(attrs: Array<[string, string | null]>);
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    intersects(_lineSegment: LineSegment2): boolean;
+    protected applyTransformation(_affineTransfm: Mat33): void;
+    description(localization: ImageComponentLocalization): string;
+}

package/dist/src/components/SVGGlobalAttributesObject.js

@@ -0,0 +1,29 @@
+import Rect2 from '../geometry/Rect2';
+import SVGRenderer from '../rendering/SVGRenderer';
+import AbstractComponent from './AbstractComponent';
+// Stores global SVG attributes (e.g. namespace identifiers.)
+export default class SVGGlobalAttributesObject extends AbstractComponent {
+    constructor(attrs) {
+        super();
+        this.attrs = attrs;
+        this.contentBBox = Rect2.empty;
+    }
+    render(canvas, _visibleRect) {
+        if (!(canvas instanceof SVGRenderer)) {
+            // Don't draw unrenderable objects if we can't
+            return;
+        }
+        console.log('Rendering to SVG.', this.attrs);
+        for (const [attr, value] of this.attrs) {
+            canvas.setRootSVGAttribute(attr, value);
+        }
+    }
+    intersects(_lineSegment) {
+        return false;
+    }
+    applyTransformation(_affineTransfm) {
+    }
+    description(localization) {
+        return localization.svgObject;
+    }
+}

package/dist/src/components/builders/FreehandLineBuilder.js

@@ -148,9 +148,21 @@ export default class FreehandLineBuilder {
                 projectionT = 0.9;
             }
         }
-        const halfVec = Vec2.ofXY(this.currentCurve.normal(projectionT))
-            .normalized().times(this.curveStartWidth / 2 * projectionT
-            + this.curveEndWidth / 2 * (1 - projectionT));
+        const halfVecT = projectionT;
+        let halfVec = Vec2.ofXY(this.currentCurve.normal(halfVecT))
+            .normalized().times(this.curveStartWidth / 2 * halfVecT
+            + this.curveEndWidth / 2 * (1 - halfVecT));
+        // Computes a boundary curve. [direction] should be either +1 or -1 (determines the side
+        // of the center curve to place the boundary).
+        const computeBoundaryCurve = (direction, halfVec) => {
+            return new Bezier(startPt.plus(startVec.times(direction)), controlPoint.plus(halfVec.times(direction)), endPt.plus(endVec.times(direction)));
+        };
+        const upperBoundary = computeBoundaryCurve(1, halfVec);
+        const lowerBoundary = computeBoundaryCurve(-1, halfVec);
+        // If the boundaries have two intersections, increasing the half vector's length could fix this.
+        if (upperBoundary.intersects(lowerBoundary).length === 2) {
+            halfVec = halfVec.times(2);
+        }
         const pathCommands = [
             {
                 kind: PathCommandType.QuadraticBezierTo,

package/dist/src/geometry/Path.js

@@ -277,14 +277,24 @@ export default class Path {
         pathString = pathString.split('\n').join(' ');
         let lastPos = Vec2.zero;
         let firstPos = null;
+        let isFirstCommand = true;
         const commands = [];
         const moveTo = (point) => {
+            // The first moveTo/lineTo is already handled by the [startPoint] parameter of the Path constructor.
+            if (isFirstCommand) {
+                isFirstCommand = false;
+                return;
+            }
             commands.push({
                 kind: PathCommandType.MoveTo,
                 point,
             });
         };
         const lineTo = (point) => {
+            if (isFirstCommand) {
+                isFirstCommand = false;
+                return;
+            }
             commands.push({
                 kind: PathCommandType.LineTo,
                 point,
@@ -390,6 +400,7 @@ export default class Path {
             if (args.length > 0) {
                 firstPos !== null && firstPos !== void 0 ? firstPos : (firstPos = args[0]);
             }
+            isFirstCommand = false;
         }
         return new Path(firstPos !== null && firstPos !== void 0 ? firstPos : Vec2.zero, commands);
     }

package/dist/src/htmlUtil.d.ts

@@ -0,0 +1 @@
+export declare const escapeHtml: (html: string) => string;

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

@@ -10,7 +10,9 @@ export default class SVGRenderer extends AbstractRenderer {
     private lastPath;
     private lastPathStart;
     private mainGroup;
+    private overwrittenAttrs;
     constructor(elem: SVGSVGElement, viewport: Viewport);
+    setRootSVGAttribute(name: string, value: string | null): void;
     displaySize(): Vec2;
     clear(): void;
     protected beginPath(startPoint: Point2): void;

package/dist/src/rendering/SVGRenderer.js

@@ -6,13 +6,38 @@ export default class SVGRenderer extends AbstractRenderer {
     constructor(elem, viewport) {
         super(viewport);
         this.elem = elem;
+        this.overwrittenAttrs = {};
         this.clear();
     }
+    // Sets an attribute on the root SVG element.
+    setRootSVGAttribute(name, value) {
+        // Make the original value of the attribute restorable on clear
+        if (!(name in this.overwrittenAttrs)) {
+            this.overwrittenAttrs[name] = this.elem.getAttribute(name);
+        }
+        if (value !== null) {
+            this.elem.setAttribute(name, value);
+        }
+        else {
+            this.elem.removeAttribute(name);
+        }
+    }
     displaySize() {
         return Vec2.of(this.elem.clientWidth, this.elem.clientHeight);
     }
     clear() {
         this.mainGroup = document.createElementNS(svgNameSpace, 'g');
+        // Restore all alltributes
+        for (const attrName in this.overwrittenAttrs) {
+            const value = this.overwrittenAttrs[attrName];
+            if (value) {
+                this.elem.setAttribute(attrName, value);
+            }
+            else {
+                this.elem.removeAttribute(attrName);
+            }
+        }
+        this.overwrittenAttrs = {};
         // Remove all children
         this.elem.replaceChildren(this.mainGroup);
     }

package/dist/src/tools/BaseTool.d.ts

@@ -6,10 +6,10 @@ export default abstract class BaseTool implements PointerEvtListener {
     readonly description: string;
     private enabled;
     private group;
-    abstract onPointerDown(event: PointerEvt): boolean;
-    abstract onPointerMove(event: PointerEvt): void;
-    abstract onPointerUp(event: PointerEvt): void;
-    abstract onGestureCancel(): void;
+    onPointerDown(_event: PointerEvt): boolean;
+    onPointerMove(_event: PointerEvt): void;
+    onPointerUp(_event: PointerEvt): void;
+    onGestureCancel(): void;
     abstract readonly kind: ToolType;
     protected constructor(notifier: EditorNotifier, description: string);
     onWheel(_event: WheelEvt): boolean;

package/dist/src/tools/SelectionTool.js

@@ -24,7 +24,6 @@ const styles = `
 		position: absolute;
 		z-index: 0;
 		transform-origin: center;
-		overflow: hidden;
 	}
 
 	.handleOverlay > .selectionBox .draggableBackground {

package/dist/src/tools/ToolController.d.ts

@@ -7,7 +7,8 @@ export declare enum ToolType {
     Pen = 1,
     Selection = 2,
     Eraser = 3,
-    PanZoom = 4
+    PanZoom = 4,
+    UndoRedoShortcut = 5
 }
 export default class ToolController {
     private tools;

package/dist/src/tools/UndoRedoShortcut.d.ts

@@ -0,0 +1,10 @@
+import Editor from '../Editor';
+import { KeyPressEvent } from '../types';
+import BaseTool from './BaseTool';
+import { ToolType } from './ToolController';
+export default class UndoRedoShortcut extends BaseTool {
+    private editor;
+    kind: ToolType.UndoRedoShortcut;
+    constructor(editor: Editor);
+    onKeyPress({ key, ctrlKey }: KeyPressEvent): boolean;
+}

package/dist/src/tools/localization.d.ts

@@ -4,6 +4,7 @@ export interface ToolLocalization {
     eraserTool: string;
     touchPanTool: string;
     twoFingerPanZoomTool: string;
+    undoRedoTool: string;
     toolEnabledAnnouncement: (toolName: string) => string;
     toolDisabledAnnouncement: (toolName: string) => string;
 }

package/dist/src/types.d.ts

@@ -29,6 +29,7 @@ export interface WheelEvt {
 export interface KeyPressEvent {
     readonly kind: InputEvtType.KeyPressEvent;
     readonly key: string;
+    readonly ctrlKey: boolean;
 }
 export interface GestureCancelEvt {
     readonly kind: InputEvtType.GestureCancelEvt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-draw",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "description": "Draw pictures using a pen, touchscreen, or mouse! JS-draw is a drawing library for JavaScript and TypeScript. ",
   "main": "dist/src/Editor.js",
   "types": "dist/src/Editor.d.ts",
@@ -75,7 +75,7 @@
     "ts-jest": "^28.0.8",
     "ts-loader": "^9.3.1",
     "ts-node": "^10.9.1",
-    "typescript": "^4.7.4",
+    "typescript": "^4.8.2",
     "webpack": "^5.74.0"
   },
   "bugs": {

package/src/Editor.ts

@@ -186,8 +186,18 @@ export class Editor {
 				evt, pointers[evt.pointerId]?.down ?? false, this.viewport
 			);
 			if (pointer.down) {
-				pointers[pointer.id] = pointer;
+				const prevData = pointers[pointer.id];
+
+				if (prevData) {
+					const distanceMoved = pointer.screenPos.minus(prevData.screenPos).magnitude();
 
+					// If the pointer moved less than two pixels, don't send a new event.
+					if (distanceMoved < 2) {
+						return;
+					}
+				}
+
+				pointers[pointer.id] = pointer;
 				if (this.toolController.dispatchInputEvent({
 					kind: InputEvtType.PointerMoveEvt,
 					current: pointer,
@@ -228,6 +238,7 @@ export class Editor {
 			if (this.toolController.dispatchInputEvent({
 				kind: InputEvtType.KeyPressEvent,
 				key: evt.key,
+				ctrlKey: evt.ctrlKey,
 			})) {
 				evt.preventDefault();
 			}

package/src/EditorImage.test.ts

@@ -5,12 +5,9 @@ import Stroke from './components/Stroke';
 import { Vec2 } from './geometry/Vec2';
 import Path, { PathCommandType } from './geometry/Path';
 import Color4 from './Color4';
-import Editor from './Editor';
-import { RenderingMode } from './Display';
 import DummyRenderer from './rendering/DummyRenderer';
 import { RenderingStyle } from './rendering/AbstractRenderer';
-
-const createEditor = () => new Editor(document.body, { renderingMode: RenderingMode.DummyRenderer });
+import createEditor from './testing/createEditor';
 
 describe('EditorImage', () => {
 	const testStroke = new Stroke([

package/src/SVGLoader.ts

@@ -1,6 +1,7 @@
 import Color4 from './Color4';
 import AbstractComponent from './components/AbstractComponent';
 import Stroke from './components/Stroke';
+import SVGGlobalAttributesObject from './components/SVGGlobalAttributesObject';
 import UnknownSVGObject from './components/UnknownSVGObject';
 import Path from './geometry/Path';
 import Rect2 from './geometry/Rect2';
@@ -66,10 +67,14 @@ export default class SVGLoader implements ImageLoader {
 		const parts = pathData.split('M');
 		let isFirst = true;
 		for (const part of parts) {
-			if (part !== '') {
+			// Skip effective no-ops -- moveTos without additional commands.
+			const isNoOpMoveTo = /^[0-9., \t\n]+$/.exec(part);
+
+			if (part !== '' && !isNoOpMoveTo) {
 				// We split the path by moveTo commands, so add the 'M' back in
 				// if it was present.
 				const current = !isFirst ? `M${part}` : part;
+
 				const path = Path.fromString(current);
 				const spec = path.toRenderable(style);
 				result.push(spec);
@@ -123,6 +128,10 @@ export default class SVGLoader implements ImageLoader {
 		this.rootViewBox = new Rect2(x, y, width, height);
 	}
 
+	private updateSVGAttrs(node: SVGSVGElement) {
+		this.onAddComponent?.(new SVGGlobalAttributesObject(this.getSourceAttrs(node)));
+	}
+
 	private async visit(node: Element) {
 		this.totalToProcess += node.childElementCount;
 
@@ -135,6 +144,7 @@ export default class SVGLoader implements ImageLoader {
 			break;
 		case 'svg':
 			this.updateViewBox(node as SVGSVGElement);
+			this.updateSVGAttrs(node as SVGSVGElement);
 			break;
 		default:
 			console.warn('Unknown SVG element,', node);
@@ -154,6 +164,13 @@ export default class SVGLoader implements ImageLoader {
 		await this.onProgress?.(this.processedCount, this.totalToProcess);
 	}
 
+	// Get SVG element attributes (e.g. xlink=...)
+	private getSourceAttrs(node: SVGSVGElement): Array<[string, string|null]> {
+		return node.getAttributeNames().map(attr => {
+			return [ attr, node.getAttribute(attr) ];
+		});
+	}
+
 	public async start(
 		onAddComponent: ComponentAddedListener, onProgress: OnProgressListener
 	): Promise<Rect2> {

package/src/UndoRedoHistory.ts

@@ -56,6 +56,14 @@ class UndoRedoHistory {
 		}
 		this.fireUpdateEvent();
 	}
+
+	public get undoStackSize(): number {
+		return this.undoStack.length;
+	}
+
+	public get redoStackSize(): number {
+		return this.redoStack.length;
+	}
 }
 
 export default UndoRedoHistory;

package/src/components/SVGGlobalAttributesObject.ts

@@ -0,0 +1,39 @@
+import LineSegment2 from '../geometry/LineSegment2';
+import Mat33 from '../geometry/Mat33';
+import Rect2 from '../geometry/Rect2';
+import AbstractRenderer from '../rendering/AbstractRenderer';
+import SVGRenderer from '../rendering/SVGRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+
+// Stores global SVG attributes (e.g. namespace identifiers.)
+export default class SVGGlobalAttributesObject extends AbstractComponent {
+	protected contentBBox: Rect2;
+	public constructor(private readonly attrs: Array<[string, string|null]>) {
+		super();
+		this.contentBBox = Rect2.empty;
+	}
+
+	public render(canvas: AbstractRenderer, _visibleRect?: Rect2): void {
+		if (!(canvas instanceof SVGRenderer)) {
+			// Don't draw unrenderable objects if we can't
+			return;
+		}
+
+		console.log('Rendering to SVG.', this.attrs);
+		for (const [ attr, value ] of this.attrs) {
+			canvas.setRootSVGAttribute(attr, value);
+		}
+	}
+
+	public intersects(_lineSegment: LineSegment2): boolean {
+		return false;
+	}
+
+	protected applyTransformation(_affineTransfm: Mat33): void {
+	}
+
+	public description(localization: ImageComponentLocalization): string {
+		return localization.svgObject;
+	}
+}

package/src/components/builders/FreehandLineBuilder.ts

@@ -183,7 +183,6 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 
 		// Approximate the normal at the location of the control point
 		let projectionT = this.currentCurve.project(controlPoint.xy).t;
-
 		if (!projectionT) {
 			if (startPt.minus(controlPoint).magnitudeSquared() < endPt.minus(controlPoint).magnitudeSquared()) {
 				projectionT = 0.1;
@@ -192,11 +191,31 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 			}
 		}
 
-		const halfVec = Vec2.ofXY(this.currentCurve.normal(projectionT))
+		const halfVecT = projectionT;
+		let halfVec = Vec2.ofXY(this.currentCurve.normal(halfVecT))
 			.normalized().times(
-				this.curveStartWidth / 2 * projectionT
-				+ this.curveEndWidth / 2 * (1 - projectionT)
+				this.curveStartWidth / 2 * halfVecT
+				+ this.curveEndWidth / 2 * (1 - halfVecT)
+			);
+
+		// Computes a boundary curve. [direction] should be either +1 or -1 (determines the side
+		// of the center curve to place the boundary).
+		const computeBoundaryCurve = (direction: number, halfVec: Vec2) => {
+			return new Bezier(
+				startPt.plus(startVec.times(direction)),
+				controlPoint.plus(halfVec.times(direction)),
+				endPt.plus(endVec.times(direction)),
 			);
+		};
+
+		const upperBoundary = computeBoundaryCurve(1, halfVec);
+		const lowerBoundary = computeBoundaryCurve(-1, halfVec);
+
+		// If the boundaries have two intersections, increasing the half vector's length could fix this.
+		if (upperBoundary.intersects(lowerBoundary).length === 2) {
+			halfVec = halfVec.times(2);
+		}
+
 
 		const pathCommands: PathCommand[] = [
 			{

package/src/geometry/Path.fromString.test.ts

@@ -14,17 +14,13 @@ describe('Path.fromString', () => {
 		const path2 = Path.fromString('M 0 0');
 		const path3 = Path.fromString('M 1,1M 2,2 M 3,3');
 
-		expect(path1.parts[0]).toMatchObject({
-			kind: PathCommandType.MoveTo,
-			point: Vec2.zero,
-		});
-		expect(path2.parts).toMatchObject(path1.parts);
+		expect(path1.parts.length).toBe(0);
+		expect(path1.startPoint).toMatchObject(Vec2.zero);
+
+		expect(path2.parts.length).toBe(0);
+		expect(path2.startPoint).toMatchObject(Vec2.zero);
 
 		expect(path3.parts).toMatchObject([
-			{
-				kind: PathCommandType.MoveTo,
-				point: Vec2.of(1, 1),
-			},
 			{
 				kind: PathCommandType.MoveTo,
 				point: Vec2.of(2, 2),
@@ -44,27 +40,22 @@ describe('Path.fromString', () => {
 				kind: PathCommandType.MoveTo,
 				point: Vec2.of(1, 1),
 			},
-			{
-				kind: PathCommandType.MoveTo,
-				point: Vec2.of(1, 1),
-			},
 			{
 				kind: PathCommandType.MoveTo,
 				point: Vec2.of(4, 4),
 			},
 		]);
+		expect(path.startPoint).toMatchObject(Vec2.of(1, 1));
 	});
 
 	it('should handle lineTo commands', () => {
 		const path = Path.fromString('l1,2L-1,0l0.1,-1.0');
+		// l is a relative lineTo, but because there
+		// is no previous command, it should act like an
+		// absolute moveTo.
+		expect(path.startPoint).toMatchObject(Vec2.of(1, 2));
+
 		expect(path.parts).toMatchObject([
-			{
-				kind: PathCommandType.LineTo,
-				// l is a relative lineTo, but because there
-				// is no previous command, it should act like an
-				// absolute moveTo.
-				point: Vec2.of(1, 2),
-			},
 			{
 				kind: PathCommandType.LineTo,
 				point: Vec2.of(-1, 0),
@@ -84,10 +75,6 @@ describe('Path.fromString', () => {
 		expect(path2.startPoint).toMatchObject(path1.startPoint);
 		expect(path1.parts).toMatchObject(path2.parts);
 		expect(path1.parts).toMatchObject([
-			{
-				kind: PathCommandType.MoveTo,
-				point: Vec2.of(3, 3),
-			},
 			{
 				kind: PathCommandType.LineTo,
 				point: Vec2.of(4, 5),