@tldraw/editor 5.1.1 → 5.2.0-canary.05c017c18b15

package/src/lib/editor/managers/HistoryManager/HistoryManager.ts

@@ -48,7 +48,11 @@ export class HistoryManager<R extends UnknownRecord> {
 			switch (this.state) {
 				case HistoryRecorderState.Recording:
 					this.pendingDiff.apply(entry.changes)
-					this.stacks.update(({ undos }) => ({ undos, redos: stack() }))
+					// this interceptor runs for every store change, so skip the update when the
+					// redo stack is already empty
+					if (this.stacks.get().redos.length > 0) {
+						this.stacks.update(({ undos }) => ({ undos, redos: stack() }))
+					}
 					break
 				case HistoryRecorderState.RecordingPreserveRedoStack:
 					this.pendingDiff.apply(entry.changes)
@@ -79,6 +83,14 @@ export class HistoryManager<R extends UnknownRecord> {
 		return this.stacks.get().redos.length
 	}
 
+	/** @internal */
+	private _isReplaying = false
+
+	/** @internal */
+	isReplaying() {
+		return this._isReplaying
+	}
+
 	/** @internal */
 	_isInBatch = false
 
@@ -115,7 +127,9 @@ export class HistoryManager<R extends UnknownRecord> {
 	// History
 	_undo({ pushToRedoStack, toMark = undefined }: { pushToRedoStack: boolean; toMark?: string }) {
 		const previousState = this.state
+		const previousIsReplaying = this._isReplaying
 		this.state = HistoryRecorderState.Paused
+		this._isReplaying = true
 		try {
 			let { undos, redos } = this.stacks.get()
 
@@ -176,11 +190,11 @@ export class HistoryManager<R extends UnknownRecord> {
 				this.pendingDiff.restore(pendingDiff)
 				return this
 			}
-
 			this.store.applyDiff(diffToUndo, { ignoreEphemeralKeys: true })
 			this.store.ensureStoreIsUsable()
 			this.stacks.set({ undos, redos })
 		} finally {
+			this._isReplaying = previousIsReplaying
 			this.state = previousState
 		}
 
@@ -195,7 +209,9 @@ export class HistoryManager<R extends UnknownRecord> {
 
 	redo() {
 		const previousState = this.state
+		const previousIsReplaying = this._isReplaying
 		this.state = HistoryRecorderState.Paused
+		this._isReplaying = true
 		try {
 			this.flushPendingDiff()
 
@@ -224,11 +240,11 @@ export class HistoryManager<R extends UnknownRecord> {
 					break
 				}
 			}
-
 			this.store.applyDiff(diffToRedo, { ignoreEphemeralKeys: true })
 			this.store.ensureStoreIsUsable()
 			this.stacks.set({ undos, redos })
 		} finally {
+			this._isReplaying = previousIsReplaying
 			this.state = previousState
 		}
 
@@ -349,7 +365,16 @@ class PendingDiff<R extends UnknownRecord> {
 
 	apply(diff: RecordsDiff<R>) {
 		squashRecordDiffsMutable(this.diff, [diff])
-		this.isEmptyAtom.set(isRecordsDiffEmpty(this.diff))
+		// Recomputing emptiness from the accumulated diff is O(N) (for-in over a
+		// dictionary-mode object pays an O(N) key-collection prologue), and this runs on
+		// every history interceptor call — e.g. every input tick while resizing many
+		// shapes. Updates can never cancel out existing entries during a squash, so the
+		// full recompute is only needed when the incoming diff adds or removes records.
+		if (hasAnyKey(diff.added) || hasAnyKey(diff.removed)) {
+			this.isEmptyAtom.set(isRecordsDiffEmpty(this.diff))
+		} else if (this.isEmptyAtom.__unsafe__getWithoutCapture()) {
+			this.isEmptyAtom.set(!hasAnyKey(diff.updated))
+		}
 	}
 
 	debug() {
@@ -357,6 +382,11 @@ class PendingDiff<R extends UnknownRecord> {
 	}
 }
 
+function hasAnyKey(obj: object) {
+	for (const _ in obj) return true
+	return false
+}
+
 type Stack<T> = StackItem<T> | EmptyStackItem<T>
 
 function stack<T>(): Stack<T> {

package/src/lib/editor/managers/SpatialIndexManager/SpatialIndexManager.ts

@@ -46,6 +46,10 @@ export class SpatialIndexManager {
 
 	private createSpatialIndexComputed() {
 		const shapeHistory = this.editor.store.query.filterHistory('shape')
+		// Binding changes can move a shape's derived bounds (e.g. creating or
+		// deleting an arrow binding relocates the arrow's body) without
+		// touching any shape record, so they must also invalidate the index.
+		const bindingHistory = this.editor.store.query.filterHistory('binding')
 
 		return computed<number>('spatialIndex', (_prevValue, lastComputedEpoch) => {
 			if (isUninitialized(_prevValue)) {
@@ -53,8 +57,9 @@ export class SpatialIndexManager {
 			}
 
 			const shapeDiff = shapeHistory.getDiffSince(lastComputedEpoch)
+			const bindingDiff = bindingHistory.getDiffSince(lastComputedEpoch)
 
-			if (shapeDiff === RESET_VALUE) {
+			if (shapeDiff === RESET_VALUE || bindingDiff === RESET_VALUE) {
 				return this.rebuildAndBumpEpoch()
 			}
 
@@ -63,8 +68,10 @@ export class SpatialIndexManager {
 				return this.rebuildAndBumpEpoch()
 			}
 
-			if (shapeDiff.length === 0) return this._boundsEpoch
+			if (shapeDiff.length === 0 && bindingDiff.length === 0) return this._boundsEpoch
 
+			// A binding-only diff passes an empty shape diff: step 1 is a no-op
+			// and the step-2 sweep re-checks the indexed bounds of every shape.
 			if (this.processIncrementalUpdate(shapeDiff)) {
 				this._boundsEpoch++
 			}

package/src/lib/editor/managers/TextManager/TextManager.test.ts

@@ -82,20 +82,22 @@ const mockEditor = {
 	getContainerDocument: vi.fn(() => mockDocument),
 } as unknown as Editor
 
-global.Range = vi.fn(() => ({
-	setStart: vi.fn(),
-	setEnd: vi.fn(),
-	getClientRects: vi.fn(() => [
-		{
-			width: 10,
-			height: 16,
-			left: 0,
-			top: 0,
-			right: 10,
-			bottom: 16,
-		},
-	]),
-})) as any
+global.Range = vi.fn(function () {
+	return {
+		setStart: vi.fn(),
+		setEnd: vi.fn(),
+		getClientRects: vi.fn(() => [
+			{
+				width: 10,
+				height: 16,
+				left: 0,
+				top: 0,
+				right: 10,
+				bottom: 16,
+			},
+		]),
+	}
+}) as any
 
 describe('TextManager', () => {
 	let textManager: TextManager

package/src/lib/editor/managers/TextManager/TextManager.ts

@@ -2,6 +2,21 @@ import { BoxModel, TLDefaultHorizontalAlignStyle } from '@tldraw/tlschema'
 import { objectMapKeys } from '@tldraw/utils'
 import type { Editor } from '../../Editor'
 
+/**
+ * The whole-pixel line-height for a given font size and tldraw's unitless line-height
+ * multiplier. tldraw's theme stores line-height as a multiplier (e.g. 1.35); resolving it
+ * to a whole pixel keeps line spacing identical across rendering engines, which otherwise
+ * disagree on fractional line boxes (WebKit snaps them to whole pixels, Blink keeps the
+ * fraction) and let multi-line text drift apart. Apply it everywhere line-height is used —
+ * measurement, on-canvas render, and export — so geometry and rendering agree.
+ * See https://github.com/tldraw/tldraw/issues/8970.
+ *
+ * @public
+ */
+export function resolveLineHeightPx(fontSize: number, lineHeight: number): number {
+	return Math.round(fontSize * lineHeight)
+}
+
 const fixNewLines = /\r?\n|\r/g
 
 function normalizeTextForDom(text: string) {
@@ -154,7 +169,7 @@ export class TextManager {
 			'font-style': opts.fontStyle,
 			'font-weight': opts.fontWeight,
 			'font-size': opts.fontSize + 'px',
-			'line-height': opts.lineHeight.toString(),
+			'line-height': `${resolveLineHeightPx(opts.fontSize, opts.lineHeight)}px`,
 			padding: opts.padding,
 			'max-width': opts.maxWidth ? opts.maxWidth + 'px' : undefined,
 			'min-width': opts.minWidth ? opts.minWidth + 'px' : undefined,
@@ -382,7 +397,7 @@ export class TextManager {
 			'font-style': opts.fontStyle,
 			'font-weight': opts.fontWeight,
 			'font-size': opts.fontSize + 'px',
-			'line-height': opts.lineHeight.toString(),
+			'line-height': `${resolveLineHeightPx(opts.fontSize, opts.lineHeight)}px`,
 			width: `${elementWidth}px`,
 			height: 'min-content',
 			'text-align': textAlignmentsForLtr[opts.textAlign],

package/src/lib/editor/managers/UserPreferencesManager/UserPreferencesManager.test.ts

@@ -1,4 +1,5 @@
 import { atom } from '@tldraw/state'
+import { createUserId } from '@tldraw/tlschema'
 import { Mocked, vi } from 'vitest'
 import { TLCurrentUser } from '../../../config/createTLCurrentUser'
 import { TLUserPreferences, defaultUserPreferences } from '../../../config/TLUserPreferences'
@@ -296,8 +297,17 @@ describe('UserPreferencesManager', () => {
 			userPreferencesManager = new UserPreferencesManager(mockUser, 'light')
 		})
 
-		describe('getId', () => {
-			it('should return user id', () => {
+		describe('getExternalId / getRecordId', () => {
+			it('should return the raw external user id', () => {
+				expect(userPreferencesManager.getExternalId()).toBe(mockUserPreferences.id)
+			})
+
+			it('should return the prefixed record id', () => {
+				expect(userPreferencesManager.getRecordId()).toBe(createUserId(mockUserPreferences.id))
+			})
+
+			it('getId() still returns the external id', () => {
+				// eslint-disable-next-line @typescript-eslint/no-deprecated
 				expect(userPreferencesManager.getId()).toBe(mockUserPreferences.id)
 			})
 		})

package/src/lib/editor/managers/UserPreferencesManager/UserPreferencesManager.ts

@@ -1,4 +1,5 @@
 import { atom, computed } from '@tldraw/state'
+import { createUserId, TLUserId } from '@tldraw/tlschema'
 import { TLCurrentUser } from '../../../config/createTLCurrentUser'
 import { TLUserPreferences, defaultUserPreferences } from '../../../config/TLUserPreferences'
 import { getGlobalWindow } from '../../../utils/dom'
@@ -39,7 +40,7 @@ export class UserPreferencesManager {
 	}
 	@computed getUserPreferences() {
 		return {
-			id: this.getId(),
+			id: this.getExternalId(),
 			name: this.getName(),
 			locale: this.getLocale(),
 			color: this.getColor(),
@@ -89,10 +90,34 @@ export class UserPreferencesManager {
 		)
 	}
 
-	@computed getId() {
+	/**
+	 * The current user's raw, app-provided id — the value set in the user's
+	 * {@link @tldraw/editor#TLUserPreferences}. Use this when you need the id your application
+	 * assigned to the user. To compare against or look up store records, use
+	 * {@link UserPreferencesManager.getRecordId} instead.
+	 */
+	@computed getExternalId(): string {
 		return this.user.userPreferences.get().id
 	}
 
+	/**
+	 * @deprecated Use {@link UserPreferencesManager.getExternalId} for the raw app-provided id, or
+	 * {@link UserPreferencesManager.getRecordId} for the prefixed `TLUserId` record id.
+	 */
+	@computed getId() {
+		return this.getExternalId()
+	}
+
+	/**
+	 * The current user's id as a tldraw {@link @tldraw/tlschema#TLUserId} record id (prefixed
+	 * with `user:`). Use this when comparing against or looking up store records, such as a
+	 * presence record's `userId` or `followingUserId`. For the raw, app-provided id, use
+	 * {@link UserPreferencesManager.getExternalId}.
+	 */
+	@computed getRecordId(): TLUserId {
+		return createUserId(this.getExternalId())
+	}
+
 	@computed getName() {
 		return this.user.userPreferences.get().name?.trim() ?? defaultUserPreferences.name
 	}

package/src/lib/editor/overlays/strokeShapeIndicators.ts

@@ -0,0 +1,86 @@
+import { createComputedCache } from '@tldraw/store'
+import { TLShape, TLShapeId } from '@tldraw/tlschema'
+import type { Editor } from '../Editor'
+
+const indicatorPathCache = createComputedCache(
+	'shapeIndicatorPath',
+	(editor: Editor, shape: TLShape) => {
+		const util = editor.getShapeUtil(shape)
+		return util.getIndicatorPath(shape)
+	},
+	{
+		areRecordsEqual(a, b) {
+			return a.props === b.props
+		},
+	}
+)
+
+/**
+ * Combine every batchable shape indicator into a single page-space `Path2D` and
+ * emit one stroke call. Shapes whose indicator needs an evenodd clip (e.g.
+ * arrows with labels or complex arrowheads) can't be batched — they still
+ * stroke individually inside a save/restore with `ctx.clip` applied.
+ *
+ * Shared by any overlay util that paints shape indicators (e.g. collaborator
+ * selections).
+ *
+ * @public
+ */
+export function strokeShapeIndicators(
+	editor: Editor,
+	ctx: CanvasRenderingContext2D,
+	shapeIds: TLShapeId[]
+): void {
+	if (shapeIds.length === 0) return
+
+	const batched = new Path2D()
+
+	for (const shapeId of shapeIds) {
+		const shape = editor.getShape(shapeId)
+		if (!shape || shape.isLocked) continue
+
+		const pageTransform = editor.getShapePageTransform(shape)
+		if (!pageTransform) continue
+
+		const indicatorPath = indicatorPathCache.get(editor, shape.id)
+		if (!indicatorPath) continue
+
+		if (indicatorPath instanceof Path2D) {
+			batched.addPath(indicatorPath, pageTransform)
+			continue
+		}
+
+		const { path, clipPath, additionalPaths } = indicatorPath
+
+		if (!clipPath) {
+			batched.addPath(path, pageTransform)
+			if (additionalPaths) {
+				for (const p of additionalPaths) batched.addPath(p, pageTransform)
+			}
+			continue
+		}
+
+		// Clipped case: fall back to an individual stroke. Rare (arrows with
+		// labels / complex arrowheads), so the extra save/restore/stroke
+		// pair per such shape isn't worth batching away.
+		ctx.save()
+		ctx.transform(
+			pageTransform.a,
+			pageTransform.b,
+			pageTransform.c,
+			pageTransform.d,
+			pageTransform.e,
+			pageTransform.f
+		)
+		ctx.save()
+		ctx.clip(clipPath, 'evenodd')
+		ctx.stroke(path)
+		ctx.restore()
+		if (additionalPaths) {
+			for (const p of additionalPaths) ctx.stroke(p)
+		}
+		ctx.restore()
+	}
+
+	ctx.stroke(batched)
+}

package/src/lib/editor/tools/BaseBoxShapeTool/children/Pointing.ts

@@ -77,6 +77,10 @@ export class Pointing extends StateNode {
 		this.cancel()
 	}
 
+	override onLongPress() {
+		if (this.editor.getInstanceState().isCoarsePointer) this.cancel()
+	}
+
 	complete() {
 		const originPagePoint = this.editor.inputs.getOriginPagePoint()
 

package/src/lib/editor/tools/StateNode.ts

@@ -268,8 +268,6 @@ export abstract class StateNode implements Partial<TLEventHandlers> {
 	onLongPress?(info: TLPointerEventInfo): void
 	onPointerUp?(info: TLPointerEventInfo): void
 	onDoubleClick?(info: TLClickEventInfo): void
-	onTripleClick?(info: TLClickEventInfo): void
-	onQuadrupleClick?(info: TLClickEventInfo): void
 	onRightClick?(info: TLPointerEventInfo): void
 	onMiddleClick?(info: TLPointerEventInfo): void
 	onKeyDown?(info: TLKeyboardEventInfo): void

package/src/lib/editor/types/event-types.ts

@@ -24,7 +24,7 @@ export type TLPointerEventName =
 	| 'middle_click'
 
 /** @public */
-export type TLCLickEventName = 'double_click' | 'triple_click' | 'quadruple_click'
+export type TLCLickEventName = 'double_click'
 
 /** @public */
 export type TLPinchEventName = 'pinch_start' | 'pinch' | 'pinch_end'
@@ -72,7 +72,7 @@ export type TLClickEventInfo = TLBaseEventInfo & {
 	point: VecLike
 	pointerId: number
 	button: number
-	phase: 'down' | 'up' | 'settle'
+	phase: 'down' | 'up' | 'settle-down' | 'settle-up'
 } & TLPointerEventTarget
 
 /** @public */
@@ -173,8 +173,6 @@ export interface TLEventHandlers {
 	onLongPress: TLPointerEvent
 	onRightClick: TLPointerEvent
 	onDoubleClick: TLClickEvent
-	onTripleClick: TLClickEvent
-	onQuadrupleClick: TLClickEvent
 	onMiddleClick: TLPointerEvent
 	onPointerUp: TLPointerEvent
 	onKeyDown: TLKeyboardEvent
@@ -206,7 +204,5 @@ export const EVENT_NAME_MAP: Record<
 	complete: 'onComplete',
 	interrupt: 'onInterrupt',
 	double_click: 'onDoubleClick',
-	triple_click: 'onTripleClick',
-	quadruple_click: 'onQuadrupleClick',
 	tick: 'onTick',
 }

package/src/lib/hooks/usePresence.ts

@@ -1,5 +1,5 @@
 import { useValue } from '@tldraw/state-react'
-import { TLInstancePresence } from '@tldraw/tlschema'
+import { TLInstancePresence, TLUserId } from '@tldraw/tlschema'
 import { useEditor } from './useEditor'
 
 // TODO: maybe move this to a computed property on the App class?
@@ -7,7 +7,7 @@ import { useEditor } from './useEditor'
  * @returns The latest presence of the user matching userId
  * @public
  */
-export function usePresence(userId: string): TLInstancePresence | null {
+export function usePresence(userId: TLUserId): TLInstancePresence | null {
 	const editor = useEditor()
 
 	const latestPresence = useValue(

package/src/lib/license/LicenseProvider.tsx

@@ -6,7 +6,9 @@ import { LicenseManager } from './LicenseManager'
 export const LicenseContext = createContext({} as LicenseManager)
 
 /** @internal */
-export const useLicenseContext = () => useContext(LicenseContext)
+export function useLicenseContext() {
+	return useContext(LicenseContext)
+}
 
 function shouldHideEditorAfterDelay(licenseState: string): boolean {
 	return licenseState === 'expired' || licenseState === 'unlicensed-production'

package/src/lib/primitives/utils.ts

@@ -363,7 +363,7 @@ export function toFixed(v: number) {
  * Check if a float is safe to use. ie: Not too big or small.
  * @public
  */
-export const isSafeFloat = (n: number) => {
+export function isSafeFloat(n: number) {
 	return Math.abs(n) < Number.MAX_SAFE_INTEGER
 }
 

package/src/lib/utils/dom.ts

@@ -86,14 +86,16 @@ export function releasePointerCapture(
  *
  * @public
  */
-export const stopEventPropagation = (e: any) => e.stopPropagation()
+export function stopEventPropagation(e: any) {
+	return e.stopPropagation()
+}
 
 /** @internal */
-export const setStyleProperty = (
+export function setStyleProperty(
 	elm: HTMLElement | null,
 	property: string,
 	value: string | number
-) => {
+) {
 	if (!elm) return
 	elm.style.setProperty(property, String(value))
 }

package/src/version.ts

@@ -1,9 +1,9 @@
 // This file is automatically generated by internal/scripts/refresh-assets.ts.
 // Do not edit manually. Or do, I'm a comment, not a cop.
 
-export const version = '5.1.1'
+export const version = '5.2.0-canary.05c017c18b15'
 export const publishDates = {
 	major: '2026-05-06T16:28:18.473Z',
-	minor: '2026-06-03T10:26:13.606Z',
-	patch: '2026-06-12T16:33:21.130Z',
+	minor: '2026-06-16T13:24:21.828Z',
+	patch: '2026-06-16T13:24:21.828Z',
 }

package/dist-cjs/lib/editor/overlays/ShapeIndicatorOverlayUtil.js

@@ -1,161 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ShapeIndicatorOverlayUtil_exports = {};
-__export(ShapeIndicatorOverlayUtil_exports, {
-  ShapeIndicatorOverlayUtil: () => ShapeIndicatorOverlayUtil,
-  strokeShapeIndicators: () => strokeShapeIndicators
-});
-module.exports = __toCommonJS(ShapeIndicatorOverlayUtil_exports);
-var import_state = require("@tldraw/state");
-var import_store = require("@tldraw/store");
-var import_OverlayUtil = require("./OverlayUtil");
-const indicatorPathCache = (0, import_store.createComputedCache)(
-  "shapeIndicatorPath",
-  (editor, shape) => {
-    const util = editor.getShapeUtil(shape);
-    return util.getIndicatorPath(shape);
-  },
-  {
-    areRecordsEqual(a, b) {
-      return a.props === b.props;
-    }
-  }
-);
-function strokeShapeIndicators(editor, ctx, shapeIds) {
-  if (shapeIds.length === 0) return;
-  const batched = new Path2D();
-  for (const shapeId of shapeIds) {
-    const shape = editor.getShape(shapeId);
-    if (!shape || shape.isLocked) continue;
-    const pageTransform = editor.getShapePageTransform(shape);
-    if (!pageTransform) continue;
-    const indicatorPath = indicatorPathCache.get(editor, shape.id);
-    if (!indicatorPath) continue;
-    if (indicatorPath instanceof Path2D) {
-      batched.addPath(indicatorPath, pageTransform);
-      continue;
-    }
-    const { path, clipPath, additionalPaths } = indicatorPath;
-    if (!clipPath) {
-      batched.addPath(path, pageTransform);
-      if (additionalPaths) {
-        for (const p of additionalPaths) batched.addPath(p, pageTransform);
-      }
-      continue;
-    }
-    ctx.save();
-    ctx.transform(
-      pageTransform.a,
-      pageTransform.b,
-      pageTransform.c,
-      pageTransform.d,
-      pageTransform.e,
-      pageTransform.f
-    );
-    ctx.save();
-    ctx.clip(clipPath, "evenodd");
-    ctx.stroke(path);
-    ctx.restore();
-    if (additionalPaths) {
-      for (const p of additionalPaths) ctx.stroke(p);
-    }
-    ctx.restore();
-  }
-  ctx.stroke(batched);
-}
-class ShapeIndicatorOverlayUtil extends import_OverlayUtil.OverlayUtil {
-  static type = "shape_indicator";
-  options = { zIndex: 50, lineWidth: 1.5, hintedLineWidth: 2.5 };
-  // Narrow projection of instance state. Reading the full record would
-  // re-fire getOverlays on every cursor move / brush update; gating on these
-  // three booleans means we only re-fire when one of them actually flips.
-  _instanceFlags$ = (0, import_state.computed)(
-    "shape indicator instance flags",
-    () => {
-      const i = this.editor.getInstanceState();
-      return {
-        isChangingStyle: i.isChangingStyle,
-        isHoveringCanvas: i.isHoveringCanvas,
-        isCoarsePointer: i.isCoarsePointer
-      };
-    },
-    {
-      isEqual: (a, b) => a.isChangingStyle === b.isChangingStyle && a.isHoveringCanvas === b.isHoveringCanvas && a.isCoarsePointer === b.isCoarsePointer
-    }
-  );
-  isActive() {
-    return true;
-  }
-  getOverlays() {
-    const editor = this.editor;
-    const renderingShapeIds = new Set(editor.getRenderingShapes().map((s) => s.id));
-    const idsToDisplay = [];
-    const { isChangingStyle, isHoveringCanvas, isCoarsePointer } = this._instanceFlags$.get();
-    const isIdleOrEditing = editor.isInAny("select.idle", "select.editing_shape");
-    const isInSelectState = editor.isInAny(
-      "select.brushing",
-      "select.scribble_brushing",
-      "select.pointing_shape",
-      "select.pointing_selection",
-      "select.pointing_handle"
-    );
-    if (!isChangingStyle && (isIdleOrEditing || isInSelectState)) {
-      for (const id of editor.getSelectedShapeIds()) {
-        if (renderingShapeIds.has(id)) idsToDisplay.push(id);
-      }
-      if (isIdleOrEditing && isHoveringCanvas && !isCoarsePointer) {
-        const hovered = editor.getHoveredShapeId();
-        if (hovered && renderingShapeIds.has(hovered) && !idsToDisplay.includes(hovered)) {
-          idsToDisplay.push(hovered);
-        }
-      }
-    }
-    const hintingShapeIds = [];
-    for (const id of editor.getHintingShapeIds()) {
-      if (renderingShapeIds.has(id)) hintingShapeIds.push(id);
-    }
-    if (idsToDisplay.length === 0 && hintingShapeIds.length === 0) {
-      return [];
-    }
-    return [
-      {
-        id: "shape_indicator",
-        type: "shape_indicator",
-        props: { idsToDisplay, hintingShapeIds }
-      }
-    ];
-  }
-  render(ctx, overlays) {
-    const overlay = overlays[0];
-    if (!overlay) return;
-    const editor = this.editor;
-    const zoom = editor.getZoomLevel();
-    const { idsToDisplay, hintingShapeIds } = overlay.props;
-    ctx.lineCap = "round";
-    ctx.lineJoin = "round";
-    ctx.strokeStyle = editor.getCurrentTheme().colors[editor.getColorMode()].selectionStroke;
-    ctx.lineWidth = this.options.lineWidth / zoom;
-    strokeShapeIndicators(editor, ctx, idsToDisplay);
-    if (hintingShapeIds.length > 0) {
-      ctx.lineWidth = this.options.hintedLineWidth / zoom;
-      strokeShapeIndicators(editor, ctx, hintingShapeIds);
-    }
-  }
-}
-//# sourceMappingURL=ShapeIndicatorOverlayUtil.js.map