fluidcad 0.0.3 → 0.0.4

package/lib/dist/features/cut-two-distances.d.ts

@@ -1,24 +0,0 @@
-import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { Extrudable } from "../helpers/types.js";
-import { CutBase } from "./cut-base.js";
-export declare class CutTwoDistances extends CutBase {
-    distance1: number;
-    distance2: number;
-    constructor(distance1: number, distance2: number, extrudable?: Extrudable);
-    build(context: BuildSceneObjectContext): void;
-    getDependencies(): SceneObject[];
-    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
-    compareTo(other: CutTwoDistances): boolean;
-    edges(...indices: number[]): SceneObject;
-    getUniqueType(): string;
-    serialize(): {
-        extrudable: any;
-        distance1: number;
-        distance2: number;
-        draft: [number, number];
-        endOffset: number;
-        fusionScope: import("./extrude-options.js").FusionScope;
-        picking: true;
-        pickPoints: number[][];
-    };
-}

package/lib/dist/features/cut-two-distances.js

@@ -1,110 +0,0 @@
-import { Extruder } from "./simple-extruder.js";
-import { BooleanOps } from "../oc/boolean-ops.js";
-import { ShapeOps } from "../oc/shape-ops.js";
-import { LazySelectionSceneObject } from "./lazy-scene-object.js";
-import { CutBase } from "./cut-base.js";
-import { FaceMaker2 } from "../oc/face-maker2.js";
-export class CutTwoDistances extends CutBase {
-    distance1;
-    distance2;
-    constructor(distance1, distance2, extrudable) {
-        super(extrudable);
-        this.distance1 = distance1;
-        this.distance2 = distance2;
-    }
-    build(context) {
-        const plane = this.extrudable.getPlane();
-        const pickedFaces = this.resolvePickedFaces(plane);
-        if (pickedFaces !== null && pickedFaces.length === 0) {
-            return;
-        }
-        const scope = this.resolveFusionScope(context.getSceneObjects());
-        const sceneObjects = new Map();
-        for (const obj of scope) {
-            const shapes = obj.getShapes({}, 'solid');
-            if (shapes.length === 0) {
-                continue;
-            }
-            sceneObjects.set(obj, shapes);
-        }
-        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
-        // Positive distance = reverse normal direction, negate before passing to Extruder
-        const extruder1 = new Extruder(faces, plane, -this.distance1, this.getDraft(), this.getEndOffset());
-        const extrusions1 = extruder1.extrude();
-        const extruder2 = new Extruder(faces, plane, this.distance2, this.getDraft(), this.getEndOffset());
-        const extrusions2 = extruder2.extrude();
-        const all = [...extrusions1, ...extrusions2];
-        const { result: toolShapes } = BooleanOps.fuse(all);
-        this.extrudable.removeShapes(this);
-        const shapeObjectMap = new Map();
-        for (const [obj, shapes] of sceneObjects) {
-            for (const shape of shapes) {
-                shapeObjectMap.set(shape, obj);
-            }
-        }
-        const stock = Array.from(shapeObjectMap.keys());
-        const cutResult = BooleanOps.cutMultiShape(stock, toolShapes, plane, this.distance1);
-        const cleanedShapes = [];
-        for (const shape of stock) {
-            const list = cutResult.modified(shape);
-            if (list.length) {
-                for (const newShape of list) {
-                    const s = ShapeOps.cleanShape(newShape);
-                    this.addShape(s);
-                    cleanedShapes.push(s);
-                }
-                const obj = shapeObjectMap.get(shape);
-                obj.removeShape(shape, this);
-            }
-        }
-        this.classifyCutResult(stock, cleanedShapes, plane, this.distance1);
-    }
-    getDependencies() {
-        return this.extrudable ? [this.extrudable] : [];
-    }
-    createCopy(remap) {
-        const extrudable = this.extrudable
-            ? (remap.get(this.extrudable) || this.extrudable)
-            : undefined;
-        return new CutTwoDistances(this.distance1, this.distance2, extrudable).syncWith(this);
-    }
-    compareTo(other) {
-        if (!(other instanceof CutTwoDistances)) {
-            return false;
-        }
-        if (!super.compareTo(other)) {
-            return false;
-        }
-        if (this.distance1 !== other.distance1 || this.distance2 !== other.distance2) {
-            return false;
-        }
-        return true;
-    }
-    edges(...indices) {
-        const suffix = indices.length > 0 ? `section-edges-${indices.join('-')}` : 'section-edges';
-        return new LazySelectionSceneObject(`${this.getOrder()}-cut-two-distances-${suffix}`, (parent) => {
-            const edges = parent.getState('section-edges') || [];
-            if (indices.length === 0) {
-                return edges;
-            }
-            return indices.filter(i => i >= 0 && i < edges.length).map(i => edges[i]);
-        }, this);
-    }
-    getUniqueType() {
-        return 'cut-by-two-distances';
-    }
-    serialize() {
-        return {
-            extrudable: this.extrudable.serialize(),
-            distance1: this.distance1,
-            distance2: this.distance2,
-            draft: this.getDraft(),
-            endOffset: this.getEndOffset(),
-            fusionScope: this.getFusionScope(),
-            picking: this.isPicking() || undefined,
-            pickPoints: this.isPicking()
-                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
-                : undefined,
-        };
-    }
-}

