@tldraw/editor 3.13.0-canary.c0afd1f5aa1e → 3.13.0-canary.c3ce2eeb1729

package/dist-esm/index.d.mts

@@ -1,12 +1,16 @@
 /// <reference types="react" />
 
 import { Atom } from '@tldraw/state';
+import { atom } from '@tldraw/state';
 import { BoxModel } from '@tldraw/tlschema';
 import { ComponentType } from 'react';
 import { Computed } from '@tldraw/state';
+import { computed } from '@tldraw/state';
 import { Dispatch } from 'react';
 import { Editor as Editor_2 } from '@tiptap/core';
 import { EditorProviderProps } from '@tiptap/react';
+import { EffectScheduler } from '@tldraw/state';
+import { EMPTY_ARRAY } from '@tldraw/state';
 import EventEmitter from 'eventemitter3';
 import { ExoticComponent } from 'react';
 import { HistoryEntry } from '@tldraw/store';
@@ -19,6 +23,7 @@ import { NamedExoticComponent } from 'react';
 import { Node as Node_2 } from '@tiptap/pm/model';
 import { PerformanceTracker } from '@tldraw/utils';
 import { PointerEventHandler } from 'react';
+import { react } from '@tldraw/state';
 import { default as React_2 } from 'react';
 import * as React_3 from 'react';
 import { ReactElement } from 'react';
@@ -77,8 +82,18 @@ import { TLStoreSnapshot } from '@tldraw/tlschema';
 import { TLUnknownBinding } from '@tldraw/tlschema';
 import { TLUnknownShape } from '@tldraw/tlschema';
 import { TLVideoAsset } from '@tldraw/tlschema';
+import { track } from '@tldraw/state-react';
+import { transact } from '@tldraw/state';
+import { transaction } from '@tldraw/state';
 import { UnknownRecord } from '@tldraw/store';
+import { useAtom } from '@tldraw/state-react';
+import { useComputed } from '@tldraw/state-react';
+import { useQuickReactor } from '@tldraw/state-react';
+import { useReactor } from '@tldraw/state-react';
+import { useStateTracking } from '@tldraw/state-react';
+import { useValue } from '@tldraw/state-react';
 import { VecModel } from '@tldraw/tlschema';
+import { whyAmIRunning } from '@tldraw/state';
 
 /* Excluded from this release type: activeElementShouldCaptureKeys */
 
@@ -121,8 +136,8 @@ export declare class Arc2d extends Geometry2d {
         start: Vec;
         sweepFlag: number;
     });
-    nearestPoint(point: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike): boolean;
+    nearestPoint(point: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec): boolean;
     getVertices(): Vec[];
     getSvgPathData(first?: boolean): string;
     getLength(): number;
