fix: Vercel.json

Signed-off-by: Mark Tolmacs <mark@lazycat.hu>

excalidraw-app/data/LocalData.ts

@@ -11,6 +11,7 @@
  */
 
 import { clearAppStateForLocalStorage } from "@excalidraw/excalidraw/appState";
+import { stringifyWithPrecision } from "@excalidraw/excalidraw/data/json";
 import {
   CANVAS_SEARCH_TAB,
   DEFAULT_SIDEBAR,
@@ -89,7 +90,7 @@ const saveDataStateToLocalStorage = (
 
     localStorage.setItem(
       STORAGE_KEYS.LOCAL_STORAGE_ELEMENTS,
-      JSON.stringify(getNonDeletedElements(elements)),
+      stringifyWithPrecision(getNonDeletedElements(elements)),
     );
     localStorage.setItem(
       STORAGE_KEYS.LOCAL_STORAGE_APP_STATE,

excalidraw-app/data/firebase.ts

@@ -1,6 +1,7 @@
 import { reconcileElements } from "@excalidraw/excalidraw";
 import { MIME_TYPES, toBrandedType } from "@excalidraw/common";
 import { decompressData } from "@excalidraw/excalidraw/data/encode";
+import { stringifyWithPrecision } from "@excalidraw/excalidraw/data/json";
 import {
   encryptData,
   decryptData,
@@ -94,7 +95,7 @@ const encryptElements = async (
   key: string,
   elements: readonly ExcalidrawElement[],
 ): Promise<{ ciphertext: ArrayBuffer; iv: Uint8Array }> => {
-  const json = JSON.stringify(elements);
+  const json = stringifyWithPrecision(elements);
   const encoded = new TextEncoder().encode(json);
   const { encryptedBuffer, iv } = await encryptData(key, encoded);
 

excalidraw-app/vite.config.mts

@@ -82,13 +82,6 @@ export default defineConfig(({ mode }) => {
             "../packages/fractional-indexing/src/index.ts",
           ),
         },
-        {
-          find: /^@excalidraw\/laser-pointer$/,
-          replacement: path.resolve(
-            __dirname,
-            "../packages/laser-pointer/src/index.ts",
-          ),
-        },
       ],
     },
     build: {

package.json

@@ -57,8 +57,7 @@
     "build:excalidraw": "yarn --cwd ./packages/excalidraw build:esm",
     "build:math": "yarn --cwd ./packages/math build:esm",
     "build:fractional-indexing": "yarn --cwd ./packages/fractional-indexing build:esm",
-    "build:laser-pointer": "yarn --cwd ./packages/laser-pointer build:esm",
-    "build:packages": "yarn build:common && yarn build:fractional-indexing && yarn build:laser-pointer && yarn build:math && yarn build:element && yarn build:excalidraw",
+    "build:packages": "yarn build:common && yarn build:fractional-indexing && yarn build:math && yarn build:element && yarn build:excalidraw",
     "build:version": "yarn --cwd ./excalidraw-app build:version",
     "build": "yarn --cwd ./excalidraw-app build",
     "build:preview": "yarn --cwd ./excalidraw-app build:preview",

packages/common/src/constants.ts

@@ -404,47 +404,11 @@ export const ROUGHNESS = {
   cartoonist: 2,
 } as const;
 
-export type StrokeWidthKey = "thin" | "medium" | "bold";
-
-export const STROKE_WIDTH_KEYS: readonly StrokeWidthKey[] = [
-  "thin",
-  "medium",
-  "bold",
-];
-
-export const STROKE_WIDTH: Readonly<
-  Record<StrokeWidthKey | "extraBold", ExcalidrawElement["strokeWidth"]>
-> = {
+export const STROKE_WIDTH = {
   thin: 1,
-  medium: 2,
-  bold: 4,
-  extraBold: 8, // unused (may be introduced in the future)
-};
-
-// freedraw schema 2.0 uses thinner stroke, but to maintain backwards and
-// forwards compatibility, instead of changing the shape renderer, we scale
-// the stroke width by 1/2 (previous, thin was 1, medium 2 etc.)
-//
-// note that in the UI, STROKE_WIDTH.thin == FREEDRAW_STROKE_WIDTH.thin still
-export const FREEDRAW_STROKE_WIDTH: Readonly<
-  Record<StrokeWidthKey | "extraBold", ExcalidrawElement["strokeWidth"]>
-> = {
-  thin: 0.5,
-  medium: 1,
   bold: 2,
-  extraBold: 4, // legacy (may be used again in the future)
-};
-
-export const getStrokeWidthByKey = (
-  elementType: ExcalidrawElement["type"],
-  strokeWidthKey: StrokeWidthKey,
-): ExcalidrawElement["strokeWidth"] => {
-  return elementType === "freedraw"
-    ? FREEDRAW_STROKE_WIDTH[strokeWidthKey]
-    : STROKE_WIDTH[strokeWidthKey];
-};
-
-export const DEFAULT_ELEMENT_STROKE_WIDTH_KEY: StrokeWidthKey = "medium";
+  extraBold: 4,
+} as const;
 
 export const DEFAULT_ELEMENT_PROPS: {
   strokeColor: ExcalidrawElement["strokeColor"];
@@ -459,7 +423,7 @@ export const DEFAULT_ELEMENT_PROPS: {
   strokeColor: COLOR_PALETTE.black,
   backgroundColor: COLOR_PALETTE.transparent,
   fillStyle: "solid",
-  strokeWidth: STROKE_WIDTH[DEFAULT_ELEMENT_STROKE_WIDTH_KEY],
+  strokeWidth: 2,
   strokeStyle: "solid",
   roughness: ROUGHNESS.artist,
   opacity: 100,
@@ -550,6 +514,3 @@ export const BIND_MODE_TIMEOUT = 700; // ms
 export const MOBILE_ACTION_BUTTON_BG = {
   background: "var(--mobile-action-button-bg)",
 } as const;
-
-export const DEFAULT_STROKE_STREAMLINE = 0.5;
-export const DEFAULT_STROKE_STREAMLINE_PRECISE = 0.2;

packages/common/src/utils.ts

@@ -1,4 +1,4 @@
-import { average } from "@excalidraw/math";
+import { average, round } from "@excalidraw/math";
 
 import type { GlobalCoord } from "@excalidraw/math";
 
@@ -429,11 +429,21 @@ export const viewportCoordsToSceneCoords = (
     scrollX: number;
     scrollY: number;
   },
+  decimals: number = 2,
 ) => {
   const x = (clientX - offsetLeft) / zoom.value - scrollX;
   const y = (clientY - offsetTop) / zoom.value - scrollY;
 
-  return { x, y } as GlobalCoord;
+  if (decimals === 0) {
+    return toBrandedType<GlobalCoord>({ x, y });
+  }
+
+  const precision = Math.pow(10, decimals);
+
+  return toBrandedType<GlobalCoord>({
+    x: round(x, precision),
+    y: round(y, precision),
+  });
 };
 
 export const sceneCoordsToViewportCoords = (

packages/common/tsconfig.json

@@ -1,8 +1,7 @@
 {
   "extends": "../tsconfig.base.json",
   "compilerOptions": {
-    "outDir": "./dist/types",
-    "rootDir": "../"
+    "outDir": "./dist/types"
   },
   "include": ["src/**/*", "global.d.ts"],
   "exclude": ["**/*.test.*", "tests", "types", "examples", "dist"]

packages/element/src/comparisons.ts

@@ -38,8 +38,6 @@ export const hasStrokeStyle = (type: ElementOrToolType) =>
   type === "arrow" ||
   type === "line";
 
-export const hasFreedrawMode = (type: ElementOrToolType) => type === "freedraw";
-
 export const canChangeRoundness = (type: ElementOrToolType) =>
   type === "rectangle" ||
   type === "iframe" ||

packages/element/src/newElement.ts

@@ -4,7 +4,6 @@ import {
   DEFAULT_FONT_SIZE,
   DEFAULT_TEXT_ALIGN,
   DEFAULT_VERTICAL_ALIGN,
-  DEFAULT_STROKE_STREAMLINE,
   VERTICAL_ALIGN,
   randomInteger,
   randomId,
@@ -445,7 +444,6 @@ export const newFreeDrawElement = (
     type: "freedraw";
     points?: ExcalidrawFreeDrawElement["points"];
     simulatePressure: boolean;
-    strokeOptions?: ExcalidrawFreeDrawElement["strokeOptions"];
     pressures?: ExcalidrawFreeDrawElement["pressures"];
   } & ElementConstructorOpts,
 ): NonDeleted<ExcalidrawFreeDrawElement> => {
@@ -454,10 +452,6 @@ export const newFreeDrawElement = (
     points: opts.points || [],
     pressures: opts.pressures || [],
     simulatePressure: opts.simulatePressure,
-    strokeOptions: opts.strokeOptions ?? {
-      variability: "variable",
-      streamline: DEFAULT_STROKE_STREAMLINE,
-    },
   };
 };
 

packages/element/src/renderElement.ts

@@ -889,10 +889,8 @@ export const renderElement = (
     case "embeddable": {
       if (renderConfig.isExporting) {
         const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
-        const centerX = (x1 + x2) / 2;
-        const centerY = (y1 + y2) / 2;
-        const cx = centerX + appState.scrollX;
-        const cy = centerY + appState.scrollY;
+        const cx = (x1 + x2) / 2 + appState.scrollX;
+        const cy = (y1 + y2) / 2 + appState.scrollY;
         let shiftX = (x2 - x1) / 2 - (element.x - x1);
         let shiftY = (y2 - y1) / 2 - (element.y - y1);
         if (isTextElement(element)) {
@@ -914,49 +912,64 @@ export const renderElement = (
         const boundTextElement = getBoundTextElement(element, elementsMap);
 
         if (isArrowElement(element) && boundTextElement) {
-          // Draw arrow directly as vector and clear label hole separately.
-          // This avoids temp-canvas bitmap blit which introduces resampling blur.
+          const tempCanvas = document.createElement("canvas");
+
+          const tempCanvasContext = tempCanvas.getContext("2d")!;
+
+          // Take max dimensions of arrow canvas so that when canvas is rotated
+          // the arrow doesn't get clipped
+          const maxDim = Math.max(distance(x1, x2), distance(y1, y2));
+          const padding = getCanvasPadding(element);
+          tempCanvas.width =
+            maxDim * appState.exportScale + padding * 10 * appState.exportScale;
+          tempCanvas.height =
+            maxDim * appState.exportScale + padding * 10 * appState.exportScale;
+
+          tempCanvasContext.translate(
+            tempCanvas.width / 2,
+            tempCanvas.height / 2,
+          );
+          tempCanvasContext.scale(appState.exportScale, appState.exportScale);
+
+          // Shift the canvas to left most point of the arrow
           shiftX = element.width / 2 - (element.x - x1);
           shiftY = element.height / 2 - (element.y - y1);
 
-          context.save();
-          context.rotate(element.angle);
-          context.translate(-shiftX, -shiftY);
-          drawElementOnCanvas(element, rc, context, renderConfig);
-          context.restore();
+          tempCanvasContext.rotate(element.angle);
+          const tempRc = rough.canvas(tempCanvas);
 
+          tempCanvasContext.translate(-shiftX, -shiftY);
+
+          drawElementOnCanvas(element, tempRc, tempCanvasContext, renderConfig);
+
+          tempCanvasContext.translate(shiftX, shiftY);
+
+          tempCanvasContext.rotate(-element.angle);
+
+          // Shift the canvas to center of bound text
           const [, , , , boundTextCx, boundTextCy] = getElementAbsoluteCoords(
             boundTextElement,
             elementsMap,
           );
-          const holeX =
-            boundTextCx -
-            centerX -
-            boundTextElement.width / 2 -
-            BOUND_TEXT_PADDING;
-          const holeY =
-            boundTextCy -
-            centerY -
-            boundTextElement.height / 2 -
-            BOUND_TEXT_PADDING;
-          const holeWidth = boundTextElement.width + BOUND_TEXT_PADDING * 2;
-          const holeHeight = boundTextElement.height + BOUND_TEXT_PADDING * 2;
+          const boundTextShiftX = (x1 + x2) / 2 - boundTextCx;
+          const boundTextShiftY = (y1 + y2) / 2 - boundTextCy;
+          tempCanvasContext.translate(-boundTextShiftX, -boundTextShiftY);
 
-          const isTransparentHole =
-            "viewBackgroundColor" in appState &&
-            (appState.viewBackgroundColor === "transparent" ||
-              !appState.viewBackgroundColor);
-          if (!isTransparentHole) {
-            context.save();
-            context.fillStyle = applyDarkModeFilter(
-              renderConfig.canvasBackgroundColor,
-              renderConfig.theme === THEME.DARK,
-            );
-            context.fillRect(holeX, holeY, holeWidth, holeHeight);
-            context.restore();
-          } else {
-            context.clearRect(holeX, holeY, holeWidth, holeHeight);
-          }
+          // Clear the bound text area
+          tempCanvasContext.clearRect(
+            -boundTextElement.width / 2,
+            -boundTextElement.height / 2,
+            boundTextElement.width,
+            boundTextElement.height,
+          );
+          context.scale(1 / appState.exportScale, 1 / appState.exportScale);
+          context.drawImage(
+            tempCanvas,
+            -tempCanvas.width / 2,
+            -tempCanvas.height / 2,
+            tempCanvas.width,
+            tempCanvas.height,
+          );
         } else {
           context.rotate(element.angle);
 

packages/element/src/shape.ts

@@ -1,6 +1,5 @@
 import { simplify } from "points-on-curve";
 import { getStroke } from "perfect-freehand";
-import { LaserPointer } from "@excalidraw/laser-pointer";
 
 import {
   type GeometricShape,
@@ -25,7 +24,6 @@ import {
   COLOR_PALETTE,
   LINE_POLYGON_POINT_MERGE_DISTANCE,
   applyDarkModeFilter,
-  DEFAULT_STROKE_STREAMLINE,
 } from "@excalidraw/common";
 
 import { RoughGenerator } from "roughjs/bin/generator";
@@ -1173,87 +1171,27 @@ const getFreeDrawSvgPath = (element: ExcalidrawFreeDrawElement) => {
   ) as SVGPathString;
 };
 
-/**
- * Freedraw stroke geometry tuning constants.
- *
- * These factors are not derived analytically — they were tuned empirically by
- * visually comparing rendered strokes until they matched the desired feel.
- * Treat them as magic numbers backed by visual verification.
- */
-const VARIABLE_WIDTH_FREEDRAW = {
-  /** Stroke size relative to `strokeWidth` for pressure-sensitive strokes. */
-  SIZE_FACTOR: 4.25,
-  THINNING: 0.6,
-  SMOOTHING: 0.5,
-} as const;
-
-const CONSTANT_WIDTH_FREEDRAW = {
-  /** Stroke size relative to `strokeWidth` for uniform (laser) strokes. */
-  SIZE_FACTOR: 1.4,
-} as const;
-
-const getFreedrawStreamline = (element: ExcalidrawFreeDrawElement) =>
-  element.strokeOptions?.streamline ?? DEFAULT_STROKE_STREAMLINE;
-
-/**
- * Pressure-sensitive (variable width) freedraw outline, rendered with
- * perfect-freehand. This is the original Excalidraw freedraw look.
- */
-const getVariableWidthFreedrawOutline = (
+export const getFreedrawOutlinePoints = (
   element: ExcalidrawFreeDrawElement,
-): [number, number][] => {
+) => {
   // If input points are empty (should they ever be?) return a dot
   const inputPoints = element.simulatePressure
     ? element.points
     : element.points.length
-    ? element.points.map(
-        ([x, y], i) => [x, y, element.pressures[i]] as [number, number, number],
-      )
+    ? element.points.map(([x, y], i) => [x, y, element.pressures[i]])
     : [[0, 0, 0.5]];
 
   return getStroke(inputPoints as number[][], {
     simulatePressure: element.simulatePressure,
-    size: element.strokeWidth * VARIABLE_WIDTH_FREEDRAW.SIZE_FACTOR,
-    thinning: VARIABLE_WIDTH_FREEDRAW.THINNING,
-    smoothing: VARIABLE_WIDTH_FREEDRAW.SMOOTHING,
-    streamline: getFreedrawStreamline(element),
+    size: element.strokeWidth * 4.25,
+    thinning: 0.6,
+    smoothing: 0.5,
+    streamline: 0.5,
     easing: (t) => Math.sin((t * Math.PI) / 2), // https://easings.net/#easeOutSine
     last: true,
   }) as [number, number][];
 };
 
-const createLaserPointer = (element: ExcalidrawFreeDrawElement) =>
-  new LaserPointer({
-    size: element.strokeWidth * CONSTANT_WIDTH_FREEDRAW.SIZE_FACTOR,
-    streamline: getFreedrawStreamline(element),
-    simplify: 0,
-    sizeMapping: (details) => Math.max(0.1, details.pressure),
-  });
-
-/**
- * Uniform (constant width) freedraw outline, rendered with the laser-pointer
- * geometry. Pressure is pinned to 1 so the stroke keeps a constant width.
- */
-const getConstantWidthFreedrawOutline = (
-  element: ExcalidrawFreeDrawElement,
-): [number, number][] => {
-  const laserPointer = createLaserPointer(element);
-  element.points.map(([x, y]) => laserPointer.addPoint([x, y, 1]));
-
-  return laserPointer
-    .getStrokeOutline()
-    .map(([x, y]) => [x, y] as [number, number]);
-};
-
-export const getFreedrawOutlinePoints = (
-  element: ExcalidrawFreeDrawElement,
-): [number, number][] => {
-  // Unknown/absent variability falls back to the original variable rendering.
-  return element.strokeOptions?.variability === "constant"
-    ? getConstantWidthFreedrawOutline(element)
-    : getVariableWidthFreedrawOutline(element);
-};
-
 const med = (A: number[], B: number[]) => {
   return [(A[0] + B[0]) / 2, (A[1] + B[1]) / 2];
 };

packages/element/src/types.ts

@@ -384,20 +384,12 @@ export type ExcalidrawElbowArrowElement = Merge<
   }
 >;
 
-export type StrokeVariability = "variable" | "constant";
-
-export type StrokeOptions = Readonly<{
-  variability: StrokeVariability;
-  streamline: number;
-}>;
-
 export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase &
   Readonly<{
     type: "freedraw";
     points: readonly LocalPoint[];
     pressures: readonly number[];
     simulatePressure: boolean;
-    strokeOptions: StrokeOptions;
   }>;
 
 export type FileId = string & { _brand: "FileId" };

packages/element/tests/align.test.tsx

@@ -72,123 +72,123 @@ describe("aligning", () => {
   it("aligns two objects correctly to the top", () => {
     createAndSelectTwoRectangles();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {
       Keyboard.keyPress(KEYS.ARROW_UP);
     });
 
     // Check if x position did not change
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(0);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(0);
   });
 
   it("aligns two objects correctly to the bottom", () => {
     createAndSelectTwoRectangles();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {
       Keyboard.keyPress(KEYS.ARROW_DOWN);
     });
 
     // Check if x position did not change
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
-    expect(API.getSelectedElements()[0].y).toEqual(110);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
   });
 
   it("aligns two objects correctly to the left", () => {
     createAndSelectTwoRectangles();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {
       Keyboard.keyPress(KEYS.ARROW_LEFT);
     });
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(0);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(0);
 
     // Check if y position did not change
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
   });
 
   it("aligns two objects correctly to the right", () => {
     createAndSelectTwoRectangles();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {
       Keyboard.keyPress(KEYS.ARROW_RIGHT);
     });
 
-    expect(API.getSelectedElements()[0].x).toEqual(110);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
     // Check if y position did not change
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
   });
 
   it("centers two objects with different sizes correctly vertically", () => {
     createAndSelectTwoRectanglesWithDifferentSizes();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
 
     API.executeAction(actionAlignVerticallyCentered);
 
     // Check if x position did not change
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
-    expect(API.getSelectedElements()[0].y).toEqual(60);
-    expect(API.getSelectedElements()[1].y).toEqual(55);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(60);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(55);
   });
 
   it("centers two objects with different sizes correctly horizontally", () => {
     createAndSelectTwoRectanglesWithDifferentSizes();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(110);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toEqual(60);
-    expect(API.getSelectedElements()[1].x).toEqual(55);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(60);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(55);
 
     // Check if y position did not change
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(110);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
   });
 
   const createAndSelectGroupAndRectangle = () => {
@@ -226,85 +226,85 @@ describe("aligning", () => {
   it("aligns a group with another element correctly to the top", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(0);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(0);
   });
 
   it("aligns a group with another element correctly to the bottom", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
   });
 
   it("aligns a group with another element correctly to the left", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(0);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(0);
   });
 
   it("aligns a group with another element correctly to the right", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
   });
 
   it("centers a group with another element correctly vertically", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(100);
   });
 
   it("centers a group with another element correctly horizontally", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(100);
   });
 
   const createAndSelectTwoGroups = () => {
@@ -354,97 +354,97 @@ describe("aligning", () => {
   it("aligns two groups correctly to the top", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(0);
-    expect(API.getSelectedElements()[3].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(100);
   });
 
   it("aligns two groups correctly to the bottom", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toEqual(200);
-    expect(API.getSelectedElements()[1].y).toEqual(300);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
   });
 
   it("aligns two groups correctly to the left", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(0);
-    expect(API.getSelectedElements()[3].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(100);
   });
 
   it("aligns two groups correctly to the right", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toEqual(200);
-    expect(API.getSelectedElements()[1].x).toEqual(300);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
   });
 
   it("centers two groups correctly vertically", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toEqual(100);
-    expect(API.getSelectedElements()[3].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(200);
   });
 
   it("centers two groups correctly horizontally", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toEqual(100);
-    expect(API.getSelectedElements()[3].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(200);
   });
 
   const createAndSelectNestedGroupAndRectangle = () => {
@@ -497,97 +497,97 @@ describe("aligning", () => {
   it("aligns nested group and other element correctly to the top", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toEqual(0);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(0);
   });
 
   it("aligns nested group and other element correctly to the bottom", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toEqual(300);
-    expect(API.getSelectedElements()[3].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
   });
 
   it("aligns nested group and other element correctly to the left", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toEqual(0);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(0);
   });
 
   it("aligns nested group and other element correctly to the right", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toEqual(300);
-    expect(API.getSelectedElements()[3].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
   });
 
   it("centers nested group and other element correctly vertically", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toEqual(250);
-    expect(API.getSelectedElements()[3].y).toEqual(150);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(250);
+    expect(API.getSelectedElements()[3].y).toBeCloseTo(150);
   });
 
   it("centers nested group and other element correctly horizontally", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toEqual(250);
-    expect(API.getSelectedElements()[3].x).toEqual(150);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(250);
+    expect(API.getSelectedElements()[3].x).toBeCloseTo(150);
   });
 
   const createGroupAndSelectInEditGroupMode = () => {
@@ -622,68 +622,68 @@ describe("aligning", () => {
   it("aligns elements within a group while in group edit mode correctly to the top", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(0);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(0);
   });
   it("aligns elements within a group while in group edit mode correctly to the bottom", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
   });
   it("aligns elements within a group while in group edit mode correctly to the left", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(0);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(0);
   });
   it("aligns elements within a group while in group edit mode correctly to the right", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
   });
   it("aligns elements within a group while in group edit mode correctly to the vertical center", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toEqual(50);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(50);
   });
   it("aligns elements within a group while in group edit mode correctly to the horizontal center", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toEqual(50);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(50);
   });
 
   const createNestedGroupAndSelectInEditGroupMode = () => {
@@ -735,80 +735,80 @@ describe("aligning", () => {
   it("aligns element and nested group while in group edit mode correctly to the top", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(0);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(0);
   });
   it("aligns element and nested group while in group edit mode correctly to the bottom", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
   });
   it("aligns element and nested group while in group edit mode correctly to the left", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(0);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(0);
   });
   it("aligns element and nested group while in group edit mode correctly to the right", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
   });
   it("aligns element and nested group while in group edit mode correctly to the vertical center", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(100);
   });
   it("aligns elements and nested group within a group while in group edit mode correctly to the horizontal center", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(100);
   });
 
   const createAndSelectSingleGroup = () => {
@@ -834,68 +834,68 @@ describe("aligning", () => {
   it("aligns elements within a single-selected group correctly to the top", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(0);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(0);
   });
   it("aligns elements within a single-selected group correctly to the bottom", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
   });
   it("aligns elements within a single-selected group correctly to the left", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(0);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(0);
   });
   it("aligns elements within a single-selected group correctly to the right", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
   });
   it("aligns elements within a single-selected group correctly to the vertical center", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toEqual(50);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(50);
   });
   it("aligns elements within a single-selected group correctly to the horizontal center", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toEqual(50);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(50);
   });
 
   const createAndSelectSingleGroupWithNestedGroup = () => {
@@ -934,79 +934,79 @@ describe("aligning", () => {
   it("aligns elements within a single-selected group containing a nested group correctly to the top", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(0);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(0);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the bottom", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the left", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(0);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(0);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the right", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the vertical center", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toEqual(100);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(100);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the horizontal center", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toEqual(100);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(100);
   });
 });

