@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/_vendor/canvas-react/host/domEventGuards.d.ts

@@ -0,0 +1,11 @@
+import { type CanvasDomEventGuard, type CanvasDomEventGuardCursorInput, type CanvasDomEventGuardInput, type LandCanvasPlugin } from "./canvasPlugin";
+export declare class CanvasDomEventGuardRegistry {
+    private readonly guards;
+    private readonly registeredGuardIds;
+    register(guard: CanvasDomEventGuard): void;
+    registerCanvasPlugins(plugins: readonly LandCanvasPlugin[]): void;
+    getGuards(): readonly CanvasDomEventGuard[];
+    handle(input: CanvasDomEventGuardInput): "continue" | "handled";
+    getCursor(input: CanvasDomEventGuardCursorInput): string | undefined;
+}
+export declare function createCanvasDomEventGuardRegistry(plugins?: readonly LandCanvasPlugin[]): CanvasDomEventGuardRegistry;

package/_vendor/canvas-react/host/extension.d.ts

@@ -0,0 +1,37 @@
+import type { LandEditorPlugin, ShapeRecordBase } from "../../canvas-core/index";
+import type { LandCanvasPlugin } from "./canvasPlugin";
+type LandExtensionOptions = Record<string, unknown>;
+export interface LandFeatureBundle {
+    id: string;
+    editorPlugins: readonly LandEditorPlugin[];
+    canvasPlugins: readonly LandCanvasPlugin[];
+    shapeTypes: readonly ShapeRecordBase["type"][];
+}
+export interface LandExtension {
+    readonly name: string;
+    readonly options: Readonly<LandExtensionOptions>;
+    readonly priority: number;
+    createFeature(): LandFeatureBundle | null;
+    getExtensions(): readonly LandExtension[];
+}
+export type LandExtensionOptionsInput<T> = T extends readonly unknown[] ? T : T extends LandExtensionOptions ? {
+    [K in keyof T]?: LandExtensionOptionsInput<T[K]>;
+} : T;
+export interface ConfigurableLandExtension<Options extends LandExtensionOptions> extends LandExtension {
+    readonly options: Readonly<Options>;
+    configure(options?: LandExtensionOptionsInput<Options>): ConfigurableLandExtension<Options>;
+}
+export interface LandExtensionConfig<Options extends LandExtensionOptions> {
+    name: string;
+    priority?: number;
+    addOptions?(): Options;
+    addExtensions?(options: Readonly<Options>): readonly LandExtension[];
+    createFeature?(options: Readonly<Options>): LandFeatureBundle;
+}
+export interface ResolvedLandExtension {
+    extension: LandExtension;
+    feature: LandFeatureBundle | null;
+}
+export declare function defineLandExtension<Options extends LandExtensionOptions = Record<string, never>>(config: LandExtensionConfig<Options>): ConfigurableLandExtension<Options>;
+export declare function resolveLandExtensions(extensions: readonly LandExtension[]): ResolvedLandExtension[];
+export {};

package/_vendor/canvas-react/host/index.d.ts

@@ -0,0 +1,13 @@
+export { CanvasRendererRegistryContext, useCanvasRendererRegistry, } from "./canvasRendererRegistryContext";
+export { CanvasOverlayRegistryContext, useCanvasOverlayRegistry, } from "./canvasOverlayRegistryContext";
+export { CanvasDomEventGuardRegistry, createCanvasDomEventGuardRegistry, } from "./domEventGuards";
+export { CanvasOverlayRegistry, createCanvasOverlayRegistry, } from "./overlayRegistry";
+export { CanvasRendererRegistry, createCanvasRendererRegistry, } from "./rendererRegistry";
+export { CanvasToolbarRegistry, createCanvasToolbarRegistry, } from "./toolbarRegistry";
+export { CanvasContextMenuRegistry, createCanvasContextMenuRegistry, } from "./contextMenuRegistry";
+export type { AnyRegisteredSelectionCustomHandleRenderer, AnyRegisteredShapeRenderer, CanvasOverlayContribution, CanvasOverlayLayer, CanvasDomEventGuard, CanvasDomEventGuardCursorInput, CanvasDomEventGuardDecision, CanvasDomEventGuardInput, CanvasDomEventGuardName, CanvasPluginComponent, CanvasPluginProvider, LandCanvasPlugin, RegisteredSelectionCustomHandleRenderer, RegisteredShapeRenderer, SelectionCustomHandleRendererProps, ShapeRendererProps, } from "./canvasPlugin";
+export { getShapeStrokeForHover, SHAPE_HOVER_STROKE, } from "./canvasPlugin";
+export { defineLandExtension, resolveLandExtensions, } from "./extension";
+export type { ConfigurableLandExtension, LandExtension, LandExtensionConfig, LandExtensionOptionsInput, LandFeatureBundle, ResolvedLandExtension, } from "./extension";
+export { createCanvasPluginHostRuntime } from "./pluginHost";
+export type { CanvasPluginHostManifestContextMenuContributionEntry, CanvasPluginHostManifestEntry, CanvasPluginHostManifestToolbarContributionEntry, CanvasPluginHostRuntime, CanvasPluginHostShapeValidationSummary, CanvasPluginHostSource, CanvasPluginHostValidationIssue, CanvasPluginHostValidationIssueSeverity, CanvasPluginHostValidationSummary, CanvasPluginHostVerdict, CreateCanvasPluginHostRuntimeOptions, } from "./pluginHost";