@@ -138,6 +153,10 @@ export declare class Arc2d extends Geometry2d {
  */
 export declare function areAnglesCompatible(a: number, b: number): boolean;
 
+export { Atom }
+
+export { atom }
+
 /** @public */
 export declare function average(A: VecLike, B: VecLike): string;
 
@@ -458,16 +477,12 @@ export declare class Box {
     set point(val: Vec);
     get minX(): number;
     set minX(n: number);
-    get left(): number;
     get midX(): number;
     get maxX(): number;
-    get right(): number;
     get minY(): number;
     set minY(n: number);
-    get top(): number;
     get midY(): number;
     get maxY(): number;
-    get bottom(): number;
     get width(): number;
     set width(n: number);
     get height(): number;
@@ -563,8 +578,8 @@ export declare class Circle2d extends Geometry2d {
     });
     getBounds(): Box;
     getVertices(): Vec[];
-    nearestPoint(point: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number): boolean;
+    nearestPoint(point: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
     getSvgPathData(): string;
 }
 
@@ -641,6 +656,8 @@ export declare class ClickManager {
  */
 export declare function clockwiseAngleDist(a0: number, a1: number): number;
 
+export { computed }
+
 /**
  * @public
  * @react
@@ -728,10 +745,10 @@ export declare class CubicBezier2d extends Polyline2d {
     });
     getVertices(): Vec[];
     midPoint(): Vec;
-    nearestPoint(A: VecLike): Vec;
+    nearestPoint(A: Vec): Vec;
     getSvgPathData(first?: boolean): string;
     static GetAtT(segment: CubicBezier2d, t: number): Vec;
-    getLength(filters?: Geometry2dFilters, precision?: number): number;
+    getLength(precision?: number): number;
 }
 
 /** @public */
@@ -744,8 +761,8 @@ export declare class CubicSpline2d extends Geometry2d {
     get segments(): CubicBezier2d[];
     getLength(): number;
     getVertices(): Vec[];
-    nearestPoint(A: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike): boolean;
+    nearestPoint(A: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec): boolean;
     getSvgPathData(): string;
 }
 
@@ -939,8 +956,8 @@ export declare class Edge2d extends Geometry2d {
     getLength(): number;
     midPoint(): Vec;
     getVertices(): Vec[];
-    nearestPoint(point: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number): boolean;
+    nearestPoint(point: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
     getSvgPathData(first?: boolean): string;
 }
 
@@ -1560,16 +1577,6 @@ export declare class Editor extends EventEmitter<TLEventMap> {
      * @public
      */
     selectAll(): this;
-    /**
-     * Select the next shape in the reading order or in cardinal order.
-     *
-     * @example
-     * ```ts
-     * editor.selectAdjacentShape('next')
-     * ```
-     *
-     * @public
-     */
     selectAdjacentShape(direction: TLAdjacentDirection): void;
     /**
      * Generates a reading order for shapes based on rows grouping.
@@ -1578,16 +1585,12 @@ export declare class Editor extends EventEmitter<TLEventMap> {
      * @public
      */
     getCurrentPageShapesInReadingOrder(): TLShape[];
-    private _getShapesInReadingOrder;
     /**
      * Find the nearest adjacent shape in a specific direction.
      *
      * @public
      */
     getNearestAdjacentShape(currentShapeId: TLShapeId, direction: 'down' | 'left' | 'right' | 'up'): TLShapeId;
-    selectParentShape(): void;
-    selectFirstChildShape(): void;
-    private _selectShapesAndZoom;
     /**
      * Clear the selection.
      *
@@ -3991,6 +3994,8 @@ export declare class Editor extends EventEmitter<TLEventMap> {
 /** @public */
 export declare const EditorContext: React_2.Context<Editor | null>;
 
+export { EffectScheduler }
+
 /** @public */
 export declare class Ellipse2d extends Geometry2d {
     config: Omit<Geometry2dOptions, 'isClosed'> & {
@@ -4006,13 +4011,15 @@ export declare class Ellipse2d extends Geometry2d {
     _edges?: Edge2d[];
     get edges(): Edge2d[];
     getVertices(): any[];
-    nearestPoint(A: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike): boolean;
+    nearestPoint(A: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec): boolean;
     getBounds(): Box;
     getLength(): number;
     getSvgPathData(first?: boolean): string;
 }
 
+export { EMPTY_ARRAY }
+
 /** @public */
 export declare class ErrorBoundary extends React_3.Component<React_3.PropsWithRef<React_3.PropsWithChildren<TLErrorBoundaryProps>>, {
     error: Error | null;
@@ -4080,27 +4087,18 @@ export declare abstract class Geometry2d {
     constructor(opts: Geometry2dOptions);
     isExcludedByFilter(filters?: Geometry2dFilters): boolean;
     abstract getVertices(filters: Geometry2dFilters): Vec[];
-    abstract nearestPoint(point: VecLike, _filters?: Geometry2dFilters): Vec;
-    hitTestPoint(point: VecLike, margin?: number, hitInside?: boolean, _filters?: Geometry2dFilters): boolean;
-    distanceToPoint(point: VecLike, hitInside?: boolean, filters?: Geometry2dFilters): number;
-    distanceToLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): number;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number, filters?: Geometry2dFilters): boolean;
+    abstract nearestPoint(point: Vec, _filters?: Geometry2dFilters): Vec;
+    hitTestPoint(point: Vec, margin?: number, hitInside?: boolean, _filters?: Geometry2dFilters): boolean;
+    distanceToPoint(point: Vec, hitInside?: boolean, filters?: Geometry2dFilters): number;
+    distanceToLineSegment(A: Vec, B: Vec, filters?: Geometry2dFilters): number;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number, filters?: Geometry2dFilters): boolean;
     intersectLineSegment(A: VecLike, B: VecLike, _filters?: Geometry2dFilters): VecLike[];
     intersectCircle(center: VecLike, radius: number, _filters?: Geometry2dFilters): VecLike[];
     intersectPolygon(polygon: VecLike[], _filters?: Geometry2dFilters): VecLike[];
     intersectPolyline(polyline: VecLike[], _filters?: Geometry2dFilters): VecLike[];
-    /**
-     * Find a point along the edge of the geometry that is a fraction `t` along the entire way round.
-     */
-    interpolateAlongEdge(t: number, _filters?: Geometry2dFilters): Vec;
-    /**
-     * Take `point`, find the closest point to it on the edge of the geometry, and return how far
-     * along the edge it is as a fraction of the total length.
-     */
-    uninterpolateAlongEdge(point: VecLike, _filters?: Geometry2dFilters): number;
     /** @deprecated Iterate the vertices instead. */
-    nearestPointOnLineSegment(A: VecLike, B: VecLike): Vec;
-    isPointInBounds(point: VecLike, margin?: number): boolean;
+    nearestPointOnLineSegment(A: Vec, B: Vec): Vec;
+    isPointInBounds(point: Vec, margin?: number): boolean;
     transform(transform: MatModel, opts?: TransformedGeometry2dOptions): Geometry2d;
     private _vertices;
     get vertices(): Vec[];
@@ -4114,7 +4112,7 @@ export declare abstract class Geometry2d {
     toSimpleSvgPath(): string;
     private _length?;
     get length(): number;
-    getLength(_filters?: Geometry2dFilters): number;
+    getLength(): number;
     abstract getSvgPathData(first: boolean): string;
 }
 
@@ -4182,15 +4180,15 @@ export declare function getFreshUserPreferences(): TLUserPreferences;
 export declare function getIncrementedName(name: string, others: string[]): string;
 
 /** @public */
-export declare function getPerfectDashProps(totalLength: number, strokeWidth: number, opts?: {
-    closed?: boolean;
-    end?: 'none' | 'outset' | 'skip';
-    forceSolid?: boolean;
-    lengthRatio?: number;
-    snap?: number;
-    start?: 'none' | 'outset' | 'skip';
-    style?: TLDefaultDashStyle;
-}): {
+export declare function getPerfectDashProps(totalLength: number, strokeWidth: number, opts?: Partial<{
+    closed: boolean;
+    end: 'none' | 'outset' | 'skip';
+    forceSolid: boolean;
+    lengthRatio: number;
+    snap: number;
+    start: 'none' | 'outset' | 'skip';
+    style: TLDefaultDashStyle;
+}>): {
     strokeDasharray: string;
     strokeDashoffset: string;
 };
@@ -4277,20 +4275,18 @@ export declare class Group2d extends Geometry2d {
         children: Geometry2d[];
     });
     getVertices(filters: Geometry2dFilters): Vec[];
-    nearestPoint(point: VecLike, filters?: Geometry2dFilters): Vec;
-    distanceToPoint(point: VecLike, hitInside?: boolean, filters?: Geometry2dFilters): number;
-    hitTestPoint(point: VecLike, margin: number, hitInside: boolean, filters?: Geometry2dFilters): boolean;
-    hitTestLineSegment(A: VecLike, B: VecLike, zoom: number, filters?: Geometry2dFilters): boolean;
+    nearestPoint(point: Vec, filters?: Geometry2dFilters): Vec;
+    distanceToPoint(point: Vec, hitInside?: boolean, filters?: Geometry2dFilters): number;
+    hitTestPoint(point: Vec, margin: number, hitInside: boolean, filters?: Geometry2dFilters): boolean;
+    hitTestLineSegment(A: Vec, B: Vec, zoom: number, filters?: Geometry2dFilters): boolean;
     intersectLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): VecLike[];
     intersectCircle(center: VecLike, radius: number, filters?: Geometry2dFilters): VecLike[];
     intersectPolygon(polygon: VecLike[], filters?: Geometry2dFilters): VecLike[];
     intersectPolyline(polyline: VecLike[], filters?: Geometry2dFilters): VecLike[];
-    interpolateAlongEdge(t: number, filters?: Geometry2dFilters): Vec;
-    uninterpolateAlongEdge(point: VecLike, filters?: Geometry2dFilters): number;
     transform(transform: Mat): Geometry2d;
     getArea(): number;
     toSimpleSvgPath(): string;
-    getLength(filters?: Geometry2dFilters): number;
+    getLength(): number;
     getSvgPathData(): string;
 }
 
@@ -4299,6 +4295,7 @@ export declare class GroupShapeUtil extends ShapeUtil<TLGroupShape> {
     static type: "group";
     static props: RecordProps<TLGroupShape>;
     static migrations: TLPropsMigrations;
+    canTabTo(): boolean;
     hideSelectionBoundsFg(): boolean;
     canBind(): boolean;
     getDefaultProps(): TLGroupShape['props'];
@@ -4594,8 +4591,8 @@ export declare class Mat {
     static Identity(): Mat;
     static Translate(x: number, y: number): Mat;
     static Rotate(r: number, cx?: number, cy?: number): Mat;
-    static Scale(x: number, y: number): Mat;
-    static Scale(x: number, y: number, cx: number, cy: number): Mat;
+    static Scale(x: number, y: number): MatModel;
+    static Scale(x: number, y: number, cx: number, cy: number): MatModel;
     static Multiply(m1: MatModel, m2: MatModel): MatModel;
     static Inverse(m: MatModel): MatModel;
     static Absolute(m: MatLike): MatModel;
@@ -4690,7 +4687,7 @@ export declare class Point2d extends Geometry2d {
     });
     getVertices(): Vec[];
     nearestPoint(): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike, margin: number): boolean;
+    hitTestLineSegment(A: Vec, B: Vec, margin: number): boolean;
     getSvgPathData(): string;
 }
 
@@ -4735,8 +4732,8 @@ export declare class Polyline2d extends Geometry2d {
     get segments(): Edge2d[];
     getLength(): number;
     getVertices(): Vec[];
-    nearestPoint(A: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number): boolean;
+    nearestPoint(A: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
     getSvgPathData(): string;
 }
 
@@ -4777,6 +4774,8 @@ export declare function radiansToDegrees(r: number): number;
  */
 export declare function rangeIntersection(a0: number, a1: number, b0: number, b1: number): [number, number] | null;
 
+export { react }
+
 /**
  * A map of {@link @tldraw/tlschema#StyleProp | StyleProps} to their {@link SharedStyle} values. See
  * {@link Editor.getSharedStyles}.
@@ -5100,7 +5099,7 @@ export declare abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknown
      *
      * @public
      */
-    canEditInReadonly(_shape: Shape): boolean;
+    canEditInReadOnly(_shape: Shape): boolean;
     /**
      * Whether the shape can be cropped.
      *
@@ -5451,14 +5450,7 @@ export declare abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknown
      */
     onClick?(shape: Shape): TLShapePartial<Shape> | void;
     /**
-     * A callback called when a shape starts being edited.
-     *
-     * @param shape - The shape.
-     * @public
-     */
-    onEditStart?(shape: Shape): void;
-    /**
-     * A callback called when a shape finishes being edited.
+     * A callback called when a shape finishes being editing.
      *
      * @param shape - The shape.
      * @public
@@ -5497,6 +5489,8 @@ export declare function shortAngleDist(a0: number, a1: number): number;
 /** @public */
 export declare const SIDES: readonly ["top", "right", "bottom", "left"];
 
+export { Signal }
+
 /** @public */
 export declare const SIN: (x: number) => number;
 
@@ -5548,8 +5542,8 @@ export declare class Stadium2d extends Geometry2d {
         height: number;
         width: number;
     });
-    nearestPoint(A: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike): boolean;
+    nearestPoint(A: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec): boolean;
     getVertices(): Vec[];
     getBounds(): Box;
     getLength(): number;
@@ -7430,6 +7424,12 @@ export declare function toFixed(v: number): number;
  */
 export declare function toPrecision(n: number, precision?: number): number;
 
+export { track }
+
+export { transact }
+
+export { transaction }
+
 /** @public */
 export declare class TransformedGeometry2d extends Geometry2d {
     private readonly geometry;
@@ -7438,13 +7438,13 @@ export declare class TransformedGeometry2d extends Geometry2d {
     private readonly decomposed;
     constructor(geometry: Geometry2d, matrix: MatModel, opts?: TransformedGeometry2dOptions);
     getVertices(filters: Geometry2dFilters): Vec[];
-    nearestPoint(point: VecLike, filters?: Geometry2dFilters): Vec;
-    hitTestPoint(point: VecLike, margin?: number, hitInside?: boolean, filters?: Geometry2dFilters): boolean;
-    distanceToPoint(point: VecLike, hitInside?: boolean, filters?: Geometry2dFilters): number;
-    distanceToLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): number;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number, filters?: Geometry2dFilters): boolean;
-    intersectLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): Vec[];
-    intersectCircle(center: VecLike, radius: number, filters?: Geometry2dFilters): Vec[];
+    nearestPoint(point: Vec, filters?: Geometry2dFilters): Vec;
+    hitTestPoint(point: Vec, margin?: number, hitInside?: boolean, filters?: Geometry2dFilters): boolean;
+    distanceToPoint(point: Vec, hitInside?: boolean, filters?: Geometry2dFilters): number;
+    distanceToLineSegment(A: Vec, B: Vec, filters?: Geometry2dFilters): number;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number, filters?: Geometry2dFilters): boolean;
+    intersectLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): VecLike[];
+    intersectCircle(center: VecLike, radius: number, filters?: Geometry2dFilters): VecLike[];
     intersectPolygon(polygon: VecLike[], filters?: Geometry2dFilters): VecLike[];
     intersectPolyline(polyline: VecLike[], filters?: Geometry2dFilters): VecLike[];
     transform(transform: MatModel, opts?: TransformedGeometry2dOptions): Geometry2d;
