pantograph2d 0.4.0 → 0.6.0

package/dist/types/draw.d.ts

@@ -0,0 +1,47 @@
+import { Vector } from "./definitions.js";
+import { Strand } from "./models/Strand.js";
+import { Diagram } from "./models/Diagram.js";
+import { Segment } from "./models/segments/Segment.js";
+export declare class DrawingPen {
+    pointer: Vector;
+    protected firstPoint: Vector;
+    protected pendingSegments: Segment[];
+    protected _nextCorner: {
+        radius: number;
+        mode: "fillet" | "chamfer";
+    } | null;
+    constructor(origin?: Vector);
+    movePointerTo(point: Vector): this;
+    protected saveSegment(segment: Segment): this;
+    lineTo(point: Vector): this;
+    line(xDist: number, yDist: number): this;
+    vLine(distance: number): this;
+    hLine(distance: number): this;
+    vLineTo(yPos: number): this;
+    hLineTo(xPos: number): this;
+    polarLineTo([r, theta]: Vector): this;
+    polarLine(distance: number, angle: number): this;
+    tangentLine(distance: number): this;
+    threePointsArcTo(end: Vector, midPoint: Vector): this;
+    threePointsArc(xDist: number, yDist: number, viaXDist: number, viaYDist: number): this;
+    sagittaArcTo(end: Vector, sagitta: number): this;
+    sagittaArc(xDist: number, yDist: number, sagitta: number): this;
+    vSagittaArc(distance: number, sagitta: number): this;
+    hSagittaArc(distance: number, sagitta: number): this;
+    bulgeArcTo(end: Vector, bulge: number): this;
+    bulgeArc(xDist: number, yDist: number, bulge: number): this;
+    vBulgeArc(distance: number, bulge: number): this;
+    hBulgeArc(distance: number, bulge: number): this;
+    tangentArcTo(end: Vector, tangentAtStart?: Vector): this;
+    tangentArc(xDist: number, yDist: number, tangentAtStart?: Vector): this;
+    ellipseTo(end: Vector, r0: number, r1: number, xAxisRotation: number, longArc: boolean, sweepFlag: boolean): this;
+    ellipse(xDist: number, yDist: number, r0: number, r1: number, xAxisRotation: number, longArc: boolean, sweepFlag: boolean): this;
+    halfEllipseTo(end: Vector, sagitta: number): this;
+    halfEllipse(xDist: number, yDist: number, sagitta: number): this;
+    customCorner(radius: number, mode?: "fillet" | "chamfer"): this;
+    protected _customCornerLastWithFirst(radius: number, mode?: "fillet" | "chamfer"): void;
+    close(ignoreChecks?: boolean): Diagram;
+    closeWithMirror(ignoreChecks?: boolean): Diagram;
+    asStrand(): Strand;
+}
+export declare function draw(origin?: Vector): DrawingPen;

package/dist/types/drawShape/drawCircle.d.ts

@@ -0,0 +1,2 @@
+import type { Diagram } from "../models/Diagram.js";
+export declare function drawCircle(radius: number): Diagram;

package/dist/types/drawShape/drawRect.d.ts

@@ -0,0 +1,5 @@
+import type { Diagram } from "../models/Diagram.js";
+export declare function drawRect(width: number, height: number, r?: number | {
+    rx?: number;
+    ry?: number;
+}): Diagram;

package/dist/types/export/json/exportJSON.d.ts