package/_vendor/canvas-react/host/overlayRegistry.d.ts

@@ -0,0 +1,18 @@
+import type { SelectionCustomHandle } from "../../canvas-core/index";
+import type { AnyRegisteredSelectionCustomHandleRenderer, CanvasOverlayContribution, CanvasOverlayLayer, LandCanvasPlugin, RegisteredSelectionCustomHandleRenderer } from "./canvasPlugin";
+export declare class CanvasOverlayRegistry {
+    private readonly selectionCustomHandleRenderers;
+    private readonly canvasOverlays;
+    private readonly registeredPluginIds;
+    registerCanvasOverlay(overlay: CanvasOverlayContribution): void;
+    getCanvasOverlay(id: string): CanvasOverlayContribution | null;
+    hasCanvasOverlay(id: string): boolean;
+    getCanvasOverlays(layer?: CanvasOverlayLayer): CanvasOverlayContribution[];
+    getRegisteredCanvasOverlayIds(): string[];
+    registerSelectionCustomHandleRenderer<H extends SelectionCustomHandle>(renderer: RegisteredSelectionCustomHandleRenderer<H>): void;
+    getSelectionCustomHandleRenderer(type: SelectionCustomHandle["type"]): AnyRegisteredSelectionCustomHandleRenderer | null;
+    hasSelectionCustomHandleRenderer(type: SelectionCustomHandle["type"]): boolean;
+    getRegisteredSelectionCustomHandleTypes(): SelectionCustomHandle["type"][];
+    registerCanvasPlugins(plugins: readonly LandCanvasPlugin[]): void;
+}
+export declare function createCanvasOverlayRegistry(plugins?: readonly LandCanvasPlugin[]): CanvasOverlayRegistry;

package/_vendor/canvas-react/host/pluginHost.d.ts

@@ -0,0 +1,2 @@
+export { createCanvasPluginHostRuntime } from "./pluginHostRuntime";
+export type { CanvasPluginHostManifestContextMenuContributionEntry, CanvasPluginHostManifestEntry, CanvasPluginHostManifestToolbarContributionEntry, CanvasPluginHostRuntime, CanvasPluginHostShapeValidationSummary, CanvasPluginHostSource, CanvasPluginHostValidationIssue, CanvasPluginHostValidationIssueSeverity, CanvasPluginHostValidationSummary, CanvasPluginHostVerdict, CreateCanvasPluginHostRuntimeOptions, } from "./pluginHostTypes";

package/_vendor/canvas-react/host/pluginHostManifest.d.ts

@@ -0,0 +1,2 @@
+import type { CanvasPluginHostManifestEntry, ResolvedCanvasFeature } from "./pluginHostTypes";
+export declare function getManifestEntryFromFeature(resolvedFeature: ResolvedCanvasFeature): CanvasPluginHostManifestEntry;

package/_vendor/canvas-react/host/pluginHostRuntime.d.ts

@@ -0,0 +1,3 @@
+import { type LandExtension } from "./extension";
+import type { CanvasPluginHostRuntime, CreateCanvasPluginHostRuntimeOptions } from "./pluginHostTypes";
+export declare function createCanvasPluginHostRuntime(extensions: readonly LandExtension[], options?: CreateCanvasPluginHostRuntimeOptions): CanvasPluginHostRuntime;

package/_vendor/canvas-react/host/pluginHostTypes.d.ts

