@yuzhouu/canvas-kit 0.1.2 → 0.1.3

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

@@ -0,0 +1,97 @@
+import { Box } from "../geometry/Box";
+import { Vec } from "../geometry/Vec";
+import type { SelectionResizeHandleId } from "./selection";
+export interface SelectionResizeBoundsResult {
+    bounds: Box;
+    scaleX: number;
+    scaleY: number;
+}
+export interface SelectionResizeScalesResult {
+    scaleX: number;
+    scaleY: number;
+}
+export declare function selectionResizeHandleMovesLeftEdge(handleId: SelectionResizeHandleId): boolean;
+export declare function selectionResizeHandleMovesRightEdge(handleId: SelectionResizeHandleId): boolean;
+export declare function selectionResizeHandleMovesTopEdge(handleId: SelectionResizeHandleId): boolean;
+export declare function selectionResizeHandleMovesBottomEdge(handleId: SelectionResizeHandleId): boolean;
+export declare function isSelectionResizeCorner(handleId: SelectionResizeHandleId): boolean;
+export declare function getSelectionResizeHandleForScale({ handleId, scaleX, scaleY, }: {
+    handleId: SelectionResizeHandleId;
+    scaleX: number;
+    scaleY: number;
+}): SelectionResizeHandleId;
+export declare function getSelectionResizeScalesFromBounds({ startBounds, bounds, handleId, scaleX, scaleY, isResizingFromCenter, }: {
+    startBounds: Box;
+    bounds: Box;
+    handleId: SelectionResizeHandleId;
+    scaleX?: number;
+    scaleY?: number;
+    isResizingFromCenter?: boolean;
+}): SelectionResizeScalesResult;
+export declare function getAnchoredSelectionResizeLocalBounds({ requestedBounds, handleId, actualWidth, actualHeight, scaleX, scaleY, isResizingFromCenter, }: {
+    requestedBounds: Box;
+    handleId: SelectionResizeHandleId;
+    actualWidth: number;
+    actualHeight: number;
+    scaleX: number;
+    scaleY: number;
+    isResizingFromCenter: boolean;
+}): Box;
+export declare function getSelectionResizeBounds({ startBounds, handleId, pagePoint, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+}): Box;
+export declare function getSelectionResizeBoundsWithScale({ startBounds, handleId, pagePoint, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+}): SelectionResizeBoundsResult;
+export declare function getCenteredSelectionResizeBounds({ startBounds, handleId, pagePoint, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+}): Box;
+export declare function getCenteredSelectionResizeBoundsWithScale({ startBounds, handleId, pagePoint, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+}): SelectionResizeBoundsResult;
+export declare function getAspectRatioLockedSelectionResizeBounds({ bounds, startBounds, handleId, aspectRatio, isResizingFromCenter, }: {
+    bounds: Box;
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    aspectRatio: number;
+    isResizingFromCenter: boolean;
+}): Box;
+export declare function getAspectRatioLockedSelectionResizeBoundsWithScale({ bounds, startBounds, handleId, aspectRatio, isResizingFromCenter, scaleX, scaleY, }: {
+    bounds: Box;
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    aspectRatio: number;
+    isResizingFromCenter: boolean;
+    scaleX?: number;
+    scaleY?: number;
+}): SelectionResizeBoundsResult;
+export declare function getConstrainedSelectionResizeBounds({ startBounds, handleId, pagePoint, isAspectRatioLocked, isResizingFromCenter, aspectRatio, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+    isAspectRatioLocked: boolean;
+    isResizingFromCenter: boolean;
+    aspectRatio: number;
+}): Box;
+export declare function getConstrainedSelectionResizeBoundsWithScale({ startBounds, handleId, pagePoint, isAspectRatioLocked, isResizingFromCenter, aspectRatio, }: {
+    startBounds: Box;
+    handleId: SelectionResizeHandleId;
+    pagePoint: Vec;
+    isAspectRatioLocked: boolean;
+    isResizingFromCenter: boolean;
+    aspectRatio: number;
+}): SelectionResizeBoundsResult;
+export declare function normalizeSelectionResizeBoundsFromEdges({ minX, minY, maxX, maxY, }: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}): Box;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,48 @@
+import { Box } from "../geometry/Box";
+import type { Editor } from "../editor/Editor";
+import type { AssetId, ShapeId, ShapeRecordBase } from "../schema/records";
+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;
+}
+export interface ShapeSvgExporter<S extends ShapeRecordBase = ShapeRecordBase> {
+    type: S["type"];
+    toSvg(shape: S, context: SvgExportContext): SvgNode | null;
+}
+export interface SvgExportOptions {
+    padding?: number;
+    background?: string;
+}
+export interface SvgExportResult {
+    svg: string;
+    bounds: Box;
+    width: number;
+    height: number;
+    requestedShapeIds: ShapeId[];
+    exportedShapeIds: ShapeId[];
+    skippedShapes: SvgExportSkippedShape[];
+}
+export type SvgExportSkipReason = "missing-shape" | "missing-bounds" | "missing-exporter" | "empty-output";
+export interface SvgExportSkippedShape {
+    id: ShapeId;
+    reason: SvgExportSkipReason;
+}
+export declare class ShapeSvgExporterRegistry {
+    private readonly registry;
+    register<S extends ShapeRecordBase>(exporter: ShapeSvgExporter<S>): void;
+    get(type: ShapeRecordBase["type"]): ShapeSvgExporter | null;
+    has(type: ShapeRecordBase["type"]): boolean;
+    unregister(type: ShapeRecordBase["type"]): boolean;
+    values(): IterableIterator<ShapeSvgExporter>;
+}
+export declare function exportShapesToSvgString(editor: Editor, shapeIds: Iterable<ShapeId>, exporters: ShapeSvgExporterRegistry, options?: SvgExportOptions): SvgExportResult | null;
+export declare function renderSvgNode(node: SvgNode): string;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/_vendor/canvas-core/geometry/{index.ts → index.d.ts}

@@ -5,9 +5,4 @@ export { Geometry2d } from "./Geometry2d";
 export { Rectangle2d } from "./Rectangle2d";
 export { Ellipse2d } from "./Ellipse2d";
 export { Polyline2d } from "./Polyline2d";
-export {
-  distanceBetweenSegments,
-  distanceToSegment,
-  nearestPointOnSegment,
-  segmentsIntersect,
-} from "./segments";
+export { distanceBetweenSegments, distanceToSegment, nearestPointOnSegment, segmentsIntersect, } from "./segments";

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

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