@yuzhouu/canvas-standard 0.1.0

package/_vendor/plugin-laser/_vendor/canvas-core/editor/viewport/cameraManager.d.ts

@@ -0,0 +1,56 @@
+import type { Signal } from "../../../signals/index";
+import type { ChangeSource } from "../../../store/index";
+import { Vec } from "../../geometry/vec";
+import { type Camera } from "../../schema/records";
+import type { PageId } from "../../schema/records";
+import type { Editor } from "../editor";
+export interface CameraAnimationScheduler {
+    requestFrame(callback: (timestamp: number) => void): unknown;
+    cancelFrame(handle: unknown): void;
+    prefersReducedMotion?(): boolean;
+}
+export interface CameraAnimationOptions {
+    durationMs: number;
+    pageId?: PageId;
+    source?: ChangeSource;
+}
+/**
+ * Camera and viewport-screen-size state for the editor. Owns the viewport size
+ * atom (viewport + camera together define the page<->screen transform) and the
+ * camera read/write/transform operations carved out of the Editor facade so the
+ * editor can stay a thinner delegating surface. Editor publishes the owned
+ * viewport signal through its grouped state facade.
+ */
+export declare class CameraManager {
+    private readonly editor;
+    private readonly animationScheduler?;
+    private readonly _viewportScreenSizeSignal;
+    readonly viewportScreenSizeSignal: Signal<{
+        w: number;
+        h: number;
+    }>;
+    private animationFrame;
+    private animationGeneration;
+    constructor(editor: Editor, animationScheduler?: CameraAnimationScheduler | undefined);
+    getCurrentCamera(): Camera;
+    getCamera(pageId?: PageId): Camera;
+    pageToScreen(point: Vec, pageId?: PageId): Vec;
+    screenToPage(point: Vec, pageId?: PageId): Vec;
+    setCamera(partial: Partial<Camera>, options?: {
+        pageId?: PageId;
+        source?: ChangeSource;
+    }): void;
+    animateCameraTo(target: Camera, options: CameraAnimationOptions): void;
+    cancelAnimation(): void;
+    dispose(): void;
+    private writeCamera;
+    panCamera(delta: Vec, source?: ChangeSource): void;
+    zoomCameraAtScreenPoint(screenPoint: Vec, deltaY: number, source?: ChangeSource): void;
+    zoomCameraToScreenPoint(screenPoint: Vec, zoom: number, source?: ChangeSource): void;
+    zoomAtViewportCenter(deltaY: number, source?: ChangeSource): void;
+    resetZoom(source?: ChangeSource): void;
+    setViewportScreenSize(size: {
+        w: number;
+        h: number;
+    }): void;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/editor/viewport/cameraPanSession.d.ts

@@ -0,0 +1,9 @@
+import type { Vec } from "../../geometry/vec";
+import type { Camera } from "../../schema/records";
+import type { Editor } from "../editor";
+export interface CameraPanSession {
+    originScreenPoint: Vec;
+    originCamera: Camera;
+}
+export declare function createCameraPanSession(editor: Editor, originScreenPoint: Vec): CameraPanSession;
+export declare function updateCameraPanSession(editor: Editor, session: CameraPanSession, screenPoint: Vec): void;

package/_vendor/plugin-laser/_vendor/canvas-core/editor/viewport/edgeScroll.d.ts

@@ -0,0 +1,5 @@
+import { Vec } from "../../geometry/vec";
+export declare function getEdgeScrollDelta(screenPoint: Vec, viewportSize: {
+    w: number;
+    h: number;
+}, elapsed: number): Vec;

package/_vendor/plugin-laser/_vendor/canvas-core/editor/viewport/renderWindow.d.ts

@@ -0,0 +1,30 @@
+import { Box } from "../../geometry/box";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+export interface RenderItem {
+    id: ShapeId;
+    shape: ShapeRecord;
+    bounds: Box;
+    isSelected: boolean;
+}
+export declare const RENDER_CULLING_OVERSCAN_SCREEN = 160;
+export interface ShapeIndexRange {
+    start: number;
+    end: number;
+}
+export interface ShapeWindowSnapshot {
+    viewportReady: boolean;
+    ranges: ShapeIndexRange[];
+    shapeIds: ShapeId[];
+}
+export declare function doesBoxContainBox(outer: Box, inner: Box): boolean;
+export declare function getRetainedRenderWindowExtraShapeBudget(culledShapeCount: number): number;
+export declare function mergeShapeIndexRanges(ranges: ShapeIndexRange[], gapAllowance?: number): ShapeIndexRange[];
+export declare function doRangesContainRanges(outerRanges: ShapeIndexRange[], innerRanges: ShapeIndexRange[]): boolean;
+export declare function getShapeIndexRangeSpan(ranges: ShapeIndexRange[]): number;
+export declare function getExpandedRetainedShapeRanges(previousRanges: ShapeIndexRange[], nextRanges: ShapeIndexRange[], extraShapeBudget: number): ShapeIndexRange[] | null;
+export declare function getExpandedRetainedBaseShapeRanges(previousRanges: ShapeIndexRange[], nextRanges: ShapeIndexRange[]): ShapeIndexRange[] | null;
+export declare function getShapeIndexRangesForShapeIds(shapeIds: ShapeId[], pageIndexById: Map<ShapeId, number>, gapAllowance?: number): ShapeIndexRange[];
+export declare function getShapeWindowSnapshot(pageShapeIds: ShapeId[], ranges: ShapeIndexRange[], options?: {
+    viewportReady?: boolean;
+}): ShapeWindowSnapshot;
+export declare function collectRetainedShapeRanges(pageShapeIds: ShapeId[], culledShapeIds: ShapeId[], selectedIds: Set<ShapeId>, extraShapeBudget: number): ShapeIndexRange[];

package/_vendor/plugin-laser/_vendor/canvas-core/editor/viewport/renderWindowManager.d.ts

@@ -0,0 +1,33 @@
+import { type Signal } from "../../../signals/index";
+import type { Box } from "../../geometry/box";
+import type { PageId, ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type RenderItem } from "./renderWindow";
+interface RenderWindowSignals {
+    currentPageId: Signal<PageId>;
+    currentPageShapeIds: Signal<ShapeId[]>;
+    selectedShapeIds: Signal<ShapeId[]>;
+    selectedShapeIdSet: Signal<Set<ShapeId>>;
+    viewportPageBounds: Signal<Box | null>;
+    renderViewportPageBounds: Signal<Box | null>;
+}
+/**
+ * Render culling and retained-window signals for the editor render host. The
+ * Editor exposes thin signal aliases that forward here.
+ */
+export declare class RenderWindowManager {
+    readonly shapeRenderOrderByIdSignal: Signal<Map<ShapeId, number>>;
+    readonly culledShapeIdsSignal: Signal<ShapeId[]>;
+    readonly culledShapeIdSetSignal: Signal<Set<ShapeId>>;
+    readonly selectedShapeIdsOutsideCulledSignal: Signal<ShapeId[]>;
+    readonly selectedShapeIdsOutsideCulledSetSignal: Signal<Set<ShapeId>>;
+    readonly renderVisibleShapeIdsSignal: Signal<ShapeId[]>;
+    readonly retainedShapeIdsSignal: Signal<ShapeId[]>;
+    readonly renderVisibleShapeIdSetSignal: Signal<Set<ShapeId>>;
+    readonly renderItemsSignal: Signal<RenderItem[]>;
+    private readonly retainedBaseShapeWindowSnapshotSignal;
+    private readonly retainedShapeWindowSnapshotSignal;
+    constructor(editor: Editor, signals: RenderWindowSignals);
+    private getPageIndexById;
+}
+export {};

package/_vendor/plugin-laser/_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/plugin-laser/_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 ThemeColorResolver } 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 interface ShapeSvgExporter<S extends ShapeRecordBase = ShapeRecordBase> {
+    type: S["type"];
+    toSvg(shape: S, context: SvgExportContext): SvgNode | null;
+    toSvgForeground?(shape: S, context: SvgExportContext): SvgNode | null;
+}
+export interface SvgExportOptions {
+    padding?: number;
+    background?: string;
+    resolveThemeColor?: ThemeColorResolver;
+}
+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/plugin-laser/_vendor/canvas-core/geometry/box.d.ts