@@ -0,0 +1,102 @@
+import type { LandEditorPlugin, ShapeCapabilitySupport } from "../../canvas-core/index";
+import type { CanvasPluginComponent, CanvasPluginProvider, LandCanvasPlugin } from "./canvasPlugin";
+import type { CanvasContextMenuRegistry } from "./contextMenuRegistry";
+import type { CanvasDomEventGuardRegistry } from "./domEventGuards";
+import type { LandFeatureBundle } from "./extension";
+import type { CanvasOverlayRegistry } from "./overlayRegistry";
+import type { CanvasRendererRegistry } from "./rendererRegistry";
+import type { CanvasToolbarRegistry } from "./toolbarRegistry";
+export type CanvasPluginHostSource = "built-in" | "dev-sample";
+export type CanvasPluginHostVerdict = "pass" | "fail";
+export interface CreateCanvasPluginHostRuntimeOptions {
+    knownHostActionIds?: readonly string[];
+    source?: CanvasPluginHostSource;
+}
+export interface CanvasPluginHostManifestEntry {
+    id: string;
+    extensionName: string;
+    source: CanvasPluginHostSource;
+    editorPluginIds: string[];
+    canvasPluginIds: string[];
+    interactionHandlerIds: string[];
+    canvasActionIds: string[];
+    toolbarContributionIds: string[];
+    toolbarContributions: CanvasPluginHostManifestToolbarContributionEntry[];
+    contextMenuContributionIds: string[];
+    contextMenuContributions: CanvasPluginHostManifestContextMenuContributionEntry[];
+    domEventGuardIds: string[];
+    canvasOverlayIds: string[];
+    selectionCustomHandleRendererTypes: string[];
+    canvasProviderIds: string[];
+    canvasComponentIds: string[];
+    shapeTypes: string[];
+}
+export interface CanvasPluginHostManifestToolbarContributionEntry {
+    id: string;
+    surface: string;
+    placement: string;
+    actionIds: string[];
+}
+export interface CanvasPluginHostManifestContextMenuContributionEntry {
+    id: string;
+    target: string;
+    actionIds: string[];
+}
+export interface CanvasPluginHostRuntime {
+    editorPlugins: LandEditorPlugin[];
+    canvasPlugins: LandCanvasPlugin[];
+    canvasProviders: CanvasPluginProvider[];
+    canvasComponents: CanvasPluginComponent[];
+    rendererRegistry: CanvasRendererRegistry;
+    overlayRegistry: CanvasOverlayRegistry;
+    domEventGuardRegistry: CanvasDomEventGuardRegistry;
+    toolbarRegistry: CanvasToolbarRegistry;
+    contextMenuRegistry: CanvasContextMenuRegistry;
+    manifest: CanvasPluginHostManifestEntry[];
+    validation: CanvasPluginHostValidationSummary;
+    externalPluginIds: string[];
+}
+export type CanvasPluginHostValidationIssueSeverity = "error" | "warning";
+export interface CanvasPluginHostValidationIssue {
+    severity: CanvasPluginHostValidationIssueSeverity;
+    code: "duplicate-feature-id" | "duplicate-editor-plugin-id" | "duplicate-canvas-plugin-id" | "duplicate-interaction-handler-id" | "duplicate-canvas-action-id" | "duplicate-toolbar-contribution-id" | "duplicate-context-menu-contribution-id" | "duplicate-dom-event-guard-id" | "duplicate-canvas-overlay-id" | "duplicate-selection-custom-handle-renderer" | "duplicate-canvas-provider-id" | "duplicate-canvas-component-id" | "missing-canvas-action" | "missing-context-menu-action" | "missing-editor-plugin" | "missing-canvas-plugin" | "missing-shape-type" | "missing-shape-capability" | "missing-shape-util" | "missing-svg-exporter" | "missing-canvas-renderer";
+    featureId: string | null;
+    pluginId: string | null;
+    shapeType: string | null;
+    message: string;
+}
+export interface CanvasPluginHostShapeValidationSummary {
+    featureId: string;
+    shapeType: string;
+    hasCapability: boolean;
+    hasShapeUtil: boolean;
+    hasSvgExporter: boolean;
+    hasCanvasRenderer: boolean;
+    exportSupport: ShapeCapabilitySupport | null;
+}
+export interface CanvasPluginHostValidationSummary {
+    verdict: CanvasPluginHostVerdict;
+    issueCount: number;
+    errorCount: number;
+    warningCount: number;
+    issues: CanvasPluginHostValidationIssue[];
+    featureIds: string[];
+    editorPluginIds: string[];
+    canvasPluginIds: string[];
+    interactionHandlerIds: string[];
+    canvasActionIds: string[];
+    toolbarContributionIds: string[];
+    contextMenuContributionIds: string[];
+    domEventGuardIds: string[];
+    canvasOverlayIds: string[];
+    selectionCustomHandleRendererTypes: string[];
+    canvasProviderIds: string[];
+    canvasComponentIds: string[];
+    registeredRendererTypes: string[];
+    shapeSummaries: CanvasPluginHostShapeValidationSummary[];
+}
+export interface ResolvedCanvasFeature {
+    extensionName: string;
+    feature: LandFeatureBundle;
+    source: CanvasPluginHostSource;
+}

package/_vendor/canvas-react/host/pluginHostValidation.d.ts

@@ -0,0 +1,11 @@
+import type { LandEditorPlugin } from "../../canvas-core/index";
+import type { LandCanvasPlugin } from "./canvasPlugin";
+import type { CanvasRendererRegistry } from "./rendererRegistry";
+import type { CanvasPluginHostValidationSummary, ResolvedCanvasFeature } from "./pluginHostTypes";
+export declare function validateCanvasPluginHost({ editorPlugins, canvasPlugins, knownHostActionIds, rendererRegistry, resolvedFeatures, }: {
+    editorPlugins: readonly LandEditorPlugin[];
+    canvasPlugins: readonly LandCanvasPlugin[];
+    knownHostActionIds: readonly string[];
+    rendererRegistry: CanvasRendererRegistry;
+    resolvedFeatures: readonly ResolvedCanvasFeature[];
+}): CanvasPluginHostValidationSummary;

package/_vendor/canvas-react/host/rendererRegistry.d.ts