package/lib/dist/features/cut.d.ts

@@ -1,27 +0,0 @@
-import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { ExtrudeOptions } from "./extrude-options.js";
-import { Extrudable } from "../helpers/types.js";
-export interface CutOptions extends ExtrudeOptions {
-}
-export type CutDirection = 'normal' | 'reversed' | 'symmetric';
-export type CutRotation = {
-    x?: number;
-    y?: number;
-};
-export declare class Cut extends SceneObject {
-    private extrudable;
-    distance: number;
-    options: CutOptions;
-    isThroughAll: boolean;
-    constructor(extrudable: Extrudable, distance: number, options?: CutOptions);
-    build(context: BuildSceneObjectContext): void;
-    clone(): SceneObject[];
-    compareTo(other: Cut): boolean;
-    getType(): string;
-    serialize(): {
-        extrudable: any;
-        distance: number;
-        isThroughAll: boolean;
-        options: CutOptions;
-    };
-}

package/lib/dist/features/cut.js

@@ -1,101 +0,0 @@
-import { SceneObject } from "../common/scene-object.js";
-import { ExtrudeThroughAll } from "./infinite-extrude.js";
-import { Sketch } from "./2d/sketch.js";
-import { FaceMaker } from "../core/2d/face-maker.js";
-import { Extruder } from "./simple-extruder.js";
-import { BooleanOps } from "../oc/boolean-ops.js";
-import { ShapeOps } from "../oc/shape-ops.js";
-export class Cut extends SceneObject {
-    extrudable;
-    distance;
-    options;
-    isThroughAll = false;
-    constructor(extrudable, distance, options = {}) {
-        super();
-        this.extrudable = extrudable;
-        this.distance = distance;
-        this.options = options;
-        this.isThroughAll = this.distance === 0;
-    }
-    build(context) {
-        let sceneObjects;
-        sceneObjects = new Map();
-        for (const obj of context.getSceneObjects()) {
-            const shapes = obj.getShapes(false, 'solid');
-            if (shapes.length === 0) {
-                continue;
-            }
-            sceneObjects.set(obj, shapes);
-        }
-        console.log('Cut: Scene objects for cut:', Array.from(sceneObjects.keys()).map(o => o.getType()));
-        let distance = this.distance === 0 ? 0 : -this.distance;
-        let extrusionShapes = [];
-        if (this.isThroughAll) {
-            const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, false, true);
-            extrusionShapes = extrudeThroughAll.build();
-        }
-        else {
-            const wires = this.extrudable.getGeometries();
-            const faces = FaceMaker.getFaces(wires, this.extrudable.getPlane());
-            const plane = this.extrudable.getPlane();
-            const extruder = new Extruder(faces, plane, distance, this.options);
-            extrusionShapes = extruder.extrude();
-        }
-        this.extrudable.removeShapes(this);
-        const shapeObjectMap = new Map();
-        for (const [obj, shapes] of sceneObjects) {
-            for (const shape of shapes) {
-                shapeObjectMap.set(shape, obj);
-            }
-        }
-        const stock = Array.from(shapeObjectMap.keys());
-        console.log('Cut: Stock shapes count:', stock.length);
-        const toBeRemoved = extrusionShapes;
-        console.log('Cut: Stock shapes count:', stock.length);
-        console.log('Cut: To be removed shapes count:', toBeRemoved.length);
-        const cutResult = BooleanOps.cutMultiShape(stock, toBeRemoved);
-        for (const shape of stock) {
-            const list = cutResult.modified(shape);
-            console.log('Cut: Modified shapes for shape:', list.length);
-            if (list.length) {
-                for (const newShape of list) {
-                    const s = ShapeOps.cleanShape(newShape);
-                    console.log('Cut: Adding modified shape:', s);
-                    this.addShape(s);
-                }
-                const obj = shapeObjectMap.get(shape);
-                obj.removeShape(shape, this);
-            }
-            console.log('Cut: Shape modified count:', list.length);
-        }
-    }
-    clone() {
-        const extrudableClone = this.extrudable.clone();
-        const extrudable = extrudableClone.find(c => c instanceof Sketch);
-        const cutClone = new Cut(extrudable, this.distance, this.options);
-        return [...extrudableClone, cutClone];
-    }
-    compareTo(other) {
-        if (!(other instanceof Cut)) {
-            return false;
-        }
-        if (this.distance !== other.distance) {
-            return false;
-        }
-        if (JSON.stringify(this.options || {}) !== JSON.stringify(other.options || {})) {
-            return false;
-        }
-        return true;
-    }
-    getType() {
-        return "cut";
-    }
-    serialize() {
-        return {
-            extrudable: this.extrudable.serialize(),
-            distance: this.distance,
-            isThroughAll: this.isThroughAll,
-            options: this.options
-        };
-    }
-}

