@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/_vendor/canvas-core/editor/selection.d.ts

@@ -0,0 +1,231 @@
+import { Box } from "../geometry/box";
+import { Vec } from "../geometry/vec";
+import type { ConnectionTerminal } from "../bindings/terminalBinding";
+import type { ShapeId, ShapeRecord } from "../schema/records";
+export type SelectionResizeHandleId = "top_left" | "top" | "top_right" | "right" | "bottom_right" | "bottom" | "bottom_left" | "left";
+export type SelectionRotateHandleId = "top_left_rotate" | "top_right_rotate" | "bottom_right_rotate" | "bottom_left_rotate";
+export interface SelectionResizeHandle {
+    kind: "resize";
+    id: SelectionResizeHandleId;
+    point: Vec;
+    bounds: Box;
+}
+export interface SelectionRotateHandle {
+    kind: "rotate";
+    id: SelectionRotateHandleId;
+    point: Vec;
+    bounds: Box;
+}
+export interface SelectionBindingTerminalHandle {
+    kind: "binding_terminal";
+    terminal: ConnectionTerminal;
+    point: Vec;
+    bounds: Box;
+}
+export interface SelectionBindingMiddleHandle {
+    kind: "binding_middle";
+    point: Vec;
+    bounds: Box;
+}
+export interface SelectionCustomHandle {
+    kind: "custom";
+    type: string;
+    id: string;
+    point: Vec;
+    bounds: Box;
+    cursor?: string;
+}
+export interface SelectionResizeHandleAnchor {
+    kind: "resize";
+    id: SelectionResizeHandleId;
+    point: Vec;
+}
+export interface SelectionRotateHandleAnchor {
+    kind: "rotate";
+    id: SelectionRotateHandleId;
+    point: Vec;
+}
+export interface SelectionBindingTerminalHandleAnchor {
+    kind: "binding_terminal";
+    terminal: ConnectionTerminal;
+    point: Vec;
+}
+export interface SelectionBindingMiddleHandleAnchor {
+    kind: "binding_middle";
+    point: Vec;
+}
+export interface SelectionCustomHandleAnchor {
+    kind: "custom";
+    type: string;
+    id: string;
+    point: Vec;
+    cursor?: string;
+}
+export interface SelectionRotationTransform {
+    rotation: number;
+    rotationCenter: Vec;
+}
+export interface SelectionFrame extends SelectionRotationTransform {
+    bounds: Box;
+    hasCompatibleRotation: boolean;
+}
+export interface SelectionResizeShapeSnapshot {
+    shape: ShapeRecord;
+    localBounds: Box;
+    rotation: number;
+}
+export interface SelectionResizePointShapeSnapshot {
+    shape: ShapeRecord;
+    startLocalPagePoint: Vec;
+    endLocalPagePoint: Vec;
+}
+export interface SelectionRotateShapeSnapshot {
+    id: ShapeId;
+    x: number;
+    y: number;
+    localBounds: Box;
+    rotation: number;
+}
+export interface SelectionRotatePointShapeSnapshot {
+    shape: ShapeRecord;
+    startPagePoint: Vec;
+    endPagePoint: Vec;
+}
+export interface SelectionResizeSnapshot extends SelectionRotationTransform {
+    startBounds: Box;
+    aspectRatio: number;
+    shapes: SelectionResizeShapeSnapshot[];
+    pointShapes: SelectionResizePointShapeSnapshot[];
+}
+export interface SelectionRotateSnapshot {
+    center: Vec;
+    initialSelectionRotation: number;
+    shapes: SelectionRotateShapeSnapshot[];
+    pointShapes: SelectionRotatePointShapeSnapshot[];
+}
+export type SelectionMirrorAxis = "horizontal" | "vertical";
+export type SelectionHandle = SelectionResizeHandle | SelectionRotateHandle | SelectionBindingTerminalHandle | SelectionBindingMiddleHandle | SelectionCustomHandle;
+export interface BindingPreviewState {
+    terminal: ConnectionTerminal;
+    targetShapeId: ShapeId;
+    resolvedPagePoint: Vec;
+    rawPagePoint: Vec;
+    guidePath?: string | null;
+}
+export interface SelectionBindingSegment {
+    terminal: ConnectionTerminal;
+    anchorPagePoint: Vec;
+    boundaryPagePoint: Vec;
+    guidePath?: string | null;
+}
+export interface PointSnapIndicatorState {
+    id: string;
+    type: "points";
+    axis: "x" | "y";
+    line: [Vec, Vec];
+    points: Vec[];
+    rotation: number;
+    rotationCenter: Vec;
+}
+export interface GapSnapIndicatorGapState {
+    startEdge: [Vec, Vec];
+    endEdge: [Vec, Vec];
+}
+export interface GapSnapIndicatorState {
+    id: string;
+    type: "gaps";
+    direction: "horizontal" | "vertical";
+    gaps: GapSnapIndicatorGapState[];
+    rotation: number;
+    rotationCenter: Vec;
+}
+export type SnapIndicatorState = PointSnapIndicatorState | GapSnapIndicatorState;
+export interface SelectionOverlayState {
+    bounds: Box;
+    rotation: number;
+    rotationCenter: Vec;
+    resizeHandles: SelectionResizeHandle[];
+    rotateHandles: SelectionRotateHandle[];
+    terminalHandles: SelectionBindingTerminalHandle[];
+    middleHandles: SelectionBindingMiddleHandle[];
+    customHandles: SelectionCustomHandle[];
+    strokeWidth: number;
+    cornerRadius: number;
+}
+export interface SelectionOverlayFrameState {
+    bounds: Box;
+    rotation: number;
+    rotationCenter: Vec;
+    strokeWidth: number;
+    cornerRadius: number;
+}
+export interface SelectionOverlayFrameGeometryState {
+    bounds: Box;
+    rotation: number;
+    rotationCenter: Vec;
+}
+export interface SelectionOverlayFrameStyleState {
+    strokeWidth: number;
+    cornerRadius: number;
+}
+export interface SelectionOverlayHandlesState {
+    resizeHandles: SelectionResizeHandle[];
+    rotateHandles: SelectionRotateHandle[];
+    terminalHandles: SelectionBindingTerminalHandle[];
+    middleHandles: SelectionBindingMiddleHandle[];
+    customHandles: SelectionCustomHandle[];
+    strokeWidth: number;
+}
+export interface SelectionOverlayHandleAnchorsState {
+    resizeHandleAnchors: SelectionResizeHandleAnchor[];
+    rotateHandleAnchors: SelectionRotateHandleAnchor[];
+    terminalHandleAnchors: SelectionBindingTerminalHandleAnchor[];
+    middleHandleAnchors: SelectionBindingMiddleHandleAnchor[];
+    customHandleAnchors: SelectionCustomHandleAnchor[];
+}
+export interface SelectionOverlayHandleCountsState {
+    resizeHandleCount: number;
+    rotateHandleCount: number;
+    terminalHandleCount: number;
+    middleHandleCount: number;
+    customHandleCount: number;
+}
+export declare function selectionPagePointToLocalPoint(point: Vec, transform: SelectionRotationTransform): Vec;
+export declare function selectionLocalPointToPagePoint(point: Vec, transform: SelectionRotationTransform): Vec;
+export declare function rotateSelectionPagePoint(point: Vec, transform: SelectionRotationTransform): Vec;
+export declare function mapSelectionLocalPointBetweenBounds({ point, fromBounds, toBounds, }: {
+    point: Vec;
+    fromBounds: Box;
+    toBounds: Box;
+}): Vec;
+export declare function mapSelectionLocalBoundsBetweenBounds({ bounds, fromBounds, toBounds, }: {
+    bounds: Box;
+    fromBounds: Box;
+    toBounds: Box;
+}): Box;
+export declare function mirrorSelectionLocalPoint({ axis, bounds, point, }: {
+    axis: SelectionMirrorAxis;
+    bounds: Box;
+    point: Vec;
+}): Vec;
+export declare function flipSelectionLocalBounds({ axis, bounds, selectionBounds, }: {
+    axis: SelectionMirrorAxis;
+    bounds: Box;
+    selectionBounds: Box;
+}): Box;
+export declare function getSelectionLocalBoundsFromPagePoints({ points, transform, }: {
+    points: readonly Vec[];
+    transform: SelectionRotationTransform;
+}): Box | null;
+export declare function getSelectionResizeSnapshot({ shapes, selectionFrame, getShapeSelectionResizePageOutlineVertices, getShapeSelectionPagePoints, }: {
+    shapes: ShapeRecord[];
+    selectionFrame: SelectionFrame;
+    getShapeSelectionResizePageOutlineVertices: (shape: ShapeRecord) => Vec[];
+    getShapeSelectionPagePoints: (shape: ShapeRecord) => readonly [Vec, Vec] | null;
+}): SelectionResizeSnapshot;
+export declare function getSelectionRotateSnapshot({ shapes, selectionFrame, getShapeLocalBounds, getShapeSelectionPagePoints, }: {
+    shapes: ShapeRecord[];
+    selectionFrame: SelectionFrame;
+    getShapeLocalBounds: (shape: ShapeRecord) => Box;
+    getShapeSelectionPagePoints: (shape: ShapeRecord) => readonly [Vec, Vec] | null;
+}): SelectionRotateSnapshot;