@@ -0,0 +1,196 @@
+import { Diagram } from "../../models/Diagram.js";
+import { Figure } from "../../models/Figure.js";
+import { Loop } from "../../models/Loop.js";
+import { Arc } from "../../models/segments/Arc.js";
+import { Line } from "../../models/segments/Line.js";
+type Shape = Loop | Figure | Diagram | Arc | Line;
+export declare function exportJSON(shape: Shape): {
+    type: string;
+    firstPoint: import("../../definitions.js").Vector;
+    lastPoint: import("../../definitions.js").Vector;
+    center?: undefined;
+    clockwise?: undefined;
+    majorRadius?: undefined;
+    minorRadius?: undefined;
+    tiltAngle?: undefined;
+} | {
+    type: string;
+    firstPoint: import("../../definitions.js").Vector;
+    lastPoint: import("../../definitions.js").Vector;
+    center: import("../../definitions.js").Vector;
+    clockwise: boolean;
+    majorRadius?: undefined;
+    minorRadius?: undefined;
+    tiltAngle?: undefined;
+} | {
+    type: string;
+    firstPoint: import("../../definitions.js").Vector;
+    lastPoint: import("../../definitions.js").Vector;
+    center: import("../../definitions.js").Vector;
+    clockwise: boolean;
+    majorRadius: number;
+    minorRadius: number;
+    tiltAngle: number;
+} | {
+    type: string;
+    segments: ({
+        type: string;
+        firstPoint: import("../../definitions.js").Vector;
+        lastPoint: import("../../definitions.js").Vector;
+        center?: undefined;
+        clockwise?: undefined;
+        majorRadius?: undefined;
+        minorRadius?: undefined;
+        tiltAngle?: undefined;
+    } | {
+        type: string;
+        firstPoint: import("../../definitions.js").Vector;
+        lastPoint: import("../../definitions.js").Vector;
+        center: import("../../definitions.js").Vector;
+        clockwise: boolean;
+        majorRadius?: undefined;
+        minorRadius?: undefined;
+        tiltAngle?: undefined;
+    } | {
+        type: string;
+        firstPoint: import("../../definitions.js").Vector;
+        lastPoint: import("../../definitions.js").Vector;
+        center: import("../../definitions.js").Vector;
+        clockwise: boolean;
+        majorRadius: number;
+        minorRadius: number;
+        tiltAngle: number;
+    })[];
+} | {
+    type: string;
+    contour: {
+        type: string;
+        segments: ({
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center?: undefined;
+            clockwise?: undefined;
+            majorRadius?: undefined;
+            minorRadius?: undefined;
+            tiltAngle?: undefined;
+        } | {
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center: import("../../definitions.js").Vector;
+            clockwise: boolean;
+            majorRadius?: undefined;
+            minorRadius?: undefined;
+            tiltAngle?: undefined;
+        } | {
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center: import("../../definitions.js").Vector;
+            clockwise: boolean;
+            majorRadius: number;
+            minorRadius: number;
+            tiltAngle: number;
+        })[];
+    };
+    holes: {
+        type: string;
+        segments: ({
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center?: undefined;
+            clockwise?: undefined;
+            majorRadius?: undefined;
+            minorRadius?: undefined;
+            tiltAngle?: undefined;
+        } | {
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center: import("../../definitions.js").Vector;
+            clockwise: boolean;
+            majorRadius?: undefined;
+            minorRadius?: undefined;
+            tiltAngle?: undefined;
+        } | {
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center: import("../../definitions.js").Vector;
+            clockwise: boolean;
+            majorRadius: number;
+            minorRadius: number;
+            tiltAngle: number;
+        })[];
+    }[];
+} | {
+    type: string;
+    figures: {
+        type: string;
+        contour: {
+            type: string;
+            segments: ({
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center?: undefined;
+                clockwise?: undefined;
+                majorRadius?: undefined;
+                minorRadius?: undefined;
+                tiltAngle?: undefined;
+            } | {
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center: import("../../definitions.js").Vector;
+                clockwise: boolean;
+                majorRadius?: undefined;
+                minorRadius?: undefined;
+                tiltAngle?: undefined;
+            } | {
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center: import("../../definitions.js").Vector;
+                clockwise: boolean;
+                majorRadius: number;
+                minorRadius: number;
+                tiltAngle: number;
+            })[];
+        };
+        holes: {
+            type: string;
+            segments: ({
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center?: undefined;
+                clockwise?: undefined;
+                majorRadius?: undefined;
+                minorRadius?: undefined;
+                tiltAngle?: undefined;
+            } | {
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center: import("../../definitions.js").Vector;
+                clockwise: boolean;
+                majorRadius?: undefined;
+                minorRadius?: undefined;
+                tiltAngle?: undefined;
+            } | {
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center: import("../../definitions.js").Vector;
+                clockwise: boolean;
+                majorRadius: number;
+                minorRadius: number;
+                tiltAngle: number;
+            })[];
+        }[];
+    }[];
+};
+export {};

