@inditextech/weave-sdk 1.0.0 → 1.0.2

package/dist/sdk.node.d.ts

@@ -0,0 +1,3678 @@
+import Konva from "konva";
+import pino, { Logger } from "pino";
+import * as Y$1 from "yjs";
+import * as Y from "yjs";
+import * as konva_lib_Node8 from "konva/lib/Node";
+import * as konva_lib_Node9 from "konva/lib/Node";
+import * as konva_lib_Node10 from "konva/lib/Node";
+import * as konva_lib_Node11 from "konva/lib/Node";
+import * as konva_lib_Node1 from "konva/lib/Node";
+import * as konva_lib_Node2 from "konva/lib/Node";
+import * as konva_lib_Node3 from "konva/lib/Node";
+import * as konva_lib_Node4 from "konva/lib/Node";
+import { KonvaEventObject } from "konva/lib/Node";
+import { Stage, StageConfig } from "konva/lib/Stage";
+import * as konva_lib_shapes_Transformer0 from "konva/lib/shapes/Transformer";
+import { TransformerConfig } from "konva/lib/shapes/Transformer";
+import * as konva_lib_types6 from "konva/lib/types";
+import * as konva_lib_Group5 from "konva/lib/Group";
+import * as konva_lib_Layer7 from "konva/lib/Layer";
+
+//#region ../types/dist/types.d.ts
+//#region src/base/node.d.ts
+interface WeaveNodeBase {
+  getNodeType(): string;
+  create(id: string, props: WeaveElementAttributes): WeaveStateElement;
+  onAdd?(nodeInstance: WeaveElementInstance): void;
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  onDestroy(instance: WeaveElementInstance): void;
+  serialize(instance: WeaveElementInstance): WeaveStateElement;
+  setupDefaultNodeAugmentation(node: Konva.Node): void;
+  setupDefaultNodeEvents(node: Konva.Node): void;
+  isNodeSelected(ele: Konva.Node): boolean;
+  lock(instance: Konva.Node): void;
+  unlock(instance: Konva.Node): void;
+  isLocked(instance: Konva.Node): boolean;
+  isSelecting(): boolean;
+  isPasting(): boolean;
+}
+
+//#endregion
+//#region src/base/action.d.ts
+interface WeaveActionBase {
+  onInit?(): void;
+  trigger(cancelAction: () => void, params?: unknown): unknown;
+  internalUpdate?(): void;
+  cleanup?(): void;
+}
+
+//#endregion
+//#region src/base/plugin.d.ts
+interface WeavePluginBase {
+  onInit?(): void;
+  onRender?(): void;
+  enable(): void;
+  disable(): void;
+  isEnabled(): boolean;
+}
+
+//#endregion
+//#region src/base/store.d.ts
+type WeaveStoreOptions = {
+  getUser: () => WeaveUser;
+  undoManagerOptions?: WeaveUndoManagerOptions;
+};
+interface WeaveStoreBase {
+  connect(): void;
+  disconnect(): void;
+  handleAwarenessChange(emit: boolean): void;
+  setAwarenessInfo(field: string, value: unknown): void;
+}
+
+//#endregion
+//#region src/types.d.ts
+type WeaveFontsPreloadFunction = () => Promise<WeaveFont[]>;
+type WeaveConfig = {
+  store: WeaveStoreBase;
+  nodes?: WeaveNodeBase[];
+  actions?: WeaveActionBase[];
+  plugins?: WeavePluginBase[];
+  fonts?: WeaveFont[] | WeaveFontsPreloadFunction;
+  logger?: WeaveLoggerConfig;
+  serverSide?: boolean;
+};
+type WeaveStatusKeys = keyof typeof WEAVE_INSTANCE_STATUS;
+type WeaveStatus = (typeof WEAVE_INSTANCE_STATUS)[WeaveStatusKeys];
+type NodeSerializable = Konva.NodeConfig & {
+  id: string;
+  nodeType: string;
+};
+type WeaveElementAttributes = {
+  [key: string]: any;
+  id?: string;
+  nodeType?: string;
+  children?: WeaveStateElement[];
+};
+type WeaveStateElement = {
+  key: string;
+  type: string;
+  props: WeaveElementAttributes;
+};
+type WeaveState = {
+  weave: {
+    key: "stage";
+    type: "stage";
+    props: {
+      [key: string]: unknown;
+      id: "stage";
+      children: WeaveStateElement[];
+    };
+  } | Record<string, WeaveStateElement>;
+};
+type WeaveSelection = {
+  instance: Konva.Shape | Konva.Group;
+  node: WeaveStateElement | undefined;
+};
+type WeaveMousePointInfoSimple = {
+  mousePoint: Konva.Vector2d;
+  container: Konva.Layer | Konva.Node | undefined;
+};
+type WeaveMousePointInfo = WeaveMousePointInfoSimple & {
+  measureContainer: Konva.Layer | Konva.Group | undefined;
+};
+type WeaveSerializedGroup = {
+  serializedNodes: WeaveStateElement[];
+  minPoint: Konva.Vector2d;
+} | undefined;
+type WeaveNodeFound = {
+  node: WeaveStateElement | null;
+  parent: WeaveStateElement | null;
+  index: number;
+};
+type WeaveElementInstance = Konva.Layer | Konva.Group | Konva.Shape;
+type WeaveLoggerConfig = {
+  disabled?: boolean;
+  level?: "debug" | "info" | "warn" | "error";
+};
+type WeavePositionKeys = keyof typeof WEAVE_NODE_POSITION;
+type WeavePosition = (typeof WEAVE_NODE_POSITION)[WeavePositionKeys];
+type WeaveExportFormatsKeys = keyof typeof WEAVE_EXPORT_FORMATS;
+type WeaveExportFormats = (typeof WEAVE_EXPORT_FORMATS)[WeaveExportFormatsKeys];
+type WeaveExportNodesOptions = {
+  format?: WeaveExportFormats;
+  padding?: number;
+  pixelRatio?: number;
+  backgroundColor?: string;
+  quality?: number;
+  backend?: WeaveKonvaBackend;
+};
+type WeaveUser = {
+  id: string;
+  name: string;
+  email: string;
+  [key: string]: any;
+};
+type WeaveFont = {
+  id: string;
+  name: string;
+  offsetX?: number;
+  offsetY?: number;
+};
+type WeaveUndoManagerOptions = {
+  captureTimeout?: number;
+  trackedOrigins?: Set<any>;
+};
+type WeaveUndoRedoChange = {
+  canRedo: boolean;
+  canUndo: boolean;
+  redoStackLength: number;
+  undoStackLength: number;
+};
+type WeaveStoreConnectionStatusKeys = keyof typeof WEAVE_STORE_CONNECTION_STATUS;
+type WeaveStoreConnectionStatus = (typeof WEAVE_STORE_CONNECTION_STATUS)[WeaveStoreConnectionStatusKeys];
+declare type docElementTypeDescription = "xml" | "text" | Array<any> | object;
+declare type DocTypeDescription = {
+  [key: string]: docElementTypeDescription;
+};
+declare type MappedTypeDescription<T extends DocTypeDescription> = { readonly [P in keyof T]: T[P] extends "xml" ? Y$1.XmlFragment : T[P] extends "text" ? Y$1.Text : T[P] extends Array<any> ? T[P] : T[P] extends object ? Partial<T[P]> : never };
+type WeaveNodeTransformerProperties = Konva.TransformerConfig;
+type WeaveNodeConfiguration = {
+  transform: Partial<WeaveNodeTransformerProperties>;
+};
+type ImageCrossOrigin = "anonymous" | "use-credentials";
+type URLTransformerFunction = (url: string) => string;
+type DeepPartial<T> = { [P in keyof T]?: T[P] extends object ? T[P] extends Function ? T[P] : DeepPartial<T[P]> : T[P] };
+type WeaveKonvaBackendKeys = keyof typeof WEAVE_KONVA_BACKEND;
+type WeaveKonvaBackend = (typeof WEAVE_KONVA_BACKEND)[WeaveKonvaBackendKeys];
+
+//#endregion
+//#region src/constants.d.ts
+
+declare const WEAVE_INSTANCE_STATUS: {
+  readonly "IDLE": "idle";
+  readonly "STARTING": "starting";
+  readonly "LOADING_FONTS": "loadingFonts";
+  readonly "CONNECTING_TO_ROOM": "connectingToRoom";
+  readonly "CONNECTING_ERROR": "connectingError";
+  readonly "LOADING_ROOM": "loadingRoom";
+  readonly "RUNNING": "running";
+};
+declare const WEAVE_NODE_POSITION: {
+  readonly "UP": "up";
+  readonly "DOWN": "down";
+  readonly "FRONT": "front";
+  readonly "BACK": "back";
+};
+declare const WEAVE_EXPORT_FORMATS: {
+  readonly "PNG": "image/png";
+  readonly "JPEG": "image/jpeg";
+};
+declare const WEAVE_STORE_CONNECTION_STATUS: {
+  readonly "ERROR": "error";
+  readonly "CONNECTING": "connecting";
+  readonly "CONNECTED": "connected";
+  readonly "DISCONNECTED": "disconnected";
+};
+declare const WEAVE_KONVA_BACKEND: {
+  readonly "CANVAS": "canvas";
+  readonly "SKIA": "skia";
+}; //#endregion
+//#region src/stores/store.d.ts
+
+//#endregion
+declare abstract class WeaveStore implements WeaveStoreBase {
+  protected instance: Weave;
+  protected name: string;
+  protected supportsUndoManager: boolean;
+  protected config: WeaveStoreOptions;
+  private state;
+  private latestState;
+  private document;
+  private logger;
+  private undoManager;
+  private isRoomLoaded;
+  constructor(config: WeaveStoreOptions);
+  getName(): string;
+  getLogger(): Logger;
+  register(instance: Weave): WeaveStore;
+  getUser(): WeaveUser;
+  setState(state: WeaveState): void;
+  setLatestState(newState: WeaveState): void;
+  getLatestState(): WeaveState;
+  getDocument(): Y.Doc;
+  getState(): MappedTypeDescription<WeaveState>;
+  getStateJson(): WeaveState;
+  getStateSnapshot(): Uint8Array;
+  setup(): void;
+  canUndoStateStep(): boolean;
+  canRedoStateStep(): boolean;
+  undoStateStep(): void;
+  redoStateStep(): void;
+  handleConnectionStatusChange(status: WeaveStoreConnectionStatus): void;
+  abstract connect(): void;
+  abstract disconnect(): void;
+  abstract handleAwarenessChange(emit: boolean): void;
+  abstract setAwarenessInfo(field: string, value: unknown): void;
+}
+
+//#endregion
+//#region src/plugins/plugin.d.ts
+//# sourceMappingURL=store.d.ts.map
+declare abstract class WeavePlugin implements WeavePluginBase {
+  protected instance: Weave;
+  protected name: string;
+  protected enabled: boolean;
+  private logger;
+  register(instance: Weave): WeavePlugin;
+  getName(): string;
+  getLogger(): Logger;
+  isEnabled(): boolean;
+  abstract onInit?(): void;
+  abstract onRender?(): void;
+  abstract enable(): void;
+  abstract disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-selection/types.d.ts
+//# sourceMappingURL=plugin.d.ts.map
+type WeaveNodesSelectionPluginOnSelectionStateEvent = boolean;
+type WeaveNodesSelectionPluginOnNodesChangeEvent = WeaveSelection[];
+type WeaveNodesSelectionPluginOnStageSelectionEvent = undefined;
+type WeaveNodesSelectionOnSelectionParams = {
+  resizeEnabled: boolean;
+  rotateEnabled: boolean;
+  enabledAnchors: string[];
+};
+type WeaveNodesSelectionBehaviorsConfig = {
+  singleSelection: {
+    enabled: boolean;
+  };
+  multipleSelection: {
+    enabled: boolean;
+  };
+  onMultipleSelection?: (selectedNodes: Konva.Node[]) => Partial<WeaveNodesSelectionOnSelectionParams>;
+};
+type WeaveNodesSelectionPanningOnSelectionConfig = {
+  edgeThreshold: number;
+  minScrollSpeed: number;
+  maxScrollSpeed: number;
+};
+type WeaveNodesSelectionConfig = {
+  selection: Konva.TransformerConfig;
+  hover: Konva.TransformerConfig;
+  selectionArea: Konva.RectConfig;
+  panningWhenSelection: WeaveNodesSelectionPanningOnSelectionConfig;
+  behaviors: WeaveNodesSelectionBehaviorsConfig;
+};
+type WeaveNodesSelectionPluginConfig = Partial<WeaveNodesSelectionConfig>;
+type WeaveNodesSelectionPluginParams = {
+  config?: WeaveNodesSelectionPluginConfig;
+};
+
+//#endregion
+//#region src/plugins/context-menu/types.d.ts
+//# sourceMappingURL=types.d.ts.map
+type WeaveStageContextMenuPluginParams = {
+  config?: WeaveStageContextMenuPluginConfig;
+};
+type WeaveStageContextMenuPluginConfig = {
+  xOffset?: number;
+  yOffset?: number;
+};
+type WeaveStageContextMenuPluginOnNodeContextMenuEvent = {
+  selection: WeaveSelection[];
+  contextMenuPoint: Konva.Vector2d;
+  clickPoint: Konva.Vector2d;
+  stageClickPoint: Konva.Vector2d;
+  visible: boolean;
+};
+
+//#endregion
+//#region src/plugins/context-menu/context-menu.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveContextMenuPlugin extends WeavePlugin {
+  private config;
+  private contextMenuVisible;
+  private tapHold;
+  private tapHoldTimeout;
+  private pointers;
+  private timer;
+  protected tapStart: {
+    x: number;
+    y: number;
+    time: number;
+  } | null;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  constructor(params: WeaveStageContextMenuPluginParams);
+  getName(): string;
+  onInit(): void;
+  isPressed(e: KonvaEventObject<PointerEvent, Stage>): boolean;
+  setTapStart(e: KonvaEventObject<PointerEvent, Stage>): void;
+  triggerContextMenu(eventTarget: Konva.Node, target: Konva.Node | undefined): void;
+  closeContextMenu(): void;
+  private getSelectionPlugin;
+  cancelLongPressTimer(): void;
+  private initEvents;
+  private getStageClickPoint;
+  isContextMenuVisible(): boolean;
+  isTapHold(): boolean;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-edge-snapping/constants.d.ts
+//# sourceMappingURL=context-menu.d.ts.map
+declare const WEAVE_NODES_EDGE_SNAPPING_PLUGIN_KEY = "nodesEdgeSnapping";
+declare const GUIDE_LINE_NAME = "guide-edge-snapping-line";
+declare const GUIDE_LINE_DEFAULT_CONFIG: Required<Pick<Konva.LineConfig, 'stroke' | 'strokeWidth' | 'dash'>>;
+declare const GUIDE_LINE_DRAG_SNAPPING_THRESHOLD = 3;
+declare const GUIDE_LINE_TRANSFORM_SNAPPING_THRESHOLD = 3;
+declare const GUIDE_ORIENTATION: {
+  readonly HORIZONTAL: "H";
+  readonly VERTICAL: "V";
+};
+declare const NODE_SNAP: {
+  readonly START: "start";
+  readonly CENTER: "center";
+  readonly END: "end";
+};
+
+//#endregion
+//#region src/plugins/nodes-edge-snapping/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type NodeSnapKeys = keyof typeof NODE_SNAP;
+type NodeSnap = (typeof NODE_SNAP)[NodeSnapKeys];
+type NodeSnappingEdge = {
+  nodeId: string;
+  guide: number;
+  offset: number;
+  snap: NodeSnap;
+};
+type NodeSnappingEdges = {
+  vertical: NodeSnappingEdge[];
+  horizontal: NodeSnappingEdge[];
+};
+type LineGuideStop = {
+  vertical: number[];
+  horizontal: number[];
+};
+type LineGuide = {
+  nodeId: string;
+  lineGuide: number;
+  diff: number;
+  snap: NodeSnap;
+  offset: number;
+};
+type GuideOrientationKeys = keyof typeof GUIDE_ORIENTATION;
+type GuideOrientation = (typeof GUIDE_ORIENTATION)[GuideOrientationKeys];
+type Guide = {
+  lineGuide: number;
+  offset: number;
+  orientation: GuideOrientation;
+  snap: NodeSnap;
+};
+type WeaveNodesEdgeSnappingPluginConfig = {
+  guideLine: Konva.LineConfig;
+  dragSnappingThreshold: number;
+  transformSnappingThreshold: number;
+};
+type WeaveNodesEdgeSnappingPluginParams = {
+  config?: WeaveNodesEdgeSnappingPluginConfig;
+};
+
+//#endregion
+//#region src/plugins/nodes-edge-snapping/nodes-edge-snapping.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveNodesEdgeSnappingPlugin extends WeavePlugin {
+  private readonly guideLineConfig;
+  private readonly dragSnappingThreshold;
+  private readonly transformSnappingThreshold;
+  onRender: undefined;
+  constructor(params?: Partial<WeaveNodesEdgeSnappingPluginParams>);
+  getName(): string;
+  onInit(): void;
+  setEnabled(enabled: boolean): void;
+  deleteGuides(): void;
+  evaluateGuidelines(e: KonvaEventObject<any>): void;
+  private getSelectionParentNode;
+  cleanupGuidelines(): void;
+  private initEvents;
+  getLineGuideStops(nodes: Konva.Node[]): LineGuideStop;
+  getObjectSnappingEdges(node: Konva.Node): NodeSnappingEdges;
+  getGuides(lineGuideStops: LineGuideStop, itemBounds: NodeSnappingEdges, type: string): Guide[];
+  private sortedGuides;
+  drawGuides(guides: Guide[]): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-distance-snapping/constants.d.ts
+//# sourceMappingURL=nodes-edge-snapping.d.ts.map
+declare const WEAVE_NODES_DISTANCE_SNAPPING_PLUGIN_KEY = "nodesDistanceSnapping";
+declare const GUIDE_HORIZONTAL_LINE_NAME = "guide-distance-snapping-horizontal-line";
+declare const GUIDE_VERTICAL_LINE_NAME = "guide-distance-snapping-vertical-line";
+declare const GUIDE_DISTANCE_LINE_DEFAULT_CONFIG: WeaveNodesDistanceSnappingUIConfig;
+declare const GUIDE_ENTER_SNAPPING_TOLERANCE = 3;
+declare const GUIDE_EXIT_SNAPPING_TOLERANCE = 5;
+declare const NODE_SNAP_HORIZONTAL: {
+  readonly LEFT: "left";
+  readonly CENTER: "center";
+  readonly RIGHT: "right";
+};
+declare const NODE_SNAP_VERTICAL: {
+  readonly TOP: "top";
+  readonly MIDDLE: "middle";
+  readonly BOTTOM: "bottom";
+};
+
+//#endregion
+//#region src/plugins/nodes-distance-snapping/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type NodeSnapHorizontalKeys = keyof typeof NODE_SNAP_HORIZONTAL;
+type NodeSnapHorizontal = (typeof NODE_SNAP_HORIZONTAL)[NodeSnapHorizontalKeys];
+type NodeSnapVerticalKeys = keyof typeof NODE_SNAP_VERTICAL;
+type NodeSnapVertical = (typeof NODE_SNAP_VERTICAL)[NodeSnapVerticalKeys];
+type WeaveNodesDistanceSnappingPluginConfig = {
+  enterSnappingTolerance: number;
+  exitSnappingTolerance: number;
+  ui: WeaveNodesDistanceSnappingUIConfig;
+};
+type WeaveNodesDistanceSnappingPluginParams = {
+  config?: DeepPartial<WeaveNodesDistanceSnappingPluginConfig>;
+};
+type DistanceInfoH = {
+  index: number;
+  from: Konva.Node;
+  to: Konva.Node;
+  midY: number;
+  distance: number;
+};
+type DistanceInfoV = {
+  index: number;
+  from: Konva.Node;
+  to: Konva.Node;
+  midX: number;
+  distance: number;
+};
+type WeaveNodesDistanceSnappingUIConfig = {
+  line: {
+    stroke: string;
+    strokeWidth: number;
+  };
+  label: {
+    height: number;
+    cornerRadius: number;
+    fill: string;
+    fontSize: number;
+    fontFamily: string;
+    fontStyle: string;
+    linePadding: number;
+    paddingX: number;
+  };
+};
+
+//#endregion
+//#region src/plugins/nodes-distance-snapping/nodes-distance-snapping.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveNodesDistanceSnappingPlugin extends WeavePlugin {
+  private readonly uiConfig;
+  private readonly enterSnappingTolerance;
+  private readonly exitSnappingTolerance;
+  private peerDistanceX;
+  private peerDistanceY;
+  private snapPositionX;
+  private snapPositionY;
+  private currentSizeSnapHorizontal;
+  private currentSizeSnapVertical;
+  private referenceLayer;
+  onRender: undefined;
+  constructor(params?: Partial<WeaveNodesDistanceSnappingPluginParams>);
+  getName(): string;
+  onInit(): void;
+  setEnabled(enabled: boolean): void;
+  deleteGuides(): void;
+  evaluateGuidelines(e: KonvaEventObject<any>): void;
+  private getBoxClientRect;
+  private getSelectionParentNode;
+  private getPeers;
+  private validateHorizontalSnapping;
+  private validateVerticalSnapping;
+  private setNodeClientRectX;
+  private setNodeClientRectY;
+  cleanupGuidelines(): void;
+  private initEvents;
+  private isOverlapping;
+  private getVerticallyIntersectingNodes;
+  private getHorizontallyIntersectingNodes;
+  private drawSizeGuidesHorizontally;
+  private drawSizeGuidesVertically;
+  private renderDistanceLabel;
+  private renderHorizontalLineWithDistanceBetweenNodes;
+  private renderVerticalLineWithDistanceBetweenNodes;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/stage-grid/constants.d.ts
+//# sourceMappingURL=nodes-distance-snapping.d.ts.map
+declare const WEAVE_STAGE_GRID_PLUGIN_KEY = "stageGrid";
+declare const WEAVE_GRID_TYPES: {
+  readonly LINES: "lines";
+  readonly DOTS: "dots";
+};
+declare const WEAVE_GRID_DEFAULT_SIZE = 50;
+declare const WEAVE_GRID_DEFAULT_TYPE: string;
+declare const WEAVE_GRID_DEFAULT_COLOR = "rgba(0,0,0,0.1)";
+declare const WEAVE_GRID_DEFAULT_ORIGIN_COLOR = "rgba(255,0,0,0.1)";
+declare const WEAVE_GRID_DEFAULT_STROKE = 0.5;
+declare const WEAVE_GRID_DEFAULT_MAJOR_LINE_RATIO = 4;
+declare const WEAVE_GRID_DEFAULT_RADIUS = 1;
+declare const WEAVE_GRID_DEFAULT_MAJOR_DOT_RATIO = 2;
+declare const WEAVE_GRID_DEFAULT_MAJOR_EVERY = 10;
+declare const WEAVE_GRID_DEFAULT_DOT_MAX_DOTS_PER_AXIS = 250;
+declare const WEAVE_GRID_LAYER_ID = "gridLayer";
+
+//#endregion
+//#region src/plugins/stage-grid/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveStageGridPluginConfig = {
+  type: WeaveStageGridType;
+  gridColor: string;
+  gridOriginColor: string;
+  gridSize: number;
+  gridMajorEvery?: number;
+  gridMajorRatio?: number;
+  gridStroke?: number;
+  gridDotRadius?: number;
+  gridDotMaxDotsPerAxis: number;
+};
+type WeaveStageGridPluginParams = {
+  config?: Partial<WeaveStageGridPluginConfig>;
+};
+type WeaveStageGridTypeKeys = keyof typeof WEAVE_GRID_TYPES;
+type WeaveStageGridType = (typeof WEAVE_GRID_TYPES)[WeaveStageGridTypeKeys];
+
+//#endregion
+//#region src/plugins/stage-grid/stage-grid.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStageGridPlugin extends WeavePlugin {
+  private moveToolActive;
+  private isMouseMiddleButtonPressed;
+  private isSpaceKeyPressed;
+  private config;
+  constructor(params?: Partial<WeaveStageGridPluginParams>);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  onInit(): void;
+  private initEvents;
+  getLayer(): Konva.Layer | undefined;
+  getAdaptiveSpacing(scale: number): number;
+  private getAdjustedSpacing;
+  private renderGridLines;
+  private renderGridDots;
+  renderGrid(): void;
+  onRender(): void;
+  enable(): void;
+  disable(): void;
+  getType(): WeaveStageGridType;
+  setType(type: WeaveStageGridType): void;
+}
+
+//#endregion
+//#region src/plugins/stage-zoom/constants.d.ts
+//# sourceMappingURL=stage-grid.d.ts.map
+declare const WEAVE_STAGE_ZOOM_TYPE: {
+  readonly MOUSE_WHEEL: "mouseWheel";
+  readonly PINCH_ZOOM: "pinchZoom";
+};
+
+//#endregion
+//#region src/plugins/stage-zoom/types.d.ts
+type WeaveStageZoomTypeKeys = keyof typeof WEAVE_STAGE_ZOOM_TYPE;
+type WeaveStageZoomType = (typeof WEAVE_STAGE_ZOOM_TYPE)[WeaveStageZoomTypeKeys];
+type WeaveStageZoomChanged = {
+  scale: number;
+  zoomSteps: number[];
+  actualStep: number;
+  onDefaultStep: boolean;
+  canZoomIn: boolean;
+  canZoomOut: boolean;
+};
+type WeaveStageZoomPluginOnZoomChangeEvent = WeaveStageZoomChanged;
+type WeaveStageZoomPluginConfig = {
+  zoomSteps: number[];
+  defaultZoom: number;
+  fitToScreen: {
+    padding: number;
+  };
+  fitToSelection: {
+    padding: number;
+  };
+  zoomInertia: {
+    friction: number;
+    mouseWheelStep: number;
+    trackpadStep: number;
+  };
+};
+type WeaveStageZoomPluginParams = {
+  config?: DeepPartial<WeaveStageZoomPluginConfig>;
+};
+
+//#endregion
+//#region src/plugins/stage-zoom/stage-zoom.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStageZoomPlugin extends WeavePlugin {
+  private isCtrlOrMetaPressed;
+  protected previousPointer: string | null;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  private config;
+  private actualScale;
+  private actualStep;
+  private updatedMinimumZoom;
+  private pinching;
+  private zooming;
+  private isTrackpad;
+  private zoomVelocity;
+  private zoomInertiaType;
+  defaultStep: number;
+  constructor(params?: WeaveStageZoomPluginParams);
+  getName(): string;
+  onInit(): void;
+  private setZoom;
+  canZoomOut(): boolean;
+  canZoomIn(): boolean;
+  zoomToStep(step: number): void;
+  private findClosestStepIndex;
+  zoomIn(pointer?: Konva.Vector2d): void;
+  zoomOut(pointer?: Konva.Vector2d): void;
+  minimumZoom(): number;
+  fitToScreen(): void;
+  fitToSelection(smartZoom?: boolean): void;
+  enable(): void;
+  disable(): void;
+  getDistance(p1: Konva.Vector2d, p2: Konva.Vector2d): number;
+  getCenter(p1: Konva.Vector2d, p2: Konva.Vector2d): {
+    x: number;
+    y: number;
+  };
+  private initEvents;
+  getInertiaScale(): number;
+  zoomTick(): void;
+  isPinching(): boolean;
+  getStageGridPlugin(): WeaveStageGridPlugin | undefined;
+  getNodesSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  getContextMenuPlugin(): WeaveContextMenuPlugin | undefined;
+}
+
+//#endregion
+//#region src/plugins/stage-panning/types.d.ts
+//# sourceMappingURL=stage-zoom.d.ts.map
+type WeaveStagePanningPluginParams = {
+  config?: Partial<WeaveStagePanningPluginConfig>;
+};
+type WeaveStagePanningPluginConfig = {
+  edgePanOffset: number;
+  edgePanSpeed: number;
+};
+
+//#endregion
+//#region src/plugins/stage-panning/stage-panning.d.ts
+//# sourceMappingURL=types.d.ts.map
+
+declare class WeaveStagePanningPlugin extends WeavePlugin {
+  private readonly config;
+  private moveToolActive;
+  private isMouseLeftButtonPressed;
+  private isMouseMiddleButtonPressed;
+  private isCtrlOrMetaPressed;
+  private isDragging;
+  private enableMove;
+  private isSpaceKeyPressed;
+  private pointers;
+  private panning;
+  protected previousPointer: string | null;
+  protected currentPointer: Konva.Vector2d | null;
+  protected stageScrollInterval: NodeJS.Timeout | undefined;
+  protected targetScrollIntervals: Record<string, NodeJS.Timeout | undefined>;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  constructor(params?: WeaveStagePanningPluginParams);
+  getName(): string;
+  onInit(): void;
+  private setCursor;
+  private disableMove;
+  private initEvents;
+  isPanning(): boolean;
+  getDistance(p1: Konva.Vector2d, p2: Konva.Vector2d): number;
+  getTouchCenter(): {
+    x: number;
+    y: number;
+  } | null;
+  getZoomPlugin(): WeaveStageZoomPlugin | undefined;
+  getContextMenuPlugin(): WeaveContextMenuPlugin | undefined;
+  getNodesSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  getNodesEdgeSnappingPlugin(): WeaveNodesEdgeSnappingPlugin | undefined;
+  getNodesDistanceSnappingPlugin(): WeaveNodesDistanceSnappingPlugin | undefined;
+  getStageGridPlugin(): WeaveStageGridPlugin | undefined;
+  getCurrentPointer(): konva_lib_types6.Vector2d | null;
+  cleanupEdgeMoveIntervals(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-selection/nodes-selection.d.ts
+//# sourceMappingURL=stage-panning.d.ts.map
+declare class WeaveNodesSelectionPlugin extends WeavePlugin {
+  private tr;
+  private trHover;
+  private config;
+  private selectionRectangle;
+  private active;
+  private defaultEnabledAnchors;
+  private selecting;
+  private didMove;
+  private initialized;
+  private isSpaceKeyPressed;
+  protected taps: number;
+  protected isDoubleTap: boolean;
+  protected tapStart: {
+    x: number;
+    y: number;
+    time: number;
+  } | null;
+  protected lastTapTime: number;
+  private x1;
+  private y1;
+  private x2;
+  private y2;
+  private selectionStart;
+  private panSpeed;
+  private readonly panDirection;
+  private pointers;
+  private panLoopId;
+  onRender: undefined;
+  constructor(params?: WeaveNodesSelectionPluginParams);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  isPasting(): boolean;
+  isAreaSelecting(): boolean;
+  isSelecting(): boolean;
+  isNodeSelected(ele: Konva.Node): boolean;
+  onInit(): void;
+  private getLayer;
+  triggerSelectedNodesEvent(): void;
+  removeSelectedNodes(): void;
+  private updateSelectionRect;
+  private getSpeedFromEdge;
+  private updatePanDirection;
+  private stopPanLoop;
+  private panLoop;
+  private setTapStart;
+  private checkMovedDrag;
+  private checkMoved;
+  private checkDoubleTap;
+  private hideSelectorArea;
+  private initEvents;
+  private handleMultipleSelectionBehavior;
+  protected syncSelection(): void;
+  protected getSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  protected hideHoverState(): void;
+  handleClickOrTap(e: KonvaEventObject<PointerEvent, Stage>): void;
+  getTransformer(): Konva.Transformer;
+  getHoverTransformer(): Konva.Transformer;
+  handleBehaviors(): void;
+  setSelectedNodes(nodes: Konva.Node[]): void;
+  getSelectedNodes(): (Konva.Group | Konva.Shape)[];
+  getSelectedNodesExtended(): WeaveSelection[];
+  selectAll(): void;
+  selectNone(): void;
+  enable(): void;
+  disable(): void;
+  getContextMenuPlugin(): WeaveContextMenuPlugin | undefined;
+  getStageGridPlugin(): WeaveStageGridPlugin | undefined;
+  getNodesEdgeSnappingPlugin(): WeaveNodesEdgeSnappingPlugin | undefined;
+  getNodesDistanceSnappingPlugin(): WeaveNodesDistanceSnappingPlugin | undefined;
+  getStagePanningPlugin(): WeaveStagePanningPlugin | undefined;
+  getSelectorConfig(): TransformerConfig;
+}
+
+//#endregion
+//#region src/nodes/node.d.ts
+//# sourceMappingURL=nodes-selection.d.ts.map
+declare abstract class WeaveNode implements WeaveNodeBase {
+  protected instance: Weave;
+  protected nodeType: string;
+  protected didMove: boolean;
+  private logger;
+  protected previousPointer: string | null;
+  register(instance: Weave): WeaveNode;
+  getNodeType(): string;
+  getLogger(): Logger;
+  getSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  isSelecting(): boolean;
+  isPasting(): boolean;
+  setupDefaultNodeAugmentation(node: Konva.Node): void;
+  isNodeSelected(ele: Konva.Node): boolean;
+  scaleReset(node: Konva.Node): void;
+  protected setHoverState(node: Konva.Node): void;
+  protected hideHoverState(): void;
+  setupDefaultNodeEvents(node: Konva.Node): void;
+  handleMouseOver(node: Konva.Node): boolean;
+  handleMouseout(node: Konva.Node): void;
+  create(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  onAdd(nodeInstance: WeaveElementInstance): void;
+  abstract onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  abstract onUpdate(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  onDestroy(nodeInstance: WeaveElementInstance): void;
+  serialize(instance: WeaveElementInstance): WeaveStateElement;
+  show(instance: Konva.Node): void;
+  hide(instance: Konva.Node): void;
+  isVisible(instance: Konva.Node): boolean;
+  lock(instance: Konva.Node): void;
+  unlock(instance: Konva.Node): void;
+  isLocked(instance: Konva.Node): boolean;
+  protected defaultGetTransformerProperties(nodeTransformConfig?: any): any;
+  private getNodesSelectionPlugin;
+  getNodesEdgeSnappingPlugin(): WeaveNodesEdgeSnappingPlugin | undefined;
+  getNodesDistanceSnappingPlugin(): WeaveNodesDistanceSnappingPlugin | undefined;
+  realOffset(instance: WeaveStateElement): Konva.Vector2d;
+  private getRealSelectedNode;
+}
+
+//#endregion
+//#region src/actions/action.d.ts
+//# sourceMappingURL=node.d.ts.map
+declare abstract class WeaveAction implements WeaveActionBase {
+  protected instance: Weave;
+  protected name: string;
+  protected tapStart: {
+    x: number;
+    y: number;
+    time: number;
+  } | null;
+  props: WeaveElementAttributes;
+  private logger;
+  constructor();
+  getName(): string;
+  getLogger(): Logger;
+  register(instance: Weave): WeaveAction;
+  updateProps(props: WeaveElementAttributes): void;
+  getProps(): WeaveElementAttributes;
+  isPressed(e: KonvaEventObject<PointerEvent, Konva.Stage>): boolean;
+  setTapStart(e: KonvaEventObject<PointerEvent, Konva.Stage>): void;
+  isTap(e: KonvaEventObject<PointerEvent, Konva.Stage>): boolean;
+  abstract onInit?(): void;
+  abstract trigger(cancelAction: () => void, params?: unknown): unknown;
+  abstract onPropsChange?(): void;
+  abstract cleanup?(): void;
+}
+
+//#endregion
+//#region src/logger/logger.d.ts
+//# sourceMappingURL=action.d.ts.map
+declare class WeaveLogger {
+  private config;
+  private disabled;
+  private logger;
+  constructor(config: WeaveLoggerConfig);
+  private log;
+  getDisabled(): boolean;
+  getLevel(): pino.LevelWithSilentOrString;
+  getLogger(): Logger;
+  getChildLogger(name: string): pino.Logger<never, boolean>;
+}
+
+//#endregion
+//#region src/managers/cloning.d.ts
+//# sourceMappingURL=logger.d.ts.map
+declare class WeaveCloningManager {
+  private instance;
+  private logger;
+  private clones;
+  constructor(instance: Weave);
+  nodesToGroupSerialized(instancesToClone: Konva.Node[]): {
+    serializedNodes: WeaveStateElement[];
+    minPoint: Konva.Vector2d;
+  } | undefined;
+  cloneNodes(instancesToClone: Konva.Node[], targetContainer: Konva.Group | Konva.Layer | undefined, onPoint: Konva.Vector2d): void;
+  private recursivelyUpdateKeys;
+  cloneNode(targetNode: Konva.Node): Konva.Node | undefined;
+  addClone(node: Konva.Node): void;
+  removeClone(node: Konva.Node): void;
+  getClones(): konva_lib_Node9.Node<konva_lib_Node8.NodeConfig>[];
+  isClone(node: Konva.Node): konva_lib_Node11.Node<konva_lib_Node10.NodeConfig> | undefined;
+  cleanupClones(): void;
+}
+
+//#endregion
+//#region src/managers/register.d.ts
+//# sourceMappingURL=cloning.d.ts.map
+declare class WeaveRegisterManager {
+  private instance;
+  private nodesHandlers;
+  private actionsHandlers;
+  private plugins;
+  private logger;
+  constructor(instance: Weave);
+  getPlugins(): Record<string, WeavePlugin>;
+  getNodesHandlers(): Record<string, WeaveNode>;
+  getActionsHandlers(): Record<string, WeaveAction>;
+  getPlugin<T>(pluginName: string): T | undefined;
+  getActionHandler<T>(actionName: string): T | undefined;
+  getNodeHandler<T>(nodeType: string): T | undefined;
+  registerPlugins(): void;
+  registerPlugin(plugin: WeavePlugin): void;
+  registerNodesHandlers(): void;
+  registerNodeHandler(node: WeaveNode): void;
+  registerActionsHandlers(): void;
+  registerActionHandler(action: WeaveAction): void;
+}
+
+//#endregion
+//#region src/managers/stage.d.ts
+//# sourceMappingURL=register.d.ts.map
+declare class WeaveStageManager {
+  private instance;
+  private logger;
+  private stage;
+  private config;
+  constructor(instance: Weave, config: Konva.StageConfig);
+  getConfiguration(): StageConfig;
+  setStage(stage: Konva.Stage): void;
+  getStage(): Konva.Stage;
+  getMainLayer(): Konva.Layer | undefined;
+  getSelectionLayer(): Konva.Layer | undefined;
+  getCommentsLayer(): Konva.Layer | undefined;
+  getGridLayer(): Konva.Layer | undefined;
+  getUtilityLayer(): Konva.Layer | undefined;
+  getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
+  initStage(): void;
+  getContainerNodes(): WeaveElementInstance[];
+}
+
+//#endregion
+//#region src/types.d.ts
+//# sourceMappingURL=stage.d.ts.map
+type DOMElement = HTMLElement | Element | null;
+
+//#endregion
+//#region src/weave.d.ts
+declare class Weave {
+  private id;
+  private emitter;
+  private config;
+  private logger;
+  private moduleLogger;
+  private reconciler;
+  private stateSerializer;
+  private renderer;
+  private initialized;
+  private status;
+  private setupManager;
+  private registerManager;
+  private stateManager;
+  private storeManager;
+  private stageManager;
+  private groupsManager;
+  private targetingManager;
+  private cloningManager;
+  private fontsManager;
+  private zIndexManager;
+  private pluginsManager;
+  private actionsManager;
+  private exportManager;
+  private readonly asyncElements;
+  constructor(weaveConfig: WeaveConfig, stageConfig: Konva.StageConfig);
+  setupRenderer(): void;
+  setStatus(status: WeaveStatus): void;
+  getStatus(): WeaveStatus;
+  setStore(store: WeaveStore): void;
+  private handleStoreConnectionStatusChange;
+  start(): Promise<void>;
+  destroy(): void;
+  getId(): string;
+  getConfiguration(): WeaveConfig;
+  augmentKonvaStageClass(): void;
+  augmentKonvaNodeClass(config?: WeaveNodeConfiguration): void;
+  emitEvent<T>(event: string, payload?: T): void;
+  addEventListener<T>(event: string, callback: (payload: T) => void): void;
+  removeEventListener<T>(event: string, callback: (payload: T) => void): void;
+  getLogger(): WeaveLogger;
+  getMainLogger(): Logger;
+  getChildLogger(name: string): pino.Logger<never, boolean>;
+  getStageManager(): WeaveStageManager;
+  getStage(): Konva.Stage;
+  getMainLayer(): Konva.Layer | undefined;
+  getSelectionLayer(): Konva.Layer | undefined;
+  getCommentsLayer(): Konva.Layer | undefined;
+  getGridLayer(): Konva.Layer | undefined;
+  getUtilityLayer(): Konva.Layer | undefined;
+  setStage(stage: Konva.Stage): void;
+  getStageConfiguration(): StageConfig;
+  getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
+  getContainerNodes(): WeaveElementInstance[];
+  getClosestParentWithWeaveId(el: DOMElement): DOMElement;
+  getRegisterManager(): WeaveRegisterManager;
+  getPlugins(): Record<string, WeavePlugin>;
+  getPlugin<T>(pluginName: string): T | undefined;
+  getNodesHandlers(): Record<string, WeaveNode>;
+  getNodeHandler<T>(nodeType: string): T | undefined;
+  getActionsHandlers(): Record<string, WeaveAction>;
+  getActionHandler<T>(actionName: string): T | undefined;
+  getStore<T extends WeaveStore>(): T;
+  registerPlugin(plugin: WeavePlugin): void;
+  registerNodeHandler(node: WeaveNode): void;
+  registerActionHandler(action: WeaveAction): void;
+  registerStore(store: WeaveStore): void;
+  isPluginEnabled(pluginName: string): boolean;
+  enablePlugin(pluginName: string): void;
+  disablePlugin(pluginName: string): void;
+  getActiveAction(): string | undefined;
+  triggerAction<T, P>(actionName: string, params?: T): P;
+  getPropsAction(actionName: string): WeaveElementAttributes;
+  updatePropsAction(actionName: string, params: WeaveElementAttributes): void;
+  cancelAction(actionName: string): void;
+  update(newState: WeaveState): void;
+  render(): void;
+  findNodeById(tree: WeaveStateElement, key: string, parent?: WeaveStateElement | null, index?: number): WeaveNodeFound;
+  findNodesByType(tree: WeaveStateElement, nodeType: string): WeaveStateElement[];
+  getNode(nodeKey: string): {
+    node: WeaveStateElement | null;
+    parent: WeaveStateElement | null;
+    index: number;
+  };
+  addNode(node: WeaveStateElement, parentId?: string, index?: number | undefined): void;
+  updateNode(node: WeaveStateElement): void;
+  updateNodes(nodes: WeaveStateElement[]): void;
+  removeNode(node: WeaveStateElement): void;
+  removeNodes(nodes: WeaveStateElement[]): void;
+  moveNode(node: WeaveStateElement, position: WeavePosition): void;
+  getElementsTree(): WeaveStateElement[];
+  isEmpty(): boolean;
+  getNodeContainerId(node: WeaveElementInstance | Konva.Node): string;
+  getNodeContainer(node: WeaveElementInstance | Konva.Node): Konva.Node | null;
+  getBoundingBox(nodes: Konva.Node[], config?: {
+    skipTransform?: boolean;
+    skipShadow?: boolean;
+    skipStroke?: boolean;
+    relativeTo?: Konva.Container;
+  } | undefined): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  moveUp(node: WeaveElementInstance): void;
+  moveDown(node: WeaveElementInstance): void;
+  sendToBack(nodes: WeaveElementInstance | WeaveElementInstance[]): void;
+  bringToFront(nodes: WeaveElementInstance | WeaveElementInstance[]): void;
+  group(nodes: WeaveStateElement[]): void;
+  unGroup(group: WeaveStateElement): void;
+  resolveNode(node: Konva.Node): WeaveElementInstance | undefined;
+  pointIntersectsElement(point?: Konva.Vector2d): Konva.Node | null;
+  nodeIntersectsContainerElement(node: Konva.Node | Konva.Transformer, actualLayer?: Konva.Layer | Konva.Group): Konva.Node | undefined;
+  getMousePointer(point?: Konva.Vector2d): WeaveMousePointInfo;
+  getMousePointerRelativeToContainer(container: Konva.Node | Konva.Layer): WeaveMousePointInfoSimple;
+  selectNodesByKey(nodesIds: string[]): void;
+  getCloningManager(): WeaveCloningManager;
+  nodesToGroupSerialized(instancesToClone: Konva.Node[]): WeaveSerializedGroup;
+  cloneNodes(instancesToClone: Konva.Node[], targetContainer: Konva.Layer | Konva.Group | undefined, onPoint: Konva.Vector2d): void;
+  getFonts(): WeaveFont[];
+  imageToBase64(img: HTMLImageElement, mimeType: string): string;
+  exportNodes(nodes: WeaveElementInstance[], boundingNodes: (nodes: Konva.Node[]) => Konva.Node[], options: WeaveExportNodesOptions): Promise<HTMLImageElement>;
+  exportNodesServerSide(nodes: string[], boundingNodes: (nodes: Konva.Node[]) => Konva.Node[], options: WeaveExportNodesOptions): Promise<{
+    composites: {
+      input: Buffer;
+      left: number;
+      top: number;
+    }[];
+    width: number;
+    height: number;
+  }>;
+  allNodesLocked(nodes: Konva.Node[]): boolean;
+  allNodesUnlocked(nodes: Konva.Node[]): boolean;
+  lockNode(node: Konva.Node): void;
+  lockNodes(nodes: Konva.Node[]): void;
+  unlockNode(node: Konva.Node): void;
+  unlockNodes(nodes: Konva.Node[]): void;
+  allNodesVisible(nodes: Konva.Node[]): boolean;
+  allNodesHidden(nodes: Konva.Node[]): boolean;
+  hideNode(node: Konva.Node): void;
+  hideNodes(nodes: Konva.Node[]): void;
+  showNode(node: Konva.Node): void;
+  showNodes(nodes: Konva.Node[]): void;
+  asyncElementsLoaded(): boolean;
+  loadAsyncElement(nodeId: string, type: string): void;
+  resolveAsyncElement(nodeId: string, type: string): void;
+  isServerSide(): boolean;
+}
+
+//#endregion
+//#region src/stores/types.d.ts
+//# sourceMappingURL=weave.d.ts.map
+type WeaveStoreOnStateChangeEvent = WeaveState;
+type WeaveStoreOnRoomLoadedEvent = boolean;
+type WeaveStoreOnUndoRedoChangeEvent = WeaveUndoRedoChange;
+type WeaveStoreOnNodeChangeEvent = WeaveSelection;
+
+//#endregion
+//#region src/actions/types.d.ts
+//# sourceMappingURL=types.d.ts.map
+type WeaveActionPropsChangeEvent = {
+  instance: WeaveAction;
+  props: WeaveElementAttributes;
+};
+
+//#endregion
+//#region src/utils.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare function resetScale(node: Konva.Node): void;
+declare function clearContainerTargets(instance: Weave): void;
+declare function containerOverCursor(instance: Weave, ignoreNodes: Konva.Node[], definedCursorPosition?: Konva.Vector2d): Konva.Node | undefined;
+declare function moveNodeToContainer(instance: Weave, node: Konva.Node, containerToMove: Konva.Layer | Konva.Node, invalidOriginsTypes?: string[]): boolean;
+declare function getExportBoundingBox(nodes: Konva.Node[]): {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+declare function getBoundingBox(nodes: Konva.Node[], config?: {
+  skipTransform?: boolean;
+  skipShadow?: boolean;
+  skipStroke?: boolean;
+  relativeTo?: Konva.Container;
+} | undefined): {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+declare function getTargetedNode(instance: Weave): Konva.Node | undefined;
+declare function hasImages(node: Konva.Node): boolean;
+declare function hasFrames(node: Konva.Node): boolean;
+declare function intersectArrays<T>(arrays: T[][]): T[];
+declare function isNodeInSelection(node: Konva.Node, nodes: Konva.Node[]): boolean;
+declare function containsNodeDeep(nodes: Konva.Node[], target: Konva.Node): boolean;
+declare function getSelectedNodesMetadata(transformer: Konva.Transformer): {
+  width: number;
+  height: number;
+  nodes: string[];
+};
+declare function getTargetAndSkipNodes(instance: Weave, e: KonvaEventObject<any, any>, forceTransformer?: boolean): {
+  targetNode: konva_lib_shapes_Transformer0.Transformer | konva_lib_Node2.Node<konva_lib_Node1.NodeConfig> | undefined;
+  skipNodes: string[];
+};
+declare function getVisibleNodesInViewport(stage: Konva.Stage, referenceLayer: Konva.Layer | Konva.Group | undefined): konva_lib_Node4.Node<konva_lib_Node3.NodeConfig>[];
+declare function isInShadowDOM(el: DOMElement): boolean;
+declare function getTopmostShadowHost(el: DOMElement): ShadowRoot | null;
+declare function getVisibleNodes(instance: Weave, stage: Konva.Stage, nodeParent: Konva.Node, skipNodes: string[], referenceLayer: Konva.Layer | Konva.Group): Konva.Node[];
+declare function memoize<T extends (...args: any[]) => any>(fn: T): T;
+declare function isIOS(): boolean;
+declare const isServer: () => boolean;
+declare const getPositionRelativeToContainerOnPosition: (instance: Weave) => Konva.Vector2d | null | undefined;
+declare const canComposite: (node: Konva.Node) => boolean | null;
+declare function mergeExceptArrays<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
+
+//#endregion
+//#region src/managers/export/types.d.ts
+//# sourceMappingURL=utils.d.ts.map
+type CanvasFontDefinition = {
+  path: string;
+  properties: {
+    family: string;
+    weight?: string;
+    style?: string;
+  };
+};
+type CanvasFonts = CanvasFontDefinition[];
+type SkiaFontDefinition = {
+  family: string;
+  paths: string[];
+};
+type SkiaFonts = SkiaFontDefinition[];
+type RenderWeaveRoom = {
+  instance: Weave;
+  destroy: () => void;
+};
+
+//#endregion
+//#region src/managers/export/utils.node.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare const registerCanvasFonts: (fonts: CanvasFonts) => void;
+declare const registerSkiaFonts: (fonts: SkiaFonts) => void;
+
+//#endregion
+//#region src/nodes/stage/stage.d.ts
+//# sourceMappingURL=utils.node.d.ts.map
+declare class WeaveStageNode extends WeaveNode {
+  protected nodeType: string;
+  protected stageFocused: boolean;
+  protected wheelMousePressed: boolean;
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(): void;
+}
+
+//#endregion
+//#region src/nodes/stage/constants.d.ts
+//# sourceMappingURL=stage.d.ts.map
+declare const WEAVE_STAGE_NODE_TYPE = "stage";
+declare const WEAVE_STAGE_DEFAULT_MODE = "default";
+
+//#endregion
+//#region src/nodes/layer/layer.d.ts
+//# sourceMappingURL=constants.d.ts.map
+declare class WeaveLayerNode extends WeaveNode {
+  protected nodeType: string;
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  serialize(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+//#endregion
+//#region src/nodes/layer/constants.d.ts
+//# sourceMappingURL=layer.d.ts.map
+declare const WEAVE_LAYER_NODE_TYPE = "layer";
+
+//#endregion
+//#region src/nodes/group/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveGroupProperties = {
+  transform: WeaveNodeTransformerProperties;
+};
+type WeaveGroupNodeParams = {
+  config: Partial<WeaveGroupProperties>;
+};
+
+//#endregion
+//#region src/nodes/group/group.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveGroupNode extends WeaveNode {
+  private config;
+  protected nodeType: string;
+  constructor(params?: WeaveGroupNodeParams);
+  groupHasFrames(group: Konva.Group): boolean;
+  groupHasImages(group: Konva.Group): boolean;
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  serialize(instance: WeaveElementInstance): WeaveStateElement;
+  scaleReset(): void;
+}
+
+//#endregion
+//#region src/nodes/group/constants.d.ts
+//# sourceMappingURL=group.d.ts.map
+declare const WEAVE_GROUP_NODE_TYPE = "group";
+
+//#endregion
+//#region src/nodes/rectangle/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveRectangleProperties = {
+  transform: WeaveNodeTransformerProperties;
+};
+type WeaveRectangleNodeParams = {
+  config: Partial<WeaveRectangleProperties>;
+};
+
+//#endregion
+//#region src/nodes/rectangle/rectangle.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveRectangleNode extends WeaveNode {
+  private config;
+  protected nodeType: string;
+  constructor(params?: WeaveRectangleNodeParams);
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  scaleReset(node: Konva.Rect): void;
+}
+
+//#endregion
+//#region src/nodes/rectangle/constants.d.ts
+//# sourceMappingURL=rectangle.d.ts.map
+declare const WEAVE_RECTANGLE_NODE_TYPE = "rectangle";
+
+//#endregion
+//#region src/nodes/ellipse/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveEllipseProperties = {
+  transform: WeaveNodeTransformerProperties;
+};
+type WeaveEllipseNodeParams = {
+  config: Partial<WeaveEllipseProperties>;
+};
+
+//#endregion
+//#region src/nodes/ellipse/ellipse.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveEllipseNode extends WeaveNode {
+  private config;
+  protected nodeType: string;
+  constructor(params?: WeaveEllipseNodeParams);
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  scaleReset(node: Konva.Ellipse): void;
+  realOffset(element: WeaveStateElement): Konva.Vector2d;
+}
+
+//#endregion
+//#region src/nodes/ellipse/constants.d.ts
+//# sourceMappingURL=ellipse.d.ts.map
+declare const WEAVE_ELLIPSE_NODE_TYPE = "ellipse";
+
+//#endregion
+//#region src/nodes/line/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveLineProperties = {
+  transform: WeaveNodeTransformerProperties;
+};
+type WeaveLineNodeParams = {
+  config: Partial<WeaveLineProperties>;
+};
+
+//#endregion
+//#region src/nodes/line/line.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveLineNode extends WeaveNode {
+  private config;
+  protected nodeType: string;
+  constructor(params?: WeaveLineNodeParams);
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  scaleReset(node: Konva.Line): void;
+}
+
+//#endregion
+//#region src/nodes/line/constants.d.ts
+//# sourceMappingURL=line.d.ts.map
+declare const WEAVE_LINE_NODE_TYPE = "line";
+
+//#endregion
+//#region src/nodes/text/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type TextSerializable = Konva.TextConfig & NodeSerializable & {
+  type: 'text';
+  id: string;
+};
+type WeaveTextProperties = {
+  transform: WeaveNodeTransformerProperties;
+};
+type WeaveTextNodeParams = {
+  config: Partial<WeaveTextProperties>;
+};
+
+//#endregion
+//#region src/nodes/text/text.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveTextNode extends WeaveNode {
+  private config;
+  protected nodeType: string;
+  private editing;
+  private textAreaSuperContainer;
+  private textAreaContainer;
+  private textArea;
+  constructor(params?: WeaveTextNodeParams);
+  private updateNode;
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  serialize(instance: WeaveElementInstance): WeaveStateElement;
+  private onZoomChangeHandler;
+  private onStageMoveHandler;
+  private textAreaDomResize;
+  measureMultilineText(textNode: Konva.Text): () => {
+    width: number;
+    height: number;
+  };
+  textRenderedSize(text: string, textNode: Konva.Text): {
+    width: number;
+    height: number;
+  };
+  private mimicTextNode;
+  private createTextAreaDOM;
+  private updateTextAreaDOM;
+  private removeTextAreaDOM;
+  private triggerEditMode;
+}
+
+//#endregion
+//#region src/nodes/text/constants.d.ts
+//# sourceMappingURL=text.d.ts.map
+declare const WEAVE_TEXT_NODE_TYPE = "text";
+
+//#endregion
+//#region src/nodes/image/constants.d.ts
+//# sourceMappingURL=constants.d.ts.map
+declare const WEAVE_IMAGE_NODE_TYPE = "image";
+declare const WEAVE_IMAGE_CROP_END_TYPE: {
+  ACCEPT: string;
+  CANCEL: string;
+};
+declare const WEAVE_IMAGE_DEFAULT_CONFIG: {
+  crossOrigin: string;
+};
+
+//#endregion
+//#region src/nodes/image/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type ImageProps = WeaveElementAttributes & {
+  id: string;
+  width?: number;
+  height?: number;
+  imageURL?: string;
+  imageInfo?: {
+    width: number;
+    height: number;
+  };
+};
+type WeaveImageState = {
+  loaded: boolean;
+  error: boolean;
+};
+type WeaveImageProperties = {
+  crossOrigin: ImageCrossOrigin;
+  transform?: WeaveNodeTransformerProperties;
+  urlTransformer?: URLTransformerFunction;
+  onDblClick?: (instance: WeaveImageNode, node: Konva.Group) => void;
+};
+type WeaveImageNodeParams = {
+  config: Partial<WeaveImageProperties>;
+};
+type WeaveImageCropEndTypeKeys = keyof typeof WEAVE_IMAGE_CROP_END_TYPE;
+type WeaveImageCropEndType = (typeof WEAVE_IMAGE_CROP_END_TYPE)[WeaveImageCropEndTypeKeys];
+type WeaveImageOnCropStartEvent = {
+  instance: Konva.Group;
+};
+type WeaveImageOnCropEndEvent = {
+  instance: Konva.Group;
+};
+
+//#endregion
+//#region src/nodes/image/image.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveImageNode extends WeaveNode {
+  private config;
+  protected imageSource: Record<string, HTMLImageElement>;
+  protected imageState: Record<string, WeaveImageState>;
+  protected tapStart: {
+    x: number;
+    y: number;
+    time: number;
+  } | null;
+  protected lastTapTime: number;
+  protected nodeType: string;
+  private imageCrop;
+  private imageLoaded;
+  constructor(params?: WeaveImageNodeParams);
+  triggerCrop(imageNode: Konva.Group): void;
+  closeCrop: (imageNode: Konva.Group, type: WeaveImageCropEndType) => void;
+  resetCrop: (imageNode: Konva.Group) => void;
+  loadAsyncElement(nodeId: string): void;
+  resolveAsyncElement(nodeId: string): void;
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  preloadImage(imageId: string, imageURL: string, {
+    onLoad,
+    onError
+  }: {
+    onLoad: () => void;
+    onError: (error: string | Event) => void;
+  }): void;
+  private loadImage;
+  updatePlaceholderSize(image: Konva.Group, imagePlaceholder: Konva.Rect): void;
+  updateImageCrop(nextProps: WeaveElementAttributes): void;
+  getImageSource(imageId: string): HTMLImageElement | undefined;
+  scaleReset(node: Konva.Group): void;
+}
+
+//#endregion
+//#region src/nodes/star/types.d.ts
+//# sourceMappingURL=image.d.ts.map
+type WeaveStarProperties = {
+  transform: WeaveNodeTransformerProperties;
+};
+type WeaveStarNodeParams = {
+  config: Partial<WeaveStarProperties>;
+};
+
+//#endregion
+//#region src/nodes/star/star.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStarNode extends WeaveNode {
+  private config;
+  protected nodeType: string;
+  constructor(params?: WeaveStarNodeParams);
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  scaleReset(node: Konva.Star): void;
+  realOffset(element: WeaveStateElement): Konva.Vector2d;
+}
+
+//#endregion
+//#region src/nodes/star/constants.d.ts
+//# sourceMappingURL=star.d.ts.map
+declare const WEAVE_STAR_NODE_TYPE = "star";
+
+//#endregion
+//#region src/nodes/arrow/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveArrowProperties = {
+  transform: WeaveNodeTransformerProperties;
+};
+type WeaveArrowNodeParams = {
+  config: Partial<WeaveArrowProperties>;
+};
+
+//#endregion
+//#region src/nodes/arrow/arrow.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveArrowNode extends WeaveNode {
+  private config;
+  protected nodeType: string;
+  constructor(params?: WeaveArrowNodeParams);
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  scaleReset(node: Konva.Arrow): void;
+}
+
+//#endregion
+//#region src/nodes/arrow/constants.d.ts
+//# sourceMappingURL=arrow.d.ts.map
+declare const WEAVE_ARROW_NODE_TYPE = "arrow";
+
+//#endregion
+//#region src/nodes/regular-polygon/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveRegularPolygonProperties = {
+  transform: WeaveNodeTransformerProperties;
+};
+type WeaveRegularPolygonNodeParams = {
+  config: Partial<WeaveRegularPolygonProperties>;
+};
+
+//#endregion
+//#region src/nodes/regular-polygon/regular-polygon.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveRegularPolygonNode extends WeaveNode {
+  private config;
+  protected nodeType: string;
+  constructor(params?: WeaveRegularPolygonNodeParams);
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  scaleReset(node: Konva.RegularPolygon): void;
+  realOffset(element: WeaveStateElement): Konva.Vector2d;
+}
+
+//#endregion
+//#region src/nodes/regular-polygon/constants.d.ts
+//# sourceMappingURL=regular-polygon.d.ts.map
+declare const WEAVE_REGULAR_POLYGON_NODE_TYPE = "regular-polygon";
+
+//#endregion
+//#region src/nodes/frame/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveFrameProperties = {
+  fontFamily: string;
+  fontStyle: string;
+  fontSize: number;
+  fontColor: string;
+  titleMargin: number;
+  borderWidth: number;
+  borderColor: string;
+  onTargetEnter: {
+    borderColor: string;
+    fill: string;
+  };
+  transform: WeaveNodeTransformerProperties;
+};
+type WeaveFrameAttributes = WeaveElementAttributes & {
+  title: string;
+  frameWidth: number;
+  frameHeight: number;
+  frameBackground: string;
+};
+type WeaveFrameNodeParams = {
+  config: Partial<WeaveFrameProperties>;
+};
+
+//#endregion
+//#region src/nodes/frame/frame.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveFrameNode extends WeaveNode {
+  private config;
+  protected nodeType: string;
+  constructor(params?: WeaveFrameNodeParams);
+  create(key: string, props: Partial<WeaveFrameAttributes>): WeaveStateElement;
+  onRender(props: WeaveFrameAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  serialize(instance: WeaveElementInstance): WeaveStateElement;
+  scaleReset(): void;
+}
+
+//#endregion
+//#region src/nodes/frame/constants.d.ts
+//# sourceMappingURL=frame.d.ts.map
+declare const WEAVE_FRAME_NODE_TYPE = "frame";
+declare const WEAVE_FRAME_NODE_DEFAULT_CONFIG: {
+  fontFamily: string;
+  fontStyle: string;
+  fontSize: number;
+  fontColor: string;
+  titleMargin: number;
+  borderColor: string;
+  borderWidth: number;
+  onTargetEnter: {
+    borderColor: string;
+    fill: string;
+  };
+  transform: {
+    rotateEnabled: boolean;
+    resizeEnabled: boolean;
+    enabledAnchors: string[];
+    borderStrokeWidth: number;
+    padding: number;
+  };
+};
+declare const WEAVE_FRAME_DEFAULT_BACKGROUND_COLOR = "#FFFFFFFF";
+declare const WEAVE_FRAME_NODE_DEFAULT_PROPS: {
+  title: string;
+  frameWidth: number;
+  frameHeight: number;
+  frameBackground: string;
+};
+
+//#endregion
+//#region src/nodes/stroke/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveStrokeProperties = {
+  splineResolution: number;
+  resamplingSpacing: number;
+  isEraser?: boolean;
+  transform?: WeaveNodeTransformerProperties;
+};
+type WeaveStrokeNodeParams = {
+  config: Partial<WeaveStrokeProperties>;
+};
+type WeaveStrokePoint = {
+  x: number;
+  y: number;
+  pressure: number;
+};
+
+//#endregion
+//#region src/nodes/stroke/stroke.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStrokeNode extends WeaveNode {
+  private readonly config;
+  protected nodeType: string;
+  constructor(params?: WeaveStrokeNodeParams);
+  private resamplePoints;
+  private getSplinePoints;
+  private drawRibbonWithDash;
+  private drawShape;
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  getZoomPlugin(): WeaveStageZoomPlugin | undefined;
+  scaleReset(node: Konva.Node): void;
+  serialize(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+//#endregion
+//#region src/nodes/stroke/constants.d.ts
+//# sourceMappingURL=stroke.d.ts.map
+declare const WEAVE_STROKE_NODE_TYPE = "stroke";
+declare const WEAVE_STROKE_NODE_DEFAULT_CONFIG: {
+  splineResolution: number;
+  resamplingSpacing: number;
+  isEraser: boolean;
+};
+
+//#endregion
+//#region src/nodes/comment/constants.d.ts
+//# sourceMappingURL=constants.d.ts.map
+declare const WEAVE_COMMENT_STATUS: {
+  readonly PENDING: "pending";
+  readonly RESOLVED: "resolved";
+};
+declare const WEAVE_COMMENT_CREATE_ACTION: {
+  readonly CREATE: "create";
+  readonly CLOSE: "close";
+};
+declare const WEAVE_COMMENT_VIEW_ACTION: {
+  readonly REPLY: "reply";
+  readonly MARK_RESOLVED: "markResolved";
+  readonly EDIT: "edit";
+  readonly DELETE: "delete";
+  readonly CLOSE: "close";
+};
+declare const WEAVE_COMMENT_NODE_ACTION: {
+  readonly IDLE: "idle";
+  readonly CREATING: "creating";
+  readonly VIEWING: "viewing";
+};
+declare const WEAVE_COMMENT_NODE_TYPE = "comment";
+declare const WEAVE_COMMENT_NODE_DEFAULTS: {
+  style: {
+    stroke: string;
+    strokeWidth: number;
+    shadowColor: string;
+    shadowBlur: number;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    shadowOpacity: number;
+    contracted: {
+      width: number;
+      height: number;
+      circlePadding: number;
+      userName: {
+        fontFamily: string;
+        fontSize: number;
+        fontStyle: string;
+      };
+    };
+    expanded: {
+      width: number;
+      userNameLeftMargin: number;
+      dateLeftMargin: number;
+      contentTopMargin: number;
+      contentBottomMargin: number;
+      userName: {
+        fontFamily: string;
+        fontSize: number;
+        fontStyle: string;
+        color: string;
+      };
+      date: {
+        fontFamily: string;
+        fontSize: number;
+        fontStyle: string;
+        color: string;
+      };
+      content: {
+        fontFamily: string;
+        fontSize: number;
+        maxLines: number;
+        fontStyle: string;
+        color: string;
+      };
+    };
+    creating: {
+      paddingX: number;
+      paddingY: number;
+      stroke: string;
+      strokeWidth: number;
+    };
+    viewing: {
+      paddingX: number;
+      paddingY: number;
+      stroke: string;
+      strokeWidth: number;
+    };
+  };
+  formatDate: (date: string) => string;
+};
+
+//#endregion
+//#region src/nodes/comment/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveCommentNodeCreateActionKeys = keyof typeof WEAVE_COMMENT_CREATE_ACTION;
+type WeaveCommentNodeCreateAction = (typeof WEAVE_COMMENT_CREATE_ACTION)[WeaveCommentNodeCreateActionKeys];
+type WeaveCommentNodeViewActionKeys = keyof typeof WEAVE_COMMENT_VIEW_ACTION;
+type WeaveCommentNodeViewAction = (typeof WEAVE_COMMENT_VIEW_ACTION)[WeaveCommentNodeViewActionKeys];
+type WeaveCommentNodeActionKeys = keyof typeof WEAVE_COMMENT_NODE_ACTION;
+type WeaveCommentNodeAction = (typeof WEAVE_COMMENT_NODE_ACTION)[WeaveCommentNodeActionKeys];
+type WeaveCommentStatusKeys = keyof typeof WEAVE_COMMENT_STATUS;
+type WeaveCommentStatus = (typeof WEAVE_COMMENT_STATUS)[WeaveCommentStatusKeys];
+type WeaveCommentNodeStyle = {
+  stroke: string;
+  strokeWidth: number;
+  shadowColor: string;
+  shadowBlur: number;
+  shadowOffsetX: number;
+  shadowOffsetY: number;
+  shadowOpacity: number;
+  contracted: {
+    width: number;
+    height: number;
+    circlePadding: number;
+    userName: {
+      fontFamily: string;
+      fontSize: number;
+      fontStyle: string;
+    };
+  };
+  expanded: {
+    width: number;
+    userNameLeftMargin: number;
+    dateLeftMargin: number;
+    contentTopMargin: number;
+    contentBottomMargin: number;
+    userName: {
+      fontFamily: string;
+      fontSize: number;
+      fontStyle: string;
+      color: string;
+    };
+    date: {
+      fontFamily: string;
+      fontSize: number;
+      fontStyle: string;
+      color: string;
+    };
+    content: {
+      maxLines: number;
+      fontFamily: string;
+      fontSize: number;
+      fontStyle: string;
+      color: string;
+    };
+  };
+  creating: {
+    paddingX: number;
+    paddingY: number;
+    stroke: string;
+    strokeWidth: number;
+  };
+  viewing: {
+    paddingX: number;
+    paddingY: number;
+    stroke: string;
+    strokeWidth: number;
+  };
+};
+type WeaveCommentNodeModel<T> = {
+  getDate: (comment: T) => string;
+  getId: (comment: T) => string;
+  getUserId: (comment: T) => string;
+  getStatus: (comment: T) => WeaveCommentStatus;
+  getUserShortName: (comment: T) => string;
+  getUserFullName: (comment: T) => string;
+  canUserDrag: (comment: T) => boolean;
+  getContent: (comment: T) => string;
+  setMarkResolved: (comment: T) => T;
+  setContent: (comment: T, content: string) => T;
+};
+type WeaveCommentNodeConfig<T> = {
+  style: WeaveCommentNodeStyle;
+  model: WeaveCommentNodeModel<T>;
+  formatDate: (date: string) => string;
+  createComment: (ele: HTMLDivElement, node: WeaveElementInstance, finish: (node: WeaveElementInstance, content: string, action: WeaveCommentNodeCreateAction) => void) => Promise<void>;
+  viewComment: (ele: HTMLDivElement, node: WeaveElementInstance, finish: (node: WeaveElementInstance, content: string, action: WeaveCommentNodeViewAction) => void) => Promise<void>;
+};
+type WeaveCommentNodeParams<T> = {
+  config: Pick<WeaveCommentNodeConfig<T>, 'model' | 'formatDate' | 'createComment' | 'viewComment'> & DeepPartial<Pick<WeaveCommentNodeConfig<T>, 'style'>>;
+};
+type WeaveCommentNodeOnFinishCreateEvent = {
+  node: WeaveElementInstance;
+  action: WeaveCommentNodeCreateAction;
+};
+type WeaveCommentNodeOnCreateCommentEvent = {
+  node: WeaveElementInstance;
+  position: Konva.Vector2d;
+  content: string;
+};
+type WeaveCommentNodeOnViewEvent = {
+  node: WeaveElementInstance;
+};
+type WeaveCommentNodeOnDragEndEvent = {
+  node: WeaveElementInstance;
+};
+
+//#endregion
+//#region src/nodes/comment/comment.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveCommentNode<T> extends WeaveNode {
+  protected nodeType: string;
+  protected config: WeaveCommentNodeConfig<T>;
+  protected commentDomAction: WeaveCommentNodeAction | null;
+  protected commentDomVisibleId: string | null;
+  protected commentDomVisible: boolean;
+  protected showResolved: boolean;
+  constructor(params: WeaveCommentNodeParams<T>);
+  onRender(props: WeaveElementAttributes): konva_lib_Group5.Group;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  onDestroy(nodeInstance: WeaveElementInstance): void;
+  private expandNode;
+  private contractNode;
+  finishCreateCommentDOM(commentNode: Konva.Group): void;
+  private setCommentDOMPosition;
+  private createCommentDOM;
+  private readonly onZoomChangeHandler;
+  private normalizeNodeSize;
+  private readonly onStageMoveHandler;
+  private openCommentDOM;
+  private closeCommentDOM;
+  setCommentModel(commentNode: WeaveElementInstance, comment: T): void;
+  focusOn(nodeId: string, duration?: number): void;
+  setCommentViewing(commentId: string | null): void;
+  isCommentViewing(): boolean;
+  isCommentCreating(): boolean;
+  getCommentId(node: WeaveElementInstance): string;
+  setShowResolved(show: boolean): void;
+}
+
+//#endregion
+//#region src/nodes/video/types.d.ts
+//# sourceMappingURL=comment.d.ts.map
+type VideoProps = WeaveElementAttributes & {
+  id: string;
+  width: number;
+  height: number;
+  videoURL: string;
+  videoPlaceholderURL: string;
+  videoInfo?: {
+    width: number;
+    height: number;
+  };
+};
+type WeaveVideoState = {
+  placeholderLoaded: boolean;
+  loaded: boolean;
+  playing: boolean;
+  paused: boolean;
+};
+type VideoBackgroundStyle = {
+  color: string;
+  strokeWidth: number;
+  strokeColor: string;
+};
+type VideoIconBackgroundStyle = {
+  color: string;
+  strokeWidth: number;
+  strokeColor: string;
+};
+type VideoTrackStyle = {
+  resetOnEnd: boolean;
+  onlyOnHover: boolean;
+  color: string;
+  height: number;
+};
+type VideoIconStyle = {
+  internal: {
+    paddingX: number;
+    paddingY: number;
+  };
+  external: {
+    paddingX: number;
+    paddingY: number;
+  };
+  width: number;
+  height: number;
+  color: string;
+  dataURL: string;
+};
+type VideoStyle = {
+  playPauseOnDblClick: boolean;
+  track: VideoTrackStyle;
+  background: VideoBackgroundStyle;
+  iconBackground: VideoIconBackgroundStyle;
+  icon: VideoIconStyle;
+};
+type WeaveVideoProperties = {
+  crossOrigin: ImageCrossOrigin;
+  transform?: WeaveNodeTransformerProperties;
+  urlTransformer?: URLTransformerFunction;
+  style: VideoStyle;
+};
+type WeaveVideoNodeParams = {
+  config: DeepPartial<WeaveVideoProperties>;
+};
+type WeaveVideoOnVideoPlayEvent = {
+  nodeId: string;
+};
+type WeaveVideoOnVideoPauseEvent = {
+  nodeId: string;
+};
+type WeaveVideoOnVideoStopEvent = {
+  nodeId: string;
+};
+
+//#endregion
+//#region src/nodes/video/video.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveVideoNode extends WeaveNode {
+  private config;
+  private videoIconImage;
+  private videoState;
+  private videoSourceFrameId;
+  private videoSource;
+  private videoPlaceholder;
+  private anim;
+  protected nodeType: string;
+  constructor(params?: WeaveVideoNodeParams);
+  private initVideoIcon;
+  private loadPlaceholder;
+  private loadVideo;
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  loadAsyncElement(nodeId: string): void;
+  resolveAsyncElement(nodeId: string): void;
+  getVideoState(nodeInstance: WeaveElementInstance): WeaveVideoState | undefined;
+  play(videoId: string): void;
+  pause(videoId: string): void;
+  stop(videoId: string): void;
+  areVideosPlaying(): boolean;
+  getVideoSource(videoId: string): HTMLVideoElement | undefined;
+  onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  getNodeSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  scaleReset(node: Konva.Group): void;
+}
+
+//#endregion
+//#region src/nodes/video/constants.d.ts
+//# sourceMappingURL=video.d.ts.map
+declare const WEAVE_VIDEO_NODE_TYPE = "video";
+declare const WEAVE_VIDEO_DEFAULT_CONFIG: WeaveVideoProperties;
+
+//#endregion
+//#region src/actions/zoom-out-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveZoomOutToolActionParams = {
+  previousAction: string;
+};
+
+//#endregion
+//#region src/actions/zoom-out-tool/zoom-out-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveZoomOutToolAction extends WeaveAction {
+  protected previousAction: string;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  getName(): string;
+  private getStageZoomPlugin;
+  onInit(): void;
+  trigger(cancelAction: () => void, params: WeaveZoomOutToolActionParams): void;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/zoom-in-tool/types.d.ts
+//# sourceMappingURL=zoom-out-tool.d.ts.map
+type WeaveZoomInToolActionParams = {
+  previousAction: string;
+};
+
+//#endregion
+//#region src/actions/zoom-in-tool/zoom-in-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveZoomInToolAction extends WeaveAction {
+  protected previousAction: string;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  getName(): string;
+  private getStageZoomPlugin;
+  onInit(): void;
+  trigger(cancelAction: () => void, params: WeaveZoomInToolActionParams): void;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/fit-to-screen-tool/types.d.ts
+//# sourceMappingURL=zoom-in-tool.d.ts.map
+type WeaveFitToScreenToolActionParams = {
+  previousAction: string;
+};
+
+//#endregion
+//#region src/actions/fit-to-screen-tool/fit-to-screen-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveFitToScreenToolAction extends WeaveAction {
+  protected previousAction: string;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  getName(): string;
+  private getStageZoomPlugin;
+  onInit(): void;
+  trigger(cancelAction: () => void, params: WeaveFitToScreenToolActionParams): void;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/fit-to-selection-tool/types.d.ts
+//# sourceMappingURL=fit-to-screen-tool.d.ts.map
+type WeaveFitToSelectionToolActionParams = {
+  previousAction: string;
+  smartZoom?: boolean;
+};
+
+//#endregion
+//#region src/actions/fit-to-selection-tool/fit-to-selection-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveFitToSelectionToolAction extends WeaveAction {
+  protected previousAction: string;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  getName(): string;
+  private getNodesSelectionPlugin;
+  private getStageZoomPlugin;
+  onInit(): void;
+  trigger(cancelAction: () => void, params: WeaveFitToSelectionToolActionParams): void;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/move-tool/constants.d.ts
+//# sourceMappingURL=fit-to-selection-tool.d.ts.map
+declare const MOVE_TOOL_ACTION_NAME = "moveTool";
+declare const MOVE_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly MOVING: "moving";
+};
+
+//#endregion
+//#region src/actions/move-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveMoveToolActionStateKeys = keyof typeof MOVE_TOOL_STATE;
+type WeaveMoveToolActionState = (typeof MOVE_TOOL_STATE)[WeaveMoveToolActionStateKeys];
+type WeaveMoveToolActionParams = {
+  triggerSelectionTool?: boolean;
+};
+
+//#endregion
+//#region src/actions/move-tool/move-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveMoveToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveMoveToolActionState;
+  protected cancelAction: () => void;
+  protected triggerSelectionTool: boolean;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  private setupEvents;
+  private setState;
+  private setMoving;
+  trigger(cancelAction: () => void, params?: WeaveMoveToolActionParams): void;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/selection-tool/constants.d.ts
+//# sourceMappingURL=move-tool.d.ts.map
+declare const SELECTION_TOOL_ACTION_NAME = "selectionTool";
+declare const SELECTION_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly SELECTING: "selection";
+};
+
+//#endregion
+//#region src/actions/selection-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveSelectionToolActionStateKeys = keyof typeof SELECTION_TOOL_STATE;
+type WeaveSelectionToolActionState = (typeof SELECTION_TOOL_STATE)[WeaveSelectionToolActionStateKeys];
+
+//#endregion
+//#region src/actions/selection-tool/selection-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveSelectionToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveSelectionToolActionState;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  private setupEvents;
+  private setState;
+  private setSelection;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/eraser-tool/constants.d.ts
+//# sourceMappingURL=selection-tool.d.ts.map
+declare const ERASER_TOOL_ACTION_NAME = "eraserTool";
+declare const ERASER_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ERASING: "erasing";
+};
+
+//#endregion
+//#region src/actions/eraser-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveEraserToolActionStateKeys = keyof typeof ERASER_TOOL_STATE;
+type WeaveEraserToolActionState = (typeof ERASER_TOOL_STATE)[WeaveEraserToolActionStateKeys];
+
+//#endregion
+//#region src/actions/eraser-tool/eraser-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveEraserToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveEraserToolActionState;
+  protected erasing: boolean;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  private setupEvents;
+  private setState;
+  private setEraser;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/rectangle-tool/constants.d.ts
+//# sourceMappingURL=eraser-tool.d.ts.map
+declare const RECTANGLE_TOOL_ACTION_NAME = "rectangleTool";
+declare const RECTANGLE_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ADDING: "adding";
+  readonly DEFINING_SIZE: "definingSize";
+  readonly ADDED: "added";
+};
+
+//#endregion
+//#region src/actions/rectangle-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveRectangleToolActionStateKeys = keyof typeof RECTANGLE_TOOL_STATE;
+type WeaveRectangleToolActionState = (typeof RECTANGLE_TOOL_STATE)[WeaveRectangleToolActionStateKeys];
+type WeaveRectangleToolActionOnAddingEvent = undefined;
+type WeaveRectangleToolActionOnAddedEvent = undefined;
+
+//#endregion
+//#region src/actions/rectangle-tool/rectangle-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveRectangleToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveRectangleToolActionState;
+  protected rectId: string | null;
+  protected moved: boolean;
+  protected tempRectNode: Konva.Rect | null;
+  protected pointers: Map<number, Konva.Vector2d>;
+  protected clickPoint: Konva.Vector2d | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected measureContainer: Konva.Layer | Konva.Group | undefined;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  initProps(): {
+    opacity: number;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    width: number;
+    height: number;
+  };
+  private setupEvents;
+  private setState;
+  private addRectangle;
+  private handleAdding;
+  private handleSettingSize;
+  private handleMovement;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/ellipse-tool/constants.d.ts
+//# sourceMappingURL=rectangle-tool.d.ts.map
+declare const ELLIPSE_TOOL_ACTION_NAME = "ellipseTool";
+declare const ELLIPSE_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ADDING: "adding";
+  readonly DEFINING_SIZE: "definingSize";
+  readonly ADDED: "added";
+};
+
+//#endregion
+//#region src/actions/ellipse-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveEllipseToolActionStateKeys = keyof typeof ELLIPSE_TOOL_STATE;
+type WeaveEllipseToolActionState = (typeof ELLIPSE_TOOL_STATE)[WeaveEllipseToolActionStateKeys];
+type WeaveEllipseToolActionOnAddingEvent = undefined;
+type WeaveEllipseToolActionOnAddedEvent = undefined;
+
+//#endregion
+//#region src/actions/ellipse-tool/ellipse-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveEllipseToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveEllipseToolActionState;
+  protected ellipseId: string | null;
+  protected creating: boolean;
+  protected moved: boolean;
+  protected pointers: Map<number, Konva.Vector2d>;
+  protected clickPoint: Konva.Vector2d | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  initProps(): {
+    opacity: number;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    radiusX: number;
+    radiusY: number;
+    keepAspectRatio: boolean;
+  };
+  private setupEvents;
+  private setState;
+  private addEllipse;
+  private handleAdding;
+  private handleSettingSize;
+  private handleMovement;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/pen-tool/constants.d.ts
+//# sourceMappingURL=ellipse-tool.d.ts.map
+declare const PEN_TOOL_ACTION_NAME = "penTool";
+declare const PEN_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ADDING: "adding";
+  readonly DEFINING_SIZE: "definingSize";
+  readonly ADDED: "added";
+};
+
+//#endregion
+//#region src/actions/pen-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeavePenToolActionStateKeys = keyof typeof PEN_TOOL_STATE;
+type WeavePenToolActionState = (typeof PEN_TOOL_STATE)[WeavePenToolActionStateKeys];
+type WeavePenToolActionOnAddingEvent = undefined;
+type WeavePenToolActionOnAddedEvent = undefined;
+
+//#endregion
+//#region src/actions/pen-tool/pen-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeavePenToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected initialCursor: string | null;
+  protected state: WeavePenToolActionState;
+  protected lineId: string | null;
+  protected tempLineId: string | null;
+  protected tempMainLineNode: Konva.Line | null;
+  protected tempLineNode: Konva.Line | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected measureContainer: Konva.Layer | Konva.Group | undefined;
+  protected clickPoint: Konva.Vector2d | null;
+  protected pointers: Map<number, Konva.Vector2d>;
+  protected tempPoint: Konva.Circle | undefined;
+  protected tempNextPoint: Konva.Circle | undefined;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  initProps(): {
+    stroke: string;
+    strokeWidth: number;
+    opacity: number;
+  };
+  private setupEvents;
+  private setState;
+  private addLine;
+  private handleAdding;
+  private handleSettingSize;
+  private handleMovement;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/brush-tool/constants.d.ts
+//# sourceMappingURL=pen-tool.d.ts.map
+declare const BRUSH_TOOL_ACTION_NAME = "brushTool";
+declare const BRUSH_TOOL_STATE: {
+  readonly INACTIVE: "inactive";
+  readonly IDLE: "idle";
+  readonly DEFINE_STROKE: "defineStroke";
+};
+declare const BRUSH_TOOL_DEFAULT_CONFIG: {
+  interpolationSteps: number;
+};
+
+//#endregion
+//#region src/actions/brush-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveBrushToolActionStateKeys = keyof typeof BRUSH_TOOL_STATE;
+type WeaveBrushToolActionState = (typeof BRUSH_TOOL_STATE)[WeaveBrushToolActionStateKeys];
+type WeaveBrushToolActionOnAddingEvent = undefined;
+type WeaveBrushToolActionOnAddedEvent = undefined;
+type WeaveBrushToolActionProperties = {
+  interpolationSteps: number;
+};
+type WeaveBrushToolActionParams = {
+  config: Partial<WeaveBrushToolActionProperties>;
+};
+
+//#endregion
+//#region src/actions/brush-tool/brush-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveBrushToolAction extends WeaveAction {
+  protected config: WeaveBrushToolActionProperties;
+  protected initialized: boolean;
+  protected state: WeaveBrushToolActionState;
+  protected clickPoint: Konva.Vector2d | null;
+  protected strokeId: string | null;
+  protected isEraser: boolean;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected measureContainer: Konva.Layer | Konva.Group | undefined;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor(params?: WeaveBrushToolActionParams);
+  getName(): string;
+  initProps(): {
+    stroke: string;
+    strokeWidth: number;
+    opacity: number;
+  };
+  private getEventPressure;
+  private setupEvents;
+  private setState;
+  private getBoundingBox;
+  private handleStartStroke;
+  private handleMovement;
+  private handleEndStroke;
+  trigger(cancel: () => void): void;
+  onEraserMode(): boolean;
+  cleanup(): void;
+  getZoomPlugin(): WeaveStageZoomPlugin | undefined;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/text-tool/constants.d.ts
+//# sourceMappingURL=brush-tool.d.ts.map
+declare const TEXT_TOOL_ACTION_NAME = "textTool";
+declare const TEXT_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ADDING: "adding";
+  readonly FINISHED: "finished";
+};
+declare const TEXT_LAYOUT: {
+  readonly AUTO_ALL: "auto-all";
+  readonly AUTO_HEIGHT: "auto-height";
+  readonly FIXED: "fixed";
+};
+
+//#endregion
+//#region src/actions/text-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveTextToolActionStateKeys = keyof typeof TEXT_TOOL_STATE;
+type WeaveTextToolActionState = (typeof TEXT_TOOL_STATE)[WeaveTextToolActionStateKeys];
+type WeaveTextLayoutKeys = keyof typeof TEXT_LAYOUT;
+type WeaveTextLayout = (typeof TEXT_LAYOUT)[WeaveTextLayoutKeys];
+type WeaveTextToolActionOnAddingEvent = undefined;
+type WeaveTextToolActionOnAddedEvent = undefined;
+
+//#endregion
+//#region src/actions/text-tool/text-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveTextToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected initialCursor: string | null;
+  protected state: WeaveTextToolActionState;
+  protected textId: string | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected clickPoint: Konva.Vector2d | null;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  initProps(): {
+    text: string;
+    layout: "auto-all";
+    fontSize: number;
+    fontFamily: string;
+    fill: string;
+    align: string;
+    verticalAlign: string;
+    strokeEnabled: boolean;
+  };
+  private setupEvents;
+  private setState;
+  private addText;
+  private handleAdding;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/image-tool/constants.d.ts
+//# sourceMappingURL=text-tool.d.ts.map
+declare const IMAGE_TOOL_ACTION_NAME = "imageTool";
+declare const IMAGE_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly UPLOADING: "uploading";
+  readonly DEFINING_POSITION: "definingPosition";
+  readonly SELECTED_POSITION: "selectedPosition";
+  readonly ADDING: "adding";
+  readonly FINISHED: "finished";
+};
+
+//#endregion
+//#region src/actions/image-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveImageToolActionStateKeys = keyof typeof IMAGE_TOOL_STATE;
+type WeaveImageToolActionState = (typeof IMAGE_TOOL_STATE)[WeaveImageToolActionStateKeys];
+type WeaveImageToolActionOnStartLoadImageEvent = undefined;
+type WeaveImageToolActionOnEndLoadImageEvent = Error | undefined;
+type WeaveImageToolActionOnAddingEvent = {
+  imageURL: string;
+};
+type WeaveImageToolActionOnAddedEvent = {
+  imageURL: string;
+  nodeId: string;
+};
+type WeaveImageToolActionTriggerParams = {
+  imageURL?: string;
+  imageId?: string;
+  options?: ImageOptions;
+  position?: Konva.Vector2d;
+  forceMainContainer?: boolean;
+};
+type ImageOptions = {
+  crossOrigin: ImageCrossOrigin;
+};
+type WeaveImageToolActionTriggerReturn = {
+  finishUploadCallback: (imageURL: string, position?: Konva.Vector2d | undefined) => void;
+} | undefined;
+
+//#endregion
+//#region src/actions/image-tool/image-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveImageToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected initialCursor: string | null;
+  protected state: WeaveImageToolActionState;
+  protected cursorPadding: number;
+  protected imageId: string | null;
+  protected tempImageId: string | null;
+  protected tempImageNode: Konva.Image | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected pointers: Map<number, Konva.Vector2d>;
+  protected imageURL: string | null;
+  protected clickPoint: Konva.Vector2d | null;
+  protected forceMainContainer: boolean;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  update: undefined;
+  constructor();
+  getName(): string;
+  initProps(): {
+    width: number;
+    height: number;
+    scaleX: number;
+    scaleY: number;
+  };
+  onInit(): void;
+  private setupEvents;
+  private setState;
+  private loadImage;
+  private isTouchDevice;
+  private addImageNode;
+  private addImage;
+  private handleAdding;
+  trigger(cancelAction: () => void, params?: WeaveImageToolActionTriggerParams): WeaveImageToolActionTriggerReturn;
+  cleanup(): void;
+  private getImageNodeHandler;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/star-tool/constants.d.ts
+//# sourceMappingURL=image-tool.d.ts.map
+declare const STAR_TOOL_ACTION_NAME = "starTool";
+declare const STAR_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ADDING: "adding";
+  readonly DEFINING_SIZE: "definingSize";
+  readonly ADDED: "added";
+};
+
+//#endregion
+//#region src/actions/star-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveStarToolActionStateKeys = keyof typeof STAR_TOOL_STATE;
+type WeaveStarToolActionState = (typeof STAR_TOOL_STATE)[WeaveStarToolActionStateKeys];
+type WeaveStarToolActionOnAddingEvent = undefined;
+type WeaveStarToolActionOnAddedEvent = undefined;
+
+//#endregion
+//#region src/actions/star-tool/star-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStarToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveStarToolActionState;
+  protected starId: string | null;
+  protected creating: boolean;
+  protected moved: boolean;
+  protected pointers: Map<number, Konva.Vector2d>;
+  protected clickPoint: Konva.Vector2d | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  initProps(): {
+    opacity: number;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    numPoints: number;
+    innerRadius: number;
+    outerRadius: number;
+    keepAspectRatio: boolean;
+  };
+  private setupEvents;
+  private setState;
+  private addStar;
+  private handleAdding;
+  private handleSettingSize;
+  private handleMovement;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/arrow-tool/constants.d.ts
+//# sourceMappingURL=star-tool.d.ts.map
+declare const ARROW_TOOL_ACTION_NAME = "arrowTool";
+declare const ARROW_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ADDING: "adding";
+  readonly DEFINING_SIZE: "definingSize";
+  readonly ADDED: "added";
+};
+
+//#endregion
+//#region src/actions/arrow-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveArrowToolActionStateKeys = keyof typeof ARROW_TOOL_STATE;
+type WeaveArrowToolActionState = (typeof ARROW_TOOL_STATE)[WeaveArrowToolActionStateKeys];
+type WeaveArrowToolActionOnAddingEvent = undefined;
+type WeaveArrowToolActionOnAddedEvent = undefined;
+
+//#endregion
+//#region src/actions/arrow-tool/arrow-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveArrowToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected initialCursor: string | null;
+  protected state: WeaveArrowToolActionState;
+  protected arrowId: string | null;
+  protected tempArrowId: string | null;
+  protected tempMainArrowNode: Konva.Line | null;
+  protected tempArrowNode: Konva.Arrow | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected measureContainer: Konva.Layer | Konva.Group | undefined;
+  protected clickPoint: Konva.Vector2d | null;
+  protected pointers: Map<number, Konva.Vector2d>;
+  protected tempPoint: Konva.Circle | undefined;
+  protected tempNextPoint: Konva.Circle | undefined;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  initProps(): {
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    opacity: number;
+    pointerLength: number;
+    pointerWidth: number;
+    pointerAtBeginning: boolean;
+    pointerAtEnding: boolean;
+  };
+  private setupEvents;
+  private setState;
+  private addArrow;
+  private handleAdding;
+  private handleSettingSize;
+  private handleMovement;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/regular-polygon-tool/constants.d.ts
+//# sourceMappingURL=arrow-tool.d.ts.map
+declare const REGULAR_POLYGON_TOOL_ACTION_NAME = "regularPolygonTool";
+declare const REGULAR_POLYGON_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ADDING: "adding";
+  readonly DEFINING_SIZE: "definingSize";
+  readonly ADDED: "added";
+};
+
+//#endregion
+//#region src/actions/regular-polygon-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveRegularPolygonToolActionStateKeys = keyof typeof REGULAR_POLYGON_TOOL_STATE;
+type WeaveRegularPolygonToolActionState = (typeof REGULAR_POLYGON_TOOL_STATE)[WeaveRegularPolygonToolActionStateKeys];
+type WeaveRegularPolygonToolActionOnAddingEvent = undefined;
+type WeaveRegularPolygonToolActionOnAddedEvent = undefined;
+
+//#endregion
+//#region src/actions/regular-polygon-tool/regular-polygon-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveRegularPolygonToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveRegularPolygonToolActionState;
+  protected regularPolygonId: string | null;
+  protected creating: boolean;
+  protected moved: boolean;
+  protected pointers: Map<number, Konva.Vector2d>;
+  protected clickPoint: Konva.Vector2d | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  initProps(): {
+    opacity: number;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    sides: number;
+    radius: number;
+  };
+  private setupEvents;
+  private setState;
+  private addRegularPolygon;
+  private handleAdding;
+  private handleSettingSize;
+  private handleMovement;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/frame-tool/constants.d.ts
+//# sourceMappingURL=regular-polygon-tool.d.ts.map
+declare const FRAME_TOOL_ACTION_NAME = "frameTool";
+declare const FRAME_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ADDING: "adding";
+  readonly ADDED: "added";
+};
+
+//#endregion
+//#region src/actions/frame-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveFrameToolActionStateKeys = keyof typeof FRAME_TOOL_STATE;
+type WeaveFrameToolActionState = (typeof FRAME_TOOL_STATE)[WeaveFrameToolActionStateKeys];
+type WeaveFrameToolActionTriggerParams = {
+  title?: string;
+  frameWidth?: number;
+  frameHeight?: number;
+  frameOrientation?: string;
+  frameType?: string;
+};
+type WeaveFrameToolProps = {
+  title: string;
+  editing: boolean;
+  opacity: number;
+};
+type WeaveFrameToolActionOnAddingEvent = undefined;
+type WeaveFrameToolActionOnAddedEvent = undefined;
+
+//#endregion
+//#region src/actions/frame-tool/frame-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveFrameToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveFrameToolActionState;
+  protected frameId: string | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected clickPoint: Konva.Vector2d | null;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  initProps(params?: WeaveFrameToolActionTriggerParams): WeaveFrameToolProps;
+  private setupEvents;
+  private setState;
+  private addFrame;
+  private handleAdding;
+  trigger(cancelAction: () => void, params?: WeaveFrameToolActionTriggerParams): void;
+  cleanup(): void;
+  private setCursor;
+  private setFocusStage;
+}
+
+//#endregion
+//#region src/actions/export-nodes-tool/types.d.ts
+//# sourceMappingURL=frame-tool.d.ts.map
+type WeaveExportNodesActionParams = {
+  nodes: WeaveElementInstance[];
+  boundingNodes?: (nodes: Konva.Node[]) => Konva.Node[];
+  options?: WeaveExportNodesOptions;
+  triggerSelectionTool?: boolean;
+};
+
+//#endregion
+//#region src/actions/export-stage-tool/export-stage-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveExportStageToolAction extends WeaveAction {
+  protected cancelAction: () => void;
+  private defaultFormatOptions;
+  private options;
+  onPropsChange: undefined;
+  onInit: undefined;
+  getName(): string;
+  private exportStage;
+  trigger(cancelAction: () => void, {
+    boundingNodes,
+    options
+  }: WeaveExportNodesActionParams): Promise<HTMLImageElement>;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/export-stage-tool/types.d.ts
+//# sourceMappingURL=export-stage-tool.d.ts.map
+type WeaveExportStageActionParams = {
+  boundingNodes?: (nodes: Konva.Node[]) => Konva.Node[];
+  options?: WeaveExportNodesOptions;
+};
+
+//#endregion
+//#region src/actions/export-nodes-tool/export-nodes-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveExportNodesToolAction extends WeaveAction {
+  protected cancelAction: () => void;
+  protected triggerSelectionTool: boolean;
+  private defaultFormatOptions;
+  private options;
+  onPropsChange: undefined;
+  onInit: undefined;
+  getName(): string;
+  private exportNodes;
+  trigger(cancelAction: () => void, {
+    nodes,
+    boundingNodes,
+    options,
+    triggerSelectionTool
+  }: WeaveExportNodesActionParams): Promise<HTMLImageElement>;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/align-nodes-tool/constants.d.ts
+//# sourceMappingURL=export-nodes-tool.d.ts.map
+declare const ALIGN_NODES_TOOL_ACTION_NAME = "alignNodesTool";
+declare const ALIGN_NODES_ALIGN_TO: {
+  readonly LEFT_HORIZONTAL: "left-horizontal";
+  readonly CENTER_HORIZONTAL: "center-horizontal";
+  readonly RIGHT_HORIZONTAL: "right-horizontal";
+  readonly TOP_VERTICAL: "top-vertical";
+  readonly CENTER_VERTICAL: "center-vertical";
+  readonly BOTTOM_VERTICAL: "bottom-vertical";
+};
+declare const ALIGN_NODES_TOOL_STATE: {
+  readonly IDLE: "idle";
+};
+
+//#endregion
+//#region src/actions/align-nodes-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveAlignNodesToolActionStateKeys = keyof typeof ALIGN_NODES_TOOL_STATE;
+type WeaveAlignNodesToolActionState = (typeof ALIGN_NODES_TOOL_STATE)[WeaveAlignNodesToolActionStateKeys];
+type WeaveAlignNodesToolActionAlignToKeys = keyof typeof ALIGN_NODES_ALIGN_TO;
+type WeaveAlignNodesToolActionAlignTo = (typeof ALIGN_NODES_ALIGN_TO)[WeaveAlignNodesToolActionAlignToKeys];
+type WeaveAlignNodesToolActionTriggerParams = {
+  alignTo: WeaveAlignNodesToolActionAlignTo;
+  triggerSelectionTool?: boolean;
+};
+
+//#endregion
+//#region src/actions/align-nodes-tool/align-nodes-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveAlignNodesToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected state: WeaveAlignNodesToolActionState;
+  protected triggerSelectionTool: boolean;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  onInit: undefined;
+  constructor();
+  getName(): string;
+  private setupEvents;
+  private setState;
+  private updateNode;
+  private getParents;
+  private alignToLeftHorizontal;
+  private alignToCenterHorizontal;
+  private alignToRightHorizontal;
+  private alignToTopVertical;
+  private alignToCenterVertical;
+  private alignToBottomVertical;
+  private alignNodes;
+  canAlignSelectedNodes(): boolean;
+  trigger(cancelAction: () => void, {
+    alignTo,
+    triggerSelectionTool
+  }: WeaveAlignNodesToolActionTriggerParams): void;
+  cleanup(): void;
+}
+
+//#endregion
+//#region src/actions/comment-tool/constants.d.ts
+//# sourceMappingURL=align-nodes-tool.d.ts.map
+declare const WEAVE_COMMENT_TOOL_ACTION_NAME = "commentTool";
+declare const WEAVE_COMMENT_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly ADDING: "adding";
+  readonly SELECTED_POSITION: "selectedPosition";
+  readonly CREATING_COMMENT: "creatingComment";
+  readonly ADDED: "added";
+};
+declare const WEAVE_COMMENT_TOOL_DEFAULT_CONFIG: {
+  style: {
+    cursor: {
+      add: string;
+      block: string;
+    };
+  };
+};
+
+//#endregion
+//#region src/actions/comment-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveCommentToolActionStateKeys = keyof typeof WEAVE_COMMENT_TOOL_STATE;
+type WeaveCommentToolActionState = (typeof WEAVE_COMMENT_TOOL_STATE)[WeaveCommentToolActionStateKeys];
+type WeaveCommentToolStyle = {
+  cursor: {
+    add: string;
+    block: string;
+  };
+};
+type WeaveCommentToolModel<T> = {
+  getCreateModel: () => DeepPartial<T>;
+};
+type WeaveCommentToolActionConfig<T> = {
+  style: WeaveCommentToolStyle;
+  getUser: () => WeaveUser;
+  getUserBackgroundColor: (user: WeaveUser) => string | CanvasGradient | undefined;
+  getUserForegroundColor: (user: WeaveUser) => string | CanvasGradient | undefined;
+  model: WeaveCommentToolModel<T>;
+};
+type WeaveCommentToolActionParams<T> = {
+  config: Pick<WeaveCommentToolActionConfig<T>, 'model' | 'getUser' | 'getUserBackgroundColor' | 'getUserForegroundColor'> & DeepPartial<Pick<WeaveCommentToolActionConfig<T>, 'style'>>;
+};
+
+//#endregion
+//#region src/actions/comment-tool/comment-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveCommentToolAction<T> extends WeaveAction {
+  private readonly config;
+  protected initialized: boolean;
+  protected state: WeaveCommentToolActionState;
+  protected pointers: Map<number, Konva.Vector2d>;
+  protected commentId: string | null;
+  protected clickPoint: Konva.Vector2d | null;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  constructor(params: WeaveCommentToolActionParams<T>);
+  getName(): string;
+  initProps(): {
+    colorToken: string;
+    width: number;
+    height: number;
+    opacity: number;
+  };
+  extractCursorUrl(cursor: string): string | null;
+  isAllowedUrl(value: string): boolean;
+  preloadCursors(): void;
+  onInit(): void;
+  private setupEvents;
+  private setState;
+  private enableAddingComment;
+  private handleAdding;
+  trigger(cancelAction: () => void): void;
+  cleanup(): void;
+  private getCommentsLayer;
+  private isCommentNode;
+  private setCursor;
+  private setCursorBlock;
+}
+
+//#endregion
+//#region src/actions/video-tool/constants.d.ts
+//# sourceMappingURL=comment-tool.d.ts.map
+declare const VIDEO_TOOL_ACTION_NAME = "videoTool";
+declare const VIDEO_TOOL_STATE: {
+  readonly IDLE: "idle";
+  readonly UPLOADING: "uploading";
+  readonly DEFINING_POSITION: "definingPosition";
+  readonly SELECTED_POSITION: "selectedPosition";
+  readonly ADDING: "adding";
+  readonly FINISHED: "finished";
+};
+
+//#endregion
+//#region src/actions/video-tool/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveVideoToolActionStateKeys = keyof typeof VIDEO_TOOL_STATE;
+type WeaveVideoToolActionState = (typeof VIDEO_TOOL_STATE)[WeaveVideoToolActionStateKeys];
+type WeaveVideoToolDragParams = {
+  placeholderUrl: string;
+  url: string;
+  width: number;
+  height: number;
+};
+type WeaveVideoToolActionTriggerParams = {
+  videoId?: string;
+  videoParams?: WeaveVideoToolDragParams;
+  position?: Konva.Vector2d;
+  forceMainContainer?: boolean;
+};
+type WeaveVideoToolActionTriggerVideoParams = {
+  videoPlaceholderURL: string;
+  videoURL: string;
+};
+type WeaveVideoToolActionTriggerReturn = {
+  finishUploadCallback: (videoParams: WeaveVideoToolDragParams, position?: Konva.Vector2d) => void;
+} | undefined;
+type WeaveVideoToolActionOnAddingEvent = {
+  videoURL: string;
+};
+type WeaveVideoToolActionOnAddedEvent = {
+  videoURL: string;
+  nodeId: string;
+};
+
+//#endregion
+//#region src/actions/video-tool/video-tool.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveVideoToolAction extends WeaveAction {
+  protected initialized: boolean;
+  protected initialCursor: string | null;
+  protected state: WeaveVideoToolActionState;
+  protected cursorPadding: number;
+  protected videoId: string | null;
+  protected container: Konva.Layer | Konva.Node | undefined;
+  protected pointers: Map<number, Konva.Vector2d>;
+  protected videoParams: WeaveVideoToolDragParams | null;
+  protected clickPoint: Konva.Vector2d | null;
+  protected forceMainContainer: boolean;
+  protected cancelAction: () => void;
+  onPropsChange: undefined;
+  update: undefined;
+  constructor();
+  getName(): string;
+  getVideoSource(videoId: string): HTMLVideoElement | undefined;
+  initProps(): {
+    width: number;
+    height: number;
+    scaleX: number;
+    scaleY: number;
+  };
+  onInit(): void;
+  private setupEvents;
+  private setState;
+  private doVideoAdding;
+  private addVideo;
+  private handleAdding;
+  trigger(cancelAction: () => void, params?: WeaveVideoToolActionTriggerParams): WeaveVideoToolActionTriggerReturn;
+  cleanup(): void;
+  private setCursor;
+}
+
+//#endregion
+//#region src/plugins/stage-panning/constants.d.ts
+//# sourceMappingURL=video-tool.d.ts.map
+declare const WEAVE_STAGE_PANNING_KEY = "stagePanning";
+declare const WEAVE_STAGE_PANNING_DEFAULT_CONFIG: {
+  edgePanOffset: number;
+  edgePanSpeed: number;
+};
+
+//#endregion
+//#region src/plugins/stage-minimap/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveStageMinimapPluginStyle = {
+  viewportReference: Konva.RectConfig;
+};
+type WeaveStageMinimapPluginConfig = {
+  getContainer: () => HTMLElement;
+  id: string;
+  width: number;
+  fitToContentPadding: number;
+  style: WeaveStageMinimapPluginStyle;
+};
+type WeaveStageMinimapPluginParams = {
+  config: Pick<WeaveStageMinimapPluginConfig, 'getContainer' | 'id' | 'width' | 'fitToContentPadding'> & DeepPartial<Pick<WeaveStageMinimapPluginConfig, 'style'>>;
+};
+
+//#endregion
+//#region src/plugins/stage-minimap/stage-minimap.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStageMinimapPlugin extends WeavePlugin {
+  getLayerName: undefined;
+  initLayer: undefined;
+  private readonly config;
+  private minimapStage;
+  private minimapLayer;
+  private minimapStageImage;
+  private minimapViewportReference;
+  private initialized;
+  private offscreenWorker;
+  constructor(params: WeaveStageMinimapPluginParams);
+  getName(): string;
+  setupMinimap(): Promise<void>;
+  private updateMinimapContent;
+  private updateMinimapViewportReference;
+  onRender(): void;
+  onInit(): void;
+  private showLayers;
+  private hideLayers;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/stage-minimap/constants.d.ts
+//# sourceMappingURL=stage-minimap.d.ts.map
+declare const WEAVE_STAGE_MINIMAP_KEY = "stageMinimap";
+declare const STAGE_MINIMAP_DEFAULT_CONFIG: {
+  style: {
+    viewportReference: {
+      fill: string;
+      strokeScaleEnabled: boolean;
+      stroke: string;
+      strokeWidth: number;
+    };
+  };
+};
+
+//#endregion
+//#region src/plugins/stage-resize/stage-resize.d.ts
+//# sourceMappingURL=constants.d.ts.map
+declare class WeaveStageResizePlugin extends WeavePlugin {
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  getName(): string;
+  private resizeStage;
+  onInit(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-selection/constants.d.ts
+//# sourceMappingURL=stage-resize.d.ts.map
+declare const WEAVE_NODES_SELECTION_KEY = "nodesSelection";
+declare const WEAVE_NODES_SELECTION_LAYER_ID = "selectionLayer";
+declare const WEAVE_NODES_SELECTION_DEFAULT_CONFIG: {
+  selection: {
+    rotationSnaps: number[];
+    rotationSnapTolerance: number;
+    ignoreStroke: boolean;
+    rotateEnabled: boolean;
+    resizeEnabled: boolean;
+    flipEnabled: boolean;
+    keepRatio: boolean;
+    useSingleNodeRotation: boolean;
+    shouldOverdrawWholeArea: boolean;
+    enabledAnchors: string[];
+    anchorStyleFunc: (anchor: any) => void;
+    borderStroke: string;
+    borderStrokeWidth: number;
+  };
+  hover: {
+    borderStrokeWidth: number;
+  };
+  selectionArea: {
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    dash: number[];
+  };
+  panningWhenSelection: {
+    edgeThreshold: number;
+    minScrollSpeed: number;
+    maxScrollSpeed: number;
+  };
+  behaviors: {
+    singleSelection: {
+      enabled: boolean;
+    };
+    multipleSelection: {
+      enabled: boolean;
+    };
+    onMultipleSelection: () => {
+      resizeEnabled: boolean;
+      rotateEnabled: boolean;
+      enabledAnchors: string[];
+    };
+  };
+};
+
+//#endregion
+//#region src/plugins/connected-users/constants.d.ts
+//# sourceMappingURL=constants.d.ts.map
+declare const WEAVE_CONNECTED_USER_INFO_KEY = "userInfo";
+
+//#endregion
+//#region src/plugins/connected-users/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveConnectedUsersPluginConfig = {
+  getUser: () => WeaveUser;
+};
+type WeaveConnectedUsersPluginParams = {
+  config: WeaveConnectedUsersPluginConfig;
+};
+type WeaveConnectedUsers = {
+  [userName: string]: WeaveUser;
+};
+type WeaveConnectedUsersChangeEvent = WeaveConnectedUsers;
+type WeaveConnectedUserInfoKey = typeof WEAVE_CONNECTED_USER_INFO_KEY;
+
+//#endregion
+//#region src/plugins/connected-users/connected-users.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveConnectedUsersPlugin extends WeavePlugin {
+  private config;
+  private connectedUsers;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  constructor(params: WeaveConnectedUsersPluginParams);
+  getName(): string;
+  onInit(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/users-selection/constants.d.ts
+//# sourceMappingURL=connected-users.d.ts.map
+declare const WEAVE_USERS_SELECTION_KEY = "usersSelection";
+declare const WEAVE_USER_SELECTION_KEY = "userSelection";
+
+//#endregion
+//#region src/plugins/users-selection/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveUsersSelectionPluginConfig = {
+  getUser: () => WeaveUser;
+  getUserColor: (user: WeaveUser) => string | CanvasGradient | undefined;
+};
+type WeaveUsersSelectionPluginParams = {
+  config: WeaveUsersSelectionPluginConfig;
+};
+type WeaveUserSelectionInfo = {
+  rawUser: WeaveUser;
+  user: string;
+  nodes: string[];
+};
+type WeaveUserSelectionKey = typeof WEAVE_USER_SELECTION_KEY;
+
+//#endregion
+//#region src/plugins/users-selection/users-selection.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveUsersSelectionPlugin extends WeavePlugin {
+  private padding;
+  private usersSelection;
+  private config;
+  constructor(params: WeaveUsersSelectionPluginParams);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  onRender(): void;
+  getLayer(): Konva.Layer | undefined;
+  onInit(): void;
+  sendSelectionAwarenessInfo(tr: Konva.Transformer): void;
+  removeSelectionAwarenessInfo(): void;
+  private getSelectedNodesRect;
+  private renderSelectors;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/users-pointers/constants.d.ts
+//# sourceMappingURL=users-selection.d.ts.map
+declare const WEAVE_USERS_POINTERS_KEY = "usersPointers";
+declare const WEAVE_USER_POINTER_KEY = "userPointer";
+declare const WEAVE_DEFAULT_USER_INFO_FUNCTION: () => {
+  name: string;
+  email: string;
+};
+declare const WEAVE_USERS_POINTERS_CONFIG_DEFAULT_PROPS: {
+  awarenessThrottleMs: number;
+  ui: {
+    separation: number;
+    pointer: {
+      circleRadius: number;
+      circleStrokeWidth: number;
+    };
+    name: {
+      fontFamily: string;
+      fontSize: number;
+      backgroundCornerRadius: number;
+      backgroundPaddingX: number;
+      backgroundPaddingY: number;
+    };
+  };
+};
+
+//#endregion
+//#region src/plugins/users-pointers/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveUserPointersUIProperties = {
+  separation: number;
+  pointer: {
+    circleRadius: number;
+    circleStrokeWidth: number;
+  };
+  name: {
+    fontFamily: string;
+    fontSize: number;
+    backgroundCornerRadius: number;
+    backgroundPaddingX: number;
+    backgroundPaddingY: number;
+  };
+};
+type WeaveUsersPointersPluginConfig = {
+  getUser: () => WeaveUser;
+  getUserBackgroundColor: (user: WeaveUser) => string | CanvasGradient | undefined;
+  getUserForegroundColor: (user: WeaveUser) => string | CanvasGradient | undefined;
+  awarenessThrottleMs: number;
+  ui: WeaveUserPointersUIProperties;
+};
+type WeaveUsersPointersPluginParams = {
+  config: Pick<WeaveUsersPointersPluginConfig, 'getUser' | 'getUserBackgroundColor' | 'getUserForegroundColor'> & Partial<Omit<WeaveUsersPointersPluginConfig, 'getUser' | 'getUserBackgroundColor' | 'getUserForegroundColor'>>;
+};
+type WeaveUserPointer = {
+  rawUser: WeaveUser;
+  user: string;
+  name: string;
+  x: number;
+  y: number;
+};
+type WeaveUserPointerKey = typeof WEAVE_USER_POINTER_KEY;
+
+//#endregion
+//#region src/plugins/users-pointers/users-pointers.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveUsersPointersPlugin extends WeavePlugin {
+  private usersPointers;
+  private config;
+  constructor(params: WeaveUsersPointersPluginParams);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  onRender(): void;
+  getLayer(): Konva.Layer | undefined;
+  onInit(): void;
+  private sendAwarenessUpdate;
+  private renderPointers;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/stage-drop-area/stage-drop-area.d.ts
+//# sourceMappingURL=users-pointers.d.ts.map
+declare class WeaveStageDropAreaPlugin extends WeavePlugin {
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  constructor();
+  getName(): string;
+  onInit(): void;
+  private initEvents;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/stage-drop-area/types.d.ts
+//# sourceMappingURL=stage-drop-area.d.ts.map
+type WeaveStageDropPluginOnStageDropEvent = DragEvent;
+
+//#endregion
+//#region src/plugins/copy-paste-nodes/constants.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare const WEAVE_COPY_PASTE_NODES_KEY = "copyPasteNodes";
+declare const WEAVE_COPY_PASTE_PASTE_CATCHER_ID = "weave-paste-catcher";
+declare const WEAVE_COPY_PASTE_PASTE_MODES: {
+  readonly INTERNAL: "internal";
+  readonly EXTERNAL: "external";
+  readonly NOT_ALLOWED: "not-allowed";
+  readonly CLIPBOARD_API_ERROR: "clipboard-api-error";
+  readonly CLIPBOARD_API_NOT_SUPPORTED: "clipboard-api-not-supported";
+};
+declare const COPY_PASTE_NODES_PLUGIN_STATE: {
+  readonly IDLE: "idle";
+  readonly PASTING: "pasting";
+};
+declare const WEAVE_COPY_PASTE_CONFIG_DEFAULT: {
+  readonly paddingOnPaste: {
+    readonly enabled: false;
+    readonly paddingX: 0;
+    readonly paddingY: 0;
+  };
+};
+
+//#endregion
+//#region src/plugins/copy-paste-nodes/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveCopyPasteNodesPluginStateKeys = keyof typeof COPY_PASTE_NODES_PLUGIN_STATE;
+type WeaveCopyPasteNodesPluginState = (typeof COPY_PASTE_NODES_PLUGIN_STATE)[WeaveCopyPasteNodesPluginStateKeys];
+type WeaveCopyPasteNodesPluginOnCopyEvent = {
+  error?: Error;
+} | undefined;
+type WeaveCopyPasteNodesPluginOnPasteEvent = {
+  error?: Error;
+  pastedNodes?: string[];
+};
+type WeaveCopyPasteNodesPluginOnPasteExternalEvent = {
+  items?: ClipboardItems;
+  dataList?: DataTransferItemList;
+  positionCalculated: boolean;
+  position: Konva.Vector2d;
+};
+type WeaveCopyPastePasteModeKeys = keyof typeof WEAVE_COPY_PASTE_PASTE_MODES;
+type WeaveCopyPastePasteMode = (typeof WEAVE_COPY_PASTE_PASTE_MODES)[WeaveCopyPastePasteModeKeys];
+type WeavePasteModel = {
+  weaveInstanceId: string;
+  weave: Record<string, {
+    element: WeaveStateElement;
+    posRelativeToSelection: Konva.Vector2d;
+    containerId: string;
+  }>;
+  weaveMinPoint: Konva.Vector2d;
+};
+type WeaveToPasteNode = {
+  konvaNode: Konva.Node;
+  node: NodeSerializable;
+};
+type PaddingOnPaste = {
+  enabled: boolean;
+  paddingX: number;
+  paddingY: number;
+};
+type WeaveCopyPasteNodesPluginConfig = {
+  paddingOnPaste: PaddingOnPaste;
+};
+type WeaveCopyPasteNodesPluginParams = {
+  config?: Partial<WeaveCopyPasteNodesPluginConfig>;
+};
+
+//#endregion
+//#region src/plugins/copy-paste-nodes/copy-paste-nodes.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveCopyPasteNodesPlugin extends WeavePlugin {
+  protected state: WeaveCopyPasteNodesPluginState;
+  private readonly config;
+  private lastInternalPasteSnapshot;
+  private actualInternalPaddingX;
+  private actualInternalPaddingY;
+  private toPaste;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  constructor(params?: Partial<WeaveCopyPasteNodesPluginParams>);
+  getName(): string;
+  onInit(): void;
+  private writeClipboardData;
+  private existsPasteCatcher;
+  private createPasteCatcher;
+  private getCatcherElement;
+  private focusPasteCatcher;
+  private checkIfInternalElementsAreNew;
+  private updateInternalPastePadding;
+  initEvents(): void;
+  private sendExternalPasteEvent;
+  private isWeaveData;
+  private mapToPasteNodes;
+  private setState;
+  private recursivelyUpdateKeys;
+  private handlePaste;
+  private performCopy;
+  copy(): Promise<void>;
+  paste(position?: Konva.Vector2d, relativePosition?: Konva.Vector2d): Promise<void>;
+  getSelectedNodes(): WeaveToPasteNode[];
+  isPasting(): boolean;
+  private cancel;
+  private getNodesSelectionPlugin;
+  isClipboardApiEnabled(): boolean;
+  getAvailablePasteMode(canHandleExternal: (items: ClipboardItems) => Promise<boolean>): Promise<WeaveCopyPastePasteMode>;
+  enable(): void;
+  disable(): void;
+  isClipboardAPIAvailable(): boolean;
+  detectBrowser(): {
+    isSafari: boolean;
+    isFirefox: boolean;
+    isChrome: boolean;
+    isEdge: boolean;
+    isIOS: boolean;
+  };
+  getStageGridPlugin(): WeaveStageGridPlugin | undefined;
+}
+
+//#endregion
+//#region src/plugins/comments-renderer/types.d.ts
+//# sourceMappingURL=copy-paste-nodes.d.ts.map
+type WeaveCommentsRendererModel<T> = {
+  getId: (comment: T) => string;
+  getUser: (comment: T) => WeaveUser;
+  getPosition: (comment: T) => Konva.Vector2d;
+  getStatus: (comment: T) => WeaveCommentStatus;
+};
+type WeaveCommentsRendererPluginConfig<T> = {
+  model: WeaveCommentsRendererModel<T>;
+  getUser: () => WeaveUser;
+  getUserBackgroundColor: (user: WeaveUser) => string | CanvasGradient | undefined;
+  getUserForegroundColor: (user: WeaveUser) => string | CanvasGradient | undefined;
+};
+type WeaveCommentsRendererPluginParams<T> = {
+  config: WeaveCommentsRendererPluginConfig<T>;
+};
+
+//#endregion
+//#region src/plugins/comments-renderer/comments-renderer.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveCommentsRendererPlugin<T> extends WeavePlugin {
+  private readonly config;
+  private comments;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  constructor(params: WeaveCommentsRendererPluginParams<T>);
+  getName(): string;
+  onInit(): void;
+  setComments(comments: T[]): void;
+  private initCommentsLayer;
+  deleteComments(): void;
+  render(): void;
+  getCommentsLayer(): konva_lib_Layer7.Layer;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/comments-renderer/constants.d.ts
+//# sourceMappingURL=comments-renderer.d.ts.map
+declare const WEAVE_COMMENTS_RENDERER_KEY = "commentsRenderer";
+declare const WEAVE_COMMENTS_TOOL_LAYER_ID = "commentsLayer";
+
+//#endregion
+//#region src/plugins/stage-keyboard-move/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveMoveOrientation = 'up' | 'down' | 'left' | 'right';
+type WeaveStageKeyboardMovePluginConfig = {
+  movementDelta: number;
+};
+type WeaveStageKeyboardMovePluginParams = {
+  config?: WeaveStageKeyboardMovePluginConfig;
+};
+
+//#endregion
+//#region src/plugins/stage-keyboard-move/stage-keyboard-move.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStageKeyboardMovePlugin extends WeavePlugin {
+  private config;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  constructor(params?: WeaveStageKeyboardMovePluginParams);
+  getName(): string;
+  handleNodesMovement(movementOrientation: WeaveMoveOrientation): void;
+  onInit(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/stage-keyboard-move/constants.d.ts
+//# sourceMappingURL=stage-keyboard-move.d.ts.map
+declare const WEAVE_STAGE_KEYBOARD_MOVE_KEY = "stageKeyboardMove";
+declare const WEAVE_STAGE_KEYBOARD_MOVE_DEFAULT_CONFIG: {
+  movementDelta: number;
+};
+
+//#endregion
+//# sourceMappingURL=constants.d.ts.map
+
+export { ALIGN_NODES_ALIGN_TO, ALIGN_NODES_TOOL_ACTION_NAME, ALIGN_NODES_TOOL_STATE, ARROW_TOOL_ACTION_NAME, ARROW_TOOL_STATE, BRUSH_TOOL_ACTION_NAME, BRUSH_TOOL_DEFAULT_CONFIG, BRUSH_TOOL_STATE, COPY_PASTE_NODES_PLUGIN_STATE, CanvasFontDefinition, CanvasFonts, DistanceInfoH, DistanceInfoV, ELLIPSE_TOOL_ACTION_NAME, ELLIPSE_TOOL_STATE, ERASER_TOOL_ACTION_NAME, ERASER_TOOL_STATE, FRAME_TOOL_ACTION_NAME, FRAME_TOOL_STATE, GUIDE_DISTANCE_LINE_DEFAULT_CONFIG, GUIDE_ENTER_SNAPPING_TOLERANCE, GUIDE_EXIT_SNAPPING_TOLERANCE, GUIDE_HORIZONTAL_LINE_NAME, GUIDE_LINE_DEFAULT_CONFIG, GUIDE_LINE_DRAG_SNAPPING_THRESHOLD, GUIDE_LINE_NAME, GUIDE_LINE_TRANSFORM_SNAPPING_THRESHOLD, GUIDE_ORIENTATION, GUIDE_VERTICAL_LINE_NAME, Guide, GuideOrientation, GuideOrientationKeys, IMAGE_TOOL_ACTION_NAME, IMAGE_TOOL_STATE, ImageOptions, ImageProps, LineGuide, LineGuideStop, MOVE_TOOL_ACTION_NAME, MOVE_TOOL_STATE, NODE_SNAP, NODE_SNAP_HORIZONTAL, NODE_SNAP_VERTICAL, NodeSnap, NodeSnapHorizontal, NodeSnapHorizontalKeys, NodeSnapKeys, NodeSnapVertical, NodeSnapVerticalKeys, NodeSnappingEdge, NodeSnappingEdges, PEN_TOOL_ACTION_NAME, PEN_TOOL_STATE, PaddingOnPaste, RECTANGLE_TOOL_ACTION_NAME, RECTANGLE_TOOL_STATE, REGULAR_POLYGON_TOOL_ACTION_NAME, REGULAR_POLYGON_TOOL_STATE, RenderWeaveRoom, SELECTION_TOOL_ACTION_NAME, SELECTION_TOOL_STATE, STAGE_MINIMAP_DEFAULT_CONFIG, STAR_TOOL_ACTION_NAME, STAR_TOOL_STATE, SkiaFontDefinition, SkiaFonts, TEXT_LAYOUT, TEXT_TOOL_ACTION_NAME, TEXT_TOOL_STATE, TextSerializable, VIDEO_TOOL_ACTION_NAME, VIDEO_TOOL_STATE, VideoBackgroundStyle, VideoIconBackgroundStyle, VideoIconStyle, VideoProps, VideoStyle, VideoTrackStyle, WEAVE_ARROW_NODE_TYPE, WEAVE_COMMENTS_RENDERER_KEY, WEAVE_COMMENTS_TOOL_LAYER_ID, WEAVE_COMMENT_CREATE_ACTION, WEAVE_COMMENT_NODE_ACTION, WEAVE_COMMENT_NODE_DEFAULTS, WEAVE_COMMENT_NODE_TYPE, WEAVE_COMMENT_STATUS, WEAVE_COMMENT_TOOL_ACTION_NAME, WEAVE_COMMENT_TOOL_DEFAULT_CONFIG, WEAVE_COMMENT_TOOL_STATE, WEAVE_COMMENT_VIEW_ACTION, WEAVE_COPY_PASTE_CONFIG_DEFAULT, WEAVE_COPY_PASTE_NODES_KEY, WEAVE_COPY_PASTE_PASTE_CATCHER_ID, WEAVE_COPY_PASTE_PASTE_MODES, WEAVE_DEFAULT_USER_INFO_FUNCTION, WEAVE_ELLIPSE_NODE_TYPE, WEAVE_FRAME_DEFAULT_BACKGROUND_COLOR, WEAVE_FRAME_NODE_DEFAULT_CONFIG, WEAVE_FRAME_NODE_DEFAULT_PROPS, WEAVE_FRAME_NODE_TYPE, WEAVE_GRID_DEFAULT_COLOR, WEAVE_GRID_DEFAULT_DOT_MAX_DOTS_PER_AXIS, WEAVE_GRID_DEFAULT_MAJOR_DOT_RATIO, WEAVE_GRID_DEFAULT_MAJOR_EVERY, WEAVE_GRID_DEFAULT_MAJOR_LINE_RATIO, WEAVE_GRID_DEFAULT_ORIGIN_COLOR, WEAVE_GRID_DEFAULT_RADIUS, WEAVE_GRID_DEFAULT_SIZE, WEAVE_GRID_DEFAULT_STROKE, WEAVE_GRID_DEFAULT_TYPE, WEAVE_GRID_LAYER_ID, WEAVE_GRID_TYPES, WEAVE_GROUP_NODE_TYPE, WEAVE_IMAGE_CROP_END_TYPE, WEAVE_IMAGE_DEFAULT_CONFIG, WEAVE_IMAGE_NODE_TYPE, WEAVE_LAYER_NODE_TYPE, WEAVE_LINE_NODE_TYPE, WEAVE_NODES_DISTANCE_SNAPPING_PLUGIN_KEY, WEAVE_NODES_EDGE_SNAPPING_PLUGIN_KEY, WEAVE_NODES_SELECTION_DEFAULT_CONFIG, WEAVE_NODES_SELECTION_KEY, WEAVE_NODES_SELECTION_LAYER_ID, WEAVE_RECTANGLE_NODE_TYPE, WEAVE_REGULAR_POLYGON_NODE_TYPE, WEAVE_STAGE_DEFAULT_MODE, WEAVE_STAGE_GRID_PLUGIN_KEY, WEAVE_STAGE_KEYBOARD_MOVE_DEFAULT_CONFIG, WEAVE_STAGE_KEYBOARD_MOVE_KEY, WEAVE_STAGE_MINIMAP_KEY, WEAVE_STAGE_NODE_TYPE, WEAVE_STAGE_PANNING_DEFAULT_CONFIG, WEAVE_STAGE_PANNING_KEY, WEAVE_STAR_NODE_TYPE, WEAVE_STROKE_NODE_DEFAULT_CONFIG, WEAVE_STROKE_NODE_TYPE, WEAVE_TEXT_NODE_TYPE, WEAVE_USERS_POINTERS_CONFIG_DEFAULT_PROPS, WEAVE_USERS_POINTERS_KEY, WEAVE_USERS_SELECTION_KEY, WEAVE_USER_POINTER_KEY, WEAVE_USER_SELECTION_KEY, WEAVE_VIDEO_DEFAULT_CONFIG, WEAVE_VIDEO_NODE_TYPE, Weave, WeaveAction, WeaveActionPropsChangeEvent, WeaveAlignNodesToolAction, WeaveAlignNodesToolActionAlignTo, WeaveAlignNodesToolActionAlignToKeys, WeaveAlignNodesToolActionState, WeaveAlignNodesToolActionStateKeys, WeaveAlignNodesToolActionTriggerParams, WeaveArrowNode, WeaveArrowNodeParams, WeaveArrowProperties, WeaveArrowToolAction, WeaveArrowToolActionOnAddedEvent, WeaveArrowToolActionOnAddingEvent, WeaveArrowToolActionState, WeaveArrowToolActionStateKeys, WeaveBrushToolAction, WeaveBrushToolActionOnAddedEvent, WeaveBrushToolActionOnAddingEvent, WeaveBrushToolActionParams, WeaveBrushToolActionProperties, WeaveBrushToolActionState, WeaveBrushToolActionStateKeys, WeaveCommentNode, WeaveCommentNodeAction, WeaveCommentNodeActionKeys, WeaveCommentNodeConfig, WeaveCommentNodeCreateAction, WeaveCommentNodeCreateActionKeys, WeaveCommentNodeModel, WeaveCommentNodeOnCreateCommentEvent, WeaveCommentNodeOnDragEndEvent, WeaveCommentNodeOnFinishCreateEvent, WeaveCommentNodeOnViewEvent, WeaveCommentNodeParams, WeaveCommentNodeStyle, WeaveCommentNodeViewAction, WeaveCommentNodeViewActionKeys, WeaveCommentStatus, WeaveCommentStatusKeys, WeaveCommentToolAction, WeaveCommentToolActionConfig, WeaveCommentToolActionParams, WeaveCommentToolActionState, WeaveCommentToolActionStateKeys, WeaveCommentToolModel, WeaveCommentToolStyle, WeaveCommentsRendererModel, WeaveCommentsRendererPlugin, WeaveCommentsRendererPluginConfig, WeaveCommentsRendererPluginParams, WeaveConnectedUserInfoKey, WeaveConnectedUsers, WeaveConnectedUsersChangeEvent, WeaveConnectedUsersPlugin, WeaveConnectedUsersPluginConfig, WeaveConnectedUsersPluginParams, WeaveContextMenuPlugin, WeaveCopyPasteNodesPlugin, WeaveCopyPasteNodesPluginConfig, WeaveCopyPasteNodesPluginOnCopyEvent, WeaveCopyPasteNodesPluginOnPasteEvent, WeaveCopyPasteNodesPluginOnPasteExternalEvent, WeaveCopyPasteNodesPluginParams, WeaveCopyPasteNodesPluginState, WeaveCopyPasteNodesPluginStateKeys, WeaveCopyPastePasteMode, WeaveCopyPastePasteModeKeys, WeaveEllipseNode, WeaveEllipseNodeParams, WeaveEllipseProperties, WeaveEllipseToolAction, WeaveEllipseToolActionOnAddedEvent, WeaveEllipseToolActionOnAddingEvent, WeaveEllipseToolActionState, WeaveEllipseToolActionStateKeys, WeaveEraserToolAction, WeaveEraserToolActionState, WeaveEraserToolActionStateKeys, WeaveExportNodesActionParams, WeaveExportNodesToolAction, WeaveExportStageActionParams, WeaveExportStageToolAction, WeaveFitToScreenToolAction, WeaveFitToScreenToolActionParams, WeaveFitToSelectionToolAction, WeaveFitToSelectionToolActionParams, WeaveFrameAttributes, WeaveFrameNode, WeaveFrameNodeParams, WeaveFrameProperties, WeaveFrameToolAction, WeaveFrameToolActionOnAddedEvent, WeaveFrameToolActionOnAddingEvent, WeaveFrameToolActionState, WeaveFrameToolActionStateKeys, WeaveFrameToolActionTriggerParams, WeaveFrameToolProps, WeaveGroupNode, WeaveGroupNodeParams, WeaveGroupProperties, WeaveImageCropEndType, WeaveImageCropEndTypeKeys, WeaveImageNode, WeaveImageNodeParams, WeaveImageOnCropEndEvent, WeaveImageOnCropStartEvent, WeaveImageProperties, WeaveImageState, WeaveImageToolAction, WeaveImageToolActionOnAddedEvent, WeaveImageToolActionOnAddingEvent, WeaveImageToolActionOnEndLoadImageEvent, WeaveImageToolActionOnStartLoadImageEvent, WeaveImageToolActionState, WeaveImageToolActionStateKeys, WeaveImageToolActionTriggerParams, WeaveImageToolActionTriggerReturn, WeaveLayerNode, WeaveLineNode, WeaveLineNodeParams, WeaveLineProperties, WeaveMoveToolAction, WeaveMoveToolActionParams, WeaveMoveToolActionState, WeaveMoveToolActionStateKeys, WeaveNode, WeaveNodesDistanceSnappingPlugin, WeaveNodesDistanceSnappingPluginConfig, WeaveNodesDistanceSnappingPluginParams, WeaveNodesDistanceSnappingUIConfig, WeaveNodesEdgeSnappingPlugin, WeaveNodesEdgeSnappingPluginConfig, WeaveNodesEdgeSnappingPluginParams, WeaveNodesSelectionBehaviorsConfig, WeaveNodesSelectionConfig, WeaveNodesSelectionOnSelectionParams, WeaveNodesSelectionPanningOnSelectionConfig, WeaveNodesSelectionPlugin, WeaveNodesSelectionPluginConfig, WeaveNodesSelectionPluginOnNodesChangeEvent, WeaveNodesSelectionPluginOnSelectionStateEvent, WeaveNodesSelectionPluginOnStageSelectionEvent, WeaveNodesSelectionPluginParams, WeavePasteModel, WeavePenToolAction, WeavePenToolActionOnAddedEvent, WeavePenToolActionOnAddingEvent, WeavePenToolActionState, WeavePenToolActionStateKeys, WeavePlugin, WeaveRectangleNode, WeaveRectangleNodeParams, WeaveRectangleProperties, WeaveRectangleToolAction, WeaveRectangleToolActionOnAddedEvent, WeaveRectangleToolActionOnAddingEvent, WeaveRectangleToolActionState, WeaveRectangleToolActionStateKeys, WeaveRegularPolygonNode, WeaveRegularPolygonNodeParams, WeaveRegularPolygonProperties, WeaveRegularPolygonToolAction, WeaveRegularPolygonToolActionOnAddedEvent, WeaveRegularPolygonToolActionOnAddingEvent, WeaveRegularPolygonToolActionState, WeaveRegularPolygonToolActionStateKeys, WeaveSelectionToolAction, WeaveSelectionToolActionState, WeaveSelectionToolActionStateKeys, WeaveStageContextMenuPluginConfig, WeaveStageContextMenuPluginOnNodeContextMenuEvent, WeaveStageContextMenuPluginParams, WeaveStageDropAreaPlugin, WeaveStageDropPluginOnStageDropEvent, WeaveStageGridPlugin, WeaveStageGridPluginConfig, WeaveStageGridPluginParams, WeaveStageGridType, WeaveStageGridTypeKeys, WeaveStageKeyboardMovePlugin, WeaveStageMinimapPlugin, WeaveStageMinimapPluginConfig, WeaveStageMinimapPluginParams, WeaveStageMinimapPluginStyle, WeaveStageNode, WeaveStagePanningPlugin, WeaveStagePanningPluginConfig, WeaveStagePanningPluginParams, WeaveStageResizePlugin, WeaveStageZoomChanged, WeaveStageZoomPlugin, WeaveStageZoomPluginConfig, WeaveStageZoomPluginOnZoomChangeEvent, WeaveStageZoomPluginParams, WeaveStageZoomType, WeaveStageZoomTypeKeys, WeaveStarNode, WeaveStarNodeParams, WeaveStarProperties, WeaveStarToolAction, WeaveStarToolActionOnAddedEvent, WeaveStarToolActionOnAddingEvent, WeaveStarToolActionState, WeaveStarToolActionStateKeys, WeaveStore, WeaveStoreOnNodeChangeEvent, WeaveStoreOnRoomLoadedEvent, WeaveStoreOnStateChangeEvent, WeaveStoreOnUndoRedoChangeEvent, WeaveStrokeNode, WeaveStrokeNodeParams, WeaveStrokePoint, WeaveStrokeProperties, WeaveTextLayout, WeaveTextLayoutKeys, WeaveTextNode, WeaveTextNodeParams, WeaveTextProperties, WeaveTextToolAction, WeaveTextToolActionOnAddedEvent, WeaveTextToolActionOnAddingEvent, WeaveTextToolActionState, WeaveTextToolActionStateKeys, WeaveToPasteNode, WeaveUserPointer, WeaveUserPointerKey, WeaveUserPointersUIProperties, WeaveUserSelectionInfo, WeaveUserSelectionKey, WeaveUsersPointersPlugin, WeaveUsersPointersPluginConfig, WeaveUsersPointersPluginParams, WeaveUsersSelectionPlugin, WeaveUsersSelectionPluginConfig, WeaveUsersSelectionPluginParams, WeaveVideoNode, WeaveVideoNodeParams, WeaveVideoOnVideoPauseEvent, WeaveVideoOnVideoPlayEvent, WeaveVideoOnVideoStopEvent, WeaveVideoProperties, WeaveVideoState, WeaveVideoToolAction, WeaveVideoToolActionOnAddedEvent, WeaveVideoToolActionOnAddingEvent, WeaveVideoToolActionState, WeaveVideoToolActionStateKeys, WeaveVideoToolActionTriggerParams, WeaveVideoToolActionTriggerReturn, WeaveVideoToolActionTriggerVideoParams, WeaveVideoToolDragParams, WeaveZoomInToolAction, WeaveZoomInToolActionParams, WeaveZoomOutToolAction, WeaveZoomOutToolActionParams, canComposite, clearContainerTargets, containerOverCursor, containsNodeDeep, getBoundingBox, getExportBoundingBox, getPositionRelativeToContainerOnPosition, getSelectedNodesMetadata, getTargetAndSkipNodes, getTargetedNode, getTopmostShadowHost, getVisibleNodes, getVisibleNodesInViewport, hasFrames, hasImages, intersectArrays, isIOS, isInShadowDOM, isNodeInSelection, isServer, memoize, mergeExceptArrays, moveNodeToContainer, registerCanvasFonts, registerSkiaFonts, resetScale };
+//# sourceMappingURL=sdk.node.d.ts.map