@yuzhouu/canvas-standard 0.1.0

package/_vendor/plugin-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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-text/_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;

package/_vendor/plugin-text/_vendor/canvas-core/schema/records.d.ts

@@ -0,0 +1,115 @@
+export type RecordScope = "document" | "session";
+export type PageId = `page:${string}`;
+export type DocumentId = "document:main";
+export type ShapeId = `shape:${string}`;
+export type BindingId = `binding:${string}`;
+export type AssetId = `asset:${string}`;
+export type SessionId = "session:main";
+export type ShapeParentId = PageId | ShapeId;
+export type PageCameraById = Partial<Record<PageId, Camera>>;
+export type PageSelectionById = Partial<Record<PageId, ShapeId[]>>;
+export interface ShapeEditingPoint {
+    x: number;
+    y: number;
+}
+export type ShapeEditingEntryMode = "selectAll" | "placeCaret" | "focusEnd";
+export interface ShapeEditingEntryRequest {
+    id: number;
+    shapeId: ShapeId;
+    entryMode: ShapeEditingEntryMode;
+    caretPagePoint?: ShapeEditingPoint;
+}
+export interface ShapeEditingSession {
+    shapeId: ShapeId;
+    operationKind: string;
+    entryMode: ShapeEditingEntryMode;
+    caretPagePoint?: ShapeEditingPoint;
+    isComposing: boolean;
+}
+export interface Camera {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface BaseRecord {
+    id: string;
+    typeName: string;
+    scope: RecordScope;
+    meta: Record<string, unknown>;
+}
+export interface DocumentMetadataRecord extends BaseRecord {
+    id: DocumentId;
+    typeName: "document";
+    scope: "document";
+}
+export interface PageRecord extends BaseRecord {
+    id: PageId;
+    typeName: "page";
+    scope: "document";
+    name: string;
+    index: string;
+}
+export interface ShapeRecordBase<Type extends string = string, Props extends object = object> extends BaseRecord {
+    id: ShapeId;
+    typeName: "shape";
+    scope: "document";
+    type: Type;
+    parentId: ShapeParentId;
+    index: string;
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    opacity: number;
+    isHidden: boolean;
+    isLocked: boolean;
+    props: Props;
+}
+export interface BindingRecordBase<Type extends string = string, Props extends object = object> extends BaseRecord {
+    id: BindingId;
+    typeName: "binding";
+    scope: "document";
+    type: Type;
+    fromId: ShapeId;
+    toId: ShapeId;
+    props: Props;
+}
+export interface AssetRecordBase<Type extends string = string, Props extends object = object> extends BaseRecord {
+    id: AssetId;
+    typeName: "asset";
+    scope: "document";
+    type: Type;
+    props: Props;
+}
+export type ShapeRecord = ShapeRecordBase<string, object>;
+export type BindingRecord = BindingRecordBase<string, object>;
+export type AssetRecord = AssetRecordBase<string, object>;
+export interface SessionRecord extends BaseRecord {
+    id: SessionId;
+    typeName: "session";
+    scope: "session";
+    currentPageId: PageId;
+    activeToolId: string;
+    isToolLocked: boolean;
+    editingShapeId: ShapeId | null;
+    shapeEditingSession: ShapeEditingSession | null;
+    pageCameraById: PageCameraById;
+    pageSelectedShapeIdsById: PageSelectionById;
+}
+export type DocumentRecord = DocumentMetadataRecord | PageRecord | ShapeRecord | BindingRecord | AssetRecord;
+export type EditorRecord = DocumentRecord | SessionRecord;
+export declare const DEFAULT_DOCUMENT_ID: DocumentId;
+export declare const DEFAULT_PAGE_ID: PageId;
+export declare const DEFAULT_SESSION_ID: SessionId;
+export declare const DEFAULT_CAMERA: Camera;
+export declare function createDefaultDocument(meta?: Record<string, unknown>): DocumentMetadataRecord;
+export declare function createDefaultPage(): PageRecord;
+export declare function createDefaultSession(currentPageId?: PageId): SessionRecord;
+export declare function isPageRecord(record: BaseRecord | null | undefined): record is PageRecord;
+export declare function isDocumentMetadataRecord(record: BaseRecord | null | undefined): record is DocumentMetadataRecord;
+export declare function isShapeRecord(record: BaseRecord | null | undefined): record is ShapeRecord;
+export declare function isSessionRecord(record: BaseRecord | null | undefined): record is SessionRecord;
+export declare function isBindingRecord(record: BaseRecord | null | undefined): record is BindingRecord;
+export declare function isAssetRecord(record: BaseRecord | null | undefined): record is AssetRecord;
+export declare function isDocumentRecord(record: EditorRecord): record is DocumentRecord;

package/_vendor/plugin-text/_vendor/canvas-core/schema/snapshots.d.ts

@@ -0,0 +1,22 @@
+import type { ShapeUtilRegistry } from "../shapes/shapeUtilRegistry";
+import type { BindingUtilRegistry } from "../bindings/bindingUtilRegistry";
+import type { StoreSnapshot } from "../../store/index";
+import { type DocumentRecord, type SessionRecord } from "./records";
+export type DocumentSnapshot = StoreSnapshot<DocumentRecord, 3>;
+export type SessionSnapshot = StoreSnapshot<SessionRecord, 1>;
+export declare class SnapshotParseError extends Error {
+    constructor(message: string);
+}
+declare const CURRENT_DOCUMENT_SNAPSHOT_VERSION: 3;
+declare const CURRENT_SESSION_SNAPSHOT_VERSION: 1;
+export declare function getSnapshotEnvelope(snapshot: unknown, kind: "document"): {
+    schemaVersion: typeof CURRENT_DOCUMENT_SNAPSHOT_VERSION;
+    records: unknown[];
+};
+export declare function getSnapshotEnvelope(snapshot: unknown, kind: "session"): {
+    schemaVersion: typeof CURRENT_SESSION_SNAPSHOT_VERSION;
+    records: unknown[];
+};
+export declare function parseDocumentSnapshot(snapshot: unknown, shapeUtils: ShapeUtilRegistry, bindingUtils: BindingUtilRegistry): DocumentSnapshot;
+export declare function parseSessionSnapshot(snapshot: unknown): SessionSnapshot;
+export {};

package/_vendor/plugin-text/_vendor/canvas-core/shapes/childTransformPolicy.d.ts

@@ -0,0 +1,16 @@
+import type { ShapeRecordBase } from "../schema/records";
+export type ChildTransformPolicy = "isometry" | "similarity";
+export declare const CHILD_TRANSFORM_POLICY_EPSILON = 1e-8;
+export interface ChildTransformPolicyProvider<S extends ShapeRecordBase = ShapeRecordBase> {
+    canReceiveChildren(shape: S): boolean;
+    getChildTransformPolicy(shape: S): ChildTransformPolicy;
+}
+export interface ChildTransformPolicyViolation {
+    shapeId: ShapeRecordBase["id"];
+    shapeType: ShapeRecordBase["type"];
+    policy: ChildTransformPolicy;
+    scaleX: number;
+    scaleY: number;
+}
+export declare function getChildTransformPolicyViolation<S extends ShapeRecordBase>(shape: S, provider: ChildTransformPolicyProvider<S>, epsilon?: number): ChildTransformPolicyViolation | null;
+export declare function formatChildTransformPolicyViolation(violation: ChildTransformPolicyViolation): string;

package/_vendor/plugin-text/_vendor/canvas-core/shapes/colors.d.ts

@@ -0,0 +1,26 @@
+export declare const LAND_THEME_COLOR_SLOTS: readonly ["fill-blue", "fill-green", "fill-red", "fill-amber", "fill-white", "fill-slate", "stroke-blue", "stroke-green", "stroke-red", "stroke-orange", "stroke-slate", "stroke-muted", "text-slate", "text-blue", "text-green", "text-red"];
+export type ThemeColorSlot = (typeof LAND_THEME_COLOR_SLOTS)[number];
+export type ThemeColorTokenName = `--land-shape-${ThemeColorSlot}`;
+export type ThemeColorResolver = (token: ThemeColorTokenName, fallback: string) => string;
+export interface ThemeShapeColorRef {
+    kind: "theme";
+    slot: ThemeColorSlot;
+}
+export interface CustomShapeColorRef {
+    kind: "custom";
+    value: string;
+}
+export type ShapeColor = ThemeShapeColorRef | CustomShapeColorRef;
+export declare const LAND_THEME_COLOR_TOKEN_BY_SLOT: Record<ThemeColorSlot, ThemeColorTokenName>;
+export declare const LAND_DEFAULT_THEME_COLOR_FALLBACKS: Record<ThemeColorSlot, string>;
+export declare function createThemeShapeColor(slot: ThemeColorSlot): ThemeShapeColorRef;
+export declare function createCustomShapeColor(value: string): CustomShapeColorRef;
+export declare function isThemeShapeColorRef(value: unknown): value is ThemeShapeColorRef;
+export declare function isCustomShapeColorRef(value: unknown): value is CustomShapeColorRef;
+export declare function isShapeColor(value: unknown): value is ShapeColor;
+export declare function getThemeColorTokenName(slot: ThemeColorSlot): ThemeColorTokenName;
+export declare function normalizeShapeColor(value: unknown, fallback: ShapeColor): ShapeColor;
+export declare function shapeColorToCssColor(color: ShapeColor): string;
+export declare function resolveShapeColor(color: ShapeColor, resolveThemeColor?: ThemeColorResolver): string;
+export declare function isTransparentShapeColor(color: ShapeColor): boolean;
+export declare function areShapeColorsEqual(left: ShapeColor | null | undefined, right: ShapeColor | null | undefined): boolean;