package/dist/types/export/json/jsonDiagram.d.ts

@@ -0,0 +1,69 @@
+import { Diagram } from "../../models/Diagram.js";
+export declare function jsonDiagram(diagram: Diagram): {
+    type: string;
+    figures: {
+        type: string;
+        contour: {
+            type: string;
+            segments: ({
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center?: undefined;
+                clockwise?: undefined;
+                majorRadius?: undefined;
+                minorRadius?: undefined;
+                tiltAngle?: undefined;
+            } | {
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center: import("../../definitions.js").Vector;
+                clockwise: boolean;
+                majorRadius?: undefined;
+                minorRadius?: undefined;
+                tiltAngle?: undefined;
+            } | {
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center: import("../../definitions.js").Vector;
+                clockwise: boolean;
+                majorRadius: number;
+                minorRadius: number;
+                tiltAngle: number;
+            })[];
+        };
+        holes: {
+            type: string;
+            segments: ({
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center?: undefined;
+                clockwise?: undefined;
+                majorRadius?: undefined;
+                minorRadius?: undefined;
+                tiltAngle?: undefined;
+            } | {
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center: import("../../definitions.js").Vector;
+                clockwise: boolean;
+                majorRadius?: undefined;
+                minorRadius?: undefined;
+                tiltAngle?: undefined;
+            } | {
+                type: string;
+                firstPoint: import("../../definitions.js").Vector;
+                lastPoint: import("../../definitions.js").Vector;
+                center: import("../../definitions.js").Vector;
+                clockwise: boolean;
+                majorRadius: number;
+                minorRadius: number;
+                tiltAngle: number;
+            })[];
+        }[];
+    }[];
+};

package/dist/types/export/json/jsonFigure.d.ts

@@ -0,0 +1,66 @@
+import type { Figure } from "../../models/Figure.js";
+export declare function jsonFigure(figure: Figure): {
+    type: string;
+    contour: {
+        type: string;
+        segments: ({
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center?: undefined;
+            clockwise?: undefined;
+            majorRadius?: undefined;
+            minorRadius?: undefined;
+            tiltAngle?: undefined;
+        } | {
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center: import("../../definitions.js").Vector;
+            clockwise: boolean;
+            majorRadius?: undefined;
+            minorRadius?: undefined;
+            tiltAngle?: undefined;
+        } | {
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center: import("../../definitions.js").Vector;
+            clockwise: boolean;
+            majorRadius: number;
+            minorRadius: number;
+            tiltAngle: number;
+        })[];
+    };
+    holes: {
+        type: string;
+        segments: ({
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center?: undefined;
+            clockwise?: undefined;
+            majorRadius?: undefined;
+            minorRadius?: undefined;
+            tiltAngle?: undefined;
+        } | {
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center: import("../../definitions.js").Vector;
+            clockwise: boolean;
+            majorRadius?: undefined;
+            minorRadius?: undefined;
+            tiltAngle?: undefined;
+        } | {
+            type: string;
+            firstPoint: import("../../definitions.js").Vector;
+            lastPoint: import("../../definitions.js").Vector;
+            center: import("../../definitions.js").Vector;
+            clockwise: boolean;
+            majorRadius: number;
+            minorRadius: number;
+            tiltAngle: number;
+        })[];
+    }[];
+};

package/dist/types/export/json/jsonLoop.d.ts