packages/element/tests/distribute.test.tsx

@@ -76,53 +76,53 @@ describe("distributing", () => {
 
   it("should distribute selected elements horizontally", async () => {
     createAndSelectThreeRectanglesWithGap();
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(10);
-    expect(API.getSelectedElements()[2].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(10);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(300);
 
     API.executeAction(distributeHorizontally);
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toEqual(300);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(300);
   });
 
   it("should distribute selected elements vertically", async () => {
     createAndSelectThreeRectanglesWithGap();
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(10);
-    expect(API.getSelectedElements()[2].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(10);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(300);
 
     API.executeAction(distributeVertically);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toEqual(300);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(300);
   });
 
   it("should distribute selected elements horizontally based on their centers", async () => {
     createAndSelectThreeRectanglesWithoutGap();
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(10);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(10);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
 
     API.executeAction(distributeHorizontally);
 
-    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toEqual(50);
-    expect(API.getSelectedElements()[2].x).toEqual(200);
+    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
   });
 
   it("should distribute selected elements vertically with based on their centers", async () => {
     createAndSelectThreeRectanglesWithoutGap();
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(10);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(10);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
 
     API.executeAction(distributeVertically);
 
-    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toEqual(50);
-    expect(API.getSelectedElements()[2].y).toEqual(200);
+    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
   });
 });

packages/element/tests/linearElementEditor.test.tsx

@@ -1318,8 +1318,8 @@ describe("Test Linear Elements", () => {
 
       expect(arrow.endBinding?.elementId).toBe(rect.id);
       expect(arrow.width).toBeCloseTo(404);
-      expect(rect.x).toBe(400);
-      expect(rect.y).toBe(0);
+      expect(rect.x).toBeCloseTo(400);
+      expect(rect.y).toBeCloseTo(0);
       expect(
         wrapText(
           textElement.originalText,
@@ -1340,9 +1340,8 @@ describe("Test Linear Elements", () => {
       expect(rect.x).toBe(200);
       expect(rect.y).toBe(0);
       expect(handleBindTextResizeSpy).toHaveBeenCalledWith(
-        h.elements[0],
+        h.elements[1],
         h.app.scene,
-        "nw",
         false,
       );
       expect(

packages/element/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "extends": "../tsconfig.base.json",
   "compilerOptions": {
-    "rootDir": "../",
     "outDir": "./dist/types"
   },
   "include": ["src/**/*", "global.d.ts"],

packages/excalidraw/actions/actionBoundText.tsx

@@ -5,7 +5,6 @@ import {
   VERTICAL_ALIGN,
   arrayToMap,
   getFontString,
-  getStrokeWidthByKey,
 } from "@excalidraw/common";
 import {
   getOriginalContainerHeightFromCache,
@@ -250,10 +249,7 @@ export const actionWrapTextInContainer = register({
           fillStyle: appState.currentItemFillStyle,
           strokeColor: appState.currentItemStrokeColor,
           roughness: appState.currentItemRoughness,
-          strokeWidth: getStrokeWidthByKey(
-            "rectangle",
-            appState.currentItemStrokeWidthKey,
-          ),
+          strokeWidth: appState.currentItemStrokeWidth,
           strokeStyle: appState.currentItemStrokeStyle,
           roundness:
             appState.currentItemRoundness === "round"

packages/excalidraw/actions/actionProperties.test.tsx

@@ -1,9 +1,8 @@
-import { fireEvent, queryByTestId } from "@testing-library/react";
+import { queryByTestId } from "@testing-library/react";
 
 import {
   COLOR_PALETTE,
   DEFAULT_ELEMENT_BACKGROUND_PICKS,
-  FREEDRAW_STROKE_WIDTH,
   FONT_FAMILY,
   STROKE_WIDTH,
 } from "@excalidraw/common";
@@ -129,62 +128,6 @@ describe("element locking", () => {
       expect(thinStrokeWidthButton).toBeChecked();
     });
 
-    it("should highlight common stroke width key across freedraw and non-freedraw elements", () => {
-      const rect = API.createElement({
-        type: "rectangle",
-        strokeWidth: STROKE_WIDTH.medium,
-      });
-      const freedraw = API.createElement({
-        type: "freedraw",
-        strokeWidth: FREEDRAW_STROKE_WIDTH.medium,
-      });
-      API.setElements([rect, freedraw]);
-      API.setSelectedElements([rect, freedraw]);
-
-      expect(queryByTestId(document.body, `strokeWidth-medium`)).toBeChecked();
-    });
-
-    it("should apply stroke width by element type", () => {
-      const rect = API.createElement({
-        type: "rectangle",
-        strokeWidth: STROKE_WIDTH.thin,
-      });
-      const freedraw = API.createElement({
-        type: "freedraw",
-        strokeWidth: FREEDRAW_STROKE_WIDTH.thin,
-      });
-      API.setElements([rect, freedraw]);
-      API.setSelectedElements([rect, freedraw]);
-
-      const boldStrokeWidthButton = queryByTestId(
-        document.body,
-        `strokeWidth-bold`,
-      );
-      expect(boldStrokeWidthButton).not.toBe(null);
-      fireEvent.click(boldStrokeWidthButton!);
-
-      const selectedElements = API.getSelectedElements();
-      const selectedRect = selectedElements.find(
-        (element) => element.type === "rectangle",
-      );
-      const selectedFreedraw = selectedElements.find(
-        (element) => element.type === "freedraw",
-      );
-
-      expect(selectedRect?.strokeWidth).toBe(STROKE_WIDTH.bold);
-      expect(selectedFreedraw?.strokeWidth).toBe(FREEDRAW_STROKE_WIDTH.bold);
-    });
-
-    it("should create new elements with stroke width by element type", () => {
-      API.setAppState({ currentItemStrokeWidthKey: "bold" });
-
-      const rect = API.createElement({ type: "rectangle" });
-      const freedraw = API.createElement({ type: "freedraw" });
-
-      expect(rect.strokeWidth).toBe(STROKE_WIDTH.bold);
-      expect(freedraw.strokeWidth).toBe(FREEDRAW_STROKE_WIDTH.bold);
-    });
-
     it("should not highlight any stroke width button if no common style", () => {
       const rect1 = API.createElement({
         type: "rectangle",
@@ -192,7 +135,7 @@ describe("element locking", () => {
       });
       const rect2 = API.createElement({
         type: "rectangle",
-        strokeWidth: STROKE_WIDTH.medium,
+        strokeWidth: STROKE_WIDTH.bold,
       });
       API.setElements([rect1, rect2]);
       API.setSelectedElements([rect1, rect2]);
@@ -202,17 +145,17 @@ describe("element locking", () => {
         queryByTestId(document.body, `strokeWidth-thin`),
       ).not.toBeChecked();
       expect(
-        queryByTestId(document.body, `strokeWidth-medium`),
+        queryByTestId(document.body, `strokeWidth-bold`),
       ).not.toBeChecked();
       expect(
-        queryByTestId(document.body, `strokeWidth-bold`),
+        queryByTestId(document.body, `strokeWidth-extraBold`),
       ).not.toBeChecked();
     });
 
     it("should show properties of different element types when selected", () => {
       const rect = API.createElement({
         type: "rectangle",
-        strokeWidth: STROKE_WIDTH.medium,
+        strokeWidth: STROKE_WIDTH.bold,
       });
       const text = API.createElement({
         type: "text",
@@ -221,7 +164,7 @@ describe("element locking", () => {
       API.setElements([rect, text]);
       API.setSelectedElements([rect, text]);
 
-      expect(queryByTestId(document.body, `strokeWidth-medium`)).toBeChecked();
+      expect(queryByTestId(document.body, `strokeWidth-bold`)).toBeChecked();
       expect(queryByTestId(document.body, `font-family-code`)).toHaveClass(
         "active",
       );

packages/excalidraw/actions/actionProperties.tsx

@@ -12,7 +12,7 @@ import {
   DEFAULT_FONT_SIZE,
   FONT_FAMILY,
   ROUNDNESS,
-  STROKE_WIDTH_KEYS,
+  STROKE_WIDTH,
   VERTICAL_ALIGN,
   KEYS,
   randomInteger,
@@ -20,11 +20,9 @@ import {
   getFontFamilyString,
   getLineHeight,
   isTransparent,
-  getStrokeWidthByKey,
   reduceToCommonValue,
   invariant,
   FONT_SIZES,
-  type StrokeWidthKey,
 } from "@excalidraw/common";
 
 import { canBecomePolygon, getNonDeletedElements } from "@excalidraw/element";
@@ -72,11 +70,9 @@ import type {
   ElementsMap,
   ExcalidrawBindableElement,
   ExcalidrawElement,
-  ExcalidrawFreeDrawElement,
   ExcalidrawLinearElement,
   ExcalidrawTextElement,
   FontFamilyValues,
-  StrokeVariability,
   TextAlign,
   VerticalAlign,
 } from "@excalidraw/element/types";
@@ -87,7 +83,6 @@ import type { CaptureUpdateActionType } from "@excalidraw/element";
 
 import { trackEvent } from "../analytics";
 import { RadioSelection } from "../components/RadioSelection";
-import { ToolButton } from "../components/ToolButton";
 import { ColorPicker } from "../components/ColorPicker/ColorPicker";
 import { FontPicker } from "../components/FontPicker/FontPicker";
 import { IconPicker } from "../components/IconPicker";
@@ -136,8 +131,6 @@ import {
   ArrowheadCardinalityOneOrManyIcon,
   ArrowheadCardinalityZeroOrManyIcon,
   ArrowheadCardinalityZeroOrOneIcon,
-  strokeVariabilityConstantIcon,
-  strokeVariabilityVariableIcon,
 } from "../components/icons";
 
 import { Fonts } from "../fonts";
@@ -197,11 +190,7 @@ export const changeProperty = (
 export const getFormValue = function <T extends Primitive>(
   elements: readonly ExcalidrawElement[],
   app: AppClassProperties,
-  /**
-   * input value (usually the element attribute value,
-   * but depends on what the action's PanelComponent input expects)
-   */
-  getValue: (element: ExcalidrawElement) => T,
+  getAttribute: (element: ExcalidrawElement) => T,
   elementPredicate: true | ((element: ExcalidrawElement) => boolean),
   defaultValue: T | ((isSomeElementSelected: boolean) => T),
 ): T {
@@ -211,7 +200,7 @@ export const getFormValue = function <T extends Primitive>(
   let ret: T | null = null;
 
   if (editingTextElement) {
-    ret = getValue(editingTextElement);
+    ret = getAttribute(editingTextElement);
   }
 
   if (!ret) {
@@ -225,7 +214,7 @@ export const getFormValue = function <T extends Primitive>(
           : selectedElements.filter((el) => elementPredicate(el));
 
       ret =
-        reduceToCommonValue(targetElements, getValue) ??
+        reduceToCommonValue(targetElements, getAttribute) ??
         (typeof defaultValue === "function"
           ? defaultValue(true)
           : defaultValue);
@@ -555,37 +544,20 @@ export const actionChangeFillStyle = register<ExcalidrawElement["fillStyle"]>({
   },
 });
 
-const getStrokeWidthKeyForElement = (
-  element: ExcalidrawElement,
-): StrokeWidthKey | null => {
-  return (
-    STROKE_WIDTH_KEYS.find(
-      (key) => getStrokeWidthByKey(element.type, key) === element.strokeWidth,
-    ) ?? null
-  );
-};
-
-const getStrokeWidthForElement = (
-  element: ExcalidrawElement,
-  strokeWidthKey: StrokeWidthKey,
-): ExcalidrawElement["strokeWidth"] => {
-  return getStrokeWidthByKey(element.type, strokeWidthKey);
-};
-
-export const actionChangeStrokeWidth = register<StrokeWidthKey>({
+export const actionChangeStrokeWidth = register<
+  ExcalidrawElement["strokeWidth"]
+>({
   name: "changeStrokeWidth",
   label: "labels.strokeWidth",
   trackEvent: false,
   perform: (elements, appState, value) => {
-    invariant(value, "actionChangeStrokeWidth: value must be defined");
-
     return {
       elements: changeProperty(elements, appState, (el) =>
         newElementWith(el, {
-          strokeWidth: getStrokeWidthForElement(el, value),
+          strokeWidth: value,
         }),
       ),
-      appState: { ...appState, currentItemStrokeWidthKey: value },
+      appState: { ...appState, currentItemStrokeWidth: value },
       captureUpdate: CaptureUpdateAction.IMMEDIATELY,
     };
   },
@@ -593,35 +565,35 @@ export const actionChangeStrokeWidth = register<StrokeWidthKey>({
     <fieldset>
       <legend>{t("labels.strokeWidth")}</legend>
       <div className="buttonList">
-        <RadioSelection<StrokeWidthKey>
+        <RadioSelection
           group="stroke-width"
           options={[
             {
-              value: "thin",
+              value: STROKE_WIDTH.thin,
               text: t("labels.thin"),
               icon: StrokeWidthBaseIcon,
               testId: "strokeWidth-thin",
             },
             {
-              value: "medium",
-              text: t("labels.medium"),
+              value: STROKE_WIDTH.bold,
+              text: t("labels.bold"),
               icon: StrokeWidthBoldIcon,
-              testId: "strokeWidth-medium",
+              testId: "strokeWidth-bold",
             },
             {
-              value: "bold",
-              text: t("labels.bold"),
+              value: STROKE_WIDTH.extraBold,
+              text: t("labels.extraBold"),
               icon: StrokeWidthExtraBoldIcon,
-              testId: "strokeWidth-bold",
+              testId: "strokeWidth-extraBold",
             },
           ]}
           value={getFormValue(
             elements,
             app,
-            getStrokeWidthKeyForElement,
+            (element) => element.strokeWidth,
             (element) => element.hasOwnProperty("strokeWidth"),
             (hasSelection) =>
-              hasSelection ? null : appState.currentItemStrokeWidthKey,
+              hasSelection ? null : appState.currentItemStrokeWidth,
           )}
           onChange={(value) => updateData(value)}
         />
@@ -684,87 +656,6 @@ export const actionChangeSloppiness = register<ExcalidrawElement["roughness"]>({
   ),
 });
 
-export const actionChangeFreedrawMode = register<StrokeVariability>({
-  name: "changeFreedrawMode",
-  label: "labels.pressure",
-  trackEvent: false,
-  perform: (elements, appState, value) => {
-    const variability = value || "constant";
-
-    return {
-      elements: changeProperty(elements, appState, (el) => {
-        if (el.type !== "freedraw") {
-          return el;
-        }
-        return newElementWith(el, {
-          strokeOptions: {
-            ...el.strokeOptions,
-            variability,
-          },
-        }) as ExcalidrawElement;
-      }),
-      appState: { ...appState, currentItemStrokeVariability: variability },
-      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
-    };
-  },
-  PanelComponent: ({ elements, appState, updateData, app, data }) => {
-    const strokeVariability =
-      getFormValue(
-        elements,
-        app,
-        (element) =>
-          (element as ExcalidrawFreeDrawElement).strokeOptions?.variability,
-        (element) => element.type === "freedraw",
-        (hasSelection) =>
-          hasSelection ? null : appState.currentItemStrokeVariability,
-      ) ?? appState.currentItemStrokeVariability;
-
-    // in the compact UI the pressure setting is rendered as a single button
-    // that cycles between the two variability modes on click
-    if (data?.cycle) {
-      const isVariable = strokeVariability === "variable";
-      return (
-        <ToolButton
-          type="button"
-          icon={
-            isVariable
-              ? strokeVariabilityVariableIcon
-              : strokeVariabilityConstantIcon
-          }
-          title={t("labels.pressure")}
-          aria-label={t("labels.pressure")}
-          onClick={() => updateData(isVariable ? "constant" : "variable")}
-        />
-      );
-    }
-
-    return (
-      <fieldset>
-        <legend>{t("labels.pressure")}</legend>
-        <div className="buttonList">
-          <RadioSelection<StrokeVariability>
-            group="strokeOptions.variability"
-            options={[
-              {
-                value: "constant",
-                text: t("labels.pressure_constant"),
-                icon: strokeVariabilityConstantIcon,
-              },
-              {
-                value: "variable",
-                text: t("labels.pressure_variable"),
-                icon: strokeVariabilityVariableIcon,
-              },
-            ]}
-            value={strokeVariability}
-            onChange={(value) => updateData(value)}
-          />
-        </div>
-      </fieldset>
-    );
-  },
-});
-
 export const actionChangeStrokeStyle = register<
   ExcalidrawElement["strokeStyle"]
 >({

packages/excalidraw/actions/index.ts

@@ -13,7 +13,6 @@ export {
   actionChangeStrokeWidth,
   actionChangeFillStyle,
   actionChangeSloppiness,
-  actionChangeFreedrawMode,
   actionChangeOpacity,
   actionChangeFontSize,
   actionChangeFontFamily,

packages/excalidraw/actions/types.ts

@@ -68,7 +68,6 @@ export type ActionName =
   | "changeStrokeWidth"
   | "changeStrokeShape"
   | "changeSloppiness"
-  | "changeFreedrawMode"
   | "changeStrokeStyle"
   | "changeArrowhead"
   | "changeArrowType"

packages/excalidraw/appState.ts

@@ -4,7 +4,6 @@ import {
   DEFAULT_ELEMENT_PROPS,
   DEFAULT_FONT_FAMILY,
   DEFAULT_FONT_SIZE,
-  DEFAULT_ELEMENT_STROKE_WIDTH_KEY,
   DEFAULT_TEXT_ALIGN,
   DEFAULT_GRID_SIZE,
   EXPORT_SCALES,
@@ -35,13 +34,12 @@ export const getDefaultAppState = (): Omit<
     currentItemFontSize: DEFAULT_FONT_SIZE,
     currentItemOpacity: DEFAULT_ELEMENT_PROPS.opacity,
     currentItemRoughness: DEFAULT_ELEMENT_PROPS.roughness,
-    currentItemStrokeVariability: "constant",
     currentItemStartArrowhead: null,
     currentItemStrokeColor: DEFAULT_ELEMENT_PROPS.strokeColor,
     currentItemRoundness: isTestEnv() ? "sharp" : "round",
     currentItemArrowType: ARROW_TYPE.round,
     currentItemStrokeStyle: DEFAULT_ELEMENT_PROPS.strokeStyle,
-    currentItemStrokeWidthKey: DEFAULT_ELEMENT_STROKE_WIDTH_KEY,
+    currentItemStrokeWidth: DEFAULT_ELEMENT_PROPS.strokeWidth,
     currentItemTextAlign: DEFAULT_TEXT_ALIGN,
     currentHoveredFontFamily: null,
     cursorButton: "up",
@@ -169,15 +167,10 @@ const APP_STATE_STORAGE_CONF = (<
   },
   currentItemOpacity: { browser: true, export: false, server: false },
   currentItemRoughness: { browser: true, export: false, server: false },
-  currentItemStrokeVariability: {
-    browser: true,
-    export: false,
-    server: false,
-  },
   currentItemStartArrowhead: { browser: true, export: false, server: false },
   currentItemStrokeColor: { browser: true, export: false, server: false },
   currentItemStrokeStyle: { browser: true, export: false, server: false },
-  currentItemStrokeWidthKey: { browser: true, export: false, server: false },
+  currentItemStrokeWidth: { browser: true, export: false, server: false },
   currentItemTextAlign: { browser: true, export: false, server: false },
   currentHoveredFontFamily: { browser: false, export: false, server: false },
   cursorButton: { browser: true, export: false, server: false },

packages/excalidraw/clipboard.ts

@@ -25,6 +25,8 @@ import type {
   NonDeletedExcalidrawElement,
 } from "@excalidraw/element/types";
 
+import { stringifyWithPrecision } from "./data/json";
+
 import { ExcalidrawError } from "./errors";
 import {
   createFile,
@@ -188,7 +190,7 @@ export const serializeAsClipboardJSON = ({
     files: files ? _files : undefined,
   };
 
-  return JSON.stringify(contents);
+  return stringifyWithPrecision(contents);
 };
 
 export const copyToClipboard = async (

packages/excalidraw/components/Actions.tsx

@@ -41,7 +41,6 @@ import {
   canHaveArrowheads,
   getTargetElements,
   hasBackground,
-  hasFreedrawMode,
   hasStrokeStyle,
   hasStrokeWidth,
 } from "../scene";
@@ -202,9 +201,9 @@ export const SelectedShapeActions = ({
         targetElements.some((element) => hasStrokeWidth(element.type))) &&
         renderAction("changeStrokeWidth")}
 
-      {(hasFreedrawMode(appState.activeTool.type) ||
-        targetElements.some((element) => hasFreedrawMode(element.type))) &&
-        renderAction("changeFreedrawMode")}
+      {(appState.activeTool.type === "freedraw" ||
+        targetElements.some((element) => element.type === "freedraw")) &&
+        renderAction("changeStrokeShape")}
 
       {(hasStrokeStyle(appState.activeTool.type) ||
         targetElements.some((element) => hasStrokeStyle(element.type))) && (
@@ -395,17 +394,6 @@ const CombinedShapeProperties = ({
                   hasStrokeWidth(element.type),
                 )) &&
                 renderAction("changeStrokeWidth")}
-              {
-                /* in compact UI the freedraw pressure setting is rendered as a
-                  standalone cycle button in the compact actions list; we render
-                  it in the combined properties popup as well for clarity
-                */
-                (hasFreedrawMode(appState.activeTool.type) ||
-                  targetElements.some((element) =>
-                    hasFreedrawMode(element.type),
-                  )) &&
-                  renderAction("changeFreedrawMode")
-              }
               {(hasStrokeStyle(appState.activeTool.type) ||
                 targetElements.some((element) =>
                   hasStrokeStyle(element.type),
@@ -838,14 +826,6 @@ export const CompactShapeActions = ({
         </div>
       )}
 
-      {/* Freedraw pressure: standalone button cycling the variability mode */}
-      {(hasFreedrawMode(appState.activeTool.type) ||
-        targetElements.some((element) => hasFreedrawMode(element.type))) && (
-        <div className="compact-action-item">
-          {renderAction("changeFreedrawMode", { cycle: true })}
-        </div>
-      )}
-
       <CombinedShapeProperties
         appState={appState}
         renderAction={renderAction}
@@ -1074,11 +1054,6 @@ export const ShapesSwitcher = ({
   const isFullStylesPanel = stylesPanelMode === "full";
   const isCompactStylesPanel = stylesPanelMode === "compact";
 
-  // a pen detected on a tool button's pointer-down, to be applied (enabling
-  // pen mode) only after the tap's `change` has committed — see the tool
-  // button handlers below
-  const pendingPenDetectionRef = useRef(false);
-
   const SELECTION_TOOLS = [
     {
       type: "selection",
@@ -1177,13 +1152,8 @@ export const ShapesSwitcher = ({
               aria-keyshortcuts={shortcut}
               data-testid={`toolbar-${value}`}
               onPointerDown={({ pointerType }) => {
-                // Detect the pen here (pointerType is reliable on pointer-down)
-                // but DON'T enable pen mode yet: calling setState mid-gesture
-                // re-renders the controlled radio and, on iOS/iPadOS, aborts
-                // the ensuing click so the tool isn't selected on the first pen
-                // tap. Defer it until the tap's `change` has committed (below).
                 if (!app.state.penDetected && pointerType === "pen") {
-                  pendingPenDetectionRef.current = true;
+                  app.togglePenMode(true);
                 }
 
                 if (value === "selection") {
@@ -1194,21 +1164,16 @@ export const ShapesSwitcher = ({
                   }
                 }
               }}
-              onChange={() => {
+              onChange={({ pointerType }) => {
                 if (app.state.activeTool.type !== value) {
                   trackEvent("toolbar", value, "ui");
                 }
-                app.setActiveTool({ type: value });
-
-                // Apply the pen detection captured on pointer-down now that the
-                // tool is selected. rAF keeps the resulting re-render out of the
-                // `change` event itself. We rely on the pointer-down detection
-                // rather than this handler's pointerType because the latter is
-                // unreliable on iOS (its backing ref is cleared before the
-                // delayed click fires).
-                if (pendingPenDetectionRef.current) {
-                  pendingPenDetectionRef.current = false;
-                  requestAnimationFrame(() => app.togglePenMode(true));
+                if (value === "image") {
+                  app.setActiveTool({
+                    type: value,
+                  });
+                } else {
+                  app.setActiveTool({ type: value });
                 }
               }}
             />

packages/excalidraw/components/App.tsx

@@ -27,8 +27,6 @@ import {
   KEYS,
   APP_NAME,
   CURSOR_TYPE,
-  DEFAULT_STROKE_STREAMLINE,
-  DEFAULT_STROKE_STREAMLINE_PRECISE,
   DEFAULT_TRANSFORM_HANDLE_SPACING,
   DEFAULT_VERTICAL_ALIGN,
   DRAGGING_THRESHOLD,
@@ -111,7 +109,6 @@ import {
   setDesktopUIMode,
   isSelectionLikeTool,
   oneOf,
-  getStrokeWidthByKey,
 } from "@excalidraw/common";
 
 import {
@@ -4137,7 +4134,7 @@ class App extends React.Component<AppProps, AppState> {
       strokeColor: this.state.currentItemStrokeColor,
       backgroundColor: this.state.currentItemBackgroundColor,
       fillStyle: this.state.currentItemFillStyle,
-      strokeWidth: this.getCurrentItemStrokeWidth("text"),
+      strokeWidth: this.state.currentItemStrokeWidth,
       strokeStyle: this.state.currentItemStrokeStyle,
       roundness: null,
       roughness: this.state.currentItemRoughness,
@@ -4308,9 +4305,6 @@ class App extends React.Component<AppProps, AppState> {
       return {
         penMode: force ?? !prevState.penMode,
         penDetected: true,
-        currentItemStrokeVariability: !prevState.penDetected
-          ? "variable"
-          : prevState.currentItemStrokeVariability,
       };
     });
   };
@@ -6310,7 +6304,7 @@ class App extends React.Component<AppProps, AppState> {
         strokeColor: this.state.currentItemStrokeColor,
         backgroundColor: this.state.currentItemBackgroundColor,
         fillStyle: this.state.currentItemFillStyle,
-        strokeWidth: this.getCurrentItemStrokeWidth("text"),
+        strokeWidth: this.state.currentItemStrokeWidth,
         strokeStyle: this.state.currentItemStrokeStyle,
         roughness: this.state.currentItemRoughness,
         opacity: this.state.currentItemOpacity,
@@ -7780,7 +7774,6 @@ class App extends React.Component<AppProps, AppState> {
         return {
           penMode: true,
           penDetected: true,
-          currentItemStrokeVariability: "variable",
         };
       });
     }
@@ -8999,8 +8992,6 @@ class App extends React.Component<AppProps, AppState> {
 
     const simulatePressure = event.pressure === 0.5;
 
-    const strokeVariability = this.state.currentItemStrokeVariability;
-
     const element = newFreeDrawElement({
       type: elementType,
       x: gridX,
@@ -9008,24 +8999,15 @@ class App extends React.Component<AppProps, AppState> {
       strokeColor: this.state.currentItemStrokeColor,
       backgroundColor: this.state.currentItemBackgroundColor,
       fillStyle: this.state.currentItemFillStyle,
-      strokeWidth: this.getCurrentItemStrokeWidth("freedraw"),
+      strokeWidth: this.state.currentItemStrokeWidth,
       strokeStyle: this.state.currentItemStrokeStyle,
       roughness: this.state.currentItemRoughness,
       opacity: this.state.currentItemOpacity,
       roundness: null,
       simulatePressure,
-      strokeOptions: {
-        variability: strokeVariability,
-        streamline:
-          event.pointerType !== "mouse"
-            ? DEFAULT_STROKE_STREAMLINE_PRECISE
-            : DEFAULT_STROKE_STREAMLINE,
-      },
       locked: false,
       frameId: topLayerFrame ? topLayerFrame.id : null,
       points: [pointFrom<LocalPoint>(0, 0)],
-      // pressures are only consumed when rendering a real-pressure stroke, so
-      // skip persisting them while pressure is being simulated
       pressures: simulatePressure ? [] : [event.pressure],
     });
 
@@ -9076,7 +9058,7 @@ class App extends React.Component<AppProps, AppState> {
       strokeColor: "transparent",
       backgroundColor: "transparent",
       fillStyle: this.state.currentItemFillStyle,
-      strokeWidth: this.getCurrentItemStrokeWidth("iframe"),
+      strokeWidth: this.state.currentItemStrokeWidth,
       strokeStyle: this.state.currentItemStrokeStyle,
       roughness: this.state.currentItemRoughness,
       roundness: this.getCurrentItemRoundness("iframe"),
@@ -9129,7 +9111,7 @@ class App extends React.Component<AppProps, AppState> {
       strokeColor: "transparent",
       backgroundColor: "transparent",
       fillStyle: this.state.currentItemFillStyle,
-      strokeWidth: this.getCurrentItemStrokeWidth("embeddable"),
+      strokeWidth: this.state.currentItemStrokeWidth,
       strokeStyle: this.state.currentItemStrokeStyle,
       roughness: this.state.currentItemRoughness,
       roundness: this.getCurrentItemRoundness("embeddable"),
@@ -9176,7 +9158,7 @@ class App extends React.Component<AppProps, AppState> {
       strokeColor: this.state.currentItemStrokeColor,
       backgroundColor: this.state.currentItemBackgroundColor,
       fillStyle: this.state.currentItemFillStyle,
-      strokeWidth: this.getCurrentItemStrokeWidth("image"),
+      strokeWidth: this.state.currentItemStrokeWidth,
       strokeStyle: this.state.currentItemStrokeStyle,
       roughness: this.state.currentItemRoughness,
       roundness: null,
@@ -9354,7 +9336,7 @@ class App extends React.Component<AppProps, AppState> {
               strokeColor: this.state.currentItemStrokeColor,
               backgroundColor: this.state.currentItemBackgroundColor,
               fillStyle: this.state.currentItemFillStyle,
-              strokeWidth: this.getCurrentItemStrokeWidth(elementType),
+              strokeWidth: this.state.currentItemStrokeWidth,
               strokeStyle: this.state.currentItemStrokeStyle,
               roughness: this.state.currentItemRoughness,
               opacity: this.state.currentItemOpacity,
@@ -9381,7 +9363,7 @@ class App extends React.Component<AppProps, AppState> {
               strokeColor: this.state.currentItemStrokeColor,
               backgroundColor: this.state.currentItemBackgroundColor,
               fillStyle: this.state.currentItemFillStyle,
-              strokeWidth: this.getCurrentItemStrokeWidth(elementType),
+              strokeWidth: this.state.currentItemStrokeWidth,
               strokeStyle: this.state.currentItemStrokeStyle,
               roughness: this.state.currentItemRoughness,
               opacity: this.state.currentItemOpacity,
@@ -9518,13 +9500,6 @@ class App extends React.Component<AppProps, AppState> {
       : null;
   }
 
-  private getCurrentItemStrokeWidth(elementType: ExcalidrawElement["type"]) {
-    return getStrokeWidthByKey(
-      elementType,
-      this.state.currentItemStrokeWidthKey,
-    );
-  }
-
   private createGenericElementOnPointerDown = (
     elementType: ExcalidrawGenericElement["type"] | "embeddable",
     pointerDownState: PointerDownState,
@@ -9548,7 +9523,7 @@ class App extends React.Component<AppProps, AppState> {
       strokeColor: this.state.currentItemStrokeColor,
       backgroundColor: this.state.currentItemBackgroundColor,
       fillStyle: this.state.currentItemFillStyle,
-      strokeWidth: this.getCurrentItemStrokeWidth(elementType),
+      strokeWidth: this.state.currentItemStrokeWidth,
       strokeStyle: this.state.currentItemStrokeStyle,
       roughness: this.state.currentItemRoughness,
       opacity: this.state.currentItemOpacity,

packages/excalidraw/components/LayerUI.scss

@@ -120,24 +120,6 @@
     }
   }
 
-  // on tablet, the pen mode button is rendered as a separate floating button
-  // below the compact actions menu (see LayerUI.tsx)
-  .App-menu_top__left > .ToolIcon__penMode {
-    justify-self: center;
-
-    .ToolIcon__icon {
-      width: var(--lg-button-size);
-      height: var(--lg-button-size);
-      background-color: var(--island-bg-color);
-      box-shadow: var(--shadow-island);
-    }
-
-    // no shadow while pen mode is active (the active fill is enough)
-    .ToolIcon_type_checkbox:checked + .ToolIcon__icon {
-      box-shadow: none;
-    }
-  }
-
   .disable-view-mode {
     display: flex;
     justify-content: center;

packages/excalidraw/components/LayerUI.tsx

@@ -235,6 +235,8 @@ const LayerUI = ({
   );
 
   const renderSelectedShapeActions = () => {
+    const isCompactMode = isCompactStylesPanel;
+
     return (
       <Section
         heading="selectedShapeActions"
@@ -242,7 +244,7 @@ const LayerUI = ({
           "transition-left": appState.zenModeEnabled,
         })}
       >
-        {isCompactStylesPanel ? (
+        {isCompactMode ? (
           <Island
             className={clsx("compact-shape-actions-island")}
             padding={0}
@@ -310,23 +312,6 @@ const LayerUI = ({
             >
               {shouldRenderSelectedShapeActions && renderSelectedShapeActions()}
             </div>
-            {/* in compact UI the pen mode button lives outside the toolbar, as
-                a separate floating button below the compact actions menu
-                (same as we render it on mobile); shown alongside the compact
-                actions island, i.e. when a drawing tool or elements are
-                selected */}
-            {isCompactStylesPanel &&
-              !appState.viewModeEnabled &&
-              shouldRenderSelectedShapeActions && (
-                <PenModeButton
-                  zenModeEnabled={appState.zenModeEnabled}
-                  checked={appState.penMode}
-                  onChange={() => onPenModeToggle(null)}
-                  title={t("toolBar.penMode")}
-                  isMobile
-                  penDetected={appState.penDetected}
-                />
-              )}
           </Stack.Col>
           {!appState.viewModeEnabled &&
             appState.openDialog?.name !== "elementLinkSelector" && (
@@ -358,18 +343,13 @@ const LayerUI = ({
                           />
                           {heading}
                           <Stack.Row gap={spacing.toolbarInnerRowGap}>
-                            {/* in compact UI the pen mode button is rendered
-                                as a separate floating button below the compact
-                                actions menu */}
-                            {!isCompactStylesPanel && (
-                              <PenModeButton
-                                zenModeEnabled={appState.zenModeEnabled}
-                                checked={appState.penMode}
-                                onChange={() => onPenModeToggle(null)}
-                                title={t("toolBar.penMode")}
-                                penDetected={appState.penDetected}
-                              />
-                            )}
+                            <PenModeButton
+                              zenModeEnabled={appState.zenModeEnabled}
+                              checked={appState.penMode}
+                              onChange={() => onPenModeToggle(null)}
+                              title={t("toolBar.penMode")}
+                              penDetected={appState.penDetected}
+                            />
                             <LockButton
                               checked={appState.activeTool.locked}
                               onChange={onLockToggle}

packages/excalidraw/components/icons.tsx

@@ -1249,74 +1249,6 @@ export const SloppinessCartoonistIcon = createIcon(
   modifiedTablerIconProps,
 );
 
-export const strokeVariabilityConstantIcon = createIcon(
-  <g>
-    <path
-      d="M4 12 C 5 8, 6 8, 8 12"
-      fill="none"
-      strokeWidth="1"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-    <path
-      d="M8 12 C 9 16, 10 16, 12 12"
-      fill="none"
-      strokeWidth="1"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-    <path
-      d="M12 12 C 14 8, 15 8, 16 12"
-      fill="none"
-      strokeWidth="1"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-    <path
-      d="M16 12 C 17 16, 18 16, 19 12"
-      fill="none"
-      strokeWidth="1"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-  </g>,
-  tablerIconProps,
-);
-
-export const strokeVariabilityVariableIcon = createIcon(
-  <g>
-    <path
-      d="M4 12 C 5 8, 6 8, 8 12"
-      fill="none"
-      strokeWidth="1.5"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-    <path
-      d="M8 12 C 9 16, 10 16, 12 12"
-      fill="none"
-      strokeWidth="2"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-    <path
-      d="M12 12 C 14 8, 15 8, 16 12"
-      fill="none"
-      strokeWidth="2.75"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-    <path
-      d="M16 12 C 17 16, 18 16, 19 12"
-      fill="none"
-      strokeWidth="3.25"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-  </g>,
-  tablerIconProps,
-);
-
 export const EdgeSharpIcon = createIcon(
   <svg strokeWidth="1.5">
     <path d="M3.33334 9.99998V6.66665C3.33334 6.04326 3.33403 4.9332 3.33539 3.33646C4.95233 3.33436 6.06276 3.33331 6.66668 3.33331H10" />

packages/excalidraw/data/json.ts

@@ -22,6 +22,41 @@ import type {
   ImportedLibraryData,
 } from "./types";
 
+const SCALAR_ROUNDED_KEYS = new Set(["x", "y", "width", "height"]);
+
+// JSON.stringify encodes \x00 as \u0000 (6-char literal sequence) in the output
+// string. We use this as a sentinel so we can strip the surrounding quotes
+// afterward, emitting raw number tokens without a float round-trip.
+const PRECISION_SENTINEL = "\x00";
+const PRECISION_SENTINEL_RE = /"\\u0000([^"]+)\\u0000"/g;
+
+export const stringifyWithPrecision = (
+  value: unknown,
+  precision = 2,
+  space?: number | string,
+): string => {
+  const fmt = (n: number) =>
+    `${PRECISION_SENTINEL}${n.toFixed(precision)}${PRECISION_SENTINEL}`;
+
+  return JSON.stringify(
+    value,
+    (key, val) => {
+      if (SCALAR_ROUNDED_KEYS.has(key) && typeof val === "number") {
+        return fmt(val);
+      }
+      if (key === "points" && Array.isArray(val)) {
+        return (val as number[][]).map((pt) =>
+          Array.isArray(pt)
+            ? pt.map((n) => (typeof n === "number" ? fmt(n) : n))
+            : pt,
+        );
+      }
+      return val;
+    },
+    space,
+  ).replace(PRECISION_SENTINEL_RE, "$1");
+};
+
 export type JSONExportData = {
   elements: readonly NonDeleted<ExcalidrawElement>[];
   appState: AppState;
@@ -71,7 +106,7 @@ export const serializeAsJSON = (
           undefined,
   };
 
-  return JSON.stringify(data, null, 2);
+  return stringifyWithPrecision(data, 2, 2);
 };
 
 export const saveAsJSON = async ({
@@ -141,7 +176,7 @@ export const serializeLibraryAsJSON = (libraryItems: LibraryItems) => {
     source: getExportSource(),
     libraryItems,
   };
-  return JSON.stringify(data, null, 2);
+  return stringifyWithPrecision(data, 2, 2);
 };
 
 export const saveLibraryAsJSON = async (libraryItems: LibraryItems) => {

packages/excalidraw/data/restore.ts

@@ -3,7 +3,6 @@ import { isFiniteNumber, isValidPoint, pointFrom } from "@excalidraw/math";
 import {
   type CombineBrandsIfNeeded,
   DEFAULT_FONT_FAMILY,
-  DEFAULT_STROKE_STREAMLINE,
   DEFAULT_TEXT_ALIGN,
   DEFAULT_VERTICAL_ALIGN,
   FONT_FAMILY,
@@ -19,9 +18,6 @@ import {
   getSizeFromPoints,
   normalizeLink,
   getLineHeight,
-  STROKE_WIDTH,
-  STROKE_WIDTH_KEYS,
-  type StrokeWidthKey,
 } from "@excalidraw/common";
 import {
   calculateFixedPointForNonElbowArrowBinding,
@@ -74,7 +70,6 @@ import type {
   FontFamilyValues,
   NonDeletedSceneElementsMap,
   OrderedExcalidrawElement,
-  StrokeVariability,
   StrokeRoundness,
 } from "@excalidraw/element/types";
 
@@ -193,43 +188,6 @@ export type RestoredDataState = {
   files: BinaryFiles;
 };
 
-const ALLOWED_STROKE_VARIABILITIES = new Set<StrokeVariability>([
-  "constant",
-  "variable",
-]);
-
-const restoreStrokeVariability = (
-  variability: unknown,
-  defaultValue: StrokeVariability,
-): StrokeVariability => {
-  return typeof variability === "string" &&
-    ALLOWED_STROKE_VARIABILITIES.has(variability as StrokeVariability)
-    ? (variability as StrokeVariability)
-    : defaultValue;
-};
-
-const getStrokeWidthKey = (strokeWidth: unknown): StrokeWidthKey | null => {
-  return isFiniteNumber(strokeWidth)
-    ? STROKE_WIDTH_KEYS.find((key) => STROKE_WIDTH[key] === strokeWidth) ?? null
-    : null;
-};
-
-const restoreFreedrawStrokeOptions = (
-  strokeOptions: unknown,
-): { variability: StrokeVariability; streamline: number } => {
-  const options =
-    strokeOptions && typeof strokeOptions === "object"
-      ? (strokeOptions as { variability?: unknown; streamline?: unknown })
-      : null;
-
-  return {
-    variability: restoreStrokeVariability(options?.variability, "variable"),
-    streamline: isFiniteNumber(options?.streamline)
-      ? options?.streamline
-      : DEFAULT_STROKE_STREAMLINE,
-  };
-};
-
 const getFontFamilyByName = (fontFamilyName: string): FontFamilyValues => {
   if (Object.keys(FONT_FAMILY).includes(fontFamilyName)) {
     return FONT_FAMILY[
@@ -525,7 +483,6 @@ export const restoreElement = (
       return restoreElementWithProperties(element, {
         points,
         simulatePressure: element.simulatePressure,
-        strokeOptions: restoreFreedrawStrokeOptions(element.strokeOptions),
         pressures,
       });
     }
@@ -1099,13 +1056,6 @@ export const restoreAppState = (
     nextAppState.boxSelectionMode = boxSelectionMode;
   }
 
-  // legacy
-  if ((appState as any).currentItemStrokeWidth !== undefined) {
-    nextAppState.currentItemStrokeWidthKey =
-      getStrokeWidthKey((appState as any).currentItemStrokeWidth) ??
-      defaultAppState.currentItemStrokeWidthKey;
-  }
-
   return {
     ...nextAppState,
     cursorButton: localAppState?.cursorButton || "up",

packages/excalidraw/index.tsx

@@ -10,7 +10,6 @@ import {
   applyDarkModeFilter,
   DEFAULT_IMAGE_OPTIONS,
   DEFAULT_UI_OPTIONS,
-  getStrokeWidthByKey,
   isShallowEqual,
 } from "@excalidraw/common";
 
@@ -451,4 +450,4 @@ export function useExcalidrawStateValue(
 
 export { _useOnAppStateChange as useOnExcalidrawStateChange };
 
-export { applyDarkModeFilter, getStrokeWidthByKey };
+export { applyDarkModeFilter };

packages/excalidraw/locales/en.json

@@ -35,9 +35,6 @@
     "strokeStyle_dashed": "Dashed",
     "strokeStyle_dotted": "Dotted",
     "sloppiness": "Sloppiness",
-    "pressure": "Pressure",
-    "pressure_constant": "Constant",
-    "pressure_variable": "Variable",
     "opacity": "Opacity",
     "textAlign": "Text align",
     "edges": "Edges",

packages/excalidraw/scene/index.ts

@@ -9,7 +9,6 @@ export {
   hasBackground,
   hasStrokeWidth,
   hasStrokeStyle,
-  hasFreedrawMode,
   canHaveArrowheads,
   canChangeRoundness,
 } from "@excalidraw/element";

packages/excalidraw/tests/__snapshots__/contextmenu.test.tsx.snap

@@ -904,8 +904,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -1104,8 +1103,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -1319,8 +1317,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -1467,7 +1464,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   "versionNonce": 493213705,
   "width": 20,
   "x": -10,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -1519,7 +1516,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -1651,8 +1648,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -1799,7 +1795,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   "versionNonce": 493213705,
   "width": 20,
   "x": -10,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -1851,7 +1847,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -1983,8 +1979,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -2198,8 +2193,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -2440,8 +2434,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -2497,7 +2490,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   "resizingElement": null,
   "scrollX": 0,
   "scrollY": 0,
-  "scrolledOutside": false,
+  "scrolledOutside": true,
   "searchMatches": null,
   "selectedElementIds": {
     "id3": true,
@@ -2739,8 +2732,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -2862,7 +2854,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   "versionNonce": 915032327,
   "width": 20,
   "x": -10,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -2948,7 +2940,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -3112,8 +3104,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#e03131",
   "currentItemStrokeStyle": "dotted",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "bold",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -3223,14 +3214,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   "seed": 1278240551,
   "strokeColor": "#e03131",
   "strokeStyle": "dotted",
-  "strokeWidth": 4,
+  "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
   "version": 4,
-  "versionNonce": 1349943049,
+  "versionNonce": 1402203177,
   "width": 20,
   "x": -10,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -3252,14 +3243,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   "opacity": 60,
   "roughness": 2,
   "roundness": null,
-  "seed": 406373543,
+  "seed": 1898319239,
   "strokeColor": "#e03131",
   "strokeStyle": "dotted",
-  "strokeWidth": 4,
+  "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
-  "version": 10,
-  "versionNonce": 1402203177,
+  "version": 9,
+  "versionNonce": 941653321,
   "width": 20,
   "x": 20,
   "y": 30,
@@ -3268,7 +3259,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
 
 exports[`contextMenu element > selecting 'Paste styles' in context menu pastes styles > [end of test] number of elements 1`] = `2`;
 
-exports[`contextMenu element > selecting 'Paste styles' in context menu pastes styles > [end of test] number of renders 1`] = `17`;
+exports[`contextMenu element > selecting 'Paste styles' in context menu pastes styles > [end of test] number of renders 1`] = `16`;
 
 exports[`contextMenu element > selecting 'Paste styles' in context menu pastes styles > [end of test] redo stack 1`] = `[]`;
 
@@ -3314,7 +3305,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -3468,11 +3459,11 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
       "updated": {
         "id3": {
           "deleted": {
-            "strokeWidth": 4,
+            "strokeStyle": "dotted",
             "version": 7,
           },
           "inserted": {
-            "strokeWidth": 2,
+            "strokeStyle": "solid",
             "version": 6,
           },
         },
@@ -3493,11 +3484,11 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
       "updated": {
         "id3": {
           "deleted": {
-            "strokeStyle": "dotted",
+            "roughness": 2,
             "version": 8,
           },
           "inserted": {
-            "strokeStyle": "solid",
+            "roughness": 1,
             "version": 7,
           },
         },
@@ -3518,11 +3509,11 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
       "updated": {
         "id3": {
           "deleted": {
-            "roughness": 2,
+            "opacity": 60,
             "version": 9,
           },
           "inserted": {
-            "roughness": 1,
+            "opacity": 100,
             "version": 8,
           },
         },
@@ -3530,31 +3521,6 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
     },
     "id": "id17",
   },
-  {
-    "appState": AppStateDelta {
-      "delta": Delta {
-        "deleted": {},
-        "inserted": {},
-      },
-    },
-    "elements": {
-      "added": {},
-      "removed": {},
-      "updated": {
-        "id3": {
-          "deleted": {
-            "opacity": 60,
-            "version": 10,
-          },
-          "inserted": {
-            "opacity": 100,
-            "version": 9,
-          },
-        },
-      },
-    },
-    "id": "id19",
-  },
   {
     "appState": AppStateDelta {
       "delta": Delta {
@@ -3582,7 +3548,6 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
             "roughness": 2,
             "strokeColor": "#e03131",
             "strokeStyle": "dotted",
-            "strokeWidth": 4,
             "version": 4,
           },
           "inserted": {
@@ -3592,13 +3557,12 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
             "roughness": 1,
             "strokeColor": "#1e1e1e",
             "strokeStyle": "solid",
-            "strokeWidth": 2,
             "version": 3,
           },
         },
       },
     },
-    "id": "id21",
+    "id": "id19",
   },
 ]
 `;
@@ -3633,8 +3597,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -3781,7 +3744,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   "versionNonce": 2019559783,
   "width": 20,
   "x": -10,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -3833,7 +3796,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -3957,8 +3920,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -4105,7 +4067,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   "versionNonce": 2019559783,
   "width": 20,
   "x": -10,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -4157,7 +4119,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -4281,8 +4243,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -4400,7 +4361,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "versionNonce": 1006504105,
   "width": 20,
   "x": -10,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -4484,7 +4445,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -5567,8 +5528,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -5686,7 +5646,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   "versionNonce": 1150084233,
   "width": 10,
   "x": -10,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -5718,7 +5678,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   "versionNonce": 23633383,
   "width": 10,
   "x": 12,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -5770,7 +5730,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
             "version": 3,
             "width": 10,
             "x": -10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -5824,7 +5784,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
             "version": 3,
             "width": 10,
             "x": 12,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -6785,8 +6745,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -6908,7 +6867,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "versionNonce": 1723083209,
   "width": 10,
   "x": -10,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -6942,7 +6901,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "versionNonce": 760410951,
   "width": 10,
   "x": 12,
-  "y": 0,
+  "y": "0.00000",
 }
 `;
 
@@ -6994,7 +6953,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
             "version": 3,
             "width": 10,
             "x": -10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -7048,7 +7007,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
             "version": 3,
             "width": 10,
             "x": 12,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -7743,8 +7702,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -8744,8 +8702,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -9736,8 +9693,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,

packages/excalidraw/tests/__snapshots__/export.test.tsx.snap

@@ -1,7 +1,7 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`export > export svg-embedded scene > svg-embdedded scene export output 1`] = `
-"<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 36 36" width="36" height="36"><!-- svg-source:excalidraw --><metadata><!-- payload-type:application/vnd.excalidraw+json --><!-- payload-version:2 --><!-- payload-start -->eyJ2ZXJzaW9uIjoiMSIsImVuY29kaW5nIjoiYnN0cmluZyIsImNvbXByZXNzZWQiOnRydWUsImVuY29kZWQiOiJ4nHVTS27bMFx1MDAxMN33XHUwMDE0grItXHUwMDEy2UW68C7NXHUwMDA3zVwiXdRcdTAwMDW6KLpgxLE0ME1cdTAwMTLkKLZrXHUwMDE4yDG661x1MDAxNXOEXGZpVTTlRFx1MDAwMlxi8M3vzZvh7kNRlLS1UM6KXHUwMDEyNrVQKJ1Yl1x1MDAxZlx1MDAwM/5cdTAwMDTOo9Fsmsa7N52ro2dLZGdcdTAwMTdcdTAwMTfKcEBrPM0+VVV1XGJcdTAwMDJcdTAwMDUr0OTZ7Vx1MDAxN9+LYlx1MDAxN0+2oFxmoVfRLVx1MDAwMv/rXHUwMDEybCihXHUwMDFihqrhts1ua5TUMjL5PEAtYNNSjlx03SjIXHUwMDAyPTmzhGujjFx1MDAwYlx1MDAxNc8mXHUwMDEw/lT0UdTLxplOy8GHnNDeXG7HzSS/XHUwMDA1KjWnbczOerBa5ajGz57idIS/XHUwMDE3xUWbVoNcdTAwMGaCTVx1MDAwNtRYUSOF5idV6lwiMLT3Mmr7O3FyYlx1MDAwNfdBXFzdKTXAqCVsxmBssa+WXHUwMDE5PIDMXHUwMDE4pOGfYN+MrnN50d/w3CmmWFxi5SFcdFx1MDAxYlxu3qadyIp2VlxuXHUwMDFh1VWol2M/3rPlXHUwMDFiuePesKIv//4+XHUwMDFmjchomuOfQHBaZeidWKFcbppeZimuXHUwMDE0NqHPUsHiaNTcLCHv92AmY5O15nxcdTAwMDI1uFPhjcNcdTAwMDa1UD/epCc6Mt/BXHUwMDFmXGKS6+C4c/g6bPP59DJcdTAwMWH2fMZZl8LaObFebD28Kd5cdTAwMDeUo1ZcdTAwMGZcdTAwMTiBTW1G6MFIuNXiUY11LJ9cdTAwMTDWX07X/2xcdTAwMTG/nng/godOXHUwMDExznnUNfFcdTAwMWWEee5cdTAwMDK/feTHb1x1MDAwM3po/1xua2IoWiJ9<!-- payload-end --></metadata><defs><style class="style-fonts">
+"<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 36 36" width="36" height="36"><!-- svg-source:excalidraw --><metadata><!-- payload-type:application/vnd.excalidraw+json --><!-- payload-version:2 --><!-- payload-start -->eyJ2ZXJzaW9uIjoiMSIsImVuY29kaW5nIjoiYnN0cmluZyIsImNvbXByZXNzZWQiOnRydWUsImVuY29kZWQiOiJ4nHVTTW/bMFxmve9XXHUwMDE47rVonVx1MDAxNN0ht36iPbSHZsBcdTAwMGXDXHUwMDBlqsXYRFx1MDAxNEmQ6CZZXHUwMDEwYD9jt/3F/YRRimvZTmtcdTAwMDNcdTAwMDb8SJGPj0+7L1mW09ZCPsty2JRCoXRinZ9cdTAwMDb8XHKcR6M5NI3/3jSujJk1kZ2dnyvDXHUwMDA3auNpdlFcdTAwMTTF4Vx1MDAxMChYgSbPaT/4P8t28ctcdTAwMTGU4ehVTIvAe1+CXHIldMNQcVZcdTAwMTRcdTAwMWSwXHUwMDFkXHUwMDAza5RUMzj52kdrwKqmI1joSoUuXHTx5MxcdTAwMTJujDIudD+ZQHhcdTAwMTOBV1EuK2dcdTAwMWEtu1x1MDAxY3JCeytcdTAwMWNcdTAwMGaW8lx1MDAxNqjUnLaxOmvDyuWjXHUwMDFl31ui01x1MDAxMf7ZKW5a1Vx1MDAxYXxcdTAwMTBv0qHGilx1MDAxMimoMOnNXHUwMDE1XHUwMDE42kdcdTAwMTl1/pk4ObGCxyC0bpTqYNRcdTAwMTI2YzCO2HZcdTAwMWJcdTAwMDQ8gFx1MDAxYzBIRjjCno0uh/Kiv2VcdTAwMGZQLLFcdTAwMTDKQ1x1MDAxMjY0vEv+XHUwMDE4NG2sXHUwMDE0NOqrUC/Heey55Vx1MDAwN7Wjh1jRf3///O6tyGia469AcFpcZtB7sUJcdTAwMTU0vVx1MDAxY5S4UliFOXNcdTAwMDWL3qp5WEL2elx1MDAxNyZjU7Tkelx1MDAwMjW4Y+GNw1xutVDfPqQnXHUwMDFhMi/gXHUwMDBmXHUwMDA0yTXQn1x1MDAxY1x1MDAxZTpDn00vY2DP37jrXFxYOyfWi6OH+8V+QDlcdTAwMWH1gFx1MDAxMdg0ZoSejIQ7LV7VWMf8XHJhfX1s/5NFfFri7Vxunlx1MDAxYUU451WXxD5cYvvcXHUwMDA1fvvIj+9cdTAwMDa00P4/o1sqkiJ9<!-- payload-end --></metadata><defs><style class="style-fonts">
       </style></defs><rect x="0" y="0" width="36" height="36" fill="#ffffff"></rect><g transform="translate(10 10) rotate(0 8 8)" data-id="A"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, sans-serif, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">😀</text></g></svg>"
 `;
 

packages/excalidraw/tests/__snapshots__/move.test.tsx.snap

@@ -128,8 +128,8 @@ exports[`move element > rectangles with binding arrow 5`] = `
   "version": 4,
   "versionNonce": 760410951,
   "width": 100,
-  "x": 0,
-  "y": 0,
+  "x": "0.00000",
+  "y": "0.00000",
 }
 `;
 

packages/excalidraw/tests/__snapshots__/regressionTests.test.tsx.snap

@@ -30,8 +30,7 @@ exports[`given element A and group of elements B and given both are selected whe
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -172,8 +171,8 @@ exports[`given element A and group of elements B and given both are selected whe
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -226,7 +225,7 @@ exports[`given element A and group of elements B and given both are selected whe
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
+            "x": "0.00000",
             "y": 30,
           },
           "inserted": {
@@ -280,7 +279,7 @@ exports[`given element A and group of elements B and given both are selected whe
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
+            "x": "0.00000",
             "y": 60,
           },
           "inserted": {
@@ -457,8 +456,7 @@ exports[`given element A and group of elements B and given both are selected whe
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -601,8 +599,8 @@ exports[`given element A and group of elements B and given both are selected whe
             "type": "rectangle",
             "version": 3,
             "width": 100,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -874,8 +872,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -1009,8 +1006,8 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -1064,7 +1061,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
             "version": 3,
             "width": 10,
             "x": 30,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -1233,7 +1230,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
             "version": 3,
             "width": 10,
             "x": 60,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -1441,8 +1438,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -1576,8 +1572,8 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
             "type": "ellipse",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -1608,8 +1604,8 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
           },
           "inserted": {
             "version": 3,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
         },
       },
@@ -1649,8 +1645,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -2034,8 +2029,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -2280,8 +2274,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -2461,8 +2454,7 @@ exports[`regression tests > can drag element that covers another element, while
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -2787,8 +2779,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1971c2",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -3043,8 +3034,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -3285,8 +3275,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -3522,8 +3511,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -3781,8 +3769,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -4096,8 +4083,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -4234,7 +4220,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -4288,7 +4274,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
             "version": 3,
             "width": 10,
             "x": 50,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -4533,8 +4519,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "down",
   "defaultSidebarDockedPreference": false,
@@ -4697,8 +4682,8 @@ exports[`regression tests > deselects group of selected elements on pointer down
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -4817,8 +4802,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -4953,8 +4937,8 @@ exports[`regression tests > deselects group of selected elements on pointer up w
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -5094,8 +5078,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "down",
   "defaultSidebarDockedPreference": false,
@@ -5257,8 +5240,8 @@ exports[`regression tests > deselects selected element on pointer down when poin
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -5303,8 +5286,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -5438,8 +5420,8 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
             "type": "ellipse",
             "version": 3,
             "width": 100,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -5504,8 +5486,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -5898,8 +5879,7 @@ exports[`regression tests > drags selected elements from point inside common bou
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -6037,8 +6017,8 @@ exports[`regression tests > drags selected elements from point inside common bou
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -6143,8 +6123,8 @@ exports[`regression tests > drags selected elements from point inside common bou
           },
           "inserted": {
             "version": 3,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
         },
         "id3": {
@@ -6196,8 +6176,7 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -6835,12 +6814,12 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
                 10,
               ],
               [
-                80,
+                "80.00000",
                 20,
               ],
             ],
             "version": 5,
-            "width": 80,
+            "width": "80.00000",
           },
           "inserted": {
             "height": 10,
@@ -6935,12 +6914,8 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
             "roundness": null,
             "simulatePressure": false,
             "strokeColor": "#1e1e1e",
-            "strokeOptions": {
-              "streamline": "0.50000",
-              "variability": "constant",
-            },
             "strokeStyle": "solid",
-            "strokeWidth": 1,
+            "strokeWidth": 2,
             "type": "freedraw",
             "version": 4,
             "width": 50,
@@ -6990,8 +6965,7 @@ exports[`regression tests > given a group of selected elements with an element t
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -7128,8 +7102,8 @@ exports[`regression tests > given a group of selected elements with an element t
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -7325,8 +7299,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -7463,8 +7436,8 @@ exports[`regression tests > given a selected element A and a not selected elemen
             "type": "rectangle",
             "version": 3,
             "width": 1000,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -7605,8 +7578,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -7841,8 +7813,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -8082,8 +8053,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -8263,8 +8233,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -8444,8 +8413,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -8625,8 +8593,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -8859,8 +8826,7 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -9091,8 +9057,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -9233,12 +9198,8 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] undo sta
             "roundness": null,
             "simulatePressure": false,
             "strokeColor": "#1e1e1e",
-            "strokeOptions": {
-              "streamline": "0.50000",
-              "variability": "constant",
-            },
             "strokeStyle": "solid",
-            "strokeWidth": 1,
+            "strokeWidth": 2,
             "type": "freedraw",
             "version": 4,
             "width": 30,
@@ -9288,8 +9249,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -9522,8 +9482,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -9703,8 +9662,7 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -9935,8 +9893,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -10116,8 +10073,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -10258,12 +10214,8 @@ exports[`regression tests > key p selects freedraw tool > [end of test] undo sta
             "roundness": null,
             "simulatePressure": false,
             "strokeColor": "#1e1e1e",
-            "strokeOptions": {
-              "streamline": "0.50000",
-              "variability": "constant",
-            },
             "strokeStyle": "solid",
-            "strokeWidth": 1,
+            "strokeWidth": 2,
             "type": "freedraw",
             "version": 4,
             "width": 30,
@@ -10313,8 +10265,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -10494,8 +10445,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -11026,8 +10976,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -11307,8 +11256,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "down",
   "defaultSidebarDockedPreference": false,
@@ -11431,8 +11379,7 @@ exports[`regression tests > shift click on selected element should deselect it o
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -11566,8 +11513,8 @@ exports[`regression tests > shift click on selected element should deselect it o
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -11632,8 +11579,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -11952,8 +11898,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -12382,8 +12327,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -12528,7 +12472,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -12582,7 +12526,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
             "version": 3,
             "width": 10,
             "x": 50,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -13023,8 +12967,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -13150,8 +13093,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -13287,8 +13229,8 @@ exports[`regression tests > supports nested groups > [end of test] undo stack 1`
             "type": "rectangle",
             "version": 3,
             "width": 50,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -13782,8 +13724,7 @@ exports[`regression tests > switches from group of selected elements to another
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "down",
   "defaultSidebarDockedPreference": false,
@@ -13876,8 +13817,8 @@ exports[`regression tests > switches from group of selected elements to another
     "version": 1,
     "versionNonce": 0,
     "width": 0,
-    "x": 0,
-    "y": 0,
+    "x": "0.00000",
+    "y": "0.00000",
   },
   "shouldCacheIgnoreZoom": false,
   "showHyperlinkPopup": false,
@@ -13948,8 +13889,8 @@ exports[`regression tests > switches from group of selected elements to another
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -14122,8 +14063,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "down",
   "defaultSidebarDockedPreference": false,
@@ -14215,8 +14155,8 @@ exports[`regression tests > switches selected element on pointer down > [end of
     "version": 1,
     "versionNonce": 0,
     "width": 0,
-    "x": 0,
-    "y": 0,
+    "x": "0.00000",
+    "y": "0.00000",
   },
   "shouldCacheIgnoreZoom": false,
   "showHyperlinkPopup": false,
@@ -14287,8 +14227,8 @@ exports[`regression tests > switches selected element on pointer down > [end of
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": 0,
-            "y": 0,
+            "x": "0.00000",
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -14387,8 +14327,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "down",
   "defaultSidebarDockedPreference": false,
@@ -14511,8 +14450,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -14645,12 +14583,12 @@ exports[`regression tests > undo/redo drawing an element > [end of test] redo st
                 10,
               ],
               [
-                100,
+                "100.00000",
                 20,
               ],
             ],
             "version": 5,
-            "width": 100,
+            "width": "100.00000",
           },
         },
       },
@@ -14832,7 +14770,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] undo st
             "version": 5,
             "width": 30,
             "x": 40,
-            "y": 0,
+            "y": "0.00000",
           },
           "inserted": {
             "isDeleted": true,
@@ -14877,8 +14815,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,
@@ -15001,8 +14938,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,

packages/excalidraw/tests/actionStyles.test.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 
-import { CODES, STROKE_WIDTH } from "@excalidraw/common";
+import { CODES } from "@excalidraw/common";
 
 import { copiedStyles } from "../actions/actionStyles";
 import { Excalidraw } from "../index";
@@ -78,7 +78,7 @@ describe("actionStyles", () => {
     expect(firstRect.strokeColor).toBe("#e03131");
     expect(firstRect.backgroundColor).toBe("#a5d8ff");
     expect(firstRect.fillStyle).toBe("cross-hatch");
-    expect(firstRect.strokeWidth).toBe(STROKE_WIDTH.bold);
+    expect(firstRect.strokeWidth).toBe(2); // Bold: 2
     expect(firstRect.strokeStyle).toBe("dotted");
     expect(firstRect.roughness).toBe(2); // Cartoonist: 2
     expect(firstRect.opacity).toBe(60);

packages/excalidraw/tests/contextmenu.test.tsx

@@ -1,7 +1,7 @@
 import React from "react";
 import { vi } from "vitest";
 
-import { KEYS, STROKE_WIDTH, reseed } from "@excalidraw/common";
+import { KEYS, reseed } from "@excalidraw/common";
 
 import { setDateTimeForTests } from "@excalidraw/common";
 
@@ -378,7 +378,7 @@ describe("contextMenu element", () => {
     expect(firstRect.strokeColor).toBe("#e03131");
     expect(firstRect.backgroundColor).toBe("#a5d8ff");
     expect(firstRect.fillStyle).toBe("cross-hatch");
-    expect(firstRect.strokeWidth).toBe(STROKE_WIDTH.bold);
+    expect(firstRect.strokeWidth).toBe(2); // Bold: 2
     expect(firstRect.strokeStyle).toBe("dotted");
     expect(firstRect.roughness).toBe(2); // Cartoonist: 2
     expect(firstRect.opacity).toBe(60);

packages/excalidraw/tests/data/__snapshots__/restore.test.ts.snap

@@ -240,12 +240,8 @@ exports[`restoreElements > should restore freedraw element correctly 1`] = `
   "seed": Any<Number>,
   "simulatePressure": true,
   "strokeColor": "#1e1e1e",
-  "strokeOptions": {
-    "streamline": "0.50000",
-    "variability": "variable",
-  },
   "strokeStyle": "solid",
-  "strokeWidth": 1,
+  "strokeWidth": 2,
   "type": "freedraw",
   "updated": 1,
   "version": 2,

packages/excalidraw/tests/data/restore.test.ts

@@ -193,53 +193,6 @@ describe("restoreElements", () => {
     expect(restoredFreedraw.pressures).toEqual([0.1, 0.4]);
   });
 
-  it("should restore freedraw stroke variability", () => {
-    const freedrawElement = API.createElement({
-      type: "freedraw",
-      id: "id-freedraw-mode",
-      points: [pointFrom(0, 0), pointFrom(10, 10)],
-    });
-
-    const [missing, bogusString, bogusNumber, valid, variable] =
-      restore.restoreElements(
-        [
-          { ...freedrawElement, id: "missing", strokeOptions: undefined },
-          {
-            ...freedrawElement,
-            id: "bogusString",
-            strokeOptions: { variability: "scribble" },
-          },
-          {
-            ...freedrawElement,
-            id: "bogusNumber",
-            strokeOptions: { variability: 42 },
-          },
-          {
-            ...freedrawElement,
-            id: "valid",
-            strokeOptions: { variability: "constant", streamline: 0.8 },
-          },
-          {
-            ...freedrawElement,
-            id: "variable",
-            strokeOptions: { variability: "variable", streamline: 0.8 },
-          },
-        ] as any,
-        null,
-      ) as ExcalidrawFreeDrawElement[];
-
-    expect(missing.strokeOptions?.variability).toBe("variable");
-    expect(bogusString.strokeOptions?.variability).toBe("variable");
-    expect(bogusNumber.strokeOptions?.variability).toBe("variable");
-    expect(valid.strokeOptions?.variability).toBe("constant");
-    expect(variable.strokeOptions?.variability).toBe("variable");
-    expect(missing.strokeOptions?.streamline).toBe(0.5);
-    expect(bogusString.strokeOptions?.streamline).toBe(0.5);
-    expect(bogusNumber.strokeOptions?.streamline).toBe(0.5);
-    expect(valid.strokeOptions?.streamline).toBe(0.8);
-    expect(variable.strokeOptions?.streamline).toBe(0.8);
-  });
-
   it("should restore line and draw elements correctly", () => {
     const lineElement = API.createElement({ type: "line", id: "id-line01" });
 
@@ -687,21 +640,6 @@ describe("restoreElements", () => {
 });
 
 describe("restoreAppState", () => {
-  it("should restore freedraw mode app state values", () => {
-    expect(
-      restore.restoreAppState(
-        { currentItemStrokeVariability: "constant" } as any,
-        null,
-      ).currentItemStrokeVariability,
-    ).toBe("constant");
-    expect(
-      restore.restoreAppState(
-        { currentItemStrokeVariability: "variable" } as any,
-        null,
-      ).currentItemStrokeVariability,
-    ).toBe("variable");
-  });
-
   it("when appState is null it should return the local app state property", () => {
     const stubLocalAppState = getDefaultAppState();
     stubLocalAppState.cursorButton = "down";
@@ -750,21 +688,6 @@ describe("restoreAppState", () => {
     expect(restoredAppState.name).toBe(stubImportedAppState.name);
   });
 
-  it("should migrate legacy current item stroke width to stroke width key", () => {
-    const stubImportedAppState = {
-      ...getDefaultAppState(),
-      currentItemStrokeWidth: 4,
-      currentItemStrokeWidthKey: undefined,
-    } as any;
-
-    const restoredAppState = restore.restoreAppState(
-      stubImportedAppState,
-      null,
-    );
-
-    expect(restoredAppState.currentItemStrokeWidthKey).toBe("bold");
-  });
-
   it("should restore with current app state when imported data state is undefined", () => {
     const stubImportedAppState = {
       ...getDefaultAppState(),

packages/excalidraw/tests/freedrawMode.test.tsx

@@ -1,57 +0,0 @@
-import type { ExcalidrawFreeDrawElement } from "@excalidraw/element/types";
-
-import { Excalidraw } from "../index";
-
-import { API } from "./helpers/api";
-import { UI } from "./helpers/ui";
-import { act, fireEvent, render, screen } from "./test-utils";
-
-const { h } = window;
-
-describe("freedraw mode action", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw handleKeyboardGlobally={true} />);
-  });
-
-  afterEach(async () => {
-    // https://github.com/floating-ui/floating-ui/issues/1908#issuecomment-1301553793
-    await act(async () => {});
-  });
-
-  it("applies currentItemStrokeVariability to newly drawn freedraw elements", () => {
-    // default app state draws constant-width strokes
-    expect(h.state.currentItemStrokeVariability).toBe("constant");
-
-    UI.createElement("freedraw", { x: 0, y: 0 });
-
-    expect(
-      (h.elements[0] as ExcalidrawFreeDrawElement).strokeOptions?.variability,
-    ).toBe("constant");
-    expect(
-      (h.elements[0] as ExcalidrawFreeDrawElement).strokeOptions?.streamline,
-    ).toBe(0.5);
-  });
-
-  it("toggling the radio updates both the selected element and the default", () => {
-    const element = UI.createElement("freedraw", { x: 0, y: 0 });
-    API.setSelectedElements([element.get()]);
-
-    fireEvent.click(screen.getByTitle("Variable"));
-    expect(
-      (h.elements[0] as ExcalidrawFreeDrawElement).strokeOptions?.variability,
-    ).toBe("variable");
-    expect(
-      (h.elements[0] as ExcalidrawFreeDrawElement).strokeOptions?.streamline,
-    ).toBe(0.5);
-    expect(h.state.currentItemStrokeVariability).toBe("variable");
-
-    fireEvent.click(screen.getByTitle("Constant"));
-    expect(
-      (h.elements[0] as ExcalidrawFreeDrawElement).strokeOptions?.variability,
-    ).toBe("constant");
-    expect(
-      (h.elements[0] as ExcalidrawFreeDrawElement).strokeOptions?.streamline,
-    ).toBe(0.5);
-    expect(h.state.currentItemStrokeVariability).toBe("constant");
-  });
-});

packages/excalidraw/tests/helpers/api.ts

@@ -4,12 +4,7 @@ import util from "util";
 
 import { pointFrom, type LocalPoint, type Radians } from "@excalidraw/math";
 
-import {
-  DEFAULT_VERTICAL_ALIGN,
-  ROUNDNESS,
-  assertNever,
-  getStrokeWidthByKey,
-} from "@excalidraw/common";
+import { DEFAULT_VERTICAL_ALIGN, ROUNDNESS, assertNever } from "@excalidraw/common";
 
 import {
   newArrowElement,
@@ -205,9 +200,6 @@ export class API {
       ? ExcalidrawTextElement["containerId"]
       : never;
     points?: T extends "arrow" | "line" | "freedraw" ? readonly LocalPoint[] : never;
-    strokeOptions?: T extends "freedraw"
-      ? ExcalidrawFreeDrawElement["strokeOptions"]
-      : never;
     locked?: boolean;
     fileId?: T extends "image" ? string : never;
     scale?: T extends "image" ? ExcalidrawImageElement["scale"] : never;
@@ -266,9 +258,7 @@ export class API {
       backgroundColor:
         rest.backgroundColor ?? appState.currentItemBackgroundColor,
       fillStyle: rest.fillStyle ?? appState.currentItemFillStyle,
-      strokeWidth:
-        rest.strokeWidth ??
-        getStrokeWidthByKey(type, appState.currentItemStrokeWidthKey),
+      strokeWidth: rest.strokeWidth ?? appState.currentItemStrokeWidth,
       strokeStyle: rest.strokeStyle ?? appState.currentItemStrokeStyle,
       roundness: (
         rest.roundness === undefined
@@ -327,7 +317,6 @@ export class API {
           type: type as "freedraw",
           simulatePressure: true,
           points: rest.points,
-          strokeOptions: rest.strokeOptions,
           ...base,
         });
         break;

packages/excalidraw/tests/move.test.tsx

@@ -108,8 +108,8 @@ describe("move element", () => {
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(3);
     expect(h.state.selectedElementIds[rectB.id]).toBeTruthy();
-    expect([rectA.x, rectA.y]).toEqual([0, 0]);
-    expect([rectB.x, rectB.y]).toEqual([200, 0]);
+    expect([[rectA.x, rectA.y]]).toCloselyEqualPoints([[0, 0]]);
+    expect([[rectB.x, rectB.y]]).toCloselyEqualPoints([[200, 0]]);
     expect([[arrow.x, arrow.y]]).toCloselyEqualPoints(
       [[106.00000000000001, 55.6867741935484]],
       0,
@@ -130,8 +130,8 @@ describe("move element", () => {
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(3);
     expect(h.state.selectedElementIds[rectB.id]).toBeTruthy();
-    expect([rectA.x, rectA.y]).toEqual([0, 0]);
-    expect([rectB.x, rectB.y]).toEqual([201, 2]);
+    expect([[rectA.x, rectA.y]]).toCloselyEqualPoints([[0, 0]]);
+    expect([[rectB.x, rectB.y]]).toCloselyEqualPoints([[201, 2]]);
     expect([[arrow.x, arrow.y]]).toCloselyEqualPoints(
       [[106, 55.6867741935484]],
       0,

packages/excalidraw/tests/packages/__snapshots__/utils.test.ts.snap

@@ -24,7 +24,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,

packages/excalidraw/tests/scene/__snapshots__/export.test.ts.snap

@@ -240,7 +240,7 @@ exports[`exportToSvg > with elements that have a link 1`] = `
 `;
 
 exports[`exportToSvg > with exportEmbedScene 1`] = `
-"<!-- svg-source:excalidraw --><metadata><!-- payload-type:application/vnd.excalidraw+json --><!-- payload-version:2 --><!-- payload-start -->eyJ2ZXJzaW9uIjoiMSIsImVuY29kaW5nIjoiYnN0cmluZyIsImNvbXByZXNzZWQiOnRydWUsImVuY29kZWQiOiJ4nO1WW2vbMFx1MDAxOH3vrzDaa1llJ2nSvGXrLoWxwTIorOxBtT7bwrLkSnIuXHUwMDBi+e+T5MVyvLLnNYtcdTAwMDOG7350dD6c3UVcdTAwMTQhs61cdTAwMDHNI1x1MDAwNJuUcEZcdTAwMTVZo0vnX4HSTFxuXHUwMDFiSrytZaNSn1lcdTAwMThTz6+uuLRcdTAwMDWF1GY+wlx1MDAxOLdFwKFcdTAwMDJhtE17sHZcdTAwMTTt/NtGXHUwMDE4daWre/X0ZZGVTNDkKa2mn25cdTAwMTdcdTAwMWa++1KftLE543jc2Vs3fTTt7DWjprC+XHUwMDE4485XXHUwMDAwy1x1MDAwYjNwXHUwMDEykXOHNXi0UbKEt5JL5YC8wv5cdKNcdTAwMWZJWuZKNoKGnHhCyGNcdTAwMTZyMsb50mx5y1x1MDAwMkmLRlx1MDAwMVx1MDAxYUy4P0BcdTAwMWP4uzotLcuhyo7MXHUwMDBiXHUwMDAxWlx1MDAxZtXImqTMbFx1MDAwN6dy+Oo76tn9XHUwMDExUClSwZ2jVzSc91x1MDAxYlx1MDAwYvq78VHAclx1MDAwZo5oRHrH11x1MDAwMNRPXHUwMDFix9eT6VxynnWRoIM4wUPvZym8JuJ4NsN4nEyvw1x1MDAxOH1r1WB824xwXHKBaofsXVDKXHUwMDExuqampC1cbmxwJsphnlVf+Uzvg5opI5VcdTAwMTRcdTAwMTR5//7yrMV/XYvx6WpcdTAwMTE4Z7WGl6HFXHUwMDE43O//1mJyulo0sDG9i5PCLNlPXHUwMDE36Z3Bed+TinHH8yS0cKW2hVQsZ4Lw6LjXwf3t72nOWnCWO+JcdTAwMTCHrFx1MDAxN7LcXHUwMDE5Zv9TdGEj61x1MDAxME0tKsJcdTAwMDSoP6/U8lx1MDAwMFx1MDAxZju5v05cdTAwMDJm0lx1MDAxOPlcdTAwMTV0e0TPyHlcdF/IXHUwMDEyjs5L2C1hXHUwMDAwfkpLaN9eKIjU9dJYYm24XUm0YrB+84zoM/+4L6lfYSd6cLe021/sf1x1MDAwMVSoRdMifQ==<!-- payload-end --></metadata><defs><style class="style-fonts">
+"<!-- svg-source:excalidraw --><metadata><!-- payload-type:application/vnd.excalidraw+json --><!-- payload-version:2 --><!-- payload-start -->eyJ2ZXJzaW9uIjoiMSIsImVuY29kaW5nIjoiYnN0cmluZyIsImNvbXByZXNzZWQiOnRydWUsImVuY29kZWQiOiJ4nO1WW2vbMFx1MDAxOH3vrzDaa2llJ2myvGXrLoWxwTIorPRBtT7bwrLkSnIuXHUwMDBi+e+V5MVy0rL3ZHHAoPNddHR0PpzNRVx1MDAxNCGzrlx1MDAwMU0jXHUwMDA0q5RwRlx1MDAxNVmiS4cvQGkmhVxyJX6tZaNSn1lcdTAwMThTT6+vubRcdTAwMDWF1GY6wFx1MDAxOLdFwKFcdTAwMDJhtE17sOso2vi3jTDqSlx1MDAxN/fq+ccsK5mgyXNajb/dzr789qU+aWVzhvHwXG7jXHUwMDBlWjtcdTAwMDKDcVx1MDAxZloyalxuXHUwMDBix1x1MDAxOPfhXHUwMDAyWF6Y1zhcdTAwMTE5d7xcdTAwMDOijZIlfJRcXCpH6lx1MDAxZPZPoPFE0jJXslx1MDAxMTTkxCNCnrKQkzHO52bNW0VIWjRcbtDBXHUwMDBl9zuiXHUwMDA3eFenpVU8VNkt80KA1ns1siYpM+v2YFx1MDAxZOr41XfUK/1cdTAwMThYKVLBnZNaNJz3XHUwMDFiXHUwMDBi+rfxXsDeXHUwMDAzONFcdTAwMTHpXHUwMDFkX1x1MDAwM1C/2zC+XHUwMDE5jd/jSVx1MDAxN1x0nohcdTAwMTN8iH6XwvsjjidcdTAwMTOMh8n4Jmyjb60zjG+bXHUwMDExriFI7Zh9XG6u2WPX1JS0RUFccs5EeZhnnVi+0XvnbMpIJVx1MDAwNUVcdTAwMWXfXp59eUy+jE/Xl8A5qzVcdTAwMWOfL2Nwv//bl8np+tLAyvQuTlxuM2d/XFykd1x1MDAwNod+Jlx1MDAxNeNO51Fo4UptXHUwMDBiqVjOXHUwMDA04dF+r1x1MDAxZPzr32luNeMsd8IhXHUwMDBlWS9ktTPM/u/owkbWIZpaVoRcdFCvr9TqXHUwMDAwXzvHXyWBM2mM/Fx0uj2iV+Q8kEc4kIPzQHZcdTAwMDNcdTAwMTmIn9JA2rc3XG5cInU9N1ZYXHUwMDFibsdcdTAwMTMtXHUwMDE4LD+8YfrMP+5cdTAwMGLrx9mZXHUwMDFl3C1ttlx1MDAxN9tcdTAwMTcwdk6zIn0=<!-- payload-end --></metadata><defs><style class="style-fonts">
       @font-face { font-family: Excalifont; src: url(data:font/woff2;base64,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); }
       @font-face { font-family: Excalifont; src: url(data:font/woff2;base64,d09GMgABAAAAAAHcAA0AAAAAA9gAAAGMAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGx4cNAZgAAQRCAoAKgsEAAE2AiQDBAQgBYMYByAbHQPIrgp4MjSeIQLqpl4jnPFQwveqm205gmrZevZ2/8kKGaJ6ictBuCwMMnsKo8hC4RwaLBrJ7dXaFrFk0Re1e/Dk3t9wCUVrYAiZkgiZ5rGDVFdY04wBF4APOCzXHr/ljrNIDqLAY/slkQf0SyjxLNBaAq8Z1AJqYW5j0GjbckRLQhoJCgwYoyfY3q33QS5DrSAwYB4hFruNve4WoN2On4P29GEFWsC+nVM/UvSlVwIcsWycI/5gbqfUhE/9Q2P7UppTOAVeIR4TYIocELVKIEACZJgXCJ5GXl0o+esbFP3g+763DcDPx6/60MrnBaBPAsGPUDRC/8+FGIqGUSBA+NIJOwTWe13HRCIrgEvfRhj1RjLiE42eG7I5DIpVNuqkNNhxwaItTI2srRz4dfHGjhZoO0O8nb2pilFYQKhenFaycLUxsYcoAQRyoRBEnPvcgfysPq+npClt8UxLyvHWjaudqbGJA+TCckNECBGBGFforuTs0M4CUMbCAvp+P4in4o864XECREBtFQAAAAA=); }
       @font-face { font-family: Nunito; src: url(data:font/woff2;base64,d09GMgABAAAAAAIsAA4AAAAABLQAAAHYAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGx4cLgZgP1NUQVREAAQRCAoAKgsEAAE2AiQDBAQgBYQkByAb5wPIrgp4Mt6IIcJZFNCfWmZY6KzqazTt6AiVHCFawzJ7V0CQBKoSQQEpFKrCVxiSFbqqqsaTevKs/q7s6uBYmujMyA9wxb6a7XnEOcNnDLgG4nW8PoPzHzYpS2uqp51pL3eB/xZoxIllCQc80B9o4j/4xMbxQB+j+SC3hsm6JmI8RMaHj+aJApW6ZbkXlg4vXSE5FECg0og6LzxP9pOarug4tF1RLpbHeZqLX0pIt2mfy3pNG6eyGaRIjrnrr/gv2c//yGdjpJ/7DuJLin5eIZRLaObBMM/NpYpuXJ8z3SE088mEFANcCARESfwChCioAwESsVxBgeyxp6+vZ3Xzv8uz7Ae8tRk+p6RUTPOR7BmlEgh+STsAimNuKibilyluhBNe5/wCACSBKrcykVfgyb+RYcK/TGq9yMyCt3bOskSnR1FqTLMSVBsMGLQVltDKKw2IYA+wcGxHJCINY9mDOCaN4IZEo1ChY4xNg8DaB0RxDqnbMNjXJJRzF9iInqahtm67M8dOHFvXaYbn+wrGxKG3YZI+2V4CW58ovdfV1tFHXFJJiPH7T1FAJxEgYo5BKkA5iDIVQluOqZYWhQapGF6TAFhaFAAoTBIZsCFHi/0oV3gpVKwbAA==); }

packages/excalidraw/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "extends": "../tsconfig.base.json",
   "compilerOptions": {
-    "rootDir": "../",
     "outDir": "./dist/types"
   },
   "include": ["**/*"],

packages/excalidraw/types.ts

@@ -4,7 +4,6 @@ import type {
   throttleRAF,
   MIME_TYPES,
   EditorInterface,
-  StrokeWidthKey,
 } from "@excalidraw/common";
 
 import type { LinearElementEditor } from "@excalidraw/element";
@@ -34,7 +33,6 @@ import type {
   ExcalidrawNonSelectionElement,
   BindMode,
   ExcalidrawTextElement,
-  StrokeVariability,
 } from "@excalidraw/element/types";
 
 import type {
@@ -364,10 +362,9 @@ export interface AppState {
   currentItemStrokeColor: string;
   currentItemBackgroundColor: string;
   currentItemFillStyle: ExcalidrawElement["fillStyle"];
-  currentItemStrokeWidthKey: StrokeWidthKey;
+  currentItemStrokeWidth: number;
   currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
   currentItemRoughness: number;
-  currentItemStrokeVariability: StrokeVariability;
   currentItemOpacity: number;
   currentItemFontFamily: FontFamilyValues;
   currentItemFontSize: number;

packages/fractional-indexing/tsconfig.json

@@ -1,8 +1,7 @@
 {
   "extends": "../tsconfig.base.json",
   "compilerOptions": {
-    "outDir": "./dist/types",
-    "rootDir": "../"
+    "outDir": "./dist/types"
   },
   "include": ["src/**/*", "global.d.ts"],
   "exclude": ["**/*.test.*", "tests", "types", "examples", "dist"]

packages/laser-pointer/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Excalidraw
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

packages/laser-pointer/README.md

@@ -1,23 +0,0 @@
-# Laser Pointer
-
-## Usage
-
-    import { LaserPointer } from '@excalidraw/laser-pointer'
-
-    const stroke = new LaserPointer(options)
-
-    stroke.addPoint([100, 200, 1])
-    stroke.close()
-
-    const outline = stroke.getStrokeOutline()
-
-## Options
-
-| Property | Type | Default | Description |
-| --- | --- | --- | --- |
-| `size` | `number` | `2` | Radius of the stroke. |
-| `streamline` | `number` | `0.42` | Interpolate input points to reduce jitter. |
-| `simplify` | `number` | `0.1` | Reduce stroke size by sacrificing precision. |
-| `simplifyPhase` | `"input" \| "output" \| "tail" ` | `"output"` | Decides when the simplification algorithm should be applied. |
-| `sizeMapping` | `(details: SizeMappingDetails) => number` | `() => 1` | Maps each point to a value between `0.0` and `1.0`. |
-| `keepHead` | `boolean` | `false` | Whether size mapping should influence the head of the stroke. |

packages/laser-pointer/package.json

@@ -1,34 +0,0 @@
-{
-  "name": "@excalidraw/laser-pointer",
-  "version": "1.3.1",
-  "description": "Generate outline for laser pointer tool",
-  "type": "module",
-  "types": "./dist/types/laser-pointer/src/index.d.ts",
-  "main": "./dist/prod/index.js",
-  "module": "./dist/prod/index.js",
-  "exports": {
-    ".": {
-      "types": "./dist/types/laser-pointer/src/index.d.ts",
-      "development": "./dist/dev/index.js",
-      "production": "./dist/prod/index.js",
-      "default": "./dist/prod/index.js"
-    }
-  },
-  "files": [
-    "dist/*"
-  ],
-  "keywords": [
-    "excalidraw",
-    "laserpointer"
-  ],
-  "bugs": "https://github.com/excalidraw/excalidraw/issues",
-  "repository": "https://github.com/excalidraw/excalidraw",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "gen:types": "rimraf types && tsc",
-    "build:esm": "rimraf dist && node ../../scripts/buildBase.js && yarn gen:types"
-  }
-}

packages/laser-pointer/src/index.ts

@@ -1,2 +0,0 @@
-export * from "./state";
-export type { Point } from "./math";

packages/laser-pointer/src/math.ts

@@ -1,105 +0,0 @@
-export type Point = [x: number, y: number, r: number];
-
-export function add([ax, ay, ar]: Point, [bx, by, br]: Point): Point {
-  return [ax + bx, ay + by, ar + br];
-}
-
-export function sub([ax, ay, ar]: Point, [bx, by, br]: Point): Point {
-  return [ax - bx, ay - by, ar - br];
-}
-
-export function smul([x, y, r]: Point, s: number): Point {
-  return [x * s, y * s, r * s];
-}
-
-export function norm([x, y, r]: Point): Point {
-  return [x / Math.sqrt(x ** 2 + y ** 2), y / Math.sqrt(x ** 2 + y ** 2), r];
-}
-
-export function rot([x, y, r]: Point, rad: number): Point {
-  return [
-    Math.cos(rad) * x - Math.sin(rad) * y,
-    Math.sin(rad) * x + Math.cos(rad) * y,
-    r,
-  ];
-}
-
-export function plerp(a: Point, b: Point, t: number): Point {
-  return add(a, smul(sub(b, a), t));
-}
-
-export function lerp(a: number, b: number, t: number): number {
-  return a + (b - a) * t;
-}
-
-export function angle(p: Point, p1: Point, p2: Point) {
-  return (
-    Math.atan2(p2[1] - p[1], p2[0] - p[0]) -
-    Math.atan2(p1[1] - p[1], p1[0] - p[0])
-  );
-}
-
-export function normAngle(a: number) {
-  return Math.atan2(Math.sin(a), Math.cos(a));
-}
-
-export function mag([x, y]: Point) {
-  return Math.sqrt(x ** 2 + y ** 2);
-}
-
-export function dist([ax, ay]: Point, [bx, by]: Point): number {
-  return Math.sqrt((bx - ax) ** 2 + (by - ay) ** 2);
-}
-
-export function getCircleAndPerpendicularLineIntersectionsAtPoint(
-  point: Point,
-  direction: Point,
-  radius: number,
-): [Point, Point] {
-  return [
-    add(point, smul(norm(rot(direction, Math.PI / 2)), radius)),
-    add(point, smul(norm(rot(direction, -Math.PI / 2)), radius)),
-  ];
-}
-
-export function runLength(ps: Point[]): number {
-  if (ps.length < 2) {
-    return 0;
-  }
-
-  let len = 0;
-
-  for (let i = 1; i <= ps.length - 1; i++) {
-    len += dist(ps[i - 1], ps[i]);
-  }
-
-  len += dist(ps[ps.length - 2], ps[ps.length - 1]);
-
-  return len;
-}
-
-export const clamp = (v: number, min: number, max: number) =>
-  Math.max(min, Math.min(max, v));
-
-export function distancePointToSegment(p3: Point, p1: Point, p2: Point) {
-  const sMag = dist(p1, p2);
-
-  if (sMag === 0) {
-    return dist(p3, p1);
-  }
-
-  const u = clamp(
-    ((p3[0] - p1[0]) * (p2[0] - p1[0]) + (p3[1] - p1[1]) * (p2[1] - p1[1])) /
-      sMag ** 2,
-    0,
-    1,
-  );
-
-  const pi: Point = [
-    p1[0] + u * (p2[0] - p1[0]),
-    p1[1] + u * (p2[1] - p1[1]),
-    p3[2],
-  ];
-
-  return dist(pi, p3);
-}

packages/laser-pointer/src/simplify.ts

@@ -1,42 +0,0 @@
-import { type Point, distancePointToSegment } from "./math";
-
-export function douglasPeucker(points: Point[], epsilon: number): Point[] {
-  if (epsilon === 0) {
-    return points;
-  }
-
-  if (points.length <= 2) {
-    return points;
-  }
-
-  const first = points[0];
-  const last = points[points.length - 1];
-
-  const [maxDistance, maxIndex] = points.reduce(
-    ([maxDistance, maxIndex], point, index) => {
-      const distance = distancePointToSegment(point, first, last);
-
-      return distance > maxDistance
-        ? [distance, index]
-        : [maxDistance, maxIndex];
-    },
-    [0, -1],
-  );
-
-  if (maxDistance >= epsilon) {
-    const maxIndexPoint = points[maxIndex];
-
-    return [
-      ...douglasPeucker(
-        [first, ...points.slice(1, maxIndex), maxIndexPoint],
-        epsilon,
-      ).slice(0, -1),
-      maxIndexPoint,
-      ...douglasPeucker(
-        [maxIndexPoint, ...points.slice(maxIndex, -1), last],
-        epsilon,
-      ).slice(1),
-    ];
-  }
-  return [first, last];
-}

packages/laser-pointer/src/state.ts

@@ -1,377 +0,0 @@
-import * as m from "./math";
-import { douglasPeucker } from "./simplify";
-
-import type { Point } from "./math";
-
-export type SizeMappingDetails = {
-  pressure: number;
-  runningLength: number;
-  currentIndex: number;
-  totalLength: number;
-};
-
-export type LaserPointerOptions = {
-  size: number;
-
-  streamline: number;
-  simplify: number;
-  simplifyPhase: "tail" | "output" | "input";
-
-  keepHead: boolean;
-
-  sizeMapping: (details: SizeMappingDetails) => number;
-};
-
-export class LaserPointer {
-  static defaults: LaserPointerOptions = {
-    size: 2,
-    streamline: 0.45,
-    simplify: 0.1,
-    simplifyPhase: "output",
-    keepHead: false,
-
-    sizeMapping: () => 1,
-  };
-
-  static constants = {
-    cornerDetectionMaxAngle: 75,
-    cornerDetectionVariance: (s: number) => (s > 35 ? 0.5 : 1),
-    maxTailLength: 50,
-  };
-
-  options: LaserPointerOptions;
-  constructor(options: Partial<LaserPointerOptions>) {
-    this.options = Object.assign({}, LaserPointer.defaults, options);
-  }
-
-  originalPoints: Point[] = [];
-
-  private stablePoints: Point[] = [];
-  private tailPoints: Point[] = [];
-
-  private isFresh = true;
-
-  private get lastPoint(): Point {
-    return (
-      this.tailPoints[this.tailPoints.length - 1] ??
-      this.stablePoints[this.stablePoints.length - 1]
-    );
-  }
-
-  addPoint(point: Point) {
-    const lastPoint = this.originalPoints[this.originalPoints.length - 1];
-
-    if (lastPoint && lastPoint[0] === point[0] && lastPoint[1] === point[1]) {
-      return;
-    }
-
-    this.originalPoints.push(point);
-
-    if (this.isFresh) {
-      this.isFresh = false;
-      this.stablePoints.push(point);
-      return;
-    }
-
-    if (this.options.streamline > 0) {
-      point = m.plerp(this.lastPoint, point, 1 - this.options.streamline);
-    }
-
-    this.tailPoints.push(point);
-
-    if (m.runLength(this.tailPoints) > LaserPointer.constants.maxTailLength) {
-      this.stabilizeTail();
-    }
-  }
-
-  close() {
-    this.stabilizeTail();
-  }
-
-  stabilizeTail() {
-    if (this.options.simplify > 0 && this.options.simplifyPhase === "tail") {
-      throw new Error("Not implemented yet");
-    } else {
-      this.stablePoints.push(...this.tailPoints);
-      this.tailPoints = [];
-    }
-  }
-
-  private getSize(
-    sizeOverride: number | undefined,
-    pressure: number,
-    index: number,
-    totalLength: number,
-    runningLength: number,
-  ) {
-    return (
-      (sizeOverride ?? this.options.size) *
-      this.options.sizeMapping({
-        pressure,
-        runningLength,
-        currentIndex: index,
-        totalLength,
-      })
-    );
-  }
-
-  getStrokeOutline(sizeOverride?: number | undefined): Point[] {
-    if (this.isFresh) {
-      return [];
-    }
-
-    let points = [...this.stablePoints, ...this.tailPoints];
-
-    if (this.options.simplify > 0 && this.options.simplifyPhase === "input") {
-      points = douglasPeucker(points, this.options.simplify);
-    }
-
-    const len = points.length;
-
-    if (len === 0) {
-      return [];
-    }
-
-    if (len === 1) {
-      const c = points[0];
-
-      const size = this.getSize(sizeOverride, c[2], 0, len, 0);
-
-      if (size < 0.5) {
-        return [];
-      }
-
-      const ps: Point[] = [];
-
-      for (let theta = 0; theta <= Math.PI * 2; theta += Math.PI / 16) {
-        ps.push(m.add(c, m.smul(m.rot([1, 0, 0] as Point, theta), size)));
-      }
-
-      ps.push(
-        m.add(
-          c,
-          m.smul(
-            [1, 0, 0] as Point,
-            this.getSize(sizeOverride, c[2], 0, len, 0),
-          ),
-        ),
-      );
-
-      return ps;
-    }
-
-    if (len === 2) {
-      const c = points[0];
-      const n = points[1];
-
-      const cSize = this.getSize(sizeOverride, c[2], 0, len, 0);
-      const nSize = this.getSize(sizeOverride, n[2], 0, len, 0);
-
-      if (cSize < 0.5 || nSize < 0.5) {
-        return [];
-      }
-
-      const ps: Point[] = [];
-
-      const pAngle = m.angle(c, [c[0], c[1] - 100, c[2]] as Point, n);
-
-      for (
-        let theta = pAngle;
-        theta <= Math.PI + pAngle;
-        theta += Math.PI / 16
-      ) {
-        ps.push(m.add(c, m.smul(m.rot([1, 0, 0] as Point, theta), cSize)));
-      }
-
-      for (
-        let theta = Math.PI + pAngle;
-        theta <= Math.PI * 2 + pAngle;
-        theta += Math.PI / 16
-      ) {
-        ps.push(m.add(n, m.smul(m.rot([1, 0, 0] as Point, theta), nSize)));
-      }
-
-      ps.push(ps[0]);
-
-      return ps;
-    }
-
-    const forwardPoints: Point[] = [];
-    const backwardPoints: Point[] = [];
-
-    let speed = 0;
-    let prevSpeed = 0;
-
-    let visibleStartIndex = 0;
-    let runningLength = 0;
-
-    for (let i = 1; i < len - 1; i++) {
-      const p = points[i - 1];
-      const c = points[i];
-      const n = points[i + 1];
-
-      const pressure = c[2];
-
-      const d = m.dist(p, c);
-      runningLength += d;
-      speed = prevSpeed + (d - prevSpeed) * 0.2;
-
-      const cSize = this.getSize(sizeOverride, pressure, i, len, runningLength);
-
-      if (cSize === 0) {
-        visibleStartIndex = i + 1;
-        continue;
-      }
-
-      const dirPC = m.norm(m.sub(p, c));
-      const dirNC = m.norm(m.sub(n, c));
-      const p1dirPC = m.rot(dirPC, Math.PI / 2);
-      const p2dirPC = m.rot(dirPC, -Math.PI / 2);
-      const p1dirNC = m.rot(dirNC, Math.PI / 2);
-      const p2dirNC = m.rot(dirNC, -Math.PI / 2);
-
-      const p1PC = m.add(c, m.smul(p1dirPC, cSize));
-      const p2PC = m.add(c, m.smul(p2dirPC, cSize));
-      const p1NC = m.add(c, m.smul(p1dirNC, cSize));
-      const p2NC = m.add(c, m.smul(p2dirNC, cSize));
-
-      const ftdir = m.add(p1dirPC, p2dirNC);
-      const btdir = m.add(p2dirPC, p1dirNC);
-
-      const paPC = m.add(
-        c,
-        m.smul(m.mag(ftdir) === 0 ? dirPC : m.norm(ftdir), cSize),
-      );
-      const paNC = m.add(
-        c,
-        m.smul(m.mag(btdir) === 0 ? dirNC : m.norm(btdir), cSize),
-      );
-
-      const cAngle = m.normAngle(m.angle(c, p, n));
-      const D_ANGLE =
-        (LaserPointer.constants.cornerDetectionMaxAngle / 180) *
-        Math.PI *
-        LaserPointer.constants.cornerDetectionVariance(speed);
-
-      if (Math.abs(cAngle) < D_ANGLE) {
-        const tAngle = Math.abs(m.normAngle(Math.PI - cAngle)); // turn angle
-
-        if (tAngle === 0) {
-          continue;
-        }
-
-        if (cAngle < 0) {
-          backwardPoints.push(p2PC, paNC);
-
-          for (let theta = 0; theta <= tAngle; theta += tAngle / 4) {
-            forwardPoints.push(m.add(c, m.rot(m.smul(p1dirPC, cSize), theta)));
-          }
-
-          for (let theta = tAngle; theta >= 0; theta -= tAngle / 4) {
-            backwardPoints.push(m.add(c, m.rot(m.smul(p1dirPC, cSize), theta)));
-          }
-
-          backwardPoints.push(paNC, p1NC);
-        } else {
-          forwardPoints.push(p1PC, paPC);
-
-          for (let theta = 0; theta <= tAngle; theta += tAngle / 4) {
-            backwardPoints.push(
-              m.add(c, m.rot(m.smul(p1dirPC, -cSize), -theta)),
-            );
-          }
-
-          for (let theta = tAngle; theta >= 0; theta -= tAngle / 4) {
-            forwardPoints.push(
-              m.add(c, m.rot(m.smul(p1dirPC, -cSize), -theta)),
-            );
-          }
-          forwardPoints.push(paPC, p2NC);
-        }
-      } else {
-        forwardPoints.push(paPC);
-        backwardPoints.push(paNC);
-      }
-
-      prevSpeed = speed;
-    }
-
-    if (visibleStartIndex >= len - 2) {
-      if (this.options.keepHead) {
-        const c = points[len - 1];
-
-        const ps: Point[] = [];
-
-        for (let theta = 0; theta <= Math.PI * 2; theta += Math.PI / 16) {
-          ps.push(
-            m.add(
-              c,
-              m.smul(m.rot([1, 0, 0] as Point, theta), this.options.size),
-            ),
-          );
-        }
-
-        ps.push(m.add(c, m.smul([1, 0, 0] as Point, this.options.size)));
-
-        return ps;
-      }
-
-      return [];
-    }
-
-    const first = points[visibleStartIndex];
-    const second = points[visibleStartIndex + 1];
-    const penultimate = points[len - 2];
-    const ultimate = points[len - 1];
-
-    const dirFS = m.norm(m.sub(second, first));
-    const dirPU = m.norm(m.sub(penultimate, ultimate));
-
-    const ppdirFS = m.rot(dirFS, -Math.PI / 2);
-    const ppdirPU = m.rot(dirPU, Math.PI / 2);
-
-    const startCapSize = this.getSize(sizeOverride, first[2], 0, len, 0);
-    const startCap: Point[] = [];
-
-    const endCapSize = this.options.keepHead
-      ? this.options.size
-      : this.getSize(sizeOverride, penultimate[2], len - 2, len, runningLength);
-
-    const endCap: Point[] = [];
-
-    // Lowered threshold to 0.1,
-    // ensuring virtually all strokes get proper rounded caps for visual consistency.
-    if (startCapSize > 0.1) {
-      for (let theta = 0; theta <= Math.PI; theta += Math.PI / 16) {
-        startCap.unshift(
-          m.add(first, m.rot(m.smul(ppdirFS, startCapSize), -theta)),
-        );
-      }
-
-      startCap.unshift(m.add(first, m.smul(ppdirFS, -startCapSize)));
-    } else {
-      startCap.push(first);
-    }
-
-    for (let theta = 0; theta <= Math.PI * 3; theta += Math.PI / 16) {
-      endCap.push(m.add(ultimate, m.rot(m.smul(ppdirPU, -endCapSize), -theta)));
-    }
-
-    const strokeOutline = [
-      ...startCap,
-      ...forwardPoints,
-      ...endCap.reverse(),
-      ...backwardPoints.reverse(),
-    ];
-
-    if (startCap.length > 0) {
-      strokeOutline.push(startCap[0]);
-    }
-
-    if (this.options.simplify > 0 && this.options.simplifyPhase === "output") {
-      return douglasPeucker(strokeOutline, this.options.simplify);
-    }
-
-    return strokeOutline;
-  }
-}

packages/laser-pointer/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist/types",
-    "rootDir": "../"
-  },
-  "include": ["src/**/*", "global.d.ts"],
-  "exclude": ["**/*.test.*", "tests", "types", "examples", "dist"]
-}

packages/math/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "extends": "../tsconfig.base.json",
   "compilerOptions": {
-    "rootDir": "../",
     "outDir": "./dist/types"
   },
   "include": ["src/**/*", "global.d.ts"],

packages/tsconfig.base.json

@@ -6,7 +6,7 @@
     "declaration": true,
     "allowSyntheticDefaultImports": true,
     "module": "ESNext",
-    "moduleResolution": "bundler",
+    "moduleResolution": "Node",
     "resolveJsonModule": true,
     "jsx": "react-jsx",
     "emitDeclarationOnly": true,
@@ -17,8 +17,6 @@
       "@excalidraw/element/*": ["./element/src/*"],
       "@excalidraw/excalidraw": ["./excalidraw/index.tsx"],
       "@excalidraw/excalidraw/*": ["./excalidraw/*"],
-      "@excalidraw/laser-pointer": ["./laser-pointer/src/index.ts"],
-      "@excalidraw/laser-pointer/*": ["./laser-pointer/src/*"],
       "@excalidraw/math": ["./math/src/index.ts"],
       "@excalidraw/math/*": ["./math/src/*"],
       "@excalidraw/utils": ["./utils/src/index.ts"],

packages/utils/tests/__snapshots__/export.test.ts.snap

@@ -30,8 +30,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeVariability": "constant",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,

packages/utils/tests/__snapshots__/utils.test.ts.snap

@@ -23,7 +23,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   "currentItemStartArrowhead": null,
   "currentItemStrokeColor": "#1e1e1e",
   "currentItemStrokeStyle": "solid",
-  "currentItemStrokeWidthKey": "medium",
+  "currentItemStrokeWidth": 2,
   "currentItemTextAlign": "left",
   "cursorButton": "up",
   "defaultSidebarDockedPreference": false,

packages/utils/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "extends": "../tsconfig.base.json",
   "compilerOptions": {
-    "rootDir": "../",
     "outDir": "./dist/types"
   },
   "include": ["src/**/*", "global.d.ts"],

tsconfig.json

@@ -12,7 +12,7 @@
     "forceConsistentCasingInFileNames": true,
     "noFallthroughCasesInSwitch": true,
     "module": "ESNext",
-    "moduleResolution": "bundler",
+    "moduleResolution": "node",
     "resolveJsonModule": true,
     "isolatedModules": true,
     "noEmit": true,
@@ -27,8 +27,6 @@
       "@excalidraw/element/*": ["./packages/element/src/*"],
       "@excalidraw/fractional-indexing": ["./packages/fractional-indexing/src/index.ts"],
       "@excalidraw/fractional-indexing/*": ["./packages/fractional-indexing/src/*"],
-      "@excalidraw/laser-pointer": ["./packages/laser-pointer/src/index.ts"],
-      "@excalidraw/laser-pointer/*": ["./packages/laser-pointer/src/*"],
       "@excalidraw/math": ["./packages/math/src/index.ts"],
       "@excalidraw/math/*": ["./packages/math/src/*"],
       "@excalidraw/utils": ["./packages/utils/src/index.ts"],

vitest.config.mts

@@ -59,17 +59,6 @@ export default defineConfig({
           "./packages/fractional-indexing/src/$1",
         ),
       },
-      {
-        find: /^@excalidraw\/laser-pointer$/,
-        replacement: path.resolve(
-          __dirname,
-          "./packages/laser-pointer/src/index.ts",
-        ),
-      },
-      {
-        find: /^@excalidraw\/laser-pointer\/(.*?)/,
-        replacement: path.resolve(__dirname, "./packages/laser-pointer/src/$1"),
-      },
     ],
   },
   //@ts-ignore

yarn.lock

@@ -1521,6 +1521,11 @@
   resolved "https://registry.yarnpkg.com/@excalidraw/eslint-config/-/eslint-config-1.0.3.tgz#2122ef7413ae77874ae9848ce0f1c6b3f0d8bbbd"
   integrity sha512-GemHNF5Z6ga0BWBSX7GJaNBUchLu6RwTcAB84eX1MeckRNhNasAsPCdelDlFalz27iS4RuYEQh0bPE8SRxJgbQ==
 
+"@excalidraw/laser-pointer@1.3.1":
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/@excalidraw/laser-pointer/-/laser-pointer-1.3.1.tgz#7c40836598e8e6ad91f01057883ed8b88fb9266c"
+  integrity sha512-psA1z1N2qeAfsORdXc9JmD2y4CmDwmuMRxnNdJHZexIcPwaNEyIpNcelw+QkL9rz9tosaN9krXuKaRqYpRAR6g==
+
 "@excalidraw/markdown-to-text@0.1.2":
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/@excalidraw/markdown-to-text/-/markdown-to-text-0.1.2.tgz#1703705e7da608cf478f17bfe96fb295f55a23eb"