@@ -0,0 +1,20 @@
+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;
+}
+export declare function isValidBox(box: Box): boolean;

package/_vendor/plugin-laser/_vendor/canvas-core/geometry/contentCutout.d.ts

@@ -0,0 +1,8 @@
+import { Box } from "./box";
+import { Mat } from "./mat";
+import { Vec } from "./vec";
+export declare function getShapeContentClipPath({ outputBounds, cutoutLocalPolygons, localToOutput, }: {
+    outputBounds: Box;
+    cutoutLocalPolygons: readonly (readonly Vec[])[];
+    localToOutput?: Mat;
+}): string | null;

package/_vendor/plugin-laser/_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/plugin-laser/_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/plugin-laser/_vendor/canvas-core/geometry/index.d.ts

@@ -0,0 +1,9 @@
+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 { doesLineSegmentIntersectPolygon, getPolygonsBounds, isPointInPolygon, isPointInPolygons, isValidPolygon, } from "./polygon";
+export { distanceBetweenSegments, distanceToSegment, nearestPointOnSegment, segmentsIntersect, } from "./segments";

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

@@ -0,0 +1,31 @@
+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;
+    determinant(): number;
+    getMaximumLinearScale(): number;
+    tryInvert(epsilon?: number): Mat | null;
+    invert(): Mat;
+    toCssString(): string;
+    toSvgString(): string;
+    /** Create a transform for a shape: translate * rotate * scale. */
+    static ForShape(x: number, y: number, rotation: number, scaleX?: number, scaleY?: number): Mat;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/geometry/polygon.d.ts