@@ -0,0 +1,12 @@
+import type { ShapeRecordBase } from "../../canvas-core/index";
+import type { AnyRegisteredShapeRenderer, LandCanvasPlugin, RegisteredShapeRenderer } from "./canvasPlugin";
+export declare class CanvasRendererRegistry {
+    private readonly registry;
+    private readonly registeredPluginIds;
+    registerShapeRenderer<S extends ShapeRecordBase>(renderer: RegisteredShapeRenderer<S>): void;
+    getShapeRenderer(type: ShapeRecordBase["type"]): AnyRegisteredShapeRenderer | null;
+    hasShapeRenderer(type: ShapeRecordBase["type"]): boolean;
+    getRegisteredShapeTypes(): ShapeRecordBase["type"][];
+    registerCanvasPlugins(plugins: readonly LandCanvasPlugin[]): void;
+}
+export declare function createCanvasRendererRegistry(plugins?: readonly LandCanvasPlugin[]): CanvasRendererRegistry;

package/_vendor/canvas-react/host/toolbarRegistry.d.ts

@@ -0,0 +1,24 @@
+import type { LandEditorPlugin, CanvasAction, CanvasActionContext, ToolbarContribution, ToolbarGroup, ToolbarPlacement, ToolbarSurface } from "../../canvas-core/index";
+export declare class CanvasToolbarRegistry {
+    private readonly actions;
+    private readonly contributions;
+    private readonly hostActionIds;
+    private readonly duplicateActionIds;
+    private readonly duplicateContributionIds;
+    registerAction(action: CanvasAction, options?: {
+        replace?: boolean;
+    }): void;
+    registerHostAction(action: CanvasAction): void;
+    registerContribution(contribution: ToolbarContribution, options?: {
+        replace?: boolean;
+    }): void;
+    registerEditorPlugins(plugins: readonly LandEditorPlugin[]): void;
+    getAction(actionId: string): CanvasAction | null;
+    getHostActionIds(): string[];
+    getDuplicateActionIds(): string[];
+    getDuplicateContributionIds(): string[];
+    getGroups(surface: ToolbarSurface, context: CanvasActionContext, options?: {
+        placement?: ToolbarPlacement;
+    }): ToolbarGroup[];
+}
+export declare function createCanvasToolbarRegistry(plugins?: readonly LandEditorPlugin[]): CanvasToolbarRegistry;

package/_vendor/canvas-react/index.d.ts

@@ -0,0 +1,4 @@
+export { Canvas, PageSpace } from "./components";
+export { CANVAS_SURFACE_DATA_UI, CANVAS_SURFACE_SELECTOR, forwardWheelEventToCanvasSurface, getCanvasSurfaceElement, getCanvasSurfaceElementForNode, getCanvasSurfacePagePoint, getCanvasSurfaceScreenPoint, getEditableEventTarget, isEditableEventTarget, } from "./dom";
+export { useEditor, EditorContext } from "./hooks/useEditor";
+export { useValue } from "./hooks/useValue";

package/_vendor/plugin-arrow/arrowBindingAnchors.d.ts

@@ -0,0 +1,5 @@
+import { Vec, type Editor, type ShapeRecord } from "../canvas-core/index";
+import type { ArrowPoint } from "./types";
+export declare function getArrowBindingAnchorPagePoint(editor: Editor, target: ShapeRecord, normalizedAnchor: ArrowPoint): Vec;
+export declare function getArrowBindingNormalizedAnchor(editor: Editor, target: ShapeRecord, rawPagePoint: Vec): ArrowPoint;
+export declare function resolveArrowBindingPagePoint(editor: Editor, target: ShapeRecord, normalizedAnchor: ArrowPoint, oppositePagePoint: Vec): Vec;

package/_vendor/plugin-arrow/arrowBindingGeometry.d.ts

@@ -0,0 +1,28 @@
+import { Vec, type Editor, type SelectionBindingSegment, type ShapeRecord } from "../canvas-core/index";
+import { type ArrowInfo } from "./arrowGeometry";
+import { type ArrowShapeRecord, type ArrowTerminal } from "./types";
+export interface ResolvedArrowPageGeometry {
+    info: ArrowInfo;
+    fullInfo: ArrowInfo;
+    bindingSegments: SelectionBindingSegment[];
+}
+export interface ArrowTerminalBindingGuide {
+    terminal: ArrowTerminal;
+    anchorPagePoint: Vec;
+    boundaryPagePoint: Vec;
+    guidePath: string | null;
+}
+export declare function getArrowTerminalHandlePagePoint(editor: Editor, arrow: ArrowShapeRecord, terminal: ArrowTerminal): Vec;
+export declare function getArrowBendReferencePagePoints(editor: Editor, shape: ArrowShapeRecord): {
+    start: Vec;
+    end: Vec;
+};
+export declare function getResolvedArrowPageGeometry(editor: Editor, shape: ArrowShapeRecord): ResolvedArrowPageGeometry;
+export declare function getResolvedArrowLocalInfo(editor: Editor, shape: ArrowShapeRecord): ArrowInfo;
+export declare function getArrowTerminalBindingGuide(editor: Editor, { arrow, terminal, target, anchorPagePoint, fallbackBoundaryPagePoint, }: {
+    arrow: ArrowShapeRecord;
+    terminal: ArrowTerminal;
+    target: ShapeRecord;
+    anchorPagePoint: Vec;
+    fallbackBoundaryPagePoint: Vec;
+}): ArrowTerminalBindingGuide;