package/_vendor/canvas-core/editor/selectionHandleInteractions.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from "./editor";
+import type { InteractionHandlerRegistry } from "./interactions";
+import type { SelectionHandleInteractionHandler, SelectionHandleInteractionInput, SelectionHandleInteractionSession } from "./interactions";
+export type { SelectionHandleInteractionHandler, SelectionHandleInteractionInput, SelectionHandleInteractionSession, } from "./interactions";
+export declare class SelectionHandleInteractionRegistry {
+    private readonly interactions?;
+    private readonly handlers;
+    constructor(interactions?: InteractionHandlerRegistry | undefined);
+    register(handler: SelectionHandleInteractionHandler): void;
+    createSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
+}

package/_vendor/canvas-core/editor/selectionOverlay.d.ts

@@ -0,0 +1,33 @@
+import { Vec } from "../geometry/vec";
+import type { ShapeId, ShapeRecord } from "../schema/records";
+import type { ShapeSelectionHandleAnchors } from "../shapes/shapeUtil";
+import type { SelectionBindingMiddleHandle, SelectionBindingSegment, SelectionBindingTerminalHandle, SelectionCustomHandle, SelectionFrame, SelectionOverlayFrameGeometryState, SelectionOverlayFrameState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandleCountsState, SelectionOverlayHandlesState, SelectionResizeHandle, SelectionRotateHandle } from "./selection";
+export interface SelectedShapeOverlayItem {
+    id: ShapeId;
+    usesSelectionPathOverlay: boolean;
+    startPagePoint: Vec | null;
+    endPagePoint: Vec | null;
+    middlePagePoint: Vec | null;
+    path: string | null;
+    bindingSegments: readonly SelectionBindingSegment[];
+}
+export interface SelectionHandleState {
+    resizeHandles: SelectionResizeHandle[];
+    rotateHandles: SelectionRotateHandle[];
+    terminalHandles: SelectionBindingTerminalHandle[];
+    middleHandles: SelectionBindingMiddleHandle[];
+    customHandles: SelectionCustomHandle[];
+}
+export declare function areSelectionBindingSegmentArraysEqual(a: readonly SelectionBindingSegment[], b: readonly SelectionBindingSegment[]): boolean;
+export declare function areSelectedShapeOverlayItemsEqual(a: SelectedShapeOverlayItem[], b: SelectedShapeOverlayItem[]): boolean;
+export declare function areSelectionOverlayFrameStatesEqual(a: SelectionOverlayFrameState | null, b: SelectionOverlayFrameState | null): boolean;
+export declare function areSelectionOverlayFrameGeometryStatesEqual(a: SelectionOverlayFrameGeometryState | null, b: SelectionOverlayFrameGeometryState | null): boolean;
+export declare function areSelectionOverlayFrameGeometryArraysEqual(a: SelectionOverlayFrameGeometryState[], b: SelectionOverlayFrameGeometryState[]): boolean;
+export declare function areSelectionOverlayFrameStyleStatesEqual(a: SelectionOverlayFrameStyleState, b: SelectionOverlayFrameStyleState): boolean;
+export declare function areSelectionOverlayHandlesStatesEqual(a: SelectionOverlayHandlesState | null, b: SelectionOverlayHandlesState | null): boolean;
+export declare function areSelectionOverlayHandleAnchorsStatesEqual(a: SelectionOverlayHandleAnchorsState | null, b: SelectionOverlayHandleAnchorsState | null): boolean;
+export declare function areSelectionOverlayHandleCountsStatesEqual(a: SelectionOverlayHandleCountsState | null, b: SelectionOverlayHandleCountsState | null): boolean;
+export declare function isSingleSelectionPathOverlay(selectedShapeItems: SelectedShapeOverlayItem[]): boolean;
+export declare function getSelectionHandleAnchorsState(selectedShapes: ShapeRecord[], selectionFrame: SelectionFrame | null, zoom: number, getShapeSelectionHandleAnchors: (shape: ShapeRecord) => ShapeSelectionHandleAnchors, canUseSelectionFrameHandles: (shape: ShapeRecord) => boolean): SelectionOverlayHandleAnchorsState;
+export declare function materializeSelectionHandleState(anchors: SelectionOverlayHandleAnchorsState, zoom: number): SelectionHandleState;
+export declare function getSelectionHandleState(selectedShapes: ShapeRecord[], selectionFrame: SelectionFrame | null, zoom: number, getShapeSelectionHandleAnchors: (shape: ShapeRecord) => ShapeSelectionHandleAnchors, canUseSelectionFrameHandles: (shape: ShapeRecord) => boolean): SelectionHandleState;

