fluidcad 0.0.28 → 0.0.30

package/lib/dist/core/2d/vline.js

@@ -9,27 +9,41 @@ import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function line() {
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
-                planeObj = resolvePlane(lastArg, context);
-                argCount--;
+        let argOffset = 0;
+        const inSketch = context.getActiveSketch() !== null;
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg)) {
+                if (inSketch) {
+                    throw new Error("vLine(plane, ...) cannot be used inside a sketch. Use vLine(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
+            else if (!inSketch && firstArg instanceof SceneObject && !isPoint2DLike(firstArg)) {
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
+            }
+        }
+        if (argOffset === 0 && inSketch && arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) {
+            // vLine(target)
+            const vline = new VerticalLine(arguments[0], null);
+            context.addSceneObject(vline);
+            return vline;
         }
-        if (typeof arguments[0] !== 'number') {
-            // vline(start, distance) or vline(start, distance, centered)
+        if (argOffset === 0 && typeof arguments[0] !== 'number') {
+            // vLine(start, distance) or vLine(start, target)
             const start = normalizePoint2D(arguments[0]);
-            const distance = arguments[1];
-            const centered = argCount >= 3 ? arguments[2] : false;
-            const vline = new VerticalLine(distance, centered, planeObj);
+            const second = arguments[1];
+            const distanceOrTarget = second instanceof SceneObject
+                ? second
+                : second;
+            const vline = new VerticalLine(distanceOrTarget, planeObj);
             context.addSceneObjects([new Move(start), vline]);
             return vline;
         }
-        const distance = arguments[0];
-        const centered = argCount >= 2 ? arguments[1] : false;
-        const vline = new VerticalLine(distance, centered, planeObj);
+        const distance = arguments[argOffset];
+        const vline = new VerticalLine(distance, planeObj);
         context.addSceneObject(vline);
         return vline;
     };

package/lib/dist/core/interfaces.d.ts

@@ -123,6 +123,14 @@ export interface IGeometry extends ISceneObject {
 }
 export interface IExtrudableGeometry extends IGeometry {
 }
+export interface IOffset extends IExtrudableGeometry {
+    /**
+     * Closes an open offset by joining it back to the source wire with
+     * straight cap edges at each endpoint. Has no effect when the offset
+     * is already closed. Cannot be combined with `removeOriginal=true`.
+     */
+    close(): this;
+}
 export interface IArcPoints extends IExtrudableGeometry {
     /**
      * Sets the bulge radius for point-to-point arcs.
@@ -219,6 +227,33 @@ export interface ISlot extends IExtrudableGeometry {
      */
     rotate(angle: number): this;
 }
+export interface IALine extends IGeometry {
+    /**
+     * Controls whether the line is centered on the current position.
+     * When `true`, the line is offset backward by half its length so that the
+     * current position falls at its midpoint.
+     * @param value - `true` to center, `false` (default) to start from the current position.
+     */
+    centered(value?: boolean): this;
+}
+export interface IHLine extends IGeometry {
+    /**
+     * Controls whether the line is centered on the current position.
+     * When `true`, the line is offset backward by half its length so that the
+     * current position falls at its midpoint.
+     * @param value - `true` to center, `false` (default) to start from the current position.
+     */
+    centered(value?: boolean): this;
+}
+export interface IVLine extends IGeometry {
+    /**
+     * Controls whether the line is centered on the current position.
+     * When `true`, the line is offset backward by half its length so that the
+     * current position falls at its midpoint.
+     * @param value - `true` to center, `false` (default) to start from the current position.
+     */
+    centered(value?: boolean): this;
+}
 export interface IPolygon extends IExtrudableGeometry {
     /**
      * Returns a specific edge of the polygon by index.
@@ -621,6 +656,33 @@ export interface ISweep extends IBooleanOperation {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
+export interface IMirror extends ISceneObject {
+    /**
+     * Excludes the given objects from the mirror operation. Useful when
+     * mirroring "everything" but a few specific objects should be skipped,
+     * or when narrowing an explicit target list.
+     * @param objects - The objects to exclude from mirroring.
+     */
+    exclude(...objects: ISceneObject[]): this;
+}
+export interface ITranslate extends ISceneObject {
+    /**
+     * Excludes the given objects from the translate operation. Useful when
+     * translating "everything" but a few specific objects should be skipped,
+     * or when narrowing an explicit target list.
+     * @param objects - The objects to exclude from translating.
+     */
+    exclude(...objects: ISceneObject[]): this;
+}
+export interface IRotate extends ISceneObject {
+    /**
+     * Excludes the given objects from the rotate operation. Useful when
+     * rotating "everything" but a few specific objects should be skipped,
+     * or when narrowing an explicit target list.
+     * @param objects - The objects to exclude from rotating.
+     */
+    exclude(...objects: ISceneObject[]): this;
+}
 export interface IDraft extends ISceneObject {
 }
 export interface IShell extends ISceneObject {

package/lib/dist/core/mirror.d.ts

@@ -1,40 +1,40 @@
 import { PlaneLike } from "../math/plane.js";
 import { AxisLike } from "../math/axis.js";
-import { ISceneObject } from "./interfaces.js";
+import { IMirror, ISceneObject } from "./interfaces.js";
 interface MirrorFunction {
     /**
     * [2D] Mirror all sketch geometries across a given line.
     * @param line The line to mirror across
     */
-    (line: ISceneObject): ISceneObject;
+    (line: ISceneObject): IMirror;
     /**
     * [2D] Mirror all sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     */
-    (axis: AxisLike): ISceneObject;
+    (axis: AxisLike): IMirror;
     /**
     * [2D] Mirror given sketch geometries across a given line.
     * @param line The line to mirror across
     * @param geometries The geometries to mirror
     */
-    (line: ISceneObject, ...geometries: ISceneObject[]): ISceneObject;
+    (line: ISceneObject, ...geometries: ISceneObject[]): IMirror;
     /**
     * [2D] Mirror given sketch geometries across a given axis.
     * @param axis The local axis to mirror across
     * @param geometries The geometries to mirror
     */
-    (axis: AxisLike, ...geometries: ISceneObject[]): ISceneObject;
+    (axis: AxisLike, ...geometries: ISceneObject[]): IMirror;
     /**
     * [3D] Mirror all scene shapes across a given plane.
     * @param plane The plane to mirror across
     */
-    (plane: PlaneLike): ISceneObject;
+    (plane: PlaneLike): IMirror;
     /**
     * [3D] Mirror given shapes across a given plane.
     * @param plane The plane to mirror across
     * @param objects The shapes to mirror
     */
-    (plane: PlaneLike, ...objects: ISceneObject[]): ISceneObject;
+    (plane: PlaneLike, ...objects: ISceneObject[]): IMirror;
 }
 declare const _default: MirrorFunction;
 export default _default;

package/lib/dist/core/mirror.js

@@ -5,11 +5,11 @@ import { MirrorShape } from "../features/mirror-shape.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { PlaneObject } from "../features/plane.js";
 import { isAxisLike, isStandardAxis } from "../math/axis.js";
+import { isPlaneLike } from "../math/plane.js";
 import { MirrorShape2D } from "../features/mirror-shape2d.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { AxisObject } from "../features/axis.js";
 import { AxisFromEdge } from "../features/axis-from-edge.js";
-const axisToPlaneName = { x: "yz", y: "xz", z: "xy" };
 function resolveAxis(arg, context) {
     if (arg instanceof AxisObjectBase) {
         return arg;
@@ -36,6 +36,20 @@ function resolvePlane(arg, context) {
 function build(context) {
     return function mirror() {
         const activeSketch = context.getActiveSketch();
+        const firstArg = arguments[0];
+        if (activeSketch) {
+            const isPlaneArg = firstArg instanceof PlaneObjectBase
+                || (!isAxisLike(firstArg) && !(firstArg instanceof SceneObject) && isPlaneLike(firstArg));
+            if (isPlaneArg) {
+                throw new Error("Cannot specify a plane for mirror inside a sketch. Use mirror(axis) or mirror(line) instead.");
+            }
+        }
+        else if (firstArg instanceof SceneObject && !(firstArg instanceof PlaneObjectBase)) {
+            throw new Error("mirror(line) is only valid inside a sketch. For 3D mirroring, specify a plane: mirror(plane).");
+        }
+        else if (isStandardAxis(firstArg)) {
+            throw new Error("Cannot specify an axis for mirror outside a sketch. For 3D mirroring, specify a plane: mirror(plane).");
+        }
         if (arguments.length === 1) {
             if (activeSketch && (isAxisLike(arguments[0]) || arguments[0] instanceof SceneObject)) {
                 const axis = resolveAxis(arguments[0], context);
@@ -43,11 +57,7 @@ function build(context) {
                 context.addSceneObject(mirror);
                 return mirror;
             }
-            let planeArg = arguments[0];
-            if (isStandardAxis(planeArg)) {
-                planeArg = axisToPlaneName[planeArg];
-            }
-            const planeObj = resolvePlane(planeArg, context);
+            const planeObj = resolvePlane(arguments[0], context);
             const mirror = new MirrorShape(planeObj);
             context.addSceneObject(mirror);
             return mirror;
@@ -61,11 +71,7 @@ function build(context) {
                 context.addSceneObject(mirror);
                 return mirror;
             }
-            let planeArg = args[0];
-            if (isStandardAxis(planeArg)) {
-                planeArg = axisToPlaneName[planeArg];
-            }
-            const planeObj = resolvePlane(planeArg, context);
+            const planeObj = resolvePlane(args[0], context);
             const targetObjects = args.slice(1);
             const mirror = new MirrorShape(planeObj, targetObjects);
             context.addSceneObject(mirror);

package/lib/dist/core/part.d.ts

@@ -1,4 +1,6 @@
 import { ISceneObject } from "./interfaces.js";
-type Extend<T> = T extends object ? T : {};
+type Extend<T> = T extends object ? {
+    features: T;
+} : {};
 declare function part<T>(name: string, callback: () => T): ISceneObject & Extend<T>;
 export default part;

package/lib/dist/core/part.js

@@ -15,7 +15,7 @@ function part(name, callback) {
     const extensions = callback();
     scene.endProgressiveContainer();
     if (extensions && typeof extensions === 'object') {
-        Object.assign(partObj, extensions);
+        partObj.features = extensions;
     }
     return partObj;
 }

package/lib/dist/core/rotate.d.ts

@@ -1,26 +1,26 @@
 import { AxisLike } from "../math/axis.js";
-import { ISceneObject } from "./interfaces.js";
+import { IRotate, ISceneObject } from "./interfaces.js";
 interface RotateFunction {
     /**
      * [2D] Rotates geometry by an angle inside a sketch.
      * @param angle - The rotation angle in degrees
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, ...targets: ISceneObject[]): ISceneObject;
+    (angle: number, ...targets: ISceneObject[]): IRotate;
     /**
      * [2D] Rotates geometry by an angle inside a sketch, optionally making a copy.
      * @param angle - The rotation angle in degrees
      * @param copy - Whether to copy instead of move
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle.
      * @param axis - The axis to rotate around
      * @param angle - The rotation angle in degrees
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): ISceneObject;
+    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle, optionally making a copy.
      * @param axis - The axis to rotate around
@@ -28,7 +28,7 @@ interface RotateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
 }
 declare const _default: RotateFunction;
 export default _default;

package/lib/dist/core/rotate.js

@@ -17,7 +17,10 @@ function build(context) {
         // Extract copy flag from the end (if boolean)
         const copy = typeof args[args.length - 1] === 'boolean' ? args.pop() : false;
         // 2D: rotate(angle, copy?, ...targets)
-        if (args.length === 1 && activeSketch) {
+        if (args.length === 1) {
+            if (!activeSketch) {
+                throw new Error("rotate(angle) is only valid inside a sketch. For 3D rotation, specify an axis: rotate(axis, angle).");
+            }
             const angle = args[0];
             const rotate = new Rotate2D(angle, copy, ...targets);
             context.addSceneObject(rotate);

package/lib/dist/core/sketch.d.ts

@@ -1,6 +1,8 @@
 import { PlaneLike } from "../math/plane.js";
 import { IPlane, ISceneObject } from "./interfaces.js";
-type Extend<T> = T extends object ? T : {};
+type Extend<T> = T extends object ? {
+    regions: T;
+} : {};
 interface SketchFunction {
     /**
      * Draws 2D geometry on a standard plane.

package/lib/dist/core/sketch.js

@@ -29,7 +29,7 @@ function build(context) {
         const extensions = sketcher();
         context.endProgressiveContainer();
         if (extensions && typeof extensions === 'object') {
-            Object.assign(sketch, extensions);
+            sketch.regions = extensions;
         }
         return sketch;
     };

package/lib/dist/core/translate.d.ts

@@ -1,26 +1,26 @@
 import { PointLike } from "../math/point.js";
-import { ISceneObject } from "./interfaces.js";
+import { ISceneObject, ITranslate } from "./interfaces.js";
 interface TranslateFunction {
     /**
      * Translates objects along the X axis.
      * @param x - The X distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X axis, optionally making a copy.
      * @param x - The X distance
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X and Y axes.
      * @param x - The X distance
      * @param y - The Y distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along the X and Y axes, optionally making a copy.
      * @param x - The X distance
@@ -28,7 +28,7 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along all three axes.
      * @param x - The X distance
@@ -36,7 +36,7 @@ interface TranslateFunction {
      * @param z - The Z distance
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, z: number, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects along all three axes, optionally making a copy.
      * @param x - The X distance
@@ -45,20 +45,20 @@ interface TranslateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (x: number, y: number, z: number, copy: boolean, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects by a point-like offset.
      * @param distance - The offset as a point
      * @param targets - The objects to translate (defaults to last object)
      */
-    (distance: PointLike, ...targets: ISceneObject[]): ISceneObject;
+    (distance: PointLike, ...targets: ISceneObject[]): ITranslate;
     /**
      * Translates objects by a point-like offset, optionally making a copy.
      * @param distance - The offset as a point
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to translate (defaults to last object)
      */
-    (distance: PointLike, copy: boolean, ...targets: ISceneObject[]): ISceneObject;
+    (distance: PointLike, copy: boolean, ...targets: ISceneObject[]): ITranslate;
 }
 declare const _default: TranslateFunction;
 export default _default;

package/lib/dist/features/2d/aline.d.ts

@@ -1,20 +1,23 @@
 import { SceneObject } from "../../common/scene-object.js";
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
-export declare class AngledLine extends GeometrySceneObject {
-    length: number;
+import { IALine } from "../../core/interfaces.js";
+export declare class AngledLine extends GeometrySceneObject implements IALine {
     angle: number;
-    centered: boolean;
+    lengthOrTarget: number | SceneObject;
     private targetPlane;
-    constructor(length: number, angle: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    private _centered;
+    constructor(angle: number, lengthOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
+    centered(value?: boolean): this;
     build(): void;
+    getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: AngledLine): boolean;
     getType(): string;
     getUniqueType(): string;
     serialize(): {
-        length: number;
         angle: number;
+        length: number;
         centered: boolean;
     };
 }

package/lib/dist/features/2d/aline.js

@@ -1,20 +1,25 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { Vertex } from "../../common/vertex.js";
 import { Geometry } from "../../oc/geometry.js";
 import { rad } from "../../helpers/math-helpers.js";
 import { Point2D } from "../../math/point.js";
 import { GeometrySceneObject } from "./geometry.js";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class AngledLine extends GeometrySceneObject {
-    length;
     angle;
-    centered;
+    lengthOrTarget;
     targetPlane;
-    constructor(length, angle, centered = false, targetPlane = null) {
+    _centered = false;
+    constructor(angle, lengthOrTarget, targetPlane = null) {
         super();
-        this.length = length;
         this.angle = angle;
-        this.centered = centered;
+        this.lengthOrTarget = lengthOrTarget;
         this.targetPlane = targetPlane;
     }
+    centered(value = true) {
+        this._centered = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         let tangent = this.sketch?.getTangentAt(this) || new Point2D(1, 0);
@@ -29,27 +34,63 @@ export class AngledLine extends GeometrySceneObject {
         const currentPos = this.targetPlane
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
-        const startPoint = this.centered
-            ? currentPos.translate(-direction.x * this.length / 2, -direction.y * this.length / 2)
-            : currentPos;
+        let startPoint;
+        let endPoint;
+        if (typeof this.lengthOrTarget === 'number') {
+            const length = this.lengthOrTarget;
+            startPoint = this._centered
+                ? currentPos.translate(-direction.x * length / 2, -direction.y * length / 2)
+                : currentPos;
+            endPoint = startPoint.translate(direction.x * length, direction.y * length);
+        }
+        else {
+            if (this._centered) {
+                throw new Error('aLine: .centered() cannot be combined with a target geometry');
+            }
+            startPoint = currentPos;
+            endPoint = findNearestRayIntersection(plane, startPoint, direction, this.lengthOrTarget);
+        }
         const start = plane.localToWorld(startPoint);
-        const worldDir = plane.xDirection.multiply(direction.x).add(plane.yDirection.multiply(direction.y));
-        const end = start.add(worldDir.multiply(this.length));
-        const endPoint = plane.worldToLocal(end);
+        const end = plane.localToWorld(endPoint);
         let segment = Geometry.makeSegment(start, end);
         const edge = Geometry.makeEdge(segment);
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(endPoint));
         this.addShape(edge);
-        this.setTangent(direction.normalize());
-        if (this.sketch)
+        // Tangent at end points from start to end (sign-aware when target is behind start)
+        const endTangent = endPoint.subtract(startPoint);
+        const endLen = Math.hypot(endTangent.x, endTangent.y);
+        if (endLen > 1e-12) {
+            this.setTangent(new Point2D(endTangent.x / endLen, endTangent.y / endLen));
+        }
+        else {
+            this.setTangent(direction.normalize());
+        }
+        if (this.sketch) {
             this.setCurrentPosition(endPoint);
-        if (this.targetPlane)
+        }
+        if (this.targetPlane) {
             this.targetPlane.removeShapes(this);
+        }
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.lengthOrTarget instanceof SceneObject) {
+            deps.push(this.lengthOrTarget);
+        }
+        return deps;
     }
     createCopy(remap) {
         const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
-        return new AngledLine(this.length, this.angle, this.centered, targetPlane);
+        const lengthOrTarget = this.lengthOrTarget instanceof SceneObject
+            ? (remap.get(this.lengthOrTarget) || this.lengthOrTarget)
+            : this.lengthOrTarget;
+        const copy = new AngledLine(this.angle, lengthOrTarget, targetPlane);
+        copy.centered(this._centered);
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof AngledLine)) {
@@ -64,7 +105,18 @@ export class AngledLine extends GeometrySceneObject {
         if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
             return false;
         }
-        return this.length === other.length && this.angle === other.angle && this.centered === other.centered;
+        if (typeof this.lengthOrTarget !== typeof other.lengthOrTarget) {
+            return false;
+        }
+        if (this.lengthOrTarget instanceof SceneObject && other.lengthOrTarget instanceof SceneObject) {
+            if (!this.lengthOrTarget.compareTo(other.lengthOrTarget)) {
+                return false;
+            }
+        }
+        else if (this.lengthOrTarget !== other.lengthOrTarget) {
+            return false;
+        }
+        return this.angle === other.angle && this._centered === other._centered;
     }
     getType() {
         return 'line';
@@ -74,9 +126,9 @@ export class AngledLine extends GeometrySceneObject {
     }
     serialize() {
         return {
-            length: this.length,
             angle: this.angle,
-            centered: this.centered
+            length: typeof this.lengthOrTarget === 'number' ? this.lengthOrTarget : null,
+            centered: this._centered
         };
     }
 }

package/lib/dist/features/2d/back.d.ts

@@ -0,0 +1,14 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class Back extends GeometrySceneObject {
+    count: number;
+    constructor(count: number);
+    getType(): string;
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: this): boolean;
+    serialize(): {
+        count: number;
+    };
+}

package/lib/dist/features/2d/back.js

@@ -0,0 +1,35 @@
+import { GeometrySceneObject } from "./geometry.js";
+export class Back extends GeometrySceneObject {
+    count;
+    constructor(count) {
+        super();
+        this.count = count;
+    }
+    getType() {
+        return 'back';
+    }
+    build() {
+        const target = this.sketch.getPreviousPosition(this, this.count);
+        this.setCurrentPosition(target);
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new Back(this.count);
+    }
+    compareTo(other) {
+        if (!(other instanceof Back)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.count === other.count;
+    }
+    serialize() {
+        return {
+            count: this.count
+        };
+    }
+}

package/lib/dist/features/2d/ellipse.d.ts

@@ -0,0 +1,23 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { Point2D } from "../../math/point.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export declare class Ellipse extends ExtrudableGeometryBase {
+    rx: number;
+    ry: number;
+    private centerOverride;
+    constructor(rx: number, ry: number, targetPlane?: PlaneObjectBase, centerOverride?: Point2D | null);
+    getType(): string;
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: this): boolean;
+    serialize(): {
+        center?: {
+            x: number;
+            y: number;
+        };
+        rx: number;
+        ry: number;
+    };
+}