package/_vendor/plugin-arrow/arrowBindingUtil.d.ts

@@ -0,0 +1,27 @@
+import { BindingUtil, type BindingUtilEffect, type Editor, type ShapeRecord } from "../canvas-core/index";
+import { type ArrowBindingRecord } from "./types";
+export declare class ArrowBindingUtil extends BindingUtil<ArrowBindingRecord> {
+    readonly type: "arrow";
+    getDefaultProps(): ArrowBindingRecord["props"];
+    validateProps(props: unknown): ArrowBindingRecord["props"];
+    canBind(_editor: Editor, _binding: ArrowBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }): boolean;
+    getExclusiveBindingKey(binding: ArrowBindingRecord): string;
+    onBindingCreate(editor: Editor, binding: ArrowBindingRecord): BindingUtilEffect | void;
+    onBindingUpdate(editor: Editor, _before: ArrowBindingRecord, after: ArrowBindingRecord): BindingUtilEffect | void;
+    onBindingLoad(editor: Editor, binding: ArrowBindingRecord): BindingUtilEffect | void;
+    getGeometryDependentShapeIds(_editor: Editor, binding: ArrowBindingRecord, context: {
+        role: "from" | "to";
+    }): ShapeRecord["id"][];
+    onAfterShapeChange(editor: Editor, binding: ArrowBindingRecord, _context: {
+        role: "from" | "to";
+    }): BindingUtilEffect | void;
+    onBeforeDeleteShape(editor: Editor, binding: ArrowBindingRecord, context: {
+        role: "from" | "to";
+    }): BindingUtilEffect | void;
+    onBeforeDeleteBinding(editor: Editor, binding: ArrowBindingRecord): BindingUtilEffect | void;
+    private syncArrowTerminal;
+    private resolveTerminalPagePoint;
+}

package/_vendor/plugin-arrow/arrowGeometry.d.ts

@@ -0,0 +1,74 @@
+import { Box, Vec } from "../canvas-core/index";
+import type { ArrowShapeProps, ArrowShapeRecord, ArrowTerminal } from "./types";
+export declare const ARROW_CURVE_EPSILON = 0.000001;
+export interface ArrowInfoTerminal {
+    terminal: ArrowTerminal;
+    point: Vec;
+    handle: Vec;
+}
+export interface StraightArrowInfo {
+    type: "straight";
+    start: ArrowInfoTerminal;
+    end: ArrowInfoTerminal;
+    middle: Vec;
+    arc: null;
+    bend: number;
+    points: Vec[];
+    bounds: Box;
+    path: string;
+}
+export interface CurvedArrowInfo {
+    type: "curved";
+    start: ArrowInfoTerminal;
+    end: ArrowInfoTerminal;
+    middle: Vec;
+    arc: ArrowArcInfo;
+    bend: number;
+    points: Vec[];
+    bounds: Box;
+    path: string;
+}
+export type ArrowInfo = StraightArrowInfo | CurvedArrowInfo;
+export interface ArrowArcInfo {
+    center: Vec;
+    radius: number;
+    largeArcFlag: 0 | 1;
+    sweepFlag: 0 | 1;
+    size: number;
+    length: number;
+}
+export declare function getArrowTerminalPagePoint(shape: ArrowShapeRecord, terminal: ArrowTerminal): Vec;
+export declare function getOppositeArrowTerminal(terminal: ArrowTerminal): ArrowTerminal;
+export declare function withArrowPagePoints(shape: ArrowShapeRecord, start: Vec, end: Vec): ArrowShapeRecord;
+export declare function setArrowTerminalPagePoint(shape: ArrowShapeRecord, terminal: ArrowTerminal, pagePoint: Vec): ArrowShapeRecord;
+export declare function normalizeArrowShapePoints(start: Vec, end: Vec): Pick<ArrowShapeProps, "w" | "h" | "start" | "end"> & {
+    x: number;
+    y: number;
+};
+export declare function getArrowInfo(shape: ArrowShapeRecord): ArrowInfo;
+export declare function getArrowLocalInfo(shape: ArrowShapeRecord): ArrowInfo;
+export declare function getArrowBendFromMiddlePagePoint(start: Vec, end: Vec, point: Vec): number;
+export declare function getArrowHitDistance(info: ArrowInfo, point: Vec): number;
+export declare function getArrowInfoFromPoints(start: Vec, end: Vec, rawBend: unknown): ArrowInfo;
+export declare function getArrowInfoFromArc({ start, end, middle, bend, arc, startHandle, endHandle, }: {
+    start: Vec;
+    end: Vec;
+    middle: Vec;
+    bend: number;
+    arc: Pick<ArrowArcInfo, "center" | "radius" | "sweepFlag">;
+    startHandle?: Vec;
+    endHandle?: Vec;
+}): ArrowInfo;
+export declare function getArrowArcMeasure(start: Vec, end: Vec, arc: Pick<ArrowArcInfo, "center" | "sweepFlag">): number;
+export declare function getArrowArcPointAt(start: Vec, end: Vec, arc: Pick<ArrowArcInfo, "center" | "radius" | "sweepFlag">, t: number): Vec;
+export declare function getArrowTerminalGuidePath({ terminal, handlePagePoint, boundaryPagePoint, fullInfo, }: {
+    terminal: ArrowTerminal;
+    handlePagePoint: Vec;
+    boundaryPagePoint: Vec;
+    fullInfo: Extract<ArrowInfo, {
+        type: "curved";
+    }>;
+}): string | null;
+export declare function getArrowArcBoundaryPointForOutline(outline: readonly Vec[], fullInfo: Extract<ArrowInfo, {
+    type: "curved";
+}>, role: ArrowTerminal): Vec | null;