@@ -0,0 +1,32 @@
+import type { Loop } from "../../models/Loop.js";
+export declare function jsonLoop(loop: Loop): {
+    type: string;
+    segments: ({
+        type: string;
+        firstPoint: import("../../definitions.js").Vector;
+        lastPoint: import("../../definitions.js").Vector;
+        center?: undefined;
+        clockwise?: undefined;
+        majorRadius?: undefined;
+        minorRadius?: undefined;
+        tiltAngle?: undefined;
+    } | {
+        type: string;
+        firstPoint: import("../../definitions.js").Vector;
+        lastPoint: import("../../definitions.js").Vector;
+        center: import("../../definitions.js").Vector;
+        clockwise: boolean;
+        majorRadius?: undefined;
+        minorRadius?: undefined;
+        tiltAngle?: undefined;
+    } | {
+        type: string;
+        firstPoint: import("../../definitions.js").Vector;
+        lastPoint: import("../../definitions.js").Vector;
+        center: import("../../definitions.js").Vector;
+        clockwise: boolean;
+        majorRadius: number;
+        minorRadius: number;
+        tiltAngle: number;
+    })[];
+};

package/dist/types/export/json/jsonSegment.d.ts

@@ -0,0 +1,29 @@
+import { Segment } from "../../models/segments/Segment.js";
+export declare function jsonSegment(segment: Segment): {
+    type: string;
+    firstPoint: import("../../definitions.js").Vector;
+    lastPoint: import("../../definitions.js").Vector;
+    center?: undefined;
+    clockwise?: undefined;
+    majorRadius?: undefined;
+    minorRadius?: undefined;
+    tiltAngle?: undefined;
+} | {
+    type: string;
+    firstPoint: import("../../definitions.js").Vector;
+    lastPoint: import("../../definitions.js").Vector;
+    center: import("../../definitions.js").Vector;
+    clockwise: boolean;
+    majorRadius?: undefined;
+    minorRadius?: undefined;
+    tiltAngle?: undefined;
+} | {
+    type: string;
+    firstPoint: import("../../definitions.js").Vector;
+    lastPoint: import("../../definitions.js").Vector;
+    center: import("../../definitions.js").Vector;
+    clockwise: boolean;
+    majorRadius: number;
+    minorRadius: number;
+    tiltAngle: number;
+};

package/dist/types/export/svg/exportSVG.d.ts

@@ -0,0 +1,18 @@
+import { Diagram } from "../../models/Diagram.js";
+import { Figure } from "../../models/Figure.js";
+import { Arc } from "../../models/segments/Arc.js";
+import { Line } from "../../models/segments/Line.js";
+import { SVGUnit } from "./wrapSVG.js";
+import type { Stroke } from "../../models/Stroke.js";
+import { EllipseArc } from "../../models/segments/EllipseArc.js";
+type Shape = Figure | Diagram | Arc | Line | EllipseArc | Stroke;
+export declare function svgBody(shape: Shape): string;
+type ConfiguredShape = Shape | {
+    shape: Shape;
+    color?: string;
+};
+export declare function exportSVG(shape: ConfiguredShape | ConfiguredShape[], { margin, unit, }?: {
+    margin?: number;
+    unit?: null | SVGUnit;
+}): string;
+export {};

package/dist/types/export/svg/svgDiagram.d.ts

@@ -0,0 +1,2 @@
+import { Diagram } from "../../models/Diagram.js";
+export declare function svgDiagram(diagram: Diagram): string;

package/dist/types/export/svg/svgFigure.d.ts

@@ -0,0 +1,2 @@
+import type { Figure } from "../../models/Figure.js";
+export declare function svgFigure(figure: Figure): string;

package/dist/types/export/svg/svgLoop.d.ts

@@ -0,0 +1,2 @@
+import type { Loop } from "../../models/Loop.js";
+export declare function svgLoop(loop: Loop): string;

package/dist/types/export/svg/svgSegment.d.ts

@@ -0,0 +1,2 @@
+import { Segment } from "../../models/segments/Segment.js";
+export declare function svgSegmentToPath(segment: Segment): string;

package/dist/types/export/svg/svgStrand.d.ts