@@ -0,0 +1,7 @@
+import { Box } from "./box";
+import { Vec } from "./vec";
+export declare function isValidPolygon(polygon: readonly Vec[]): boolean;
+export declare function getPolygonsBounds(polygons: readonly (readonly Vec[])[]): Box | null;
+export declare function isPointInPolygon(point: Vec, polygon: readonly Vec[]): boolean;
+export declare function isPointInPolygons(point: Vec, polygons: readonly (readonly Vec[])[]): boolean;
+export declare function doesLineSegmentIntersectPolygon(start: Vec, end: Vec, polygon: readonly Vec[], margin?: number): boolean;

package/_vendor/plugin-laser/_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/plugin-laser/_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/plugin-laser/_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/plugin-laser/_vendor/canvas-core/geometry/vec.d.ts

@@ -0,0 +1,35 @@
+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;
+    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/plugin-laser/_vendor/canvas-core/index.d.ts

@@ -0,0 +1,64 @@
+export { Editor, type CenterOnShapeOptions, } from "./editor/editor";
+export type { CameraAnimationScheduler } from "./editor/viewport/cameraManager";
+export { createEditor, type CreateEditorOptions, } from "./editor/createEditor";
+export { HistoryManager, type HistoryScope, type HistoryState, } from "./editor/history/historyManager";
+export { EditorOperationManager, type EditorCommit, type EditorOperation, type EditorOperationHistory, type EditorOperationOptions, } from "./editor/history/operationManager";
+export type { SnapDiagnostics, SnapDiagnosticsState, } from "./editor/snapping/snapManager";
+export { doesLineSegmentIntersectPolygon, distanceBetweenSegments, distanceToSegment, getPolygonsBounds, isPointInPolygon, isPointInPolygons, isValidPolygon, nearestPointOnSegment, segmentsIntersect, } from "./geometry";
+export { getShapeContentClipPath } from "./geometry/contentCutout";
+export { getShapeGeometry, getShapeExportPageBounds, getShapeExportToPageTransform, getShapeLocalToPageTransform, getShapeTransformFieldsFromMatrix, getShapePositionedOutlineVertices, getShapePositionedToPageTransform, getShapePageBounds, getShapePageCenter, getShapePageCorners, getShapePageOutlineVertices, pagePointToShapePositionedPoint, positionedShapePointToPagePoint, getShapeRenderToPageTransform, } from "./editor/queries/shapeTransforms";
+export type { ShapeGeometry, ShapeTransformDecompositionOptions, ShapeTransformFields, } from "./editor/queries/shapeTransforms";
+export type { BindingPreviewState, GapSnapIndicatorGapState, GapSnapIndicatorState, PointSnapIndicatorState, SnapIndicatorState, SelectionBindingSegment, TerminalBindingGuideState, SelectionBindingMiddleHandle, SelectionBindingMiddleHandleAnchor, SelectionBindingTerminalHandle, SelectionBindingTerminalHandleAnchor, SelectionCustomHandle, SelectionCustomHandleAnchor, SelectionHandle, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandlesState, SelectionResizeHandle, SelectionResizeHandleAnchor, SelectionResizeHandleId, SelectionResizeMode, SelectionRotateHandle, SelectionRotateHandleAnchor, SelectionRotateHandleId, SelectionMirrorAxis, } from "./editor/selection/selection";
+export { SELECTION_RESIZE_ALL_MODES, SELECTION_RESIZE_ASPECT_RATIO_LOCKED_ONLY_MODES, SELECTION_RESIZE_CORNER_HANDLE_IDS, SELECTION_RESIZE_FREE_ONLY_MODES, SELECTION_RESIZE_HANDLE_IDS, flipSelectionLocalBounds, getSelectionLocalBoundsFromPagePoints, mapSelectionLocalBoundsBetweenBounds, mapSelectionLocalPointBetweenBounds, mirrorSelectionLocalPoint, rotateSelectionPagePoint, selectionLocalPointToPagePoint, selectionPagePointToLocalPoint, } from "./editor/selection/selection";
+export { getAnchoredSelectionResizeLocalBounds, getAspectRatioLockedSelectionResizeBounds, getCenteredSelectionResizeBounds, getConstrainedSelectionResizeBounds, getLocalDimensionsFromSelectionResize, getSelectionResizeBounds, getSelectionResizeDimensionsFromLocal, getSelectionResizeScalesFromBounds, isSelectionResizeCorner, normalizeSelectionResizeBoundsFromEdges, selectionResizeHandleMovesBottomEdge, selectionResizeHandleMovesLeftEdge, selectionResizeHandleMovesRightEdge, selectionResizeHandleMovesTopEdge, } from "./editor/selection/resizeGeometry";
+export { InteractionHandlerRegistry } from "./editor/events/interactions";
+export { doesKeyboardShortcutMatch, formatKeyboardShortcut, normalizeKeyboardShortcut, } from "./editor/events/keyboardShortcuts";
+export type { EditorEventInteractionHandler, LandInteractionHandler, PointerDragInteractionSession, PointerDragInteractionUpdateResult, SelectionHandleInteractionHandler, SelectionHandleInteractionInput, SelectionHandleInteractionSession, SelectionHandleInteractionUpdateResult, ShapePointerInteractionHandler, ShapePointerInteractionInput, } from "./editor/events/interactions";
+export type { KeyboardShortcutChord, KeyboardShortcutEventLike, KeyboardShortcutInput, } from "./editor/events/keyboardShortcuts";
+export type { EditorSelectionMetadata, EditorSelectionState, EditorShapeEditingState, EditorToolState, } from "./editor/state/editorReadModels";
+export type { EditorRenderInteractionSignals, EditorRenderOverlaySignals, EditorRenderSignals, EditorRenderViewportSignals, EditorStateSignals, } from "./editor/state/editorSignals";
+export type { ContainerBoundsQueryOptions, ShapeContainment, } from "./editor/shapes/shapeContainment";
+export type { ShapeGroupState } from "./editor/shapes/shapeGrouping";
+export type { LayerOrderDirection, LayerOrderEdge, ShapeSiblingOrderDirection, ShapeSiblingOrderEdge, ShapeSiblingOrderState, ShapeSelectionSiblingOrderState, } from "./editor/shapes/shapeOrder";
+export type { ReparentShapePlacementInput, ReparentShapePlacementFailureReason, ReparentShapePlacementResult, } from "./editor/shapes/shapeReparenting";
+export type { ShapePropsPatch } from "./editor/commands/commandTypes";
+export type { ShapeAtPointOptions, ShapeLineSegmentHitTestOptions, SpatialQueryOptions, } from "./editor/queries/spatialIndexManager";
+export type { TerminalBindingTargetInput, ConnectionPoint, ConnectionTerminal, TerminalBindingResolver, TerminalBindingResolverInput, ResolvedTerminalBinding, } from "./bindings/terminalBinding";
+export { DEFAULT_TERMINAL_BINDING_PORTS, getResolvedShapeTerminalBindingPort, getResolvedShapeTerminalBindingPorts, } from "./bindings/terminalPorts";
+export type { ResolvedShapeTerminalBindingPort, ShapeTerminalBindingPort, TerminalBindingPortId, } from "./bindings/terminalPorts";
+export type { EditorCommandOptions, EditorCommands, CreateAssetInput, CreateBindingInput, CreatePageInput, MovePageInput, RenamePageInput, ReparentShapesInput, CreateShapeInput, SetCameraInput, ShapeUpdate, StartEditingShapeInput, UpdateAssetInput, UpdateBindingInput, UpdateDocumentMetaInput, UpdatePageMetaInput, } from "./editor/commands/commands";
+export { reparentShapeToContainingParent } from "./editor/commands/commands";
+export { isEditorClipboardPayload, } from "./editor/clipboard";
+export type { ClipboardAssetSidecar, DuplicateSelectionInput, EditorClipboardPayload, PasteClipboardPayloadInput, } from "./editor/clipboard";
+export type { EditorEvent, EditorEventContext, EditorEventRoutingEffect, EditorEventResult, DoubleClickEditorEvent, PointerEditorEvent, KeyboardEditorEvent, WheelEditorEvent, TickEditorEvent, CancelEditorEvent, EditorPointerType, } from "./editor/events/events";
+export type { ChangeSource, RecordUpdate, RecordsDiff, ScopedStoreRecord, StoreRecord, StoreChange, StoreScopeOf, StoreSnapshot, } from "../store/index";
+export { SnapshotParseError, parseDocumentSnapshot, parseSessionSnapshot, } from "./schema/snapshots";
+export type { DocumentSnapshot, SessionSnapshot } from "./schema/snapshots";
+export { ShapeUtil } from "./shapes/shapeUtil";
+export { CHILD_TRANSFORM_POLICY_EPSILON, formatChildTransformPolicyViolation, getChildTransformPolicyViolation, } from "./shapes/childTransformPolicy";
+export type { ChildTransformPolicy, ChildTransformPolicyProvider, ChildTransformPolicyViolation, } from "./shapes/childTransformPolicy";
+export type { ShapeBoundsSnapGeometry, ShapeBrushSelectInput, ShapeBrushWrapInput, ShapeClipboardCopyInput, ShapeBindingPointInput, ShapeChildPlacementInput, ShapeChildVisibilityInput, ShapeEditEndInput, ShapeEditEndResult, ShapeGeometryInput, ShapeGroupingInput, ShapeHandleSnapContext, ShapeHandleSnapGeometry, ShapeHoverTargetInput, ShapeLineSegmentHitTestInput, ShapeLabelPathGeometry, ShapeLabelPathNearestPositionOptions, ShapePointHitTestInput, ShapeSnapPoint, ShapeSnapPointKind, ShapeTerminalBindingOutline, ShapeSelectionHandleAnchorInput, ShapeSelectionHandleAnchors, ShapeSelectionFrameInput, ShapeSelectionFlipAxis, ShapeSelectionFlipInput, ShapeSelectionOverlayInfo, ShapeSelectionOverlayInfoInput, ShapeSelectionPathStyle, ShapeSelectionPagePoints, ShapeSelectionPagePointsInput, ShapeSelectionResizeInput, ShapeSelectionResizeCapabilityInput, ShapeSelectionResizeModesInput, ShapeSelectionTransformCapabilityInput, ShapeSelectionTranslateInput, } from "./shapes/shapeUtil";
+export type { HandleSnapContext, HandleSnapInput, HandleSnapMode, HandleSnapResult, HandleSnapSnapshot, HandleSnapSnapshotInput, ResizeSnapInput, ResizeSnapResult, ResizeSnapSnapshot, SnapAxis, SnapCoordinateSpace, SnapPointIndex, SnapPointIndexEntry, SnapPointKind, TranslateSnapInput, TranslateSnapResult, TranslateSnapSnapshot, } from "./editor/snapping/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, SvgNode, } from "./exports/svg";
+export { getExportIntegrityReport, repairExportIntegrity, } from "./exports/integrity";
+export type { ExportIntegrityIssue, ExportIntegrityIssueKind, ExportIntegrityRepairResult, ExportIntegrityReport, } from "./exports/integrity";
+export { BindingUtil } from "./bindings/bindingUtil";
+export type { BindingSelectionCompanionFrameContext, BindingTargetShapeContentCutoutContext, BindingUtilEffect, } from "./bindings/bindingUtil";
+export { BindingUtilRegistry } from "./bindings/bindingUtilRegistry";
+export { StateNode } from "./tools/stateNode";
+export type { StateNodeEvent } from "./tools/stateNode";
+export { getEdgeScrollDelta } from "./editor/viewport/edgeScroll";
+export { HandTool } from "./tools/hand/handTool";
+export { SelectTool } from "./tools/select/selectTool";
+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, ThemeColorSlot, ThemeColorResolver, ThemeColorTokenName, ThemeShapeColorRef, } from "./shapes/colors";
+export { type EditorPlugin, createEditorRuntimeToken, EditorRuntimeRegistry, type EditorRuntimeToken, } from "./plugins";
+export { DEFAULT_CAMERA, DEFAULT_DOCUMENT_ID, DEFAULT_PAGE_ID, DEFAULT_SESSION_ID, createDefaultDocument, createDefaultPage, createDefaultSession, isAssetRecord, isBindingRecord, isDocumentRecord, isDocumentMetadataRecord, isPageRecord, isSessionRecord, isShapeRecord, type AssetId, type AssetRecord, type AssetRecordBase, type BaseRecord, type BindingId, type BindingRecordBase, type BindingRecord, type Camera, type DocumentId, type DocumentMetadataRecord, 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";

package/_vendor/plugin-laser/_vendor/canvas-core/plugins/editorRuntimePlugin.d.ts

@@ -0,0 +1,19 @@
+import type { BindingUtil } from "../bindings/bindingUtil";
+import type { Editor } from "../editor/editor";
+import type { LandInteractionHandler } from "../editor/events/interactions";
+import type { ShapeSvgExporter } from "../exports/svg";
+import type { ShapeUtil } from "../shapes/shapeUtil";
+export interface EditorPlugin {
+    id: string;
+    shapeUtils?: ShapeUtil[];
+    shapeSvgExporters?: ShapeSvgExporter[];
+    bindingUtils?: BindingUtil[];
+    interactionHandlers?: LandInteractionHandler[];
+    setup?(editor: Editor): void | (() => void);
+}
+export declare function collectEditorPluginContributions(plugins: readonly EditorPlugin[]): {
+    shapeUtils: ShapeUtil[];
+    shapeSvgExporters: ShapeSvgExporter[];
+    bindingUtils: BindingUtil[];
+};
+export declare function setupEditorPlugins(editor: Editor, plugins: readonly EditorPlugin[]): () => void;

package/_vendor/plugin-laser/_vendor/canvas-core/plugins/editorRuntimeRegistry.d.ts

@@ -0,0 +1,15 @@
+export interface EditorRuntimeToken<TValue> {
+    readonly id: string;
+    readonly __value?: TValue;
+}
+export declare function createEditorRuntimeToken<TValue>(id: string): EditorRuntimeToken<TValue>;
+export declare class EditorRuntimeRegistry {
+    private readonly values;
+    private readonly disposers;
+    private isDisposed;
+    provide<TValue>(token: EditorRuntimeToken<TValue>, value: TValue, dispose?: (value: TValue) => void): TValue;
+    get<TValue>(token: EditorRuntimeToken<TValue>): TValue | null;
+    require<TValue>(token: EditorRuntimeToken<TValue>): TValue;
+    onDispose(dispose: () => void): void;
+    dispose(): void;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export type { EditorPlugin } from "./editorRuntimePlugin";
+export { createEditorRuntimeToken, EditorRuntimeRegistry, type EditorRuntimeToken, } from "./editorRuntimeRegistry";

package/_vendor/plugin-laser/_vendor/canvas-core/reactivity.d.ts

@@ -0,0 +1,8 @@
+import type { SignalGraph } from "../signals/index";
+export interface ReadonlyValue<T> {
+    readonly graph: SignalGraph;
+    get(): T;
+}
+export declare function observeValue<T>(name: string, value: ReadonlyValue<T>, onChange: () => void, options?: {
+    fireImmediately?: boolean;
+}): () => void;