package/_vendor/plugin-arrow/arrowShapeUtil.d.ts

@@ -0,0 +1,21 @@
+import { Box, ShapeUtil, Vec, type ShapeBrushWrapInput, type ShapeGeometryInput, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeLineSegmentHitTestInput, type ShapeSelectionOverlayInfo, type ShapeSelectionOverlayInfoInput, type ShapeSelectionPagePointsInput, type ShapeSelectionPagePoints, type ShapePointHitTestInput, type ShapeUpdate } from "../canvas-core/index";
+import { type ArrowShapeProps, type ArrowShapeRecord } from "./types";
+export declare class ArrowShapeUtil extends ShapeUtil<ArrowShapeRecord> {
+    readonly type: "arrow";
+    getDefaultProps(): ArrowShapeProps;
+    validateProps(props: unknown): ArrowShapeProps;
+    getBounds(shape: ArrowShapeRecord): Box;
+    getPointHitTestBounds(shape: ArrowShapeRecord, input?: ShapeGeometryInput): Box;
+    getLocalBounds(shape: ArrowShapeRecord): Box;
+    getExportBounds(shape: ArrowShapeRecord): Box;
+    repairLoadedShape(shape: ArrowShapeRecord): ArrowShapeRecord | null;
+    updateSelectionPagePoints(shape: ArrowShapeRecord, input: ShapeSelectionPagePointsInput): ShapeUpdate;
+    isWrappedByBrush(shape: ArrowShapeRecord, input: ShapeBrushWrapInput): boolean;
+    getSelectionPagePoints(shape: ArrowShapeRecord): ShapeSelectionPagePoints;
+    contributesToSelectionFrame(_shape: ArrowShapeRecord): boolean;
+    canStartTranslateFromSelectionBounds(_shape: ArrowShapeRecord): boolean;
+    getSelectionHandleAnchors(shape: ArrowShapeRecord, input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+    getSelectionOverlayInfo(shape: ArrowShapeRecord, input: ShapeSelectionOverlayInfoInput): ShapeSelectionOverlayInfo;
+    hitTest(shape: ArrowShapeRecord, point: Vec, input?: ShapePointHitTestInput): boolean;
+    hitTestLineSegment(shape: ArrowShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
+}

package/_vendor/plugin-arrow/arrowTerminalBindingResolver.d.ts

@@ -0,0 +1,20 @@
+import { Vec, type Editor, type ResolvedTerminalBinding, type ShapeId } from "../canvas-core/index";
+import { type ArrowShapeRecord } from "./types";
+export declare function resolveArrowTerminalBindingAtPoint(editor: Editor, { terminal, rawPagePoint, oppositePagePoint, excludeShapeId, ignoreTargets, }: {
+    terminal: "start" | "end";
+    rawPagePoint: Vec;
+    oppositePagePoint: Vec;
+    excludeShapeId?: ShapeId;
+    ignoreTargets?: boolean;
+}): ResolvedTerminalBinding;
+export declare function resolveArrowTerminalBindingAtStartPoint(editor: Editor, { terminal, rawPagePoint, ignoreTargets, }: {
+    terminal: "start" | "end";
+    rawPagePoint: Vec;
+    ignoreTargets?: boolean;
+}): ResolvedTerminalBinding;
+export declare function resolveArrowTerminalBindingForArrow(editor: Editor, { arrow, terminal, rawPagePoint, ignoreTargets, }: {
+    arrow: ArrowShapeRecord;
+    terminal: "start" | "end";
+    rawPagePoint: Vec;
+    ignoreTargets?: boolean;
+}): ResolvedTerminalBinding;

package/_vendor/plugin-arrow/arrowTerminalCommands.d.ts

@@ -0,0 +1,12 @@
+import { Vec, type ChangeSource, type Editor, type PageId, type ResolvedTerminalBinding, type ShapeId, type TerminalBindingTargetInput } from "../canvas-core/index";
+import { type ArrowShapeRecord, type ArrowShapeProps, type ArrowTerminal } from "./types";
+export interface CreateArrowInput {
+    startPagePoint: Vec;
+    endPagePoint: Vec;
+    startBinding?: TerminalBindingTargetInput | null;
+    endBinding?: TerminalBindingTargetInput | null;
+    props?: Partial<ArrowShapeProps>;
+    parentId?: PageId;
+}
+export declare function createArrow(editor: Editor, input: CreateArrowInput, source?: ChangeSource): ArrowShapeRecord;
+export declare function applyResolvedTerminalBinding(editor: Editor, shapeId: ShapeId | null, terminal: ArrowTerminal, resolvedBinding: ResolvedTerminalBinding, source?: ChangeSource): ArrowShapeRecord | null;

package/_vendor/plugin-arrow/arrowTool.d.ts

@@ -0,0 +1,4 @@
+import { StateNode, type Editor } from "../canvas-core/index";
+export declare class ArrowTool extends StateNode {
+    constructor(editor: Editor);
+}

package/_vendor/plugin-arrow/canvas.d.ts

@@ -0,0 +1,2 @@
+import { type LandCanvasPlugin } from "../canvas-react/host/index";
+export declare function createArrowCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-arrow/editor.d.ts

@@ -0,0 +1,7 @@
+import { type LandEditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
+import type { ArrowShapeRecord } from "./types";
+export declare class ArrowShapeSvgExporter implements ShapeSvgExporter<ArrowShapeRecord> {
+    readonly type: "arrow";
+    toSvg(shape: ArrowShapeRecord, context: SvgExportContext): SvgNode;
+}
+export declare function createArrowEditorPlugin(): LandEditorPlugin;

package/_vendor/plugin-arrow/feature.d.ts

@@ -0,0 +1,3 @@
+import { type LandFeatureBundle } from "../canvas-react/host/index";
+export declare function createArrowFeatureBundle(): LandFeatureBundle;
+export declare const Arrow: import("../canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>;

package/_vendor/plugin-arrow/index.d.ts

@@ -0,0 +1,12 @@
+export { ArrowBindingUtil } from "./arrowBindingUtil";
+export { ArrowShapeUtil } from "./arrowShapeUtil";
+export { ArrowTool } from "./arrowTool";
+export { ArrowShapeSvgExporter, createArrowEditorPlugin } from "./editor";
+export { createArrowCanvasPlugin } from "./canvas";
+export { Arrow, createArrowFeatureBundle } from "./feature";
+export { isArrowBindingRecord, isArrowShapeRecord, type ArrowBindingProps, type ArrowBindingRecord, type ArrowPoint, type ArrowShapeProps, type ArrowShapeRecord, type ArrowTerminal, } from "./types";
+export { getArrowBindingAnchorPagePoint, resolveArrowBindingPagePoint, } from "./arrowBindingAnchors";
+export { resolveArrowTerminalBindingAtPoint, resolveArrowTerminalBindingAtStartPoint, resolveArrowTerminalBindingForArrow, } from "./arrowTerminalBindingResolver";
+export { createArrow } from "./arrowTerminalCommands";
+export { getArrowTerminalPagePoint } from "./arrowGeometry";
+export { createArrowInteractionHandler, createArrowSelectionHandleInteractionHandler, } from "./selectionHandleInteractions";

package/_vendor/plugin-arrow/selectionHandleInteractions.d.ts

@@ -0,0 +1,3 @@
+import { type LandInteractionHandler, type SelectionHandleInteractionHandler } from "../canvas-core/index";
+export declare function createArrowSelectionHandleInteractionHandler(): SelectionHandleInteractionHandler;
+export declare function createArrowInteractionHandler(): LandInteractionHandler;

package/_vendor/plugin-arrow/types.d.ts

@@ -0,0 +1,31 @@
+import type { BaseRecord, BindingRecordBase, ShapeColor, ShapeRecordBase } from "../canvas-core/index";
+export interface ArrowPoint {
+    x: number;
+    y: number;
+}
+export type ArrowTerminal = "start" | "end";
+export interface ArrowShapeProps {
+    w: number;
+    h: number;
+    start: ArrowPoint;
+    end: ArrowPoint;
+    bend: number;
+    stroke: ShapeColor;
+    strokeWidth: number;
+    headStart: "none" | "arrow";
+    headEnd: "none" | "arrow";
+}
+export interface ArrowShapeRecord extends ShapeRecordBase<"arrow", ArrowShapeProps> {
+    type: "arrow";
+    props: ArrowShapeProps;
+}
+export interface ArrowBindingProps {
+    terminal: ArrowTerminal;
+    normalizedAnchor: ArrowPoint;
+}
+export interface ArrowBindingRecord extends BindingRecordBase<"arrow", ArrowBindingProps> {
+    type: "arrow";
+    props: ArrowBindingProps;
+}
+export declare function isArrowShapeRecord(record: BaseRecord | null | undefined): record is ArrowShapeRecord;
+export declare function isArrowBindingRecord(record: BaseRecord | null | undefined): record is ArrowBindingRecord;

package/_vendor/plugin-draw/DrawShapeRenderer.d.ts

@@ -0,0 +1,10 @@
+import { type ShapeColor } from "../canvas-core/index";
+import type { DrawShapeRecord } from "./types";
+interface DrawShapeSvgProps {
+    shape: DrawShapeRecord;
+    isHovered?: boolean;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+}
+export declare function DrawShapeSvg({ shape, isHovered, stroke, strokeWidth, }: DrawShapeSvgProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/_vendor/plugin-draw/canvas.d.ts

@@ -0,0 +1,2 @@
+import type { LandCanvasPlugin } from "../canvas-react/host/index";
+export declare function createDrawCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-draw/drawGeometry.d.ts

@@ -0,0 +1,45 @@
+import { Box, Vec } from "../canvas-core/index";
+import { type DrawSelectionFlipInput, type DrawSelectionResizeInput } from "./drawSelectionTransform";
+import { getDrawPointGeometry, getDrawSegmentGeometry, type DrawShapeGeometry, type DrawShapeSamplingStats } from "./drawShapeGeometry";
+import type { DrawShapePoint, DrawShapeRecord, DrawShapeSegment } from "./types";
+export { getDrawPointGeometry, getDrawSegmentGeometry };
+export type { DrawShapeGeometry, DrawShapeSamplingStats, } from "./drawShapeGeometry";
+type DrawLocalGeometryCacheKey = Pick<DrawShapeRecord, "props">;
+type DrawPositionedGeometryCacheKey = Pick<DrawShapeRecord, "x" | "y" | "props">;
+type DrawPageGeometryCacheKey = Pick<DrawShapeRecord, "x" | "y" | "rotation" | "scaleX" | "scaleY" | "props">;
+export interface DrawShapeDiagnostics extends DrawShapeSamplingStats {
+    hasPath: boolean;
+    hasSelectionPath: boolean;
+    outlineVertexCount: number;
+}
+export interface NormalizedDrawShape {
+    x: number;
+    y: number;
+    segments: DrawShapeSegment[];
+    pointBounds: Box;
+    localBounds: Box;
+    renderBounds: Box;
+    path: string | null;
+    selectionPath: string | null;
+    fillPath: string | null;
+    outlineVertices: Vec[];
+    outlinePolygons: Vec[][];
+    sampling: DrawShapeSamplingStats;
+}
+export declare function getDrawShapeLocalGeometry(shape: DrawLocalGeometryCacheKey): DrawShapeGeometry;
+export declare function normalizeDrawShapeFromSegmentSet(segments: readonly DrawShapeSegment[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function normalizeDrawShapeFromPointSet(points: readonly DrawShapePoint[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function normalizeDrawShapeFromPagePoints(pagePoints: readonly DrawShapePoint[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function normalizeDrawShapeFromPageSegments(pageSegments: readonly DrawShapeSegment[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function getDrawShapePositionedSegments(shape: Pick<DrawShapeRecord, "x" | "y" | "props">): DrawShapeSegment[];
+export declare function getDrawShapePositionedPoints(shape: Pick<DrawShapeRecord, "x" | "y" | "props">): DrawShapePoint[];
+export declare function getDrawShapePositionedGeometry(shape: DrawPositionedGeometryCacheKey): DrawShapeGeometry;
+export declare function getDrawShapePagePoints(shape: DrawShapeRecord): DrawShapePoint[];
+export declare function getDrawShapePageSegments(shape: DrawShapeRecord): DrawShapeSegment[];
+export declare function normalizeTransformedDrawShape(shape: DrawShapeRecord): NormalizedDrawShape;
+export declare function getDrawShapePageGeometry(shape: DrawPageGeometryCacheKey): DrawShapeGeometry;
+export declare function resizeDrawShapeToSelectionBounds(shape: DrawShapeRecord, input: DrawSelectionResizeInput): NormalizedDrawShape;
+export declare function flipDrawShapeInSelectionBounds(shape: DrawShapeRecord, input: DrawSelectionFlipInput): NormalizedDrawShape;
+export declare function resizeDrawShapeToPageBounds(shape: Pick<DrawShapeRecord, "x" | "y" | "props">, nextPageBounds: Box): NormalizedDrawShape;
+export declare function cloneDrawShapeSegmentsForUpdate(segments: readonly DrawShapeSegment[]): DrawShapeSegment[];
+export declare function getDrawShapeDiagnostics(shape: DrawLocalGeometryCacheKey): DrawShapeDiagnostics;

package/_vendor/plugin-draw/drawHitTest.d.ts

@@ -0,0 +1,11 @@
+import { Vec, type ShapeColor } from "../canvas-core/index";
+import type { DrawShapeGeometry } from "./drawShapeGeometry";
+interface DrawShapeHitTestOptions {
+    fill?: ShapeColor;
+    isClosed?: boolean;
+}
+export declare function hitTestDrawShapeGeometry(geometry: Pick<DrawShapeGeometry, "outlinePolygons" | "outlineVertices" | "normalizedPoints">, strokeWidth: number, point: Vec, options?: DrawShapeHitTestOptions): boolean;
+export declare function hitTestDrawShapeLineSegmentGeometry(geometry: Pick<DrawShapeGeometry, "outlinePolygons" | "outlineVertices" | "normalizedPoints">, strokeWidth: number, start: Vec, end: Vec, options?: DrawShapeHitTestOptions & {
+    margin?: number;
+}): boolean;
+export {};

package/_vendor/plugin-draw/drawInterpolation.d.ts

@@ -0,0 +1,5 @@
+import type { DrawShapeRecord } from "./types";
+export interface DrawShapeInterpolationOptions {
+    pointCount?: number;
+}
+export declare function interpolateDrawShapeRecords(from: DrawShapeRecord, to: DrawShapeRecord, t: number, options?: DrawShapeInterpolationOptions): DrawShapeRecord;