@@ -0,0 +1,2 @@
+import type { Strand } from "../../models/Strand.js";
+export declare function svgStrand(strand: Strand): string;

package/dist/types/export/svg/wrapSVG.d.ts

@@ -0,0 +1,4 @@
+import { BoundingBox } from "../../models/BoundingBox.js";
+export declare function SVGViewbox(bbox: BoundingBox, margin?: number): string;
+export type SVGUnit = "mm" | "cm" | "in" | "pc" | "px" | "pt";
+export declare function wrapSVG(body: string, boundingBox: BoundingBox, margin: number | undefined, unit: null | SVGUnit): string;

package/dist/types/import/json/importJSON.d.ts

@@ -0,0 +1,7 @@
+import { Line } from "../../models/segments/Line.js";
+import { Arc } from "../../models/segments/Arc.js";
+import { Loop } from "../../models/Loop.js";
+import { Figure } from "../../models/Figure.js";
+import { Diagram } from "../../models/Diagram.js";
+import { EllipseArc } from "../../models/segments/EllipseArc.js";
+export declare function importJSON(json: any): Diagram | Figure | Loop | Line | Arc | EllipseArc;

package/dist/types/main.d.ts

@@ -0,0 +1,12 @@
+import type { Vector } from "./definitions.js";
+export { Vector };
+export declare const DEG2RAD: number;
+export declare const RAD2DEG: number;
+export declare function polarToCartesian(r: number, theta: number): Vector;
+export declare function cartesianToPolar([x, y]: Vector): [number, number];
+export type { Diagram, Figure, Loop, Strand, Stroke, TransformationMatrix, BoundingBox, Segment, Line, Arc, } from "./models/exports.js";
+export { draw } from "./draw.js";
+export { fuseAll, fuse, cut, intersect, eraseStrand, confineStrand, offset, outlineStroke, } from "./operations.js";
+export { exportSVG, svgBody } from "./export/svg/exportSVG.js";
+export { exportJSON } from "./export/json/exportJSON.js";
+export { importJSON } from "./import/json/importJSON.js";

package/dist/types/models/BoundingBox.d.ts

@@ -0,0 +1,15 @@
+import { Vector } from "../definitions.js";
+export declare class BoundingBox {
+    readonly xMin: number;
+    readonly yMin: number;
+    readonly xMax: number;
+    readonly yMax: number;
+    constructor(xMin?: number, yMin?: number, xMax?: number, yMax?: number);
+    get width(): number;
+    get height(): number;
+    contains(point: Vector): boolean;
+    overlaps(other: BoundingBox): boolean;
+    addPoint(point: Vector): BoundingBox;
+    merge(other: BoundingBox): BoundingBox;
+}
+export declare function pointsBoundingBox(points: Vector[]): BoundingBox;

package/dist/types/models/Diagram.d.ts

@@ -0,0 +1,25 @@
+import type { Vector } from "../definitions.js";
+import { BoundingBox } from "./BoundingBox.js";
+import type { Figure } from "./Figure.js";
+import type { TransformationMatrix } from "./TransformationMatrix.js";
+import { Transformable } from "./utils/Transformable.js";
+import { Strand } from "./Strand.js";
+import type { Stroke } from "./Stroke.js";
+export declare class Diagram extends Transformable<Diagram> {
+    figures: Figure[];
+    constructor(figures?: Figure[], { ignoreChecks }?: {
+        ignoreChecks?: boolean | undefined;
+    });
+    private _boundingBox;
+    get isEmpty(): boolean;
+    get boundingBox(): BoundingBox;
+    clone(): Diagram;
+    transform(matrix: TransformationMatrix): Diagram;
+    contains(point: Vector): boolean;
+    intersects(other: Diagram): boolean;
+    overlappingStrands(other: Diagram | Figure | Stroke): Strand[];
+    fuse(other: Diagram): Diagram;
+    cut(other: Diagram): Diagram;
+    intersect(other: Diagram): Diagram;
+}
+export declare function checkIsValidDiagram(figures: Figure[]): void;

