@plait/draw 0.1.0-next.12 → 0.1.0-next.13

package/constants/image.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_IMAGE_WIDTH = 1000;

package/constants/index.d.ts

@@ -1,2 +1,3 @@
 export * from './geometry';
 export * from './pointer';
+export * from './image';

package/constants/pointer.d.ts

@@ -1,14 +1,4 @@
-export declare enum DrawPointerType {
-    text = "text",
-    rectangle = "rectangle",
-    line = "line",
-    diamond = "diamond",
-    roundRectangle = "roundRectangle",
-    parallelogram = "parallelogram",
-    ellipse = "ellipse",
-    triangle = "triangle",
-    leftArrow = "leftArrow",
-    trapezoid = "trapezoid",
-    rightArrow = "rightArrow"
-}
-export declare const GeometryPointer: DrawPointerType[];
+import { GeometryShape, LineShape } from '../interfaces';
+export type DrawPointerType = GeometryShape | LineShape;
+export declare const getGeometryPointers: () => string[];
+export declare const getLinePointers: () => string[];

package/engines/comment.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const CommentEngine: ShapeEngine;
+export declare const getCommentPoints: (rectangle: RectangleClient) => Point[];

package/engines/cross.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const CrossEngine: ShapeEngine;
+export declare const getCrossPoints: (rectangle: RectangleClient) => Point[];

package/{utils/engine → engines}/diamond.d.ts

@@ -1,2 +1,2 @@
-import { ShapeEngine } from '../../interfaces';
+import { ShapeEngine } from '../interfaces';
 export declare const DiamondEngine: ShapeEngine;

package/{utils/engine → engines}/ellipse.d.ts

@@ -1,4 +1,4 @@
 import { Point } from '@plait/core';
-import { ShapeEngine } from '../../interfaces';
+import { ShapeEngine } from '../interfaces';
 export declare const EllipseEngine: ShapeEngine;
 export declare function getNearestPointBetweenPointAndEllipse(point: Point, center: Point, rx: number, ry: number, rotation?: number): Point;

package/engines/hexagon.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const HexagonEngine: ShapeEngine;
+export declare const getHexagonPoints: (rectangle: RectangleClient) => Point[];

package/{utils/engine → engines}/index.d.ts

@@ -1,3 +1,3 @@
-import { GeometryShape, ShapeEngine } from '../../interfaces';
+import { GeometryShape, ShapeEngine } from '../interfaces';
 export declare const ShapeEngineMap: Record<GeometryShape, ShapeEngine>;
 export declare const getEngine: (shape: GeometryShape) => ShapeEngine;

package/{utils/engine → engines}/left-arrow.d.ts

@@ -1,4 +1,4 @@
 import { Point, RectangleClient } from '@plait/core';
-import { ShapeEngine } from '../../interfaces';
+import { ShapeEngine } from '../interfaces';
 export declare const LeftArrowEngine: ShapeEngine;
 export declare const getLeftArrowPoints: (rectangle: RectangleClient) => Point[];

package/engines/octagon.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const OctagonEngine: ShapeEngine;
+export declare const getOctagonPoints: (rectangle: RectangleClient) => Point[];

package/{utils/engine → engines}/parallelogram.d.ts

@@ -1,4 +1,4 @@
 import { Point, RectangleClient } from '@plait/core';
-import { ShapeEngine } from '../../interfaces';
+import { ShapeEngine } from '../interfaces';
 export declare const ParallelogramEngine: ShapeEngine;
 export declare const getParallelogramCornerPoints: (rectangle: RectangleClient) => Point[];

package/engines/pentagon-arrow.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const PentagonArrowEngine: ShapeEngine;
+export declare const getPentagonArrowPoints: (rectangle: RectangleClient) => Point[];

package/engines/pentagon.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const PentagonEngine: ShapeEngine;
+export declare const getPentagonPoints: (rectangle: RectangleClient) => Point[];

package/engines/process-arrow.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const ProcessArrowEngine: ShapeEngine;
+export declare const getProcessArrowPoints: (rectangle: RectangleClient) => Point[];

package/{utils/engine → engines}/rectangle.d.ts

@@ -1,2 +1,2 @@
-import { ShapeEngine } from '../../interfaces';
+import { ShapeEngine } from '../interfaces';
 export declare const RectangleEngine: ShapeEngine;

package/{utils/engine → engines}/right-arrow.d.ts

@@ -1,4 +1,4 @@
 import { Point, RectangleClient } from '@plait/core';
-import { ShapeEngine } from '../../interfaces';
+import { ShapeEngine } from '../interfaces';
 export declare const RightArrowEngine: ShapeEngine;
 export declare const getRightArrowPoints: (rectangle: RectangleClient) => Point[];

package/engines/round-comment.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const RoundCommentEngine: ShapeEngine;
+export declare const getRoundCommentPoints: (rectangle: RectangleClient) => Point[];

package/{utils/engine → engines}/round-rectangle.d.ts

@@ -1,5 +1,5 @@
 import { Point, RectangleClient } from '@plait/core';
-import { ShapeEngine } from '../../interfaces';
+import { ShapeEngine } from '../interfaces';
 export declare const RoundRectangleEngine: ShapeEngine;
 export declare const getRoundRectangleRadius: (rectangle: RectangleClient) => number;
 export declare function getNearestPointBetweenPointAndRoundRectangle(point: Point, rectangle: RectangleClient, radius: number): Point;

package/engines/star.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const StarEngine: ShapeEngine;
+export declare const getStarPoints: (rectangle: RectangleClient) => Point[];

package/{utils/engine → engines}/trapezoid.d.ts

@@ -1,4 +1,4 @@
 import { Point, RectangleClient } from '@plait/core';
-import { ShapeEngine } from '../../interfaces';
+import { ShapeEngine } from '../interfaces';
 export declare const TrapezoidEngine: ShapeEngine;
 export declare const getTrapezoidPoints: (rectangle: RectangleClient) => Point[];

package/{utils/engine → engines}/triangle.d.ts

@@ -1,4 +1,4 @@
 import { Point, RectangleClient } from '@plait/core';
-import { ShapeEngine } from '../../interfaces';
+import { ShapeEngine } from '../interfaces';
 export declare const TriangleEngine: ShapeEngine;
 export declare const getTrianglePoints: (rectangle: RectangleClient) => Point[];

package/engines/two-way-arrow.d.ts

@@ -0,0 +1,4 @@
+import { Point, RectangleClient } from '@plait/core';
+import { ShapeEngine } from '../interfaces';
+export declare const TwoWayArrowEngine: ShapeEngine;
+export declare const getTwoWayArrowPoints: (rectangle: RectangleClient) => Point[];

package/esm2022/constants/geometry.mjs

@@ -1,4 +1,4 @@
-import { ACTIVE_STROKE_WIDTH } from "@plait/core";
+import { ACTIVE_STROKE_WIDTH } from '@plait/core';
 export const ShapeDefaultSpace = {
     rectangleAndText: 4
 };