package/lib/dist/features/extrude-symmetric.d.ts

@@ -1,28 +0,0 @@
-import { BuildSceneObjectContext } from "../common/scene-object.js";
-import { ExtrudeOptions } from "./extrude-options.js";
-import { ExtrudeBase } from "./extrude-base.js";
-import { SceneObject } from "../common/scene-object.js";
-import { Extrudable } from "../helpers/types.js";
-export declare class ExtrudeSymmetric extends ExtrudeBase {
-    extrudable: Extrudable;
-    distance?: number;
-    options: ExtrudeOptions;
-    constructor(extrudable: Extrudable, distance?: number, options?: ExtrudeOptions);
-    build(context: BuildSceneObjectContext): void;
-    private applyDraft;
-    private doExtrude;
-    private getUniqueName;
-    startFace(...indices: number[]): SceneObject;
-    endFace(...indices: number[]): SceneObject;
-    startEdge(...indices: number[]): SceneObject;
-    endEdge(...indices: number[]): SceneObject;
-    sideFace(...indices: number[]): SceneObject;
-    compareTo(other: ExtrudeSymmetric): boolean;
-    getUniqueType(): string;
-    serialize(): {
-        extrudables: any;
-        distance: number;
-        symmetric: boolean;
-        options: ExtrudeOptions;
-    };
-}

package/lib/dist/features/extrude-symmetric.js