package/dist/types/models/Figure.d.ts

@@ -0,0 +1,23 @@
+import { Vector } from "../definitions.js";
+import { TransformationMatrix } from "./TransformationMatrix.js";
+import type { BoundingBox } from "./BoundingBox.js";
+import { Loop } from "./Loop.js";
+import { Strand } from "./Strand.js";
+import type { Stroke } from "./Stroke.js";
+import { Transformable } from "./utils/Transformable.js";
+export declare class Figure extends Transformable<Figure> {
+    readonly contour: Loop;
+    readonly holes: Loop[];
+    constructor(contour: Loop, holes?: Loop[], { ignoreChecks }?: {
+        ignoreChecks?: boolean | undefined;
+    });
+    get boundingBox(): BoundingBox;
+    get isFull(): boolean;
+    get allLoops(): Loop[];
+    clone(): Figure;
+    transform(matrix: TransformationMatrix): Figure;
+    contains(point: Vector): boolean;
+    intersects(other: Figure): boolean;
+    overlappingStrands(other: Figure | Stroke): Strand[];
+}
+export declare function checkIsValidFigure(contour?: Loop, holes?: Loop[]): void;

package/dist/types/models/Loop.d.ts

@@ -0,0 +1,18 @@
+import type { Vector } from "../definitions.js";
+import { AbstractStroke } from "./Stroke.js";
+import type { TransformationMatrix } from "./TransformationMatrix.js";
+import { Segment } from "./segments/Segment.js";
+export declare class Loop extends AbstractStroke<Loop> {
+    strokeType: string;
+    constructor(segments: Segment[], { ignoreChecks }?: {
+        ignoreChecks?: boolean | undefined;
+    });
+    private _clockwise;
+    get clockwise(): boolean;
+    clone(): Loop;
+    reverse(): Loop;
+    transform(matrix: TransformationMatrix): Loop;
+    contains(point: Vector): boolean;
+    simplify(): Loop;
+}
+export declare function checkValidLoop(segments: Segment[]): void;

package/dist/types/models/Strand.d.ts

@@ -0,0 +1,10 @@
+import { AbstractStroke } from "./Stroke.js";
+import { TransformationMatrix } from "./TransformationMatrix.js";
+export declare class Strand extends AbstractStroke<Strand> {
+    strokeType: string;
+    reverse(): Strand;
+    clone(): Strand;
+    extend(strand: Strand): Strand;
+    simplify(): Strand;
+    transform(matrix: TransformationMatrix): Strand;
+}

package/dist/types/models/Stroke.d.ts

@@ -0,0 +1,29 @@
+import { BoundingBox } from "./BoundingBox.js";
+import { Vector } from "../definitions.js";
+import { Segment } from "./segments/Segment.js";
+import { TransformationMatrix } from "./TransformationMatrix.js";
+import { Transformable } from "./utils/Transformable.js";
+export type Stroke = AbstractStroke<any>;
+export declare abstract class AbstractStroke<T extends AbstractStroke<T>> extends Transformable<T> {
+    readonly segments: Segment[];
+    abstract strokeType: string;
+    get repr(): string;
+    get info(): string;
+    constructor(segments: Segment[], { ignoreChecks }?: {
+        ignoreChecks?: boolean | undefined;
+    });
+    get firstPoint(): Vector;
+    get lastPoint(): Vector;
+    get segmentsCount(): number;
+    onStroke(point: Vector): boolean;
+    intersects(other: Stroke): boolean;
+    overlappingSegments(other: Stroke): Segment[];
+    private _boundingBox;
+    get boundingBox(): BoundingBox;
+    abstract reverse(): T;
+    abstract clone(): T;
+    abstract transform(matrix: TransformationMatrix): T;
+    abstract simplify(): T;
+}
+export declare function checkSelfIntersections(segments: Segment[], type?: string): void;
+export declare function checkValidStroke(segments: Segment[], type?: string): void;