@@ -7471,6 +7471,10 @@ export declare function uniq<T>(array: {
     readonly length: number;
 } | null | undefined): T[];
 
+export { useAtom }
+
+export { useComputed }
+
 /** @public */
 export declare function useContainer(): HTMLElement;
 
@@ -7540,9 +7544,12 @@ export declare function usePeerIds(): string[];
  */
 export declare function usePresence(userId: string): null | TLInstancePresence;
 
+export { useQuickReactor }
+
 /* Excluded from this release type: USER_COLORS */
 
 /* Excluded from this release type: useReactiveEvent */
+export { useReactor }
 
 /* Excluded from this release type: useRefState */
 
@@ -7605,6 +7612,8 @@ export declare function useSelectionEvents(handle: TLSelectionHandle): {
  */
 export declare function useSharedSafeId(id: string): SafeId;
 
+export { useStateTracking }
+
 /**
  * Returns the current SVG export context. Returns null if the component isn't being rendered for an
  * SVG export.
@@ -7638,6 +7647,8 @@ export declare function useTransform(ref: React.RefObject<HTMLElement | SVGEleme
  */
 export declare function useUniqueSafeId(suffix?: string): SafeId;
 
+export { useValue }
+
 /** @public */
 export declare function useViewportHeight(): number;
 
@@ -7709,7 +7720,6 @@ export declare class Vec {
     static Per(A: VecLike): Vec;
     static Abs(A: VecLike): Vec;
     static Dist(A: VecLike, B: VecLike): number;
-    static ManhattanDist(A: VecLike, B: VecLike): number;
     static DistMin(A: VecLike, B: VecLike, n: number): boolean;
     static Dist2(A: VecLike, B: VecLike): number;
     /**
@@ -7757,15 +7767,7 @@ export declare class Vec {
     static Cast(A: VecLike): Vec;
     static Slope(A: VecLike, B: VecLike): number;
     static IsNaN(A: VecLike): boolean;
-    /**
-     * Get the angle from position A to position B.
-     */
     static Angle(A: VecLike, B: VecLike): number;
-    /**
-     * Get the angle between vector A and vector B. This will return the smallest angle between the
-     * two vectors, between -π and π. The sign indicates direction of angle.
-     */
-    static AngleBetween(A: VecLike, B: VecLike): number;
     /**
      * Linearly interpolate between two points.
      * @param A - The first point.
@@ -7809,9 +7811,9 @@ export declare class Vec {
 /** @public */
 export declare type VecLike = Vec | VecModel;
 
+export { whyAmIRunning }
+
 
-export * from "@tldraw/state";
-export * from "@tldraw/state-react";
 export * from "@tldraw/store";
 export * from "@tldraw/tlschema";
 export * from "@tldraw/utils";

package/dist-esm/index.mjs

@@ -4,8 +4,30 @@ import "core-js/stable/array/flat-map.js";
 import "core-js/stable/array/flat.js";
 import "core-js/stable/string/at.js";
 import "core-js/stable/string/replace-all.js";
-export * from "@tldraw/state";
-export * from "@tldraw/state-react";
+import {
+  EMPTY_ARRAY,
+  EffectScheduler,
+  atom,
+  computed,
+  react,
+  transact,
+  transaction,
+  whyAmIRunning
+} from "@tldraw/state";
+import {
+  track,
+  useAtom,
+  useComputed,
+  useQuickReactor,
+  useReactor,
+  useStateTracking,
+  useValue
+} from "@tldraw/state-react";
+import { resizeScaled } from "./lib/editor/shapes/shared/resizeScaled.mjs";
+import {
+  getFontsFromRichText
+} from "./lib/utils/richText.mjs";
+import { LocalIndexedDb, Table } from "./lib/utils/sync/LocalIndexedDb.mjs";
 export * from "@tldraw/store";
 export * from "@tldraw/tlschema";
 export * from "@tldraw/utils";
@@ -119,7 +141,6 @@ import {
 import { GroupShapeUtil } from "./lib/editor/shapes/group/GroupShapeUtil.mjs";
 import { getPerfectDashProps } from "./lib/editor/shapes/shared/getPerfectDashProps.mjs";
 import { resizeBox } from "./lib/editor/shapes/shared/resizeBox.mjs";
-import { resizeScaled } from "./lib/editor/shapes/shared/resizeScaled.mjs";
 import { BaseBoxShapeTool } from "./lib/editor/tools/BaseBoxShapeTool/BaseBoxShapeTool.mjs";
 import { maybeSnapToGrid } from "./lib/editor/tools/BaseBoxShapeTool/children/Pointing.mjs";
 import { StateNode } from "./lib/editor/tools/StateNode.mjs";
@@ -269,15 +290,11 @@ import { hardResetEditor } from "./lib/utils/hardResetEditor.mjs";
 import { isAccelKey } from "./lib/utils/keyboard.mjs";
 import { normalizeWheel } from "./lib/utils/normalizeWheel.mjs";
 import { refreshPage } from "./lib/utils/refreshPage.mjs";
-import {
-  getFontsFromRichText
-} from "./lib/utils/richText.mjs";
 import {
   applyRotationToSnapshotShapes,
   getRotationSnapshot
 } from "./lib/utils/rotation.mjs";
 import { runtime, setRuntimeOverrides } from "./lib/utils/runtime.mjs";
-import { LocalIndexedDb, Table } from "./lib/utils/sync/LocalIndexedDb.mjs";
 import { hardReset } from "./lib/utils/sync/hardReset.mjs";
 import { uniq } from "./lib/utils/uniq.mjs";
 import { openWindow } from "./lib/utils/window-open.mjs";
@@ -286,7 +303,7 @@ function debugEnableLicensing() {
 }
 registerTldrawLibraryVersion(
   "@tldraw/editor",
-  "3.13.0-canary.c0afd1f5aa1e",
+  "3.13.0-canary.c3ce2eeb1729",
   "esm"
 );
 export {
@@ -321,11 +338,13 @@ export {
   DefaultSpinner,
   DefaultSvgDefs,
   EASINGS,
+  EMPTY_ARRAY,
   EVENT_NAME_MAP,
   Edge2d,
   EdgeScrollManager,
   Editor,
   EditorContext,
+  EffectScheduler,
   Ellipse2d,
   ErrorBoundary,
   ErrorScreen,
@@ -374,6 +393,7 @@ export {
   applyRotationToSnapshotShapes,
   approximately,
   areAnglesCompatible,
+  atom,
   average,
   canonicalizeRotation,
   centerOfCircleFromThreePoints,
@@ -381,6 +401,7 @@ export {
   clampRadians,
   clampToBrowserMaxCanvasSize,
   clockwiseAngleDist,
+  computed,
   coreShapes,
   counterClockwiseAngleDist,
   createDeepLinkString,
@@ -443,6 +464,7 @@ export {
   preventDefault,
   radiansToDegrees,
   rangeIntersection,
+  react,
   refreshPage,
   releasePointerCapture,
   resizeBox,
@@ -463,7 +485,12 @@ export {
   toDomPrecision,
   toFixed,
   toPrecision,
+  track,
+  transact,
+  transaction,
   uniq,
+  useAtom,
+  useComputed,
   useContainer,
   useContainerIfExists,
   useDelaySvgExport,
@@ -481,19 +508,24 @@ export {
   usePassThroughWheelEvents,
   usePeerIds,
   usePresence,
+  useQuickReactor,
   useReactiveEvent,
+  useReactor,
   useRefState,
   useSelectionEvents,
   useShallowArrayIdentity,
   useShallowObjectIdentity,
   useSharedSafeId,
+  useStateTracking,
   useSvgExportContext,
   useTLSchemaFromUtils,
   useTLStore,
   useTldrawUser,
   useTransform,
   useUniqueSafeId,
+  useValue,
   useViewportHeight,
-  userTypeValidator
+  userTypeValidator,
+  whyAmIRunning
 };
 //# sourceMappingURL=index.mjs.map