package/_vendor/canvas-core/editor/stateNode.d.ts

@@ -0,0 +1,31 @@
+import type { Editor } from "./editor";
+import type { CancelEditorEvent, ClickEditorEvent, EditorEvent, KeyboardEditorEvent, PointerEditorEvent, TickEditorEvent, WheelEditorEvent } from "./events";
+export declare abstract class StateNode {
+    readonly editor: Editor;
+    readonly id: string;
+    readonly parent?: StateNode | undefined;
+    protected readonly children: Map<string, StateNode>;
+    protected currentChild: StateNode | null;
+    protected initial: string | null;
+    constructor(editor: Editor, id: string, parent?: StateNode | undefined);
+    protected addChild(child: StateNode): void;
+    enter(info?: unknown): void;
+    exit(info?: unknown): void;
+    transition(id: string, info?: unknown): void;
+    isInInitialState(): boolean;
+    dispatch(event: EditorEvent): void;
+    protected onEnter(_info?: unknown): void;
+    protected onExit(_info?: unknown): void;
+    protected onPointerDown(_event: PointerEditorEvent): void;
+    protected onPointerMove(_event: PointerEditorEvent): void;
+    protected onPointerUp(_event: PointerEditorEvent): void;
+    protected onDoubleClick(_event: ClickEditorEvent): void;
+    protected onCancel(_event: CancelEditorEvent): void;
+    protected onKeyDown(_event: KeyboardEditorEvent): void;
+    protected onKeyUp(_event: KeyboardEditorEvent): void;
+    protected onWheel(_event: WheelEditorEvent): void;
+    protected onTick(_event: TickEditorEvent): void;
+    private handlePointerEvent;
+    private handleClickEvent;
+    private handleKeyboardEvent;
+}