@@ -1,177 +0,0 @@
-import { rad } from "../helpers/math-helpers.js";
-import { ExtrudeBase } from "./extrude-base.js";
-import { fuseWithSceneObjects } from "../helpers/scene-helpers.js";
-import { FaceMaker } from "../core/2d/face-maker.js";
-import { ExtrudeOps } from "../oc/extrude-ops.js";
-import { ShapeOps } from "../oc/shape-ops.js";
-import { BooleanOps } from "../oc/boolean-ops.js";
-import { Explorer } from "../oc/explorer.js";
-import { LazySceneObject } from "./lazy-scene-object.js";
-export class ExtrudeSymmetric extends ExtrudeBase {
-    extrudable;
-    distance;
-    options;
-    constructor(extrudable, distance, options = {}) {
-        super(options);
-        this.extrudable = extrudable;
-        this.distance = distance;
-        this.options = options;
-    }
-    build(context) {
-        let solids = [];
-        const sceneObjects = context.getSceneObjects();
-        const wires = this.extrudable.getGeometries();
-        const faces = FaceMaker.getFaces(wires, this.extrudable.getPlane());
-        console.log("Extruding faces:", faces);
-        const plane = this.extrudable.getPlane();
-        const hasDraft = !!this.options?.draft;
-        let startFaces = [];
-        let endFaces = [];
-        let sideFaces = [];
-        if (hasDraft) {
-            let vec = plane.normal.multiply(this.distance / 2);
-            for (const face of faces) {
-                let { solid, firstFace, lastFace } = this.doExtrude(face, vec);
-                solid = this.applyDraft(solid, firstFace, lastFace, plane);
-                const center = face.center();
-                const mirrored = ShapeOps.mirrorShape(solid, center);
-                const fused = BooleanOps.fuseShapes(solid, mirrored);
-                const solidFaces = Explorer.findFacesWrapped(fused);
-                for (const f of solidFaces) {
-                    if (f.getShape().IsSame(firstFace.getShape())) {
-                        startFaces.push(f);
-                    }
-                    else if (f.getShape().IsSame(lastFace.getShape())) {
-                        endFaces.push(f);
-                    }
-                    else {
-                        sideFaces.push(f);
-                    }
-                }
-                solids.push(fused);
-            }
-        }
-        else {
-            let vec = plane.normal.multiply(this.distance);
-            const translateVec = vec.multiply(-0.5);
-            for (const face of faces) {
-                let { solid, firstFace, lastFace } = this.doExtrude(face, vec);
-                solid = ShapeOps.translateShape(solid, translateVec);
-                const solidFaces = Explorer.findFacesWrapped(solid);
-                for (const f of solidFaces) {
-                    // here we use IsPartner instead of IsSame because the place location has changed after translation
-                    if (f.getShape().IsPartner(firstFace.getShape())) {
-                        startFaces.push(f);
-                    }
-                    else if (f.getShape().IsPartner(lastFace.getShape())) {
-                        endFaces.push(f);
-                    }
-                    else {
-                        sideFaces.push(f);
-                    }
-                }
-                solids.push(solid);
-            }
-        }
-        this.setState('start-faces', startFaces);
-        this.setState('end-faces', endFaces);
-        this.setState('side-faces', sideFaces);
-        this.extrudable.removeShapes(this);
-        if (this.options?.mergeScope === 'none' || solids.length === 0 || sceneObjects?.length === 0) {
-            const fusionResult = fuseWithSceneObjects(sceneObjects, solids);
-            solids = fusionResult.extrusions;
-            for (const modifiedShape of fusionResult.modifiedShapes) {
-                modifiedShape.object.removeShape(modifiedShape.shape, this);
-            }
-        }
-        this.addShapes(solids);
-    }
-    applyDraft(solid, firstFace, lastFace, plane) {
-        if (this.options.draft instanceof Array) {
-            throw new Error("Draft with two angles for start and end faces is supported only for extrusions with two distances");
-        }
-        const angle = this.options.draft;
-        return ExtrudeOps.applyDraftOnSideFaces(solid, firstFace, lastFace, plane, rad(angle));
-    }
-    doExtrude(shape, vector) {
-        const { solid: rawSolid, firstFace, lastFace } = ExtrudeOps.makePrismFromVec(shape, vector);
-        const solid = ShapeOps.cleanShape(rawSolid);
-        return { solid, firstFace, lastFace };
-    }
-    getUniqueName(suffix) {
-        return `${this.getOrder()}-${this.getUniqueType()}-${suffix}`;
-    }
-    startFace(...indices) {
-        const suffix = indices.length > 0 ? `start-faces-${indices.join('-')}` : 'start-faces';
-        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
-            const faces = this.getState('start-faces') || [];
-            if (indices.length === 0)
-                return faces.length > 0 ? [faces[0]] : [];
-            return indices.filter(i => i >= 0 && i < faces.length).map(i => faces[i]);
-        });
-    }
-    endFace(...indices) {
-        const suffix = indices.length > 0 ? `end-faces-${indices.join('-')}` : 'end-faces';
-        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
-            const faces = this.getState('end-faces') || [];
-            if (indices.length === 0)
-                return faces.length > 0 ? [faces[0]] : [];
-            return indices.filter(i => i >= 0 && i < faces.length).map(i => faces[i]);
-        });
-    }
-    startEdge(...indices) {
-        const suffix = indices.length > 0 ? `start-edges-${indices.join('-')}` : 'start-edges';
-        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
-            const faces = this.getState('start-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
-            if (indices.length === 0)
-                return edges.length > 0 ? [edges[0]] : [];
-            return indices.filter(i => i >= 0 && i < edges.length).map(i => edges[i]);
-        });
-    }
-    endEdge(...indices) {
-        const suffix = indices.length > 0 ? `end-edges-${indices.join('-')}` : 'end-edges';
-        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
-            const faces = this.getState('end-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
-            if (indices.length === 0)
-                return edges.length > 0 ? [edges[0]] : [];
-            return indices.filter(i => i >= 0 && i < edges.length).map(i => edges[i]);
-        });
-    }
-    sideFace(...indices) {
-        const suffix = indices.length > 0 ? `side-faces-${indices.join('-')}` : 'side-faces';
-        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
-            const faces = this.getState('side-faces') || [];
-            if (indices.length === 0)
-                return faces.length > 0 ? [faces[0]] : [];
-            return indices.filter(i => i >= 0 && i < faces.length).map(i => faces[i]);
-        });
-    }
-    compareTo(other) {
-        if (!(other instanceof ExtrudeSymmetric)) {
-            return false;
-        }
-        if (this.distance !== other.distance) {
-            return false;
-        }
-        if (JSON.stringify(this.options || {}) !== JSON.stringify(other.options || {})) {
-            return false;
-        }
-        if (!this.extrudable.compareTo(other.extrudable)) {
-            return false;
-        }
-        return true;
-    }
-    getUniqueType() {
-        return 'extrude-symmetric';
-    }
-    serialize() {
-        return {
-            extrudables: this.extrudable.serialize(),
-            distance: this.distance,
-            symmetric: true,
-            options: this.options
-        };
-    }
-}

