@yuzhouu/canvas-standard 0.1.0

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

@@ -0,0 +1,81 @@
+import type { Vec } from "../../geometry/vec";
+export type EditorPointerType = "mouse" | "touch" | "pen";
+export interface PointerEditorEvent {
+    type: "pointer";
+    name: "pointer_down" | "pointer_move" | "pointer_up" | "pointer_cancel";
+    timestamp: number;
+    pointerId: number;
+    button: number;
+    buttons: number;
+    pointerType: EditorPointerType;
+    screenPoint: Vec;
+    pagePoint: Vec;
+    pressure: number;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export interface DoubleClickEditorEvent {
+    type: "double_click";
+    timestamp: number;
+    pointerId: number;
+    button: number;
+    buttons: number;
+    pointerType: EditorPointerType;
+    screenPoint: Vec;
+    pagePoint: Vec;
+    pressure: number;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export interface KeyboardEditorEvent {
+    type: "keyboard";
+    name: "key_down" | "key_up";
+    key: string;
+    code: string;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export interface WheelEditorEvent {
+    type: "wheel";
+    screenPoint: Vec;
+    pagePoint: Vec;
+    delta: Vec;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export interface TickEditorEvent {
+    type: "tick";
+    timestamp: number;
+    elapsed: number;
+}
+export interface CancelEditorEvent {
+    type: "cancel";
+    reason: "escape" | "pointer_cancel" | "blur" | "page_switch" | "tool_switch" | "dispose" | "command" | "restore";
+}
+export interface EditorEventContext {
+    readonly origin: "external" | "derived";
+    readonly pointer: {
+        readonly clickCount: number;
+    } | null;
+}
+export interface EditorEventRoutingEffect {
+    propagation?: "stop";
+    clickSequence?: "break";
+}
+export interface EditorEventResult {
+    claimed: boolean;
+}
+export type EditorEvent = PointerEditorEvent | DoubleClickEditorEvent | KeyboardEditorEvent | WheelEditorEvent | TickEditorEvent | CancelEditorEvent;
+export declare function mergeEditorEventRoutingEffects(left?: EditorEventRoutingEffect | void, right?: EditorEventRoutingEffect | void): EditorEventRoutingEffect | undefined;

package/_vendor/plugin-laser/_vendor/canvas-core/editor/events/inputsManager.d.ts

@@ -0,0 +1,49 @@
+import type { Atom, Computed, SignalGraph } from "../../../signals/index";
+import type { EditorEvent, PointerEditorEvent } from "./events";
+import { Vec } from "../../geometry/vec";
+export type InputDragPhase = "idle" | "pointing" | "dragging";
+export interface InputsState {
+    originPagePoint: Vec | null;
+    currentPagePoint: Vec | null;
+    previousPagePoint: Vec | null;
+    originScreenPoint: Vec | null;
+    currentScreenPoint: Vec | null;
+    previousScreenPoint: Vec | null;
+    currentTimestamp: number | null;
+    previousTimestamp: number | null;
+    pageVelocity: Vec;
+    screenVelocity: Vec;
+    pointerId: number | null;
+    pointerType: PointerEditorEvent["pointerType"] | null;
+    buttons: number;
+    isPointing: boolean;
+    isDragging: boolean;
+    dragPhase: InputDragPhase;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export declare class InputsManager {
+    readonly pressedKeyCodes: Atom<ReadonlySet<string>>;
+    readonly isSpacePressed: Computed<boolean>;
+    readonly state: Atom<InputsState>;
+    constructor(signals: SignalGraph);
+    setCurrentPointerPoint(input: {
+        timestamp: number;
+        pagePoint: Vec;
+        screenPoint: Vec;
+        shiftKey: boolean;
+        altKey: boolean;
+        ctrlKey: boolean;
+        metaKey: boolean;
+        accelKey: boolean;
+    }): void;
+    handleEvent(event: EditorEvent): void;
+    resetPointer(): void;
+    private handlePointerEvent;
+    private handleKeyboardEvent;
+    private resetKeyboard;
+    private handleWheelEvent;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/editor/events/interactions.d.ts

@@ -0,0 +1,84 @@
+import type { ChangeSource } from "../../../store/index";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { CancelEditorEvent, EditorEvent, EditorEventContext, EditorEventRoutingEffect, PointerEditorEvent } from "./events";
+import type { SelectionHandle } from "../selection/selection";
+import type { HandleSnapContext, HandleSnapMode } from "../snapping/snapTypes";
+export interface SelectionHandleInteractionInput {
+    handle: SelectionHandle;
+    shape: ShapeRecord;
+    originPagePoint: Vec;
+}
+export interface PointerDragInteractionSession {
+    readonly shapeId: ShapeId;
+    readonly operationKind: string;
+    readonly shouldClearBindingPreviewOnExit?: boolean;
+    onDragStart?(input: {
+        editor: Editor;
+    }): void;
+    onClick?(input: {
+        editor: Editor;
+        source: ChangeSource;
+    }): void;
+    onDoubleClick?(input: {
+        editor: Editor;
+        source: ChangeSource;
+    }): void;
+    onCancel?(input: {
+        editor: Editor;
+        reason: CancelEditorEvent["reason"];
+    }): void;
+    onComplete?(input: {
+        editor: Editor;
+    }): void;
+    update(input: {
+        editor: Editor;
+        pagePoint: Vec;
+        accelKey: boolean;
+        source: ChangeSource;
+    }): "continue" | "stop" | PointerDragInteractionUpdateResult;
+}
+export interface PointerDragInteractionUpdateResult {
+    status: "continue" | "stop";
+    finalPagePoint?: Vec | null;
+}
+export interface SelectionHandleInteractionSession extends PointerDragInteractionSession {
+    readonly handleSnapMode?: HandleSnapMode;
+    readonly handleSnapContext?: HandleSnapContext;
+    readonly allowSelfSnap?: boolean;
+    readonly excludedSnapShapeIds?: readonly ShapeId[];
+}
+export type SelectionHandleInteractionUpdateResult = PointerDragInteractionUpdateResult;
+export interface SelectionHandleInteractionHandler {
+    createSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
+}
+export interface ShapePointerInteractionInput {
+    shape: ShapeRecord;
+    selectionTargetId: ShapeId;
+    originPagePoint: Vec;
+    event: PointerEditorEvent;
+}
+export interface ShapePointerInteractionHandler {
+    createSession(editor: Editor, input: ShapePointerInteractionInput): PointerDragInteractionSession | null;
+}
+export interface EditorEventInteractionHandler {
+    handleEvent(editor: Editor, event: EditorEvent, context: EditorEventContext): EditorEventRoutingEffect | void;
+}
+export interface LandInteractionHandler {
+    id: string;
+    enabledInReadonly?: boolean;
+    editorEvent?: EditorEventInteractionHandler;
+    selectionHandle?: SelectionHandleInteractionHandler;
+    shapePointer?: ShapePointerInteractionHandler;
+}
+export declare class InteractionHandlerRegistry {
+    private readonly handlers;
+    private readonly registeredIds;
+    register(handler: LandInteractionHandler): void;
+    getHandlers(): readonly LandInteractionHandler[];
+    handleEvent(editor: Editor, event: EditorEvent, context: EditorEventContext): EditorEventRoutingEffect | undefined;
+    broadcastEvent(editor: Editor, event: EditorEvent, context: EditorEventContext): EditorEventRoutingEffect | undefined;
+    createSelectionHandleSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
+    createShapePointerSession(editor: Editor, input: ShapePointerInteractionInput): PointerDragInteractionSession | null;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/editor/events/keyboardShortcuts.d.ts

@@ -0,0 +1,23 @@
+import type { KeyboardEditorEvent } from "./events";
+export interface KeyboardShortcutChord {
+    key: string;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    accelKey?: boolean;
+}
+export type KeyboardShortcutInput = string | KeyboardShortcutChord;
+export type KeyboardShortcutEventLike = Pick<KeyboardEditorEvent, "key" | "altKey" | "ctrlKey" | "metaKey" | "shiftKey" | "accelKey">;
+interface NormalizedKeyboardShortcutChord {
+    key: string;
+    altKey: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey: boolean;
+    accelKey?: boolean;
+}
+export declare function normalizeKeyboardShortcut(shortcut: KeyboardShortcutInput): NormalizedKeyboardShortcutChord;
+export declare function formatKeyboardShortcut(shortcut: KeyboardShortcutInput): string;
+export declare function doesKeyboardShortcutMatch(shortcut: KeyboardShortcutInput, event: KeyboardShortcutEventLike): boolean;
+export {};

package/_vendor/plugin-laser/_vendor/canvas-core/editor/events/pointerClickRecognizer.d.ts

@@ -0,0 +1,11 @@
+import type { DoubleClickEditorEvent, EditorEvent, EditorEventContext, EditorEventRoutingEffect } from "./events";
+export declare class PointerClickRecognizer {
+    private lastPointerDown;
+    private lastPointerUp;
+    private currentClickCount;
+    createContext(event: EditorEvent, origin: EditorEventContext["origin"]): EditorEventContext;
+    complete(event: EditorEvent, context: EditorEventContext, effect?: EditorEventRoutingEffect | void): DoubleClickEditorEvent | null;
+    private isContinuation;
+    private matchesCurrentPointer;
+    private reset;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/editor/history/historyManager.d.ts

@@ -0,0 +1,40 @@
+import type { Signal } from "../../../signals/index";
+import { type StoreHistoryEntry } from "../../../store/index";
+import type { DocumentRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+export interface HistoryState {
+    canUndo: boolean;
+    canRedo: boolean;
+}
+/** A temporary modal history source that takes priority over document history. */
+export interface HistoryScope {
+    getState(): HistoryState;
+    subscribe(listener: () => void): () => void;
+    undo(): boolean;
+    redo(): boolean;
+}
+/**
+ * Records undoable user commits, routes temporary history scopes, and replays
+ * document history through EditorOperationManager without recording it again.
+ */
+export declare class HistoryManager {
+    private readonly editor;
+    private readonly buffer;
+    private readonly activeScopes;
+    private readonly stateAtom;
+    private readonly unsubscribeOperations;
+    private isDisposed;
+    readonly state: Signal<HistoryState>;
+    constructor(editor: Editor);
+    clear(): void;
+    activateScope(scope: HistoryScope): () => void;
+    dispose(): void;
+    undo(): boolean;
+    redo(): boolean;
+    getEntries(): readonly StoreHistoryEntry<DocumentRecord>[];
+    private handleCommit;
+    private deactivateScope;
+    private step;
+    private replay;
+    private publishEffectiveState;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/editor/history/operationManager.d.ts

@@ -0,0 +1,77 @@
+import { type ChangeSource, type RecordsDiff } from "../../../store/index";
+import { type DocumentRecord } from "../../schema/records";
+import type { DocumentSnapshot, SessionSnapshot } from "../../schema/snapshots";
+import type { Editor } from "../editor";
+export type EditorOperationHistory = "record" | "ignore";
+export interface EditorOperationOptions {
+    /** Stable semantic name such as `shape.translate` or `history.undo`. */
+    kind: string;
+    label?: string;
+    source?: ChangeSource;
+    /** Controls undo recording without suppressing commit publication. */
+    history?: EditorOperationHistory;
+}
+/**
+ * The net document change published at the end of a root editor operation.
+ * Store listeners still observe every realtime batch that produced this commit.
+ */
+export interface EditorCommit {
+    id: string;
+    revision: number;
+    kind: string;
+    label: string;
+    source: ChangeSource;
+    history: EditorOperationHistory;
+    diff: RecordsDiff<DocumentRecord>;
+    snapshot: DocumentSnapshot;
+    sessionSnapshot: SessionSnapshot;
+}
+export interface EditorOperation {
+    readonly id: string;
+    readonly kind: string;
+    readonly source: ChangeSource;
+    readonly isActive: boolean;
+    commit(): EditorCommit | null;
+    cancel(): void;
+}
+interface EditorOperationState {
+    id: string;
+    kind: string;
+    label: string;
+    source: ChangeSource;
+    history: EditorOperationHistory;
+    parent: EditorOperationState | null;
+    diff: RecordsDiff<DocumentRecord>;
+    status: "active" | "committed" | "cancelled";
+}
+type CommitListener = (commit: EditorCommit) => void;
+/**
+ * Groups realtime document Store changes into semantic editor operations.
+ *
+ * This is not the Store transaction boundary and does not own the undo stack.
+ * It collects already-committed Store diffs, supports operation rollback, and
+ * publishes one EditorCommit for HistoryManager and persistence consumers.
+ */
+export declare class EditorOperationManager {
+    private readonly editor;
+    private readonly onUnhandledError;
+    private readonly stack;
+    private readonly commitListeners;
+    private readonly commitQueue;
+    private nextOperationId;
+    private revision;
+    private isDrainingCommitQueue;
+    constructor(editor: Editor, onUnhandledError?: (error: unknown) => void);
+    begin(options: EditorOperationOptions): EditorOperation;
+    run<T>(options: EditorOperationOptions, fn: () => T): T;
+    getActive(): EditorOperation | null;
+    subscribe(listener: CommitListener): () => void;
+    commit(state: EditorOperationState): EditorCommit | null;
+    cancel(state: EditorOperationState): void;
+    private handleStoreChange;
+    private getActiveState;
+    private assertTopActive;
+    private enqueueCommit;
+    private reportUnhandledError;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import type { Editor } from "./editor";
+import type { Store } from "../../store/index";
+import type { EditorRecord } from "../schema/records";
+declare const editorStoreSymbol: unique symbol;
+export declare function setEditorStore(editor: Editor, store: Store<EditorRecord>): void;
+export declare function getEditorStore(editor: Editor): Store<EditorRecord>;
+export { editorStoreSymbol };

package/_vendor/plugin-laser/_vendor/canvas-core/editor/queries/bindingQueryCache.d.ts

@@ -0,0 +1,28 @@
+import type { Signal } from "../../../signals/index";
+import { type BindingRecord, type ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare class BindingQueryCache {
+    private readonly editor;
+    private state;
+    private readonly bindingsFromShapeSignals;
+    private readonly bindingsToShapeSignals;
+    private readonly bindingsForShapeSignals;
+    private draftBindingIndex;
+    private readonly unsubscribeFromStore;
+    constructor(editor: Editor);
+    dispose(): void;
+    getBindingsFromShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsFromShapeSignal(shapeId: ShapeId): Signal<readonly BindingRecord[]>;
+    getBindingsToShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsToShapeSignal(shapeId: ShapeId): Signal<readonly BindingRecord[]>;
+    getBindingsForShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsForShapeSignal(shapeId: ShapeId): Signal<readonly BindingRecord[]>;
+    private handleStoreChange;
+    private updateCachedSignals;
+    private getBindingsFromState;
+    private getBindingsToState;
+    private getBindingsForState;
+    private getBindingsForIds;
+    private getDraftBindingIndex;
+    private getDraftBindingsForRelation;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/editor/queries/bindingQueryState.d.ts

@@ -0,0 +1,11 @@
+import type { StoreChange } from "../../../store/index";
+import { type BindingId, type BindingRecord, type EditorRecord, type ShapeId } from "../../schema/records";
+export interface BindingQueryState {
+    bindingById: Map<BindingId, BindingRecord>;
+    bindingIdsByFromShape: Map<ShapeId, BindingId[]>;
+    bindingIdsByToShape: Map<ShapeId, BindingId[]>;
+    relatedBindingIdsByShape: Map<ShapeId, BindingId[]>;
+}
+export declare function compareBindings(left: BindingRecord, right: BindingRecord): number;
+export declare function buildBindingQueryState(records: readonly EditorRecord[]): BindingQueryState;
+export declare function updateBindingQueryState(previous: BindingQueryState, change: StoreChange<EditorRecord>): BindingQueryState;

package/_vendor/plugin-laser/_vendor/canvas-core/editor/queries/draftBindingIndex.d.ts

@@ -0,0 +1,19 @@
+import type { RecordsDiff } from "../../../store/index";
+import { type BindingId, type BindingRecord, type EditorRecord, type ShapeId } from "../../schema/records";
+export type BindingRelation = "from" | "to" | "related";
+interface DraftRelationIndex {
+    changesByShape: Map<ShapeId, Map<BindingId, BindingRecord | undefined>>;
+    cacheByShape: Map<ShapeId, readonly BindingRecord[]>;
+}
+export interface DraftBindingIndex {
+    revision: number;
+    relations: Record<BindingRelation, DraftRelationIndex>;
+}
+export declare function createDraftBindingIndex(revision: number, diff: RecordsDiff<EditorRecord>): DraftBindingIndex;
+export declare function getDraftBindingsForRelation({ committed, draftIndex, relation, shapeId, }: {
+    committed: readonly BindingRecord[];
+    draftIndex: DraftBindingIndex;
+    relation: BindingRelation;
+    shapeId: ShapeId;
+}): readonly BindingRecord[];
+export {};

package/_vendor/plugin-laser/_vendor/canvas-core/editor/queries/shapeGeometryQueryCache.d.ts

@@ -0,0 +1,34 @@
+import type { Signal } from "../../../signals/index";
+import { Box } from "../../geometry/box";
+import { Mat } from "../../geometry/mat";
+import { Vec } from "../../geometry/vec";
+import { type ShapeId, type ShapeParentId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type ShapeGeometry } from "./shapeTransforms";
+type ShapeReader = (id: ShapeId) => ShapeRecord | undefined;
+export declare function resolveShapeParentToPageTransform(editor: Editor, parentId: ShapeParentId, readShape: ShapeReader): Mat | undefined;
+export declare class ShapeGeometryQueryCache {
+    private readonly editor;
+    private readonly signalsByShapeId;
+    private readonly unsubscribeFromStore;
+    constructor(editor: Editor);
+    dispose(): void;
+    getCachedShapeGeometry(shapeId: ShapeId): ShapeGeometry | undefined;
+    getShapePageBoundsSignal(shapeId: ShapeId): Signal<Box | undefined>;
+    getShapeLocalToPageTransformSignal(shapeId: ShapeId): Signal<Mat | undefined>;
+    getShapeGeometry(shapeId: ShapeId): ShapeGeometry | undefined;
+    getShapeLocalToPageTransform(shapeId: ShapeId): Mat | undefined;
+    getShapeParentToPageTransform(parentId: ShapeParentId): Mat | undefined;
+    getShapePositionedToPageTransform(shapeId: ShapeId): Mat | undefined;
+    getShapePageBounds(shapeId: ShapeId): Box | undefined;
+    getShapePositionedBounds(shapeId: ShapeId): Box | undefined;
+    getShapePageCenter(shapeId: ShapeId): Vec | undefined;
+    getShapePageCorners(shapeId: ShapeId): Vec[] | undefined;
+    getShapePageOutlineVertices(shapeId: ShapeId): Vec[] | undefined;
+    getShapeClipAncestorIds(shapeId: ShapeId): ShapeId[];
+    getShapeClipAncestorIdsSignal(shapeId: ShapeId): Signal<ShapeId[]>;
+    isPagePointInShapeClip(shapeId: ShapeId, point: Vec): boolean;
+    getShapeClippedPageBounds(shapeId: ShapeId): Box | null;
+    private getOrCreateSignals;
+}
+export {};

package/_vendor/plugin-laser/_vendor/canvas-core/editor/queries/shapeTransforms.d.ts

@@ -0,0 +1,43 @@
+import { Box } from "../../geometry/box";
+import { Mat } from "../../geometry/mat";
+import { Vec } from "../../geometry/vec";
+import type { ShapeRecord } from "../../schema/records";
+import type { ShapeUtil } from "../../shapes/shapeUtil";
+export interface ShapeGeometry {
+    bounds: Box;
+    center: Vec;
+    corners: Vec[];
+    outlineVertices: Vec[];
+}
+export interface ShapeTransformFields {
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+}
+export interface ShapeTransformDecompositionOptions {
+    epsilon?: number;
+    preferredRotation?: number;
+    preferredScaleXSign?: number;
+    preferredScaleYSign?: number;
+}
+/**
+ * Strictly decompose a local-to-parent affine transform into the shape model's
+ * translate/rotate/scale fields. Non-orthogonal matrices cannot be represented
+ * without shear and therefore return null.
+ */
+export declare function getShapeTransformFieldsFromMatrix(matrix: Mat, localBounds: Box, options?: ShapeTransformDecompositionOptions): ShapeTransformFields | null;
+export declare function getShapeLocalToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Mat;
+export declare function getShapePositionedToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Mat;
+export declare function getShapeRenderToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Mat;
+export declare function getShapeExportToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Mat;
+export declare function getShapePageCenter<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Vec;
+export declare function positionedShapePointToPagePoint<S extends ShapeRecord>(shape: S, point: Vec, util: ShapeUtil<S>, parentToPage: Mat): Vec;
+export declare function pagePointToShapePositionedPoint<S extends ShapeRecord>(shape: S, point: Vec, util: ShapeUtil<S>, parentToPage: Mat): Vec;
+export declare function getShapePositionedOutlineVertices<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Vec[];
+export declare function getShapePageCorners<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Vec[];
+export declare function getShapePageOutlineVertices<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Vec[];
+export declare function getShapePageBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Box;
+export declare function getShapeExportPageBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Box;
+export declare function getShapeGeometry<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): ShapeGeometry;

package/_vendor/plugin-laser/_vendor/canvas-core/editor/queries/shapeTreeIndex.d.ts

@@ -0,0 +1,27 @@
+import type { Signal } from "../../../signals/index";
+import { type PageId, type PageRecord, type ShapeId, type ShapeParentId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { ShapeTreeSnapshotEntry } from "../state/editorReadModels";
+export declare class ShapeTreeIndex {
+    private readonly editor;
+    readonly pagesSignal: Signal<PageRecord[]>;
+    readonly currentPageShapeIdsSignal: Signal<ShapeId[]>;
+    readonly currentPageShapesSignal: Signal<ShapeRecord[]>;
+    readonly currentPageShapeTreeSignal: Signal<ShapeTreeSnapshotEntry[]>;
+    private readonly stateAtom;
+    private readonly pagesAtom;
+    private readonly pageShapeIdsSignals;
+    private readonly unsubscribeFromStore;
+    constructor(editor: Editor, currentPageIdSignal: Signal<PageId>);
+    dispose(): void;
+    getShapeIdsForPageSignal(pageId: PageId): Signal<ShapeId[]>;
+    getShapeIdsForPage(pageId: PageId): ShapeId[];
+    getShapesForPage(pageId: PageId): ShapeRecord[];
+    getChildShapeIds(parentId: ShapeParentId): ShapeId[];
+    getChildShapes(parentId: ShapeParentId): ShapeRecord[];
+    getDescendantShapeIds(parentId: ShapeParentId): ShapeId[];
+    getPageIdForShape(shapeId: ShapeId): PageId | null;
+    private getShapeIdsForPageSnapshot;
+    private getChildShapeIdsSnapshot;
+    private handleStoreChange;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/editor/queries/shapeTreeIndexState.d.ts

@@ -0,0 +1,11 @@
+import type { StoreChange } from "../../../store/index";
+import { type EditorRecord, type PageId, type ShapeId, type ShapeParentId } from "../../schema/records";
+export interface ShapeTreeIndexState {
+    pageShapeIdsByPage: Map<PageId, ShapeId[]>;
+    childShapeIdsByParent: Map<ShapeParentId, ShapeId[]>;
+    pageIdByShape: Map<ShapeId, PageId>;
+}
+type ReadEditorRecord = (id: string) => EditorRecord | undefined;
+export declare function buildShapeTreeIndexState(records: readonly EditorRecord[]): ShapeTreeIndexState;
+export declare function updateShapeTreeIndexState(previous: ShapeTreeIndexState, change: StoreChange<EditorRecord>, getRecord: ReadEditorRecord): ShapeTreeIndexState;
+export {};

package/_vendor/plugin-laser/_vendor/canvas-core/editor/queries/spatialIndexManager.d.ts

@@ -0,0 +1,34 @@
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { PageId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { ShapeGeometryQueryCache } from "./shapeGeometryQueryCache";
+import type { ShapeTreeIndex } from "./shapeTreeIndex";
+export interface SpatialQueryOptions {
+    pageId?: PageId;
+}
+export interface ShapeAtPointOptions extends SpatialQueryOptions {
+    filter?: (shape: ShapeRecord) => boolean;
+    hitTest?: "point" | "bindingTarget";
+}
+export interface ShapeLineSegmentHitTestOptions extends SpatialQueryOptions {
+    margin?: number;
+    filter?: (shape: ShapeRecord) => boolean;
+}
+export declare class SpatialIndexManager {
+    private readonly editor;
+    private readonly shapeTree;
+    private readonly geometry;
+    private readonly pageIndexSignals;
+    constructor(editor: Editor, shapeTree: ShapeTreeIndex, geometry: ShapeGeometryQueryCache);
+    getShapesInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
+    getShapeIdsInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeRecord["id"][];
+    getShapesInViewport(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
+    getShapeIdsInViewport(bounds: Box, options?: SpatialQueryOptions): ShapeRecord["id"][];
+    getShapeAtPoint(point: Vec, options?: ShapeAtPointOptions): ShapeRecord | null;
+    getShapesAtPoint(point: Vec, options?: ShapeAtPointOptions): ShapeRecord[];
+    getShapesHitByLineSegment(start: Vec, end: Vec, options?: ShapeLineSegmentHitTestOptions): ShapeRecord[];
+    private doesLineSegmentIntersectShapeClip;
+    private getPageIndexSignal;
+    private getPageIndex;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/editor/records/documentSnapshots.d.ts

@@ -0,0 +1,14 @@
+import { type ChangeSource } from "../../../store/index";
+import { type EditorRecord } from "../../schema/records";
+import { type DocumentSnapshot, type SessionSnapshot } from "../../schema/snapshots";
+import type { Editor } from "../editor";
+export declare function createInitialEditorRecords(documentMeta?: Record<string, unknown>): EditorRecord[];
+export declare function getEditorDocumentSnapshot(editor: Editor): DocumentSnapshot;
+export declare function getEditorSessionSnapshot(editor: Editor): SessionSnapshot;
+export declare function loadEditorDocumentSnapshot(editor: Editor, snapshot: unknown, options?: {
+    source?: ChangeSource;
+}): void;
+export declare function loadEditorSessionSnapshot(editor: Editor, snapshot: unknown, options?: {
+    source?: ChangeSource;
+}): void;
+export declare function syncAfterDocumentRestore(editor: Editor): void;

package/_vendor/plugin-laser/_vendor/canvas-core/editor/records/editorRecordFactory.d.ts

@@ -0,0 +1,19 @@
+import { type AssetRecord, type BindingRecord, type PageRecord, type ShapeRecord } from "../../schema/records";
+import type { CreateAssetInput, CreateBindingInput, CreatePageInput, CreateShapeInput } from "../commands/commandTypes";
+import type { Editor } from "../editor";
+export declare function getEditorRecordFactory(editor: Editor): EditorRecordFactory;
+export declare function createEditorRecordFactory(editor: Editor): EditorRecordFactory;
+export declare class EditorRecordFactory {
+    private readonly editor;
+    private nextShapeNumber;
+    private nextPageNumber;
+    private nextBindingNumber;
+    private nextAssetNumber;
+    constructor(editor: Editor);
+    createPage(input?: CreatePageInput): PageRecord;
+    createShape(input: CreateShapeInput): ShapeRecord;
+    createBinding(input: CreateBindingInput): BindingRecord;
+    createAsset(input: CreateAssetInput): AssetRecord;
+    createShapeIndex(shapeNumber: number): string;
+    syncCounters(): void;
+}

package/_vendor/plugin-laser/_vendor/canvas-core/editor/records/recordQueries.d.ts

@@ -0,0 +1,3 @@
+import type { AssetId, PageId, ShapeId, ShapeRecord } from "../../schema/records";
+export declare function getShapePageIdFromParentChain(shape: ShapeRecord, shapeById: ReadonlyMap<ShapeId, ShapeRecord>, pageIds: ReadonlySet<PageId>): PageId | null;
+export declare function getShapeAssetId(shape: ShapeRecord): AssetId | null;