package/_vendor/canvas-core/exports/integrity.d.ts

@@ -0,0 +1,32 @@
+import type { Editor } from "../editor/editor";
+import { type BindingId, type ShapeId } from "../schema/records";
+import type { ShapeSvgExporterRegistry } from "./svg";
+export type ExportIntegrityIssueKind = "missing-shape" | "missing-bounds" | "missing-exporter" | "missing-binding-endpoint" | "invalid-binding" | "duplicate-exclusive-binding";
+export interface ExportIntegrityIssue {
+    kind: ExportIntegrityIssueKind;
+    id: ShapeId | BindingId;
+    canRepair: boolean;
+}
+export interface ExportIntegrityReport {
+    requestedShapeIds: ShapeId[];
+    issues: ExportIntegrityIssue[];
+    repairableIssueCount: number;
+    fatalIssueCount: number;
+    canExport: boolean;
+}
+export interface ExportIntegrityRepairResult {
+    before: ExportIntegrityReport;
+    after: ExportIntegrityReport;
+    repaired: boolean;
+}
+export declare function countExportIssueKinds(issues: readonly ExportIntegrityIssue[]): Partial<Record<ExportIntegrityIssueKind, number>>;
+export declare function getExportIntegrityReport({ editor, exporters, shapeIds, }: {
+    editor: Editor;
+    exporters: ShapeSvgExporterRegistry;
+    shapeIds: Iterable<ShapeId>;
+}): ExportIntegrityReport;
+export declare function repairExportIntegrity({ editor, exporters, shapeIds, }: {
+    editor: Editor;
+    exporters: ShapeSvgExporterRegistry;
+    shapeIds: Iterable<ShapeId>;
+}): ExportIntegrityRepairResult;

package/_vendor/canvas-core/exports/svg.d.ts

@@ -0,0 +1,52 @@
+import { Box } from "../geometry/box";
+import type { Editor } from "../editor/editor";
+import type { AssetId, ShapeId, ShapeRecordBase } from "../schema/records";
+import { type ShapeColor, type ThemeColorTokenName } from "../shapes/colors";
+export type SvgAttributeValue = string | number | boolean | null | undefined;
+export interface SvgElementNode {
+    tag: string;
+    attrs?: Record<string, SvgAttributeValue>;
+    children?: SvgNode[];
+}
+export type SvgNode = SvgElementNode | string;
+export interface SvgExportContext {
+    editor: Editor;
+    bounds: Box;
+    addDef(def: SvgElementNode): string;
+    resolveAssetUrl(assetId: AssetId): string | null;
+    resolveColor(color: ShapeColor): string;
+}
+export type SvgThemeColorResolver = (token: ThemeColorTokenName, fallback: string) => string;
+export interface ShapeSvgExporter<S extends ShapeRecordBase = ShapeRecordBase> {
+    type: S["type"];
+    toSvg(shape: S, context: SvgExportContext): SvgNode | null;
+}
+export interface SvgExportOptions {
+    padding?: number;
+    background?: string;
+    resolveThemeColor?: SvgThemeColorResolver;
+}
+export interface SvgExportResult {
+    svg: string;
+    bounds: Box;
+    width: number;
+    height: number;
+    requestedShapeIds: ShapeId[];
+    exportedShapeIds: ShapeId[];
+    skippedShapes: SvgExportSkippedShape[];
+}
+export type SvgExportSkipReason = "missing-shape" | "missing-bounds" | "missing-exporter" | "empty-output";
+export interface SvgExportSkippedShape {
+    id: ShapeId;
+    reason: SvgExportSkipReason;
+}
+export declare class ShapeSvgExporterRegistry {
+    private readonly registry;
+    register<S extends ShapeRecordBase>(exporter: ShapeSvgExporter<S>): void;
+    get(type: ShapeRecordBase["type"]): ShapeSvgExporter | null;
+    has(type: ShapeRecordBase["type"]): boolean;
+    unregister(type: ShapeRecordBase["type"]): boolean;
+    values(): IterableIterator<ShapeSvgExporter>;
+}
+export declare function exportShapesToSvgString(editor: Editor, shapeIds: Iterable<ShapeId>, exporters: ShapeSvgExporterRegistry, options?: SvgExportOptions): SvgExportResult | null;
+export declare function renderSvgNode(node: SvgNode): string;