@@ -24,6 +24,6 @@ export const DefaultTextProperty = {
     text: '文本'
 };
 export const GeometryThreshold = {
-    defaultTextMaxWidth: 34 * 14,
+    defaultTextMaxWidth: 34 * 14
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VvbWV0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kcmF3L3NyYy9jb25zdGFudHMvZ2VvbWV0cnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRWxELE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHO0lBQzdCLGdCQUFnQixFQUFFLENBQUM7Q0FDdEIsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHO0lBQ2hDLFdBQVcsRUFBRSxDQUFDO0lBQ2QsYUFBYSxFQUFFLENBQUM7SUFDaEIsV0FBVyxFQUFFLE1BQU07SUFDbkIsSUFBSSxFQUFFLE1BQU07Q0FDZixDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUc7SUFDdEMsV0FBVyxFQUFFLG1CQUFtQjtJQUNoQyxvQkFBb0IsRUFBRSxtQkFBbUI7Q0FDNUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHO0lBQ25DLEtBQUssRUFBRSxHQUFHO0lBQ1YsTUFBTSxFQUFFLEdBQUc7SUFDWCxXQUFXLEVBQUUsTUFBTTtJQUNuQixXQUFXLEVBQUUsQ0FBQztDQUNqQixDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUc7SUFDL0IsS0FBSyxFQUFFLEVBQUU7SUFDVCxNQUFNLEVBQUUsRUFBRTtJQUNWLElBQUksRUFBRSxJQUFJO0NBQ2IsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHO0lBQzdCLG1CQUFtQixFQUFFLEVBQUUsR0FBRyxFQUFFO0NBQy9CLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBQ1RJVkVfU1RST0tFX1dJRFRIIH0gZnJvbSBcIkBwbGFpdC9jb3JlXCI7XG5cbmV4cG9ydCBjb25zdCBTaGFwZURlZmF1bHRTcGFjZSA9IHtcbiAgICByZWN0YW5nbGVBbmRUZXh0OiA0XG59O1xuXG5leHBvcnQgY29uc3QgRGVmYXVsdEdlb21ldHJ5U3R5bGUgPSB7XG4gICAgc3Ryb2tlV2lkdGg6IDIsXG4gICAgZGVmYXVsdFJhZGl1czogNCxcbiAgICBzdHJva2VDb2xvcjogJyMwMDAnLFxuICAgIGZpbGw6ICdub25lJ1xufTtcblxuZXhwb3J0IGNvbnN0IERlZmF1bHRHZW9tZXRyeUFjdGl2ZVN0eWxlID0ge1xuICAgIHN0cm9rZVdpZHRoOiBBQ1RJVkVfU1RST0tFX1dJRFRILFxuICAgIHNlbGVjdGlvblN0cm9rZVdpZHRoOiBBQ1RJVkVfU1RST0tFX1dJRFRIXG59O1xuXG5leHBvcnQgY29uc3QgRGVmYXVsdEdlb21ldHJ5UHJvcGVydHkgPSB7XG4gICAgd2lkdGg6IDEwMCxcbiAgICBoZWlnaHQ6IDEwMCxcbiAgICBzdHJva2VDb2xvcjogJyMzMzMnLFxuICAgIHN0cm9rZVdpZHRoOiAyXG59O1xuXG5leHBvcnQgY29uc3QgRGVmYXVsdFRleHRQcm9wZXJ0eSA9IHtcbiAgICB3aWR0aDogMzYsXG4gICAgaGVpZ2h0OiAyMCxcbiAgICB0ZXh0OiAn5paH5pysJ1xufTtcblxuZXhwb3J0IGNvbnN0IEdlb21ldHJ5VGhyZXNob2xkID0ge1xuICAgIGRlZmF1bHRUZXh0TWF4V2lkdGg6IDM0ICogMTQsXG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VvbWV0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kcmF3L3NyYy9jb25zdGFudHMvZ2VvbWV0cnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRWxELE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHO0lBQzdCLGdCQUFnQixFQUFFLENBQUM7Q0FDdEIsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHO0lBQ2hDLFdBQVcsRUFBRSxDQUFDO0lBQ2QsYUFBYSxFQUFFLENBQUM7SUFDaEIsV0FBVyxFQUFFLE1BQU07SUFDbkIsSUFBSSxFQUFFLE1BQU07Q0FDZixDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUc7SUFDdEMsV0FBVyxFQUFFLG1CQUFtQjtJQUNoQyxvQkFBb0IsRUFBRSxtQkFBbUI7Q0FDNUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHO0lBQ25DLEtBQUssRUFBRSxHQUFHO0lBQ1YsTUFBTSxFQUFFLEdBQUc7SUFDWCxXQUFXLEVBQUUsTUFBTTtJQUNuQixXQUFXLEVBQUUsQ0FBQztDQUNqQixDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUc7SUFDL0IsS0FBSyxFQUFFLEVBQUU7SUFDVCxNQUFNLEVBQUUsRUFBRTtJQUNWLElBQUksRUFBRSxJQUFJO0NBQ2IsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHO0lBQzdCLG1CQUFtQixFQUFFLEVBQUUsR0FBRyxFQUFFO0NBQy9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBQ1RJVkVfU1RST0tFX1dJRFRIIH0gZnJvbSAnQHBsYWl0L2NvcmUnO1xuXG5leHBvcnQgY29uc3QgU2hhcGVEZWZhdWx0U3BhY2UgPSB7XG4gICAgcmVjdGFuZ2xlQW5kVGV4dDogNFxufTtcblxuZXhwb3J0IGNvbnN0IERlZmF1bHRHZW9tZXRyeVN0eWxlID0ge1xuICAgIHN0cm9rZVdpZHRoOiAyLFxuICAgIGRlZmF1bHRSYWRpdXM6IDQsXG4gICAgc3Ryb2tlQ29sb3I6ICcjMDAwJyxcbiAgICBmaWxsOiAnbm9uZSdcbn07XG5cbmV4cG9ydCBjb25zdCBEZWZhdWx0R2VvbWV0cnlBY3RpdmVTdHlsZSA9IHtcbiAgICBzdHJva2VXaWR0aDogQUNUSVZFX1NUUk9LRV9XSURUSCxcbiAgICBzZWxlY3Rpb25TdHJva2VXaWR0aDogQUNUSVZFX1NUUk9LRV9XSURUSFxufTtcblxuZXhwb3J0IGNvbnN0IERlZmF1bHRHZW9tZXRyeVByb3BlcnR5ID0ge1xuICAgIHdpZHRoOiAxMDAsXG4gICAgaGVpZ2h0OiAxMDAsXG4gICAgc3Ryb2tlQ29sb3I6ICcjMzMzJyxcbiAgICBzdHJva2VXaWR0aDogMlxufTtcblxuZXhwb3J0IGNvbnN0IERlZmF1bHRUZXh0UHJvcGVydHkgPSB7XG4gICAgd2lkdGg6IDM2LFxuICAgIGhlaWdodDogMjAsXG4gICAgdGV4dDogJ+aWh+acrCdcbn07XG5cbmV4cG9ydCBjb25zdCBHZW9tZXRyeVRocmVzaG9sZCA9IHtcbiAgICBkZWZhdWx0VGV4dE1heFdpZHRoOiAzNCAqIDE0XG59O1xuIl19

package/esm2022/constants/image.mjs

@@ -0,0 +1,2 @@
+export const DEFAULT_IMAGE_WIDTH = 1000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kcmF3L3NyYy9jb25zdGFudHMvaW1hZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IERFRkFVTFRfSU1BR0VfV0lEVEggPSAxMDAwO1xuIl19

package/esm2022/constants/index.mjs

@@ -1,3 +1,4 @@
 export * from './geometry';
 export * from './pointer';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kcmF3L3NyYy9jb25zdGFudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2dlb21ldHJ5JztcbmV4cG9ydCAqIGZyb20gJy4vcG9pbnRlcic7XG4iXX0=
+export * from './image';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kcmF3L3NyYy9jb25zdGFudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2dlb21ldHJ5JztcbmV4cG9ydCAqIGZyb20gJy4vcG9pbnRlcic7XG5leHBvcnQgKiBmcm9tICcuL2ltYWdlJztcbiJdfQ==

package/esm2022/constants/pointer.mjs

@@ -1,27 +1,8 @@
-export var DrawPointerType;
-(function (DrawPointerType) {
-    DrawPointerType["text"] = "text";
-    DrawPointerType["rectangle"] = "rectangle";
-    DrawPointerType["line"] = "line";
-    DrawPointerType["diamond"] = "diamond";
-    DrawPointerType["roundRectangle"] = "roundRectangle";
-    DrawPointerType["parallelogram"] = "parallelogram";
-    DrawPointerType["ellipse"] = "ellipse";
-    DrawPointerType["triangle"] = "triangle";
-    DrawPointerType["leftArrow"] = "leftArrow";
-    DrawPointerType["trapezoid"] = "trapezoid";
-    DrawPointerType["rightArrow"] = "rightArrow";
-})(DrawPointerType || (DrawPointerType = {}));
-export const GeometryPointer = [
-    DrawPointerType.rectangle,
-    DrawPointerType.text,
-    DrawPointerType.diamond,
-    DrawPointerType.ellipse,
-    DrawPointerType.parallelogram,
-    DrawPointerType.roundRectangle,
-    DrawPointerType.triangle,
-    DrawPointerType.leftArrow,
-    DrawPointerType.trapezoid,
-    DrawPointerType.rightArrow
-];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9pbnRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2RyYXcvc3JjL2NvbnN0YW50cy9wb2ludGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGVBWVg7QUFaRCxXQUFZLGVBQWU7SUFDdkIsZ0NBQWEsQ0FBQTtJQUNiLDBDQUF1QixDQUFBO0lBQ3ZCLGdDQUFhLENBQUE7SUFDYixzQ0FBbUIsQ0FBQTtJQUNuQixvREFBaUMsQ0FBQTtJQUNqQyxrREFBK0IsQ0FBQTtJQUMvQixzQ0FBbUIsQ0FBQTtJQUNuQix3Q0FBcUIsQ0FBQTtJQUNyQiwwQ0FBdUIsQ0FBQTtJQUN2QiwwQ0FBdUIsQ0FBQTtJQUN2Qiw0Q0FBeUIsQ0FBQTtBQUM3QixDQUFDLEVBWlcsZUFBZSxLQUFmLGVBQWUsUUFZMUI7QUFFRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUc7SUFDM0IsZUFBZSxDQUFDLFNBQVM7SUFDekIsZUFBZSxDQUFDLElBQUk7SUFDcEIsZUFBZSxDQUFDLE9BQU87SUFDdkIsZUFBZSxDQUFDLE9BQU87SUFDdkIsZUFBZSxDQUFDLGFBQWE7SUFDN0IsZUFBZSxDQUFDLGNBQWM7SUFDOUIsZUFBZSxDQUFDLFFBQVE7SUFDeEIsZUFBZSxDQUFDLFNBQVM7SUFDekIsZUFBZSxDQUFDLFNBQVM7SUFDekIsZUFBZSxDQUFDLFVBQVU7Q0FDN0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIERyYXdQb2ludGVyVHlwZSB7XG4gICAgdGV4dCA9ICd0ZXh0JyxcbiAgICByZWN0YW5nbGUgPSAncmVjdGFuZ2xlJyxcbiAgICBsaW5lID0gJ2xpbmUnLFxuICAgIGRpYW1vbmQgPSAnZGlhbW9uZCcsXG4gICAgcm91bmRSZWN0YW5nbGUgPSAncm91bmRSZWN0YW5nbGUnLFxuICAgIHBhcmFsbGVsb2dyYW0gPSAncGFyYWxsZWxvZ3JhbScsXG4gICAgZWxsaXBzZSA9ICdlbGxpcHNlJyxcbiAgICB0cmlhbmdsZSA9ICd0cmlhbmdsZScsXG4gICAgbGVmdEFycm93ID0gJ2xlZnRBcnJvdycsXG4gICAgdHJhcGV6b2lkID0gJ3RyYXBlem9pZCcsXG4gICAgcmlnaHRBcnJvdyA9ICdyaWdodEFycm93J1xufVxuXG5leHBvcnQgY29uc3QgR2VvbWV0cnlQb2ludGVyID0gW1xuICAgIERyYXdQb2ludGVyVHlwZS5yZWN0YW5nbGUsXG4gICAgRHJhd1BvaW50ZXJUeXBlLnRleHQsXG4gICAgRHJhd1BvaW50ZXJUeXBlLmRpYW1vbmQsXG4gICAgRHJhd1BvaW50ZXJUeXBlLmVsbGlwc2UsXG4gICAgRHJhd1BvaW50ZXJUeXBlLnBhcmFsbGVsb2dyYW0sXG4gICAgRHJhd1BvaW50ZXJUeXBlLnJvdW5kUmVjdGFuZ2xlLFxuICAgIERyYXdQb2ludGVyVHlwZS50cmlhbmdsZSxcbiAgICBEcmF3UG9pbnRlclR5cGUubGVmdEFycm93LFxuICAgIERyYXdQb2ludGVyVHlwZS50cmFwZXpvaWQsXG4gICAgRHJhd1BvaW50ZXJUeXBlLnJpZ2h0QXJyb3dcbl07XG4iXX0=
+import { GeometryShape, LineShape } from '../interfaces';
+export const getGeometryPointers = () => {
+    return Object.keys(GeometryShape);
+};
+export const getLinePointers = () => {
+    return Object.keys(LineShape);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9pbnRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2RyYXcvc3JjL2NvbnN0YW50cy9wb2ludGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSXpELE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLEdBQUcsRUFBRTtJQUNwQyxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUM7QUFDdEMsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLEdBQUcsRUFBRTtJQUNoQyxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7QUFDbEMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgR2VvbWV0cnlTaGFwZSwgTGluZVNoYXBlIH0gZnJvbSAnLi4vaW50ZXJmYWNlcyc7XG5cbmV4cG9ydCB0eXBlIERyYXdQb2ludGVyVHlwZSA9IEdlb21ldHJ5U2hhcGUgfCBMaW5lU2hhcGU7XG5cbmV4cG9ydCBjb25zdCBnZXRHZW9tZXRyeVBvaW50ZXJzID0gKCkgPT4ge1xuICAgIHJldHVybiBPYmplY3Qua2V5cyhHZW9tZXRyeVNoYXBlKTtcbn07XG5cbmV4cG9ydCBjb25zdCBnZXRMaW5lUG9pbnRlcnMgPSAoKSA9PiB7XG4gICAgcmV0dXJuIE9iamVjdC5rZXlzKExpbmVTaGFwZSk7XG59O1xuIl19

package/esm2022/engines/comment.mjs

@@ -0,0 +1,57 @@
+import { PlaitBoard, RectangleClient, getNearestPointBetweenPointAndSegments, isPointInPolygon, setStrokeLinecap } from '@plait/core';
+import { getEdgeOnPolygonByPoint } from '../utils/geometry';
+import { getRectangleByPoints } from '@plait/common';
+import { ShapeDefaultSpace } from '../constants';
+import { getStrokeWidthByElement } from '../utils';
+const heightRatio = 3 / 4;
+export const CommentEngine = {
+    draw(board, rectangle, options) {
+        const points = getCommentPoints(rectangle);
+        const rs = PlaitBoard.getRoughSVG(board);
+        const polygon = rs.polygon(points, { ...options, fillStyle: 'solid' });
+        setStrokeLinecap(polygon, 'round');
+        return polygon;
+    },
+    isHit(rectangle, point) {
+        const parallelogramPoints = getCommentPoints(rectangle);
+        return isPointInPolygon(point, parallelogramPoints);
+    },
+    getCornerPoints(rectangle) {
+        return getCommentPoints(rectangle);
+    },
+    getNearestPoint(rectangle, point) {
+        return getNearestPointBetweenPointAndSegments(point, getCommentPoints(rectangle));
+    },
+    getEdgeByConnectionPoint(rectangle, pointOfRectangle) {
+        const corners = getCommentPoints(rectangle);
+        const point = RectangleClient.getConnectionPoint(rectangle, pointOfRectangle);
+        return getEdgeOnPolygonByPoint(corners, point);
+    },
+    getConnectorPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    },
+    getTextRectangle(element) {
+        const elementRectangle = getRectangleByPoints(element.points);
+        const strokeWidth = getStrokeWidthByElement(element);
+        const height = element.textHeight;
+        const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        return {
+            height,
+            width: width > 0 ? width : 0,
+            x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth,
+            y: elementRectangle.y + (elementRectangle.height * heightRatio - height) / 2
+        };
+    }
+};
+export const getCommentPoints = (rectangle) => {
+    return [
+        [rectangle.x, rectangle.y],
+        [rectangle.x + rectangle.width, rectangle.y],
+        [rectangle.x + rectangle.width, rectangle.y + rectangle.height * heightRatio],
+        [rectangle.x + (rectangle.width * 3) / 5, rectangle.y + rectangle.height * heightRatio],
+        [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height],
+        [rectangle.x + (rectangle.width * 2) / 5, rectangle.y + rectangle.height * heightRatio],
+        [rectangle.x, rectangle.y + rectangle.height * heightRatio]
+    ];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2RyYXcvc3JjL2VuZ2luZXMvY29tbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0gsVUFBVSxFQUdWLGVBQWUsRUFDZixzQ0FBc0MsRUFDdEMsZ0JBQWdCLEVBQ2hCLGdCQUFnQixFQUNuQixNQUFNLGFBQWEsQ0FBQztBQUVyQixPQUFPLEVBQTRCLHVCQUF1QixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFdEYsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3JELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUNqRCxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFbkQsTUFBTSxXQUFXLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUUxQixNQUFNLENBQUMsTUFBTSxhQUFhLEdBQWdCO0lBQ3RDLElBQUksQ0FBQyxLQUFpQixFQUFFLFNBQTBCLEVBQUUsT0FBZ0I7UUFDaEUsTUFBTSxNQUFNLEdBQUcsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDM0MsTUFBTSxFQUFFLEdBQUcsVUFBVSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN6QyxNQUFNLE9BQU8sR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxFQUFFLEdBQUcsT0FBTyxFQUFFLFNBQVMsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ3ZFLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQztRQUNuQyxPQUFPLE9BQU8sQ0FBQztJQUNuQixDQUFDO0lBQ0QsS0FBSyxDQUFDLFNBQTBCLEVBQUUsS0FBWTtRQUMxQyxNQUFNLG1CQUFtQixHQUFHLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ3hELE9BQU8sZ0JBQWdCLENBQUMsS0FBSyxFQUFFLG1CQUFtQixDQUFDLENBQUM7SUFDeEQsQ0FBQztJQUNELGVBQWUsQ0FBQyxTQUEwQjtRQUN0QyxPQUFPLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7SUFDRCxlQUFlLENBQUMsU0FBMEIsRUFBRSxLQUFZO1FBQ3BELE9BQU8sc0NBQXNDLENBQUMsS0FBSyxFQUFFLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7SUFDdEYsQ0FBQztJQUNELHdCQUF3QixDQUFDLFNBQTBCLEVBQUUsZ0JBQWtDO1FBQ25GLE1BQU0sT0FBTyxHQUFHLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQzVDLE1BQU0sS0FBSyxHQUFHLGVBQWUsQ0FBQyxrQkFBa0IsQ0FBQyxTQUFTLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQztRQUM5RSxPQUFPLHVCQUF1QixDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUMsQ0FBQztJQUNuRCxDQUFDO0lBQ0Qsa0JBQWtCLENBQUMsU0FBMEI7UUFDekMsT0FBTyxlQUFlLENBQUMsbUJBQW1CLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDMUQsQ0FBQztJQUNELGdCQUFnQixDQUFDLE9BQXNCO1FBQ25DLE1BQU0sZ0JBQWdCLEdBQUcsb0JBQW9CLENBQUMsT0FBTyxDQUFDLE1BQU8sQ0FBQyxDQUFDO1FBQy9ELE1BQU0sV0FBVyxHQUFHLHVCQUF1QixDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3JELE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUM7UUFDbEMsTUFBTSxLQUFLLEdBQUcsZ0JBQWdCLENBQUMsS0FBSyxHQUFHLGlCQUFpQixDQUFDLGdCQUFnQixHQUFHLENBQUMsR0FBRyxXQUFXLEdBQUcsQ0FBQyxDQUFDO1FBQ2hHLE9BQU87WUFDSCxNQUFNO1lBQ04sS0FBSyxFQUFFLEtBQUssR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUM1QixDQUFDLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxHQUFHLGlCQUFpQixDQUFDLGdCQUFnQixHQUFHLFdBQVc7WUFDeEUsQ0FBQyxFQUFFLGdCQUFnQixDQUFDLENBQUMsR0FBRyxDQUFDLGdCQUFnQixDQUFDLE1BQU0sR0FBRyxXQUFXLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQztTQUMvRSxDQUFDO0lBQ04sQ0FBQztDQUNKLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLFNBQTBCLEVBQVcsRUFBRTtJQUNwRSxPQUFPO1FBQ0gsQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUM7UUFDMUIsQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxLQUFLLEVBQUUsU0FBUyxDQUFDLENBQUMsQ0FBQztRQUM1QyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLEtBQUssRUFBRSxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxNQUFNLEdBQUcsV0FBVyxDQUFDO1FBQzdFLENBQUMsU0FBUyxDQUFDLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sR0FBRyxXQUFXLENBQUM7UUFDdkYsQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sQ0FBQztRQUNuRSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsRUFBRSxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxNQUFNLEdBQUcsV0FBVyxDQUFDO1FBQ3ZGLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxNQUFNLEdBQUcsV0FBVyxDQUFDO0tBQzlELENBQUM7QUFDTixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICAgIFBsYWl0Qm9hcmQsXG4gICAgUG9pbnQsXG4gICAgUG9pbnRPZlJlY3RhbmdsZSxcbiAgICBSZWN0YW5nbGVDbGllbnQsXG4gICAgZ2V0TmVhcmVzdFBvaW50QmV0d2VlblBvaW50QW5kU2VnbWVudHMsXG4gICAgaXNQb2ludEluUG9seWdvbixcbiAgICBzZXRTdHJva2VMaW5lY2FwXG59IGZyb20gJ0BwbGFpdC9jb3JlJztcbmltcG9ydCB7IFBsYWl0R2VvbWV0cnksIFNoYXBlRW5naW5lIH0gZnJvbSAnLi4vaW50ZXJmYWNlcyc7XG5pbXBvcnQgeyBnZXRDZW50ZXJQb2ludHNPblBvbHlnb24sIGdldEVkZ2VPblBvbHlnb25CeVBvaW50IH0gZnJvbSAnLi4vdXRpbHMvZ2VvbWV0cnknO1xuaW1wb3J0IHsgT3B0aW9ucyB9IGZyb20gJ3JvdWdoanMvYmluL2NvcmUnO1xuaW1wb3J0IHsgZ2V0UmVjdGFuZ2xlQnlQb2ludHMgfSBmcm9tICdAcGxhaXQvY29tbW9uJztcbmltcG9ydCB7IFNoYXBlRGVmYXVsdFNwYWNlIH0gZnJvbSAnLi4vY29uc3RhbnRzJztcbmltcG9ydCB7IGdldFN0cm9rZVdpZHRoQnlFbGVtZW50IH0gZnJvbSAnLi4vdXRpbHMnO1xuXG5jb25zdCBoZWlnaHRSYXRpbyA9IDMgLyA0O1xuXG5leHBvcnQgY29uc3QgQ29tbWVudEVuZ2luZTogU2hhcGVFbmdpbmUgPSB7XG4gICAgZHJhdyhib2FyZDogUGxhaXRCb2FyZCwgcmVjdGFuZ2xlOiBSZWN0YW5nbGVDbGllbnQsIG9wdGlvbnM6IE9wdGlvbnMpIHtcbiAgICAgICAgY29uc3QgcG9pbnRzID0gZ2V0Q29tbWVudFBvaW50cyhyZWN0YW5nbGUpO1xuICAgICAgICBjb25zdCBycyA9IFBsYWl0Qm9hcmQuZ2V0Um91Z2hTVkcoYm9hcmQpO1xuICAgICAgICBjb25zdCBwb2x5Z29uID0gcnMucG9seWdvbihwb2ludHMsIHsgLi4ub3B0aW9ucywgZmlsbFN0eWxlOiAnc29saWQnIH0pO1xuICAgICAgICBzZXRTdHJva2VMaW5lY2FwKHBvbHlnb24sICdyb3VuZCcpO1xuICAgICAgICByZXR1cm4gcG9seWdvbjtcbiAgICB9LFxuICAgIGlzSGl0KHJlY3RhbmdsZTogUmVjdGFuZ2xlQ2xpZW50LCBwb2ludDogUG9pbnQpIHtcbiAgICAgICAgY29uc3QgcGFyYWxsZWxvZ3JhbVBvaW50cyA9IGdldENvbW1lbnRQb2ludHMocmVjdGFuZ2xlKTtcbiAgICAgICAgcmV0dXJuIGlzUG9pbnRJblBvbHlnb24ocG9pbnQsIHBhcmFsbGVsb2dyYW1Qb2ludHMpO1xuICAgIH0sXG4gICAgZ2V0Q29ybmVyUG9pbnRzKHJlY3RhbmdsZTogUmVjdGFuZ2xlQ2xpZW50KSB7XG4gICAgICAgIHJldHVybiBnZXRDb21tZW50UG9pbnRzKHJlY3RhbmdsZSk7XG4gICAgfSxcbiAgICBnZXROZWFyZXN0UG9pbnQocmVjdGFuZ2xlOiBSZWN0YW5nbGVDbGllbnQsIHBvaW50OiBQb2ludCkge1xuICAgICAgICByZXR1cm4gZ2V0TmVhcmVzdFBvaW50QmV0d2VlblBvaW50QW5kU2VnbWVudHMocG9pbnQsIGdldENvbW1lbnRQb2ludHMocmVjdGFuZ2xlKSk7XG4gICAgfSxcbiAgICBnZXRFZGdlQnlDb25uZWN0aW9uUG9pbnQocmVjdGFuZ2xlOiBSZWN0YW5nbGVDbGllbnQsIHBvaW50T2ZSZWN0YW5nbGU6IFBvaW50T2ZSZWN0YW5nbGUpOiBbUG9pbnQsIFBvaW50XSB8IG51bGwge1xuICAgICAgICBjb25zdCBjb3JuZXJzID0gZ2V0Q29tbWVudFBvaW50cyhyZWN0YW5nbGUpO1xuICAgICAgICBjb25zdCBwb2ludCA9IFJlY3RhbmdsZUNsaWVudC5nZXRDb25uZWN0aW9uUG9pbnQocmVjdGFuZ2xlLCBwb2ludE9mUmVjdGFuZ2xlKTtcbiAgICAgICAgcmV0dXJuIGdldEVkZ2VPblBvbHlnb25CeVBvaW50KGNvcm5lcnMsIHBvaW50KTtcbiAgICB9LFxuICAgIGdldENvbm5lY3RvclBvaW50cyhyZWN0YW5nbGU6IFJlY3RhbmdsZUNsaWVudCkge1xuICAgICAgICByZXR1cm4gUmVjdGFuZ2xlQ2xpZW50LmdldEVkZ2VDZW50ZXJQb2ludHMocmVjdGFuZ2xlKTtcbiAgICB9LFxuICAgIGdldFRleHRSZWN0YW5nbGUoZWxlbWVudDogUGxhaXRHZW9tZXRyeSkge1xuICAgICAgICBjb25zdCBlbGVtZW50UmVjdGFuZ2xlID0gZ2V0UmVjdGFuZ2xlQnlQb2ludHMoZWxlbWVudC5wb2ludHMhKTtcbiAgICAgICAgY29uc3Qgc3Ryb2tlV2lkdGggPSBnZXRTdHJva2VXaWR0aEJ5RWxlbWVudChlbGVtZW50KTtcbiAgICAgICAgY29uc3QgaGVpZ2h0ID0gZWxlbWVudC50ZXh0SGVpZ2h0O1xuICAgICAgICBjb25zdCB3aWR0aCA9IGVsZW1lbnRSZWN0YW5nbGUud2lkdGggLSBTaGFwZURlZmF1bHRTcGFjZS5yZWN0YW5nbGVBbmRUZXh0ICogMiAtIHN0cm9rZVdpZHRoICogMjtcbiAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgIGhlaWdodCxcbiAgICAgICAgICAgIHdpZHRoOiB3aWR0aCA+IDAgPyB3aWR0aCA6IDAsXG4gICAgICAgICAgICB4OiBlbGVtZW50UmVjdGFuZ2xlLnggKyBTaGFwZURlZmF1bHRTcGFjZS5yZWN0YW5nbGVBbmRUZXh0ICsgc3Ryb2tlV2lkdGgsXG4gICAgICAgICAgICB5OiBlbGVtZW50UmVjdGFuZ2xlLnkgKyAoZWxlbWVudFJlY3RhbmdsZS5oZWlnaHQgKiBoZWlnaHRSYXRpbyAtIGhlaWdodCkgLyAyXG4gICAgICAgIH07XG4gICAgfVxufTtcblxuZXhwb3J0IGNvbnN0IGdldENvbW1lbnRQb2ludHMgPSAocmVjdGFuZ2xlOiBSZWN0YW5nbGVDbGllbnQpOiBQb2ludFtdID0+IHtcbiAgICByZXR1cm4gW1xuICAgICAgICBbcmVjdGFuZ2xlLngsIHJlY3RhbmdsZS55XSxcbiAgICAgICAgW3JlY3RhbmdsZS54ICsgcmVjdGFuZ2xlLndpZHRoLCByZWN0YW5nbGUueV0sXG4gICAgICAgIFtyZWN0YW5nbGUueCArIHJlY3RhbmdsZS53aWR0aCwgcmVjdGFuZ2xlLnkgKyByZWN0YW5nbGUuaGVpZ2h0ICogaGVpZ2h0UmF0aW9dLFxuICAgICAgICBbcmVjdGFuZ2xlLnggKyAocmVjdGFuZ2xlLndpZHRoICogMykgLyA1LCByZWN0YW5nbGUueSArIHJlY3RhbmdsZS5oZWlnaHQgKiBoZWlnaHRSYXRpb10sXG4gICAgICAgIFtyZWN0YW5nbGUueCArIHJlY3RhbmdsZS53aWR0aCAvIDIsIHJlY3RhbmdsZS55ICsgcmVjdGFuZ2xlLmhlaWdodF0sXG4gICAgICAgIFtyZWN0YW5nbGUueCArIChyZWN0YW5nbGUud2lkdGggKiAyKSAvIDUsIHJlY3RhbmdsZS55ICsgcmVjdGFuZ2xlLmhlaWdodCAqIGhlaWdodFJhdGlvXSxcbiAgICAgICAgW3JlY3RhbmdsZS54LCByZWN0YW5nbGUueSArIHJlY3RhbmdsZS5oZWlnaHQgKiBoZWlnaHRSYXRpb11cbiAgICBdO1xufTtcbiJdfQ==

package/esm2022/engines/cross.mjs

@@ -0,0 +1,46 @@
+import { PlaitBoard, RectangleClient, getNearestPointBetweenPointAndSegments, isPointInPolygon, setStrokeLinecap } from '@plait/core';
+import { getEdgeOnPolygonByPoint } from '../utils/geometry';
+export const CrossEngine = {
+    draw(board, rectangle, options) {
+        const points = getCrossPoints(rectangle);
+        const rs = PlaitBoard.getRoughSVG(board);
+        const polygon = rs.polygon(points, { ...options, fillStyle: 'solid' });
+        setStrokeLinecap(polygon, 'round');
+        return polygon;
+    },
+    isHit(rectangle, point) {
+        const parallelogramPoints = getCrossPoints(rectangle);
+        return isPointInPolygon(point, parallelogramPoints);
+    },
+    getCornerPoints(rectangle) {
+        return getCrossPoints(rectangle);
+    },
+    getNearestPoint(rectangle, point) {
+        return getNearestPointBetweenPointAndSegments(point, getCrossPoints(rectangle));
+    },
+    getEdgeByConnectionPoint(rectangle, pointOfRectangle) {
+        const corners = getCrossPoints(rectangle);
+        const point = RectangleClient.getConnectionPoint(rectangle, pointOfRectangle);
+        return getEdgeOnPolygonByPoint(corners, point);
+    },
+    getConnectorPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    }
+};
+export const getCrossPoints = (rectangle) => {
+    return [
+        [rectangle.x + rectangle.width / 4, rectangle.y],
+        [rectangle.x + (rectangle.width * 3) / 4, rectangle.y],
+        [rectangle.x + (rectangle.width * 3) / 4, rectangle.y + rectangle.height / 4],
+        [rectangle.x + rectangle.width, rectangle.y + rectangle.height / 4],
+        [rectangle.x + rectangle.width, rectangle.y + (rectangle.height * 3) / 4],
+        [rectangle.x + (rectangle.width * 3) / 4, rectangle.y + (rectangle.height * 3) / 4],
+        [rectangle.x + (rectangle.width * 3) / 4, rectangle.y + rectangle.height],
+        [rectangle.x + rectangle.width / 4, rectangle.y + rectangle.height],
+        [rectangle.x + rectangle.width / 4, rectangle.y + (rectangle.height * 3) / 4],
+        [rectangle.x, rectangle.y + (rectangle.height * 3) / 4],
+        [rectangle.x, rectangle.y + rectangle.height / 4],
+        [rectangle.x + rectangle.width / 4, rectangle.y + rectangle.height / 4]
+    ];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3Jvc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kcmF3L3NyYy9lbmdpbmVzL2Nyb3NzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDSCxVQUFVLEVBR1YsZUFBZSxFQUNmLHNDQUFzQyxFQUN0QyxnQkFBZ0IsRUFDaEIsZ0JBQWdCLEVBQ25CLE1BQU0sYUFBYSxDQUFDO0FBRXJCLE9BQU8sRUFBNEIsdUJBQXVCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUd0RixNQUFNLENBQUMsTUFBTSxXQUFXLEdBQWdCO0lBQ3BDLElBQUksQ0FBQyxLQUFpQixFQUFFLFNBQTBCLEVBQUUsT0FBZ0I7UUFDaEUsTUFBTSxNQUFNLEdBQUcsY0FBYyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ3pDLE1BQU0sRUFBRSxHQUFHLFVBQVUsQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDekMsTUFBTSxPQUFPLEdBQUcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsRUFBRSxHQUFHLE9BQU8sRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztRQUN2RSxnQkFBZ0IsQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDbkMsT0FBTyxPQUFPLENBQUM7SUFDbkIsQ0FBQztJQUNELEtBQUssQ0FBQyxTQUEwQixFQUFFLEtBQVk7UUFDMUMsTUFBTSxtQkFBbUIsR0FBRyxjQUFjLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDdEQsT0FBTyxnQkFBZ0IsQ0FBQyxLQUFLLEVBQUUsbUJBQW1CLENBQUMsQ0FBQztJQUN4RCxDQUFDO0lBQ0QsZUFBZSxDQUFDLFNBQTBCO1FBQ3RDLE9BQU8sY0FBYyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFDRCxlQUFlLENBQUMsU0FBMEIsRUFBRSxLQUFZO1FBQ3BELE9BQU8sc0NBQXNDLENBQUMsS0FBSyxFQUFFLGNBQWMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDO0lBQ3BGLENBQUM7SUFDRCx3QkFBd0IsQ0FBQyxTQUEwQixFQUFFLGdCQUFrQztRQUNuRixNQUFNLE9BQU8sR0FBRyxjQUFjLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDMUMsTUFBTSxLQUFLLEdBQUcsZUFBZSxDQUFDLGtCQUFrQixDQUFDLFNBQVMsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO1FBQzlFLE9BQU8sdUJBQXVCLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ25ELENBQUM7SUFDRCxrQkFBa0IsQ0FBQyxTQUEwQjtRQUN6QyxPQUFPLGVBQWUsQ0FBQyxtQkFBbUIsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUMxRCxDQUFDO0NBQ0osQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFDLFNBQTBCLEVBQVcsRUFBRTtJQUNsRSxPQUFPO1FBQ0gsQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUM7UUFDaEQsQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLEtBQUssR0FBRyxDQUFDLENBQUMsR0FBRyxDQUFDLEVBQUUsU0FBUyxDQUFDLENBQUMsQ0FBQztRQUN0RCxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsRUFBRSxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDO1FBQzdFLENBQUMsU0FBUyxDQUFDLENBQUMsR0FBRyxTQUFTLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7UUFDbkUsQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxLQUFLLEVBQUUsU0FBUyxDQUFDLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3pFLENBQUMsU0FBUyxDQUFDLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNuRixDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsRUFBRSxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxNQUFNLENBQUM7UUFDekUsQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sQ0FBQztRQUNuRSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLEtBQUssR0FBRyxDQUFDLEVBQUUsU0FBUyxDQUFDLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQzdFLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxTQUFTLENBQUMsQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDdkQsQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7UUFDakQsQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7S0FDMUUsQ0FBQztBQUNOLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gICAgUGxhaXRCb2FyZCxcbiAgICBQb2ludCxcbiAgICBQb2ludE9mUmVjdGFuZ2xlLFxuICAgIFJlY3RhbmdsZUNsaWVudCxcbiAgICBnZXROZWFyZXN0UG9pbnRCZXR3ZWVuUG9pbnRBbmRTZWdtZW50cyxcbiAgICBpc1BvaW50SW5Qb2x5Z29uLFxuICAgIHNldFN0cm9rZUxpbmVjYXBcbn0gZnJvbSAnQHBsYWl0L2NvcmUnO1xuaW1wb3J0IHsgU2hhcGVFbmdpbmUgfSBmcm9tICcuLi9pbnRlcmZhY2VzJztcbmltcG9ydCB7IGdldENlbnRlclBvaW50c09uUG9seWdvbiwgZ2V0RWRnZU9uUG9seWdvbkJ5UG9pbnQgfSBmcm9tICcuLi91dGlscy9nZW9tZXRyeSc7XG5pbXBvcnQgeyBPcHRpb25zIH0gZnJvbSAncm91Z2hqcy9iaW4vY29yZSc7XG5cbmV4cG9ydCBjb25zdCBDcm9zc0VuZ2luZTogU2hhcGVFbmdpbmUgPSB7XG4gICAgZHJhdyhib2FyZDogUGxhaXRCb2FyZCwgcmVjdGFuZ2xlOiBSZWN0YW5nbGVDbGllbnQsIG9wdGlvbnM6IE9wdGlvbnMpIHtcbiAgICAgICAgY29uc3QgcG9pbnRzID0gZ2V0Q3Jvc3NQb2ludHMocmVjdGFuZ2xlKTtcbiAgICAgICAgY29uc3QgcnMgPSBQbGFpdEJvYXJkLmdldFJvdWdoU1ZHKGJvYXJkKTtcbiAgICAgICAgY29uc3QgcG9seWdvbiA9IHJzLnBvbHlnb24ocG9pbnRzLCB7IC4uLm9wdGlvbnMsIGZpbGxTdHlsZTogJ3NvbGlkJyB9KTtcbiAgICAgICAgc2V0U3Ryb2tlTGluZWNhcChwb2x5Z29uLCAncm91bmQnKTtcbiAgICAgICAgcmV0dXJuIHBvbHlnb247XG4gICAgfSxcbiAgICBpc0hpdChyZWN0YW5nbGU6IFJlY3RhbmdsZUNsaWVudCwgcG9pbnQ6IFBvaW50KSB7XG4gICAgICAgIGNvbnN0IHBhcmFsbGVsb2dyYW1Qb2ludHMgPSBnZXRDcm9zc1BvaW50cyhyZWN0YW5nbGUpO1xuICAgICAgICByZXR1cm4gaXNQb2ludEluUG9seWdvbihwb2ludCwgcGFyYWxsZWxvZ3JhbVBvaW50cyk7XG4gICAgfSxcbiAgICBnZXRDb3JuZXJQb2ludHMocmVjdGFuZ2xlOiBSZWN0YW5nbGVDbGllbnQpIHtcbiAgICAgICAgcmV0dXJuIGdldENyb3NzUG9pbnRzKHJlY3RhbmdsZSk7XG4gICAgfSxcbiAgICBnZXROZWFyZXN0UG9pbnQocmVjdGFuZ2xlOiBSZWN0YW5nbGVDbGllbnQsIHBvaW50OiBQb2ludCkge1xuICAgICAgICByZXR1cm4gZ2V0TmVhcmVzdFBvaW50QmV0d2VlblBvaW50QW5kU2VnbWVudHMocG9pbnQsIGdldENyb3NzUG9pbnRzKHJlY3RhbmdsZSkpO1xuICAgIH0sXG4gICAgZ2V0RWRnZUJ5Q29ubmVjdGlvblBvaW50KHJlY3RhbmdsZTogUmVjdGFuZ2xlQ2xpZW50LCBwb2ludE9mUmVjdGFuZ2xlOiBQb2ludE9mUmVjdGFuZ2xlKTogW1BvaW50LCBQb2ludF0gfCBudWxsIHtcbiAgICAgICAgY29uc3QgY29ybmVycyA9IGdldENyb3NzUG9pbnRzKHJlY3RhbmdsZSk7XG4gICAgICAgIGNvbnN0IHBvaW50ID0gUmVjdGFuZ2xlQ2xpZW50LmdldENvbm5lY3Rpb25Qb2ludChyZWN0YW5nbGUsIHBvaW50T2ZSZWN0YW5nbGUpO1xuICAgICAgICByZXR1cm4gZ2V0RWRnZU9uUG9seWdvbkJ5UG9pbnQoY29ybmVycywgcG9pbnQpO1xuICAgIH0sXG4gICAgZ2V0Q29ubmVjdG9yUG9pbnRzKHJlY3RhbmdsZTogUmVjdGFuZ2xlQ2xpZW50KSB7XG4gICAgICAgIHJldHVybiBSZWN0YW5nbGVDbGllbnQuZ2V0RWRnZUNlbnRlclBvaW50cyhyZWN0YW5nbGUpO1xuICAgIH1cbn07XG5cbmV4cG9ydCBjb25zdCBnZXRDcm9zc1BvaW50cyA9IChyZWN0YW5nbGU6IFJlY3RhbmdsZUNsaWVudCk6IFBvaW50W10gPT4ge1xuICAgIHJldHVybiBbXG4gICAgICAgIFtyZWN0YW5nbGUueCArIHJlY3RhbmdsZS53aWR0aCAvIDQsIHJlY3RhbmdsZS55XSxcbiAgICAgICAgW3JlY3RhbmdsZS54ICsgKHJlY3RhbmdsZS53aWR0aCAqIDMpIC8gNCwgcmVjdGFuZ2xlLnldLFxuICAgICAgICBbcmVjdGFuZ2xlLnggKyAocmVjdGFuZ2xlLndpZHRoICogMykgLyA0LCByZWN0YW5nbGUueSArIHJlY3RhbmdsZS5oZWlnaHQgLyA0XSxcbiAgICAgICAgW3JlY3RhbmdsZS54ICsgcmVjdGFuZ2xlLndpZHRoLCByZWN0YW5nbGUueSArIHJlY3RhbmdsZS5oZWlnaHQgLyA0XSxcbiAgICAgICAgW3JlY3RhbmdsZS54ICsgcmVjdGFuZ2xlLndpZHRoLCByZWN0YW5nbGUueSArIChyZWN0YW5nbGUuaGVpZ2h0ICogMykgLyA0XSxcbiAgICAgICAgW3JlY3RhbmdsZS54ICsgKHJlY3RhbmdsZS53aWR0aCAqIDMpIC8gNCwgcmVjdGFuZ2xlLnkgKyAocmVjdGFuZ2xlLmhlaWdodCAqIDMpIC8gNF0sXG4gICAgICAgIFtyZWN0YW5nbGUueCArIChyZWN0YW5nbGUud2lkdGggKiAzKSAvIDQsIHJlY3RhbmdsZS55ICsgcmVjdGFuZ2xlLmhlaWdodF0sXG4gICAgICAgIFtyZWN0YW5nbGUueCArIHJlY3RhbmdsZS53aWR0aCAvIDQsIHJlY3RhbmdsZS55ICsgcmVjdGFuZ2xlLmhlaWdodF0sXG4gICAgICAgIFtyZWN0YW5nbGUueCArIHJlY3RhbmdsZS53aWR0aCAvIDQsIHJlY3RhbmdsZS55ICsgKHJlY3RhbmdsZS5oZWlnaHQgKiAzKSAvIDRdLFxuICAgICAgICBbcmVjdGFuZ2xlLngsIHJlY3RhbmdsZS55ICsgKHJlY3RhbmdsZS5oZWlnaHQgKiAzKSAvIDRdLFxuICAgICAgICBbcmVjdGFuZ2xlLngsIHJlY3RhbmdsZS55ICsgcmVjdGFuZ2xlLmhlaWdodCAvIDRdLFxuICAgICAgICBbcmVjdGFuZ2xlLnggKyByZWN0YW5nbGUud2lkdGggLyA0LCByZWN0YW5nbGUueSArIHJlY3RhbmdsZS5oZWlnaHQgLyA0XVxuICAgIF07XG59O1xuIl19

package/esm2022/engines/diamond.mjs

@@ -0,0 +1,30 @@
+import { PlaitBoard, RectangleClient, getNearestPointBetweenPointAndSegments, isPointInPolygon, setStrokeLinecap } from '@plait/core';
+import { getEdgeOnPolygonByPoint } from '../utils/geometry';
+export const DiamondEngine = {
+    draw(board, rectangle, options) {
+        const points = RectangleClient.getEdgeCenterPoints(rectangle);
+        const rs = PlaitBoard.getRoughSVG(board);
+        const polygon = rs.polygon(points, { ...options, fillStyle: 'solid' });
+        setStrokeLinecap(polygon, 'round');
+        return polygon;
+    },
+    isHit(rectangle, point) {
+        const controlPoints = RectangleClient.getEdgeCenterPoints(rectangle);
+        return isPointInPolygon(point, controlPoints);
+    },
+    getCornerPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    },
+    getNearestPoint(rectangle, point) {
+        return getNearestPointBetweenPointAndSegments(point, DiamondEngine.getCornerPoints(rectangle));
+    },
+    getEdgeByConnectionPoint(rectangle, pointOfRectangle) {
+        const corners = DiamondEngine.getCornerPoints(rectangle);
+        const point = RectangleClient.getConnectionPoint(rectangle, pointOfRectangle);
+        return getEdgeOnPolygonByPoint(corners, point);
+    },
+    getConnectorPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/engines/ellipse.mjs

@@ -0,0 +1,92 @@
+import { PlaitBoard, RectangleClient, isPointInEllipse } from '@plait/core';
+export const EllipseEngine = {
+    draw(board, rectangle, options) {
+        const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];
+        const rs = PlaitBoard.getRoughSVG(board);
+        return rs.ellipse(centerPoint[0], centerPoint[1], rectangle.width, rectangle.height, { ...options, fillStyle: 'solid' });
+    },
+    isHit(rectangle, point) {
+        const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];
+        return isPointInEllipse(point, centerPoint, rectangle.width / 2, rectangle.height / 2);
+    },
+    getCornerPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    },
+    getNearestPoint(rectangle, point) {
+        const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];
+        return getNearestPointBetweenPointAndEllipse(point, centerPoint, rectangle.width / 2, rectangle.height / 2);
+    },
+    getTangentVectorByConnectionPoint(rectangle, pointOfRectangle) {
+        const connectionPoint = RectangleClient.getConnectionPoint(rectangle, pointOfRectangle);
+        const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];
+        const point = [connectionPoint[0] - centerPoint[0], -(connectionPoint[1] - centerPoint[1])];
+        const a = rectangle.width / 2;
+        const b = rectangle.height / 2;
+        const slope = getTangentSlope(point[0], point[1], a, b);
+        return getVectorBySlope(point[0], point[1], slope);
+    },
+    getConnectorPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    }
+};
+export function getNearestPointBetweenPointAndEllipse(point, center, rx, ry, rotation = 0) {
+    const rectangleClient = {
+        x: center[0] - rx,
+        y: center[1] - ry,
+        height: ry * 2,
+        width: rx * 2
+    };
+    // https://stackoverflow.com/a/46007540/232122
+    const px = Math.abs(point[0] - rectangleClient.x - rectangleClient.width / 2);
+    const py = Math.abs(point[1] - rectangleClient.y - rectangleClient.height / 2);
+    let tx = 0.707;
+    let ty = 0.707;
+    const a = Math.abs(rectangleClient.width) / 2;
+    const b = Math.abs(rectangleClient.height) / 2;
+    [0, 1, 2, 3].forEach(x => {
+        const xx = a * tx;
+        const yy = b * ty;
+        const ex = ((a * a - b * b) * tx ** 3) / a;
+        const ey = ((b * b - a * a) * ty ** 3) / b;
+        const rx = xx - ex;
+        const ry = yy - ey;
+        const qx = px - ex;
+        const qy = py - ey;
+        const r = Math.hypot(ry, rx);
+        const q = Math.hypot(qy, qx);
+        tx = Math.min(1, Math.max(0, ((qx * r) / q + ex) / a));
+        ty = Math.min(1, Math.max(0, ((qy * r) / q + ey) / b));
+        const t = Math.hypot(ty, tx);
+        tx /= t;
+        ty /= t;
+    });
+    const signX = point[0] > center[0] ? 1 : -1;
+    const signY = point[1] > center[1] ? 1 : -1;
+    return [center[0] + a * tx * signX, center[1] + b * ty * signY];
+}
+/**
+ * the result of slope is based on Cartesian coordinate system
+ * x, y are based on the position in the Cartesian coordinate system
+ */
+function getTangentSlope(x, y, a, b) {
+    const k = (-b * b * x) / (a * a * y);
+    return k;
+}
+/**
+ * x, y are based on the position in the Cartesian coordinate system
+ */
+function getVectorBySlope(x, y, slope) {
+    const deltaX = 30;
+    const deltaY = -slope * deltaX;
+    let start = [0 - deltaX, 0 - deltaY];
+    let end = [0 + deltaX, 0 + deltaY];
+    // y < 0 acts on the lower half of the x-axis, with the starting point at the top and the end point at the bottom.
+    if (y < 0) {
+        const temp = start;
+        start = end;
+        end = temp;
+    }
+    const vector = [end[0] - start[0], end[1] - start[1]];
+    return vector;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ellipse.js","sourceRoot":"","sources":["../../../../packages/draw/src/engines/ellipse.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlaitBoard, Point, PointOfRectangle, RectangleClient, Vector, isPointInEllipse } from '@plait/core';\nimport { ShapeEngine } from '../interfaces';\nimport { Options } from 'roughjs/bin/core';\n\nexport const EllipseEngine: ShapeEngine = {\n    draw(board: PlaitBoard, rectangle: RectangleClient, options: Options) {\n        const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];\n        const rs = PlaitBoard.getRoughSVG(board);\n        return rs.ellipse(centerPoint[0], centerPoint[1], rectangle.width, rectangle.height, { ...options, fillStyle: 'solid' });\n    },\n    isHit(rectangle: RectangleClient, point: Point) {\n        const centerPoint: Point = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];\n        return isPointInEllipse(point, centerPoint, rectangle.width / 2, rectangle.height / 2);\n    },\n    getCornerPoints(rectangle: RectangleClient) {\n        return RectangleClient.getEdgeCenterPoints(rectangle);\n    },\n    getNearestPoint(rectangle: RectangleClient, point: Point) {\n        const centerPoint: Point = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];\n        return getNearestPointBetweenPointAndEllipse(point, centerPoint, rectangle.width / 2, rectangle.height / 2);\n    },\n    getTangentVectorByConnectionPoint(rectangle: RectangleClient, pointOfRectangle: PointOfRectangle) {\n        const connectionPoint = RectangleClient.getConnectionPoint(rectangle, pointOfRectangle);\n        const centerPoint: Point = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];\n        const point = [connectionPoint[0] - centerPoint[0], -(connectionPoint[1] - centerPoint[1])];\n        const a = rectangle.width / 2;\n        const b = rectangle.height / 2;\n        const slope = getTangentSlope(point[0], point[1], a, b) as any;\n        return getVectorBySlope(point[0], point[1], slope);\n    },\n    getConnectorPoints(rectangle: RectangleClient) {\n        return RectangleClient.getEdgeCenterPoints(rectangle);\n    }\n};\n\nexport function getNearestPointBetweenPointAndEllipse(point: Point, center: Point, rx: number, ry: number, rotation: number = 0): Point {\n    const rectangleClient = {\n        x: center[0] - rx,\n        y: center[1] - ry,\n        height: ry * 2,\n        width: rx * 2\n    };\n    // https://stackoverflow.com/a/46007540/232122\n    const px = Math.abs(point[0] - rectangleClient.x - rectangleClient.width / 2);\n    const py = Math.abs(point[1] - rectangleClient.y - rectangleClient.height / 2);\n\n    let tx = 0.707;\n    let ty = 0.707;\n\n    const a = Math.abs(rectangleClient.width) / 2;\n    const b = Math.abs(rectangleClient.height) / 2;\n\n    [0, 1, 2, 3].forEach(x => {\n        const xx = a * tx;\n        const yy = b * ty;\n\n        const ex = ((a * a - b * b) * tx ** 3) / a;\n        const ey = ((b * b - a * a) * ty ** 3) / b;\n\n        const rx = xx - ex;\n        const ry = yy - ey;\n\n        const qx = px - ex;\n        const qy = py - ey;\n\n        const r = Math.hypot(ry, rx);\n        const q = Math.hypot(qy, qx);\n\n        tx = Math.min(1, Math.max(0, ((qx * r) / q + ex) / a));\n        ty = Math.min(1, Math.max(0, ((qy * r) / q + ey) / b));\n        const t = Math.hypot(ty, tx);\n        tx /= t;\n        ty /= t;\n    });\n    const signX = point[0] > center[0] ? 1 : -1;\n    const signY = point[1] > center[1] ? 1 : -1;\n\n    return [center[0] + a * tx * signX, center[1] + b * ty * signY];\n}\n\n/**\n * the result of slope is based on Cartesian coordinate system\n * x, y are based on the position in the Cartesian coordinate system\n */\nfunction getTangentSlope(x: number, y: number, a: number, b: number) {\n    const k = (-b * b * x) / (a * a * y);\n    return k;\n}\n\n/**\n * x, y are based on the position in the Cartesian coordinate system\n */\nfunction getVectorBySlope(x: number, y: number, slope: number) {\n    const deltaX = 30;\n    const deltaY = -slope * deltaX;\n    let start = [0 - deltaX, 0 - deltaY] as Point;\n    let end = [0 + deltaX, 0 + deltaY] as Point;\n    // y < 0 acts on the lower half of the x-axis, with the starting point at the top and the end point at the bottom.\n    \n    if (y < 0) {\n        const temp = start;\n        start = end;\n        end = temp;\n    }\n    const vector = [end[0] - start[0], end[1] - start[1]] as Vector;\n    return vector;\n}\n"]}

package/esm2022/engines/hexagon.mjs

@@ -0,0 +1,40 @@
+import { PlaitBoard, RectangleClient, getNearestPointBetweenPointAndSegments, isPointInPolygon, setStrokeLinecap } from '@plait/core';
+import { getEdgeOnPolygonByPoint } from '../utils/geometry';
+export const HexagonEngine = {
+    draw(board, rectangle, options) {
+        const points = getHexagonPoints(rectangle);
+        const rs = PlaitBoard.getRoughSVG(board);
+        const polygon = rs.polygon(points, { ...options, fillStyle: 'solid' });
+        setStrokeLinecap(polygon, 'round');
+        return polygon;
+    },
+    isHit(rectangle, point) {
+        const parallelogramPoints = getHexagonPoints(rectangle);
+        return isPointInPolygon(point, parallelogramPoints);
+    },
+    getCornerPoints(rectangle) {
+        return getHexagonPoints(rectangle);
+    },
+    getNearestPoint(rectangle, point) {
+        return getNearestPointBetweenPointAndSegments(point, getHexagonPoints(rectangle));
+    },
+    getEdgeByConnectionPoint(rectangle, pointOfRectangle) {
+        const corners = getHexagonPoints(rectangle);
+        const point = RectangleClient.getConnectionPoint(rectangle, pointOfRectangle);
+        return getEdgeOnPolygonByPoint(corners, point);
+    },
+    getConnectorPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    }
+};
+export const getHexagonPoints = (rectangle) => {
+    return [
+        [rectangle.x + rectangle.width / 4, rectangle.y],
+        [rectangle.x + (rectangle.width * 3) / 4, rectangle.y],
+        [rectangle.x + rectangle.width, rectangle.y + rectangle.height / 2],
+        [rectangle.x + (rectangle.width * 3) / 4, rectangle.y + rectangle.height],
+        [rectangle.x + rectangle.width / 4, rectangle.y + rectangle.height],
+        [rectangle.x, rectangle.y + rectangle.height / 2]
+    ];
+};
+//# sourceMappingURL=data:application/json;base64,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