package/lib/dist/features/region2d.d.ts

@@ -1,25 +0,0 @@
-import { SceneObject } from "../common/scene-object.js";
-import { Edge } from "../common/edge.js";
-import { Wire } from "../common/wire.js";
-import { Extrudable } from "../helpers/types.js";
-import { LazyVertex } from "./lazy-vertex.js";
-import { GeometrySceneObject } from "./2d/geometry.js";
-export declare class Region2D extends SceneObject implements Extrudable {
-    private _points;
-    private _extrudable;
-    constructor(extrudable: Extrudable);
-    points(...ps: LazyVertex[]): this;
-    isExtrudable(): boolean;
-    build(): void;
-    getGeometries(): (Wire | Edge)[];
-    getGeometriesWithOwner(): Map<Wire | Edge, GeometrySceneObject>;
-    getPlane(): import("../math/plane.js").Plane;
-    getDependencies(): SceneObject[];
-    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
-    compareTo(other: Region2D): boolean;
-    getType(): string;
-    serialize(): {
-        plane: any;
-        selections: any;
-    };
-}

package/lib/dist/features/region2d.js

@@ -1,185 +0,0 @@
-import { SceneObject } from "../common/scene-object.js";
-import { FaceOps } from "../oc/face-ops.js";
-import { Explorer } from "../oc/explorer.js";
-import { ShapeOps } from "../oc/shape-ops.js";
-export class Region2D extends SceneObject {
-    _points = [];
-    _extrudable;
-    constructor(extrudable) {
-        super();
-        this._extrudable = extrudable;
-    }
-    points(...ps) {
-        this._points = ps;
-        return this;
-    }
-    isExtrudable() {
-        return true;
-    }
-    build() {
-        const plane = this._extrudable.getPlane();
-        const shapes = this._extrudable.getGeometries();
-        const allFaces = FaceOps.buildPlanarFaces(shapes, plane);
-        if (allFaces.length === 0) {
-            return;
-        }
-        // Compute bounding box diagonals for disambiguation (smallest face wins)
-        const faceDiagonals = allFaces.map(face => {
-            const bbox = ShapeOps.getBoundingBox(face);
-            return Math.sqrt((bbox.maxX - bbox.minX) ** 2 +
-                (bbox.maxY - bbox.minY) ** 2);
-        });
-        // Match each user point to the smallest face containing it
-        const selectedIndices = new Set();
-        const pointForFace = new Map();
-        for (const lazyPoint of this._points) {
-            const point2d = lazyPoint.asPoint2D();
-            const point3d = plane.localToWorld(point2d);
-            let bestIdx = -1;
-            let bestDiag = Infinity;
-            for (let i = 0; i < allFaces.length; i++) {
-                if (FaceOps.isPointInsideFace(point3d, allFaces[i])) {
-                    if (faceDiagonals[i] < bestDiag) {
-                        bestDiag = faceDiagonals[i];
-                        bestIdx = i;
-                    }
-                }
-            }
-            if (bestIdx >= 0) {
-                selectedIndices.add(bestIdx);
-                // Store rounded values to match what handleInsertPoint writes to source code
-                pointForFace.set(bestIdx, [
-                    Math.round(point2d.x * 100) / 100,
-                    Math.round(point2d.y * 100) / 100,
-                ]);
-            }
-        }
-        // Determine nesting: find holes for each selected face
-        const holesFor = new Map();
-        for (const selIdx of selectedIndices) {
-            const holes = [];
-            for (let i = 0; i < allFaces.length; i++) {
-                if (i === selIdx || selectedIndices.has(i)) {
-                    continue;
-                }
-                const innerWires = Explorer.findWiresWrapped(allFaces[i]);
-                if (innerWires.length > 0) {
-                    const firstVertex = innerWires[0].getFirstVertex();
-                    if (firstVertex && FaceOps.isPointInsideFace(firstVertex.toPoint(), allFaces[selIdx])) {
-                        holes.push(i);
-                    }
-                }
-            }
-            if (holes.length > 0) {
-                holesFor.set(selIdx, holes);
-            }
-        }
-        // Extract wires for getGeometries() BEFORE drilling (which mutates wires in-place)
-        const resultWires = [];
-        for (const selIdx of selectedIndices) {
-            const wires = Explorer.findWiresWrapped(allFaces[selIdx]);
-            if (wires.length > 0) {
-                resultWires.push(wires[0]);
-            }
-        }
-        for (const [, holeIndices] of holesFor) {
-            for (const hi of holeIndices) {
-                const wires = Explorer.findWiresWrapped(allFaces[hi]);
-                if (wires.length > 0) {
-                    resultWires.push(wires[0]);
-                }
-            }
-        }
-        this.setState('result-wires', resultWires);
-        // Build drilled faces for selected regions with holes
-        const drilledFaces = new Map();
-        for (const [selIdx, holeIndices] of holesFor) {
-            const outerWires = Explorer.findWiresWrapped(allFaces[selIdx]);
-            if (outerWires.length === 0) {
-                continue;
-            }
-            const outerWire = outerWires[0];
-            const holeWires = [];
-            for (const hi of holeIndices) {
-                const wires = Explorer.findWiresWrapped(allFaces[hi]);
-                if (wires.length > 0) {
-                    wires[0].getShape().Reverse();
-                    holeWires.push(wires[0]);
-                }
-            }
-            if (holeWires.length > 0) {
-                drilledFaces.set(selIdx, FaceOps.makeFaceWithHoles(outerWire, holeWires));
-            }
-        }
-        // Add ALL faces as shapes (for rendering/raycasting)
-        // Selected faces that have holes are replaced with drilled versions
-        for (let i = 0; i < allFaces.length; i++) {
-            const face = drilledFaces.has(i) ? drilledFaces.get(i) : allFaces[i];
-            this.addShape(face);
-        }
-        // Build selection mapping: map shape indices to their selection state
-        const addedShapes = this.getOwnShapes({ excludeMeta: false, excludeGuide: false });
-        const selections = [];
-        for (let i = 0; i < addedShapes.length; i++) {
-            if (selectedIndices.has(i) && pointForFace.has(i)) {
-                selections.push({
-                    shapeId: addedShapes[i].id,
-                    point: pointForFace.get(i),
-                });
-            }
-        }
-        this.setState('selections', selections);
-        this.setState('all-face-count', allFaces.length);
-        this.setState('selected-indices', [...selectedIndices]);
-    }
-    getGeometries() {
-        return this.getState('result-wires') || [];
-    }
-    getGeometriesWithOwner() {
-        const result = new Map();
-        for (const wire of this.getGeometries()) {
-            result.set(wire, this);
-        }
-        return result;
-    }
-    getPlane() {
-        return this._extrudable.getPlane();
-    }
-    getDependencies() {
-        return [this._extrudable];
-    }
-    createCopy(remap) {
-        const extrudable = (remap.get(this._extrudable) || this._extrudable);
-        const copy = new Region2D(extrudable);
-        if (this._points.length > 0) {
-            copy.points(...this._points);
-        }
-        return copy;
-    }
-    compareTo(other) {
-        if (!(other instanceof Region2D)) {
-            return false;
-        }
-        if (!super.compareTo(other)) {
-            return false;
-        }
-        if (this._points.length !== other._points.length) {
-            return false;
-        }
-        for (let i = 0; i < this._points.length; i++) {
-            if (!this._points[i].compareTo(other._points[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    getType() {
-        return "region";
-    }
-    serialize() {
-        return {
-            plane: this._extrudable.serialize?.()?.plane || null,
-            selections: this.getState('selections') || [],
-        };
-    }
-}