package/_vendor/canvas-core/geometry/box.d.ts

@@ -0,0 +1,19 @@
+import { Vec } from "./vec";
+export declare class Box {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    constructor(x: number, y: number, w: number, h: number);
+    get minX(): number;
+    get minY(): number;
+    get maxX(): number;
+    get maxY(): number;
+    get center(): Vec;
+    containsPoint(p: Vec): boolean;
+    containsBox(other: Box): boolean;
+    intersects(other: Box): boolean;
+    expand(amount: number): Box;
+    clone(): Box;
+    static FromPoints(points: Vec[]): Box;
+}

package/_vendor/canvas-core/geometry/ellipse2d.d.ts

@@ -0,0 +1,16 @@
+import { Geometry2d } from "./geometry2d";
+import { Vec } from "./vec";
+import { Box } from "./box";
+export declare class Ellipse2d extends Geometry2d {
+    readonly width: number;
+    readonly height: number;
+    constructor(opts: {
+        width: number;
+        height: number;
+    });
+    get bounds(): Box;
+    get isClosed(): boolean;
+    get vertices(): Vec[];
+    nearestPoint(point: Vec): Vec;
+    hitTestPoint(point: Vec, margin?: number): boolean;
+}

package/_vendor/canvas-core/geometry/geometry2d.d.ts

@@ -0,0 +1,15 @@
+import { Vec } from "./vec";
+import { Box } from "./box";
+export declare abstract class Geometry2d {
+    abstract get bounds(): Box;
+    abstract get isClosed(): boolean;
+    abstract get vertices(): Vec[];
+    abstract nearestPoint(point: Vec): Vec;
+    abstract hitTestPoint(point: Vec, margin?: number): boolean;
+    distanceToPoint(point: Vec): number;
+    /**
+     * Find intersection points between a line segment (a→b) and the shape outline.
+     * Default implementation uses the polygon formed by `vertices`.
+     */
+    intersectLineSegment(a: Vec, b: Vec): Vec[];
+}

package/_vendor/canvas-core/geometry/index.d.ts

@@ -0,0 +1,8 @@
+export { Vec } from "./vec";
+export { Box } from "./box";
+export { Mat } from "./mat";
+export { Geometry2d } from "./geometry2d";
+export { Rectangle2d } from "./rectangle2d";
+export { Ellipse2d } from "./ellipse2d";
+export { Polyline2d } from "./polyline2d";
+export { distanceBetweenSegments, distanceToSegment, nearestPointOnSegment, segmentsIntersect, } from "./segments";

package/_vendor/canvas-core/geometry/mat.d.ts

@@ -0,0 +1,28 @@
+import { Vec } from "./vec";
+/**
+ * 2D affine transform matrix:
+ * [a c e]
+ * [b d f]
+ * [0 0 1]
+ */
+export declare class Mat {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+    constructor(a: number, b: number, c: number, d: number, e: number, f: number);
+    static Identity(): Mat;
+    static Translate(x: number, y: number): Mat;
+    static Rotate(angle: number): Mat;
+    static Scale(sx: number, sy: number): Mat;
+    /** Compose: this × other */
+    compose(other: Mat): Mat;
+    applyToPoint(p: Vec): Vec;
+    invert(): Mat;
+    toCssString(): string;
+    toSvgString(): string;
+    /** Create a transform for a shape: translate(x,y) * rotate(rotation) * scale(scaleX, scaleY) */
+    static ForShape(x: number, y: number, rotation: number, scaleX?: number, scaleY?: number): Mat;
+}

package/_vendor/canvas-core/geometry/polyline2d.d.ts

@@ -0,0 +1,14 @@
+import { Geometry2d } from "./geometry2d";
+import { Vec } from "./vec";
+import { Box } from "./box";
+export declare class Polyline2d extends Geometry2d {
+    readonly points: Vec[];
+    constructor(opts: {
+        points: Vec[];
+    });
+    get bounds(): Box;
+    get isClosed(): boolean;
+    get vertices(): Vec[];
+    nearestPoint(point: Vec): Vec;
+    hitTestPoint(point: Vec, margin?: number): boolean;
+}

package/_vendor/canvas-core/geometry/rectangle2d.d.ts

@@ -0,0 +1,16 @@
+import { Geometry2d } from "./geometry2d";
+import { Vec } from "./vec";
+import { Box } from "./box";
+export declare class Rectangle2d extends Geometry2d {
+    readonly width: number;
+    readonly height: number;
+    constructor(opts: {
+        width: number;
+        height: number;
+    });
+    get bounds(): Box;
+    get isClosed(): boolean;
+    get vertices(): Vec[];
+    nearestPoint(point: Vec): Vec;
+    hitTestPoint(point: Vec, margin?: number): boolean;
+}

package/_vendor/canvas-core/geometry/segments.d.ts

@@ -0,0 +1,5 @@
+import { Vec } from "./vec";
+export declare function nearestPointOnSegment(start: Vec, end: Vec, point: Vec): Vec;
+export declare function distanceToSegment(point: Vec, start: Vec, end: Vec): number;
+export declare function segmentsIntersect(firstStart: Vec, firstEnd: Vec, secondStart: Vec, secondEnd: Vec): boolean;
+export declare function distanceBetweenSegments(firstStart: Vec, firstEnd: Vec, secondStart: Vec, secondEnd: Vec): number;

package/_vendor/canvas-core/geometry/vec.d.ts

@@ -0,0 +1,37 @@
+export declare class Vec {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    add(v: Vec): Vec;
+    sub(v: Vec): Vec;
+    mul(s: number): Vec;
+    div(s: number): Vec;
+    len2(): number;
+    len(): number;
+    dist2(v: Vec): number;
+    dist(v: Vec): number;
+    rot(angle: number): Vec;
+    /** Perpendicular vector (rotated 90° counter-clockwise). */
+    per(): Vec;
+    /** Unit vector (alias for normalize). */
+    uni(): Vec;
+    normalize(): Vec;
+    equals(v: Vec): boolean;
+    clone(): Vec;
+    static From(x: number, y: number): Vec;
+    static Zero(): Vec;
+    /** Midpoint between two vectors. */
+    static Med(a: Vec, b: Vec): Vec;
+    /** Linear interpolation between two vectors. */
+    static Lrp(a: Vec, b: Vec, t: number): Vec;
+    /** Distance between two vectors. */
+    static Dist(a: Vec, b: Vec): number;
+    static Dist2(a: Vec, b: Vec): number;
+    /** Angle from center to point (atan2). */
+    static Angle(center: Vec, point: Vec): number;
+    /** Move point toward target by distance. */
+    static Nudge(from: Vec, toward: Vec, distance: number): Vec;
+    /** Rotate point around a center by angle. */
+    static RotWith(point: Vec, center: Vec, angle: number): Vec;
+    static IsNaN(v: Vec): boolean;
+}

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

@@ -0,0 +1,59 @@
+export { Editor } from "./editor/editor";
+export { createEditorWithPlugins, type CreateEditorWithPluginsOptions, } from "./editor/createEditorWithPlugins";
+export { distanceBetweenSegments, distanceToSegment, nearestPointOnSegment, segmentsIntersect, } from "./geometry";
+export { getShapeGeometry, getShapeExportBounds, getShapeExportPageBounds, getShapeExportToPageTransform, getShapeLocalBounds, getShapeLocalToPageTransform, getShapePositionedOutlineVertices, getShapePositionedToPageTransform, getShapePageBounds, getShapePageCenter, getShapePageCorners, getShapePageOutlineVertices, pagePointToShapePositionedPoint, positionedShapePointToPagePoint, getShapeRenderBounds, getShapeRenderToPageTransform, } from "./editor/queries/shapeTransforms";
+export type { ShapeGeometry } from "./editor/queries/shapeTransforms";
+export type { BindingPreviewState, GapSnapIndicatorGapState, GapSnapIndicatorState, PointSnapIndicatorState, SnapIndicatorState, SelectionBindingSegment, SelectionBindingMiddleHandle, SelectionBindingMiddleHandleAnchor, SelectionBindingTerminalHandle, SelectionBindingTerminalHandleAnchor, SelectionCustomHandle, SelectionCustomHandleAnchor, SelectionHandle, SelectionOverlayFrameState, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandleCountsState, SelectionOverlayHandlesState, SelectionOverlayState, SelectionResizeHandle, SelectionResizeHandleAnchor, SelectionResizeHandleId, SelectionRotateHandle, SelectionRotateHandleAnchor, SelectionRotateHandleId, SelectionMirrorAxis, } from "./editor/selection";
+export { flipSelectionLocalBounds, getSelectionLocalBoundsFromPagePoints, mapSelectionLocalBoundsBetweenBounds, mapSelectionLocalPointBetweenBounds, mirrorSelectionLocalPoint, rotateSelectionPagePoint, selectionLocalPointToPagePoint, selectionPagePointToLocalPoint, } from "./editor/selection";
+export { getAnchoredSelectionResizeLocalBounds, getAspectRatioLockedSelectionResizeBounds, getCenteredSelectionResizeBounds, getConstrainedSelectionResizeBounds, getSelectionResizeBounds, getSelectionResizeScalesFromBounds, isSelectionResizeCorner, normalizeSelectionResizeBoundsFromEdges, selectionResizeHandleMovesBottomEdge, selectionResizeHandleMovesLeftEdge, selectionResizeHandleMovesRightEdge, selectionResizeHandleMovesTopEdge, } from "./editor/resizeGeometry";
+export { InteractionHandlerRegistry } from "./editor/interactions";
+export { SelectionHandleInteractionRegistry } from "./editor/selectionHandleInteractions";
+export { ShortcutManager, formatKeyboardShortcut, normalizeKeyboardShortcut, } from "./editor/managers/shortcutManager";
+export type { EditorEventInteractionDecision, EditorEventInteractionHandler, LandInteractionHandler, SelectionHandleInteractionHandler, SelectionHandleInteractionInput, SelectionHandleInteractionSession, SelectionHandleInteractionUpdateResult, } from "./editor/interactions";
+export type { EditorKeyboardShortcutCommand, KeyboardShortcutBinding, KeyboardShortcutChord, KeyboardShortcutEventLike, KeyboardShortcutInput, KeyboardShortcutTarget, } from "./editor/managers/shortcutManager";
+export type { ContainerBoundsQueryOptions, EditorPageState, EditorOverlayDebugState, EditorRenderHostDebugState, EditorSelectionState, LayerOrderDirection, LayerOrderEdge, ReparentShapePlacementInput, ReparentShapePlacementFailureReason, ReparentShapePlacementResult, ShapeSiblingOrderDirection, ShapeSiblingOrderEdge, ShapeSiblingOrderState, ShapeGroupState, ShapeSelectionSiblingOrderState, ShapePropsPatch, EditorToolState, EditorShapeEditingState, } from "./editor/editor";
+export type { ShapeContainment } from "./editor/managers/queryManager";
+export type { ShapeAtPointOptions, ShapeLineSegmentHitTestOptions, SpatialQueryOptions, } from "./editor/managers/spatialIndexManager";
+export type { TerminalBindingTargetInput, ConnectionPoint, ConnectionTerminal, TerminalBindingResolver, TerminalBindingResolverInput, ResolvedTerminalBinding, } from "./bindings/terminalBinding";
+export type { EditorCommandOptions, EditorCommands, CreateAssetInput, CreateBindingInput, CreatePageInput, MovePageInput, RenamePageInput, ReparentShapesInput, CreateShapeInput, SetCameraInput, ShapeUpdate, StartEditingShapeInput, UpdateAssetInput, UpdateBindingInput, } from "./editor/commands";
+export { reparentShapeToContainingParent } from "./editor/commands";
+export { isEditorClipboardPayload, } from "./editor/clipboard";
+export type { ClipboardAssetSidecar, DuplicateSelectionInput, EditorClipboardPayload, PasteClipboardPayloadInput, } from "./editor/clipboard";
+export type { EditorEvent, ClickEditorEvent, PointerEditorEvent, KeyboardEditorEvent, WheelEditorEvent, TickEditorEvent, CancelEditorEvent, EditorPointerType, } from "./editor/events";
+export type { ChangeSource, RecordUpdate, RecordsDiff, ScopedStoreRecord, StoreRecord, StoreChange, StoreScopeOf, StoreSnapshot, } from "../store/index";
+export { SnapshotParseError, parseDocumentSnapshot, parseSessionSnapshot, migrateSnapshotRecords, } from "./schema/snapshots";
+export type { DocumentSnapshot, SessionSnapshot, SnapshotMigration, } from "./schema/snapshots";
+export { createDocumentSnapshotSupport, filterDocumentSnapshotBySupport, getDocumentSnapshotRequirements, getUnsupportedDocumentSnapshotRequirements, } from "./schema/snapshotSupport";
+export type { DocumentSnapshotRequirements, DocumentSnapshotSupport, FilterDocumentSnapshotBySupportResult, UnsupportedDocumentSnapshotRequirements, } from "./schema/snapshotSupport";
+export { ShapeUtil } from "./shapes/shapeUtil";
+export type { ShapeBoundsSnapGeometry, ShapeBrushSelectInput, ShapeBrushWrapInput, ShapeBindingPointInput, ShapeEditEndResult, ShapeGeometryInput, ShapeHandleSnapContext, ShapeHandleSnapGeometry, ShapeLineSegmentHitTestInput, ShapePointHitTestInput, ShapeSelectionHandleAnchorInput, ShapeSelectionHandleAnchors, ShapeSelectionFrameInput, ShapeSelectionFlipAxis, ShapeSelectionFlipInput, ShapeSelectionOverlayInfo, ShapeSelectionOverlayInfoInput, ShapeSelectionPagePoints, ShapeSelectionPagePointsInput, ShapeSelectionResizeAspectRatioLockInput, ShapeSelectionResizeInput, ShapeSelectionTranslateInput, } from "./shapes/shapeUtil";
+export type { LaserTrailState } from "./editor/managers/interactionTransientManager";
+export type { HandleSnapContext, HandleSnapInput, HandleSnapMode, HandleSnapResult, HandleSnapSnapshot, HandleSnapSnapshotInput, ResizeSnapInput, ResizeSnapResult, ResizeSnapSnapshot, SnapAxis, SnapCoordinateSpace, TranslateSnapInput, TranslateSnapResult, TranslateSnapSnapshot, } from "./editor/managers/snapTypes";
+export { ShapeUtilRegistry } from "./shapes/shapeUtilRegistry";
+export { resolveTerminalBindingAtPoint, } from "./bindings/terminalBinding";
+export { ShapeSvgExporterRegistry, exportShapesToSvgString, renderSvgNode, } from "./exports/svg";
+export type { ShapeSvgExporter, SvgAttributeValue, SvgElementNode, SvgExportContext, SvgExportOptions, SvgExportResult, SvgExportSkipReason, SvgExportSkippedShape, SvgThemeColorResolver, SvgNode, } from "./exports/svg";
+export { getExportIntegrityReport, repairExportIntegrity, } from "./exports/integrity";
+export type { ExportIntegrityIssue, ExportIntegrityIssueKind, ExportIntegrityRepairResult, ExportIntegrityReport, } from "./exports/integrity";
+export { getShapeCapabilityManifest } from "./shapes/capabilities";
+export type { ShapeCapabilityDefinition, ShapeCapabilityManifest, ShapeCapabilityManifestEntry, ShapeCapabilitySupport, } from "./shapes/capabilities";
+export { BindingUtil } from "./bindings/bindingUtil";
+export type { BindingSelectionCompanionFrameContext, BindingUtilEffect, } from "./bindings/bindingUtil";
+export { BindingUtilRegistry } from "./bindings/bindingUtilRegistry";
+export { StateNode } from "./editor/stateNode";
+export { getEdgeScrollDelta } from "./editor/edgeScroll";
+export { HandTool } from "./tools/hand/handTool";
+export { SelectTool } from "./tools/select/selectTool";
+export { SET_ACTIVE_TOOL_TOOLBAR_ACTION_ID, TOGGLE_TOOL_LOCKED_TOOLBAR_ACTION_ID, } from "./surfaces/toolbar";
+export { LAND_DEFAULT_THEME_COLOR_FALLBACKS, LAND_THEME_COLOR_SLOTS, LAND_THEME_COLOR_TOKEN_BY_SLOT, areShapeColorsEqual, createCustomShapeColor, createThemeShapeColor, getThemeColorTokenName, isCustomShapeColorRef, isShapeColor, isThemeShapeColorRef, isTransparentShapeColor, normalizeShapeColor, resolveShapeColor, shapeColorToCssColor, } from "./shapes/colors";
+export type { CustomShapeColorRef, ShapeColor, ShapeColorRef, ThemeColorSlot, ThemeColorTokenName, ThemeShapeColorRef, } from "./shapes/colors";
+export type { ContextMenuBadgeItem, ContextMenuCanvasTarget, ContextMenuCommandItem, ContextMenuContext, ContextMenuContribution, ContextMenuContributionTarget, ContextMenuItem, ActiveContextMenu, ContextMenuSection, ContextMenuSelectionTarget, ContextMenuSeparatorItem, ContextMenuShapeTarget, ContextMenuTarget, } from "./surfaces/contextMenu";
+export { getEditorOptionsFromEditorPlugins, setupEditorPlugins, type LandEditorPlugin, } from "./plugins";
+export type { CanvasAction, CanvasActionRunInput, CanvasActionValue, CanvasActionContext, CanvasSelectionSnapshot, CanvasToolSnapshot, } from "./surfaces/actions";
+export type { ToolbarBadgeItem, ToolbarButtonItem, ToolbarContribution, ToolbarGroup, ToolbarItem, ToolbarSegmentedItem, ToolbarSegmentedOption, ToolbarSeparatorItem, ToolbarStepperItem, ToolbarStepperOption, ToolbarTextInputItem, ToolbarPlacement, ToolbarSurface, ToolbarSwatchesItem, ToolbarSwatchOption, } from "./surfaces/toolbar";
+export { DEFAULT_CAMERA, DEFAULT_PAGE_ID, DEFAULT_SESSION_ID, createDefaultPage, createDefaultSession, isAnyAssetRecord, isAnyBindingRecord, isAnyShapeRecord, isAssetRecord, isBindingRecord, isDocumentRecord, isPageRecord, isSessionRecord, isShapeRecord, type AnyBindingRecord, type AnyAssetRecord, type AnyShapeRecord, type AssetId, type AssetRecord, type AssetRecordBase, type BaseRecord, type BindingId, type BindingRecordBase, type BindingRecord, type Camera, type DocumentRecord, type EditorRecord, type PageCameraById, type PageId, type PageSelectionById, type PageRecord, type RecordScope, type SessionRecord, type ShapeId, type ShapeParentId, type ShapeRecordBase, type ShapeRecord, type ShapeEditingEntryRequest, type ShapeEditingEntryMode, type ShapeEditingPoint, type ShapeEditingSession, } from "./schema/records";
+export { Vec } from "./geometry/vec";
+export { Box } from "./geometry/box";
+export { Mat } from "./geometry/mat";
+export { observeValue } from "./reactivity";
+export type { ReadonlyValue } from "./reactivity";