fluidcad 0.0.2

package/lib/dist/tests/features/2d/project.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import extrude from "../../../core/extrude.js";
+import { project, rect } from "../../../core/2d/index.js";
+describe("project", () => {
+    setupOC();
+    describe("project 3D shape onto sketch plane", () => {
+        it("should project a box onto the current sketch plane", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const s = sketch("xy", () => {
+                project(e.sideFaces(0));
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+    });
+});

package/lib/dist/tests/features/2d/rect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/2d/rect.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import extrude from "../../../core/extrude.js";
+import { rect } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+describe("rect", () => {
+    setupOC();
+    describe("in sketch", () => {
+        it("should create a rectangle with width and height", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(100, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(50, 0);
+        });
+        it("should create a square when only width is given", () => {
+            sketch("xy", () => {
+                rect(60);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(60, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(60, 0);
+        });
+        it("should create a centered rectangle", () => {
+            sketch("xy", () => {
+                rect(100, 50).center();
+            });
+            const e = extrude(10);
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(-50, 0);
+            expect(bbox.maxX).toBeCloseTo(50, 0);
+            expect(bbox.minY).toBeCloseTo(-25, 0);
+            expect(bbox.maxY).toBeCloseTo(25, 0);
+        });
+        it("should create a rounded rectangle", () => {
+            sketch("xy", () => {
+                rect(100, 50).radius(10);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            // Rounded rect has more edges than a sharp rect (arcs at corners)
+            expect(solid.getEdges().length).toBeGreaterThan(12);
+        });
+    });
+    describe("standalone with targetPlane", () => {
+        it("should create a rectangle on a specific plane", () => {
+            rect(80, 40, "xy");
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(80, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(40, 0);
+        });
+    });
+});

package/lib/dist/tests/features/2d/rmove.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/2d/rmove.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import { rMove, hLine } from "../../../core/2d/index.js";
+describe("rMove", () => {
+    setupOC();
+    it("should rotate the cursor direction", () => {
+        const s = sketch("xy", () => {
+            // Draw horizontal, rotate 90°, draw "horizontal" (now vertical)
+            hLine(50);
+            rMove(90);
+            hLine(30);
+        });
+        render();
+        const shapes = s.getShapes();
+        // Should have 2 edges: one horizontal, one vertical after rotation
+        expect(shapes.length).toBeGreaterThanOrEqual(2);
+    });
+    it("should rotate around a pivot point", () => {
+        const s = sketch("xy", () => {
+            hLine(40);
+            rMove(90, [20, 0]);
+            hLine(30);
+        });
+        render();
+        const shapes = s.getShapes();
+        expect(shapes.length).toBeGreaterThanOrEqual(2);
+    });
+});

package/lib/dist/tests/features/2d/slot-from-edge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/2d/slot-from-edge.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import { slot, hLine, aLine } from "../../../core/2d/index.js";
+describe("slot from edge", () => {
+    setupOC();
+    it("should create a slot from a horizontal line", () => {
+        const s = sketch("xy", () => {
+            const l = hLine(60);
+            slot(l, 10);
+        });
+        render();
+        const shapes = s.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+    });
+    it("should create a slot from an angled line", () => {
+        const s = sketch("xy", () => {
+            const l = aLine(60, 45);
+            slot(l, 10);
+        });
+        render();
+        const shapes = s.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+    });
+    it("should keep source line when deleteSource is false", () => {
+        const s = sketch("xy", () => {
+            const l = hLine(60);
+            slot(l, 10, false);
+        });
+        render();
+        const children = s.getChildren();
+        const lineObj = children[0];
+        expect(lineObj.getShapes().length).toBeGreaterThan(0);
+    });
+});

package/lib/dist/tests/features/2d/slot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/2d/slot.test.js

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import extrude from "../../../core/extrude.js";
+import { slot } from "../../../core/2d/index.js";
+import { ShapeOps } from "../../../oc/shape-ops.js";
+import { getEdgesByType } from "../../utils.js";
+describe("slot", () => {
+    setupOC();
+    describe("in sketch", () => {
+        it("should create a slot with distance and radius", () => {
+            sketch("xy", () => {
+                slot(80, 15);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // Slot total width = distance + 2*radius = 80 + 30 = 110
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(110, 0);
+            // Slot height = 2*radius = 30
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(30, 0);
+        });
+        it("should produce arc edges from rounded ends", () => {
+            sketch("xy", () => {
+                slot(60, 10);
+            });
+            const e = extrude(10);
+            render();
+            const solid = e.getShapes()[0];
+            // Slot has arc edges at its rounded ends
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("standalone with targetPlane", () => {
+        it("should create a slot on a specific plane", () => {
+            slot(60, 10, "xy");
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+        });
+    });
+});

package/lib/dist/tests/features/2d/tarc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/2d/tarc.test.js

@@ -0,0 +1,237 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import extrude from "../../../core/extrude.js";
+import { tArc, hLine, vLine, circle, move, arc } from "../../../core/2d/index.js";
+import { outside } from "../../../features/2d/constraints/geometry-qualifier.js";
+import { getEdgesByType } from "../../utils.js";
+describe("tArc", () => {
+    setupOC();
+    describe("tangent arc from previous geometry (radius, angle)", () => {
+        it("should create a tangent arc after a horizontal line", () => {
+            sketch("xy", () => {
+                hLine(50);
+                tArc(20, 90);
+                vLine(-20);
+                hLine(-50);
+                vLine(-20);
+            });
+            const e = extrude(5);
+            render();
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+        it("should create a tangent arc after a vertical line", () => {
+            const s = sketch("xy", () => {
+                vLine(50);
+                tArc(20, 90);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should create a tangent arc with default parameters", () => {
+            const s = sketch("xy", () => {
+                hLine(50);
+                tArc();
+            });
+            render();
+            const shapes = s.getShapes();
+            // hLine + tArc = at least 2 edges
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should create a clockwise arc with negative angle", () => {
+            const s = sketch("xy", () => {
+                hLine(50);
+                tArc(20, -90);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should create a 180-degree arc", () => {
+            const s = sketch("xy", () => {
+                hLine(50);
+                tArc(30, 180);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should chain multiple tangent arcs", () => {
+            const s = sketch("xy", () => {
+                hLine(50);
+                tArc(20, 90);
+                tArc(20, 90);
+            });
+            render();
+            const shapes = s.getShapes();
+            // hLine + 2 tArcs = at least 3 edges
+            expect(shapes.length).toBeGreaterThanOrEqual(3);
+        });
+        it("should create a tangent arc after another arc", () => {
+            const s = sketch("xy", () => {
+                move([0, 0]);
+                arc(30, 0, 90);
+                tArc(20, 45);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe("tangent arc with explicit tangent (radius, angle, tangent)", () => {
+        it("should create a tangent arc with a specified start tangent", () => {
+            const s = sketch("xy", () => {
+                move([0, 0]);
+                tArc(30, 90, [1, 0]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should create a tangent arc with a diagonal start tangent", () => {
+            const s = sketch("xy", () => {
+                move([0, 0]);
+                tArc(25, 120, [1, 1]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+    describe("tangent arc to endpoint (endPoint)", () => {
+        it("should create a tangent arc to a given point", () => {
+            const s = sketch("xy", () => {
+                hLine(50);
+                tArc([50, 30]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should create a tangent arc to a point above", () => {
+            const s = sketch("xy", () => {
+                hLine(40);
+                tArc([60, 40]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should create a tangent arc to a point below", () => {
+            const s = sketch("xy", () => {
+                hLine(40);
+                tArc([60, -30]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe("tangent arc to endpoint with tangent (endPoint, tangent)", () => {
+        it("should create a tangent arc to a point with explicit end tangent", () => {
+            const s = sketch("xy", () => {
+                hLine(50);
+                tArc([70, 30], [0, 1]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should create a tangent arc with a horizontal end tangent", () => {
+            const s = sketch("xy", () => {
+                vLine(30);
+                tArc([50, 50], [1, 0]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe("tangent arc from start to end with tangent (startPoint, endPoint, tangent)", () => {
+        it("should create a tangent arc between two points with explicit tangent", () => {
+            const s = sketch("xy", () => {
+                tArc([0, 0], [50, 50], [1, 0]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should create a tangent arc with vertical tangent direction", () => {
+            const s = sketch("xy", () => {
+                tArc([10, 0], [60, 40], [0, 1]);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+    describe("tangent arc between two objects (c1, c2, radius)", () => {
+        it("should create a fillet arc between two circles", () => {
+            sketch("xy", () => {
+                const c1 = circle(40);
+                const c2 = circle([80, 0], 40);
+                tArc(c1, c2, 15);
+            });
+            const e = extrude(10);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should create a fillet arc between two circles with outside qualifier", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(160);
+                const c2 = circle([200, 0], 60);
+                tArc(outside(c1), outside(c2), 80).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+        it("should create a fillet arc between a circle and a point", () => {
+            const s = sketch("xy", () => {
+                const c = circle([100, 0], 40);
+                tArc(outside(c), [100, 50], 100).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+        it("should create a fillet arc with mustTouch enabled", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(60);
+                const c2 = circle([100, 0], 60);
+                tArc(c1, c2, 40, true).guide();
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+        });
+        it("should expose start and end accessors on constrained arc", () => {
+            sketch("xy", () => {
+                const c1 = circle(100);
+                const c2 = circle([200, 0], 60);
+                const t = tArc(outside(c1), outside(c2), 80);
+                const startPt = t.start();
+                const endPt = t.end();
+                expect(startPt).toBeDefined();
+                expect(endPt).toBeDefined();
+            });
+            render();
+        });
+        it("should expose indexed start and end accessors", () => {
+            sketch("xy", () => {
+                const c1 = circle(100);
+                const c2 = circle([200, 0], 60);
+                const t = tArc(outside(c1), outside(c2), 80);
+                const start0 = t.start(0);
+                const end0 = t.end(0);
+                expect(start0).toBeDefined();
+                expect(end0).toBeDefined();
+            });
+            render();
+        });
+    });
+});

package/lib/dist/tests/features/2d/tcircle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/2d/tcircle.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import { tCircle, circle } from "../../../core/2d/index.js";
+describe("tCircle", () => {
+    setupOC();
+    describe("tangent circle between two objects", () => {
+        it("should create a circle tangent to two circles", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle(40);
+                const c2 = circle([80, 0], 40);
+                tCircle(c1, c2, 30);
+            });
+            render();
+            const shapes = s.getShapes();
+            // Original circles + tangent circle edges
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should create a circle tangent to two points", () => {
+            const s = sketch("xy", () => {
+                tCircle([0, 0], [50, 0], 60);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+});

package/lib/dist/tests/features/2d/tline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/2d/tline.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../../setup.js";
+import sketch from "../../../core/sketch.js";
+import extrude from "../../../core/extrude.js";
+import { tLine, circle, hLine } from "../../../core/2d/index.js";
+describe("tLine", () => {
+    setupOC();
+    describe("tangent line from previous geometry", () => {
+        it("should create a tangent line with given distance", () => {
+            const s = sketch("xy", () => {
+                hLine(50);
+                tLine(30);
+            });
+            render();
+            const shapes = s.getShapes();
+            // hLine + tLine = at least 2 edges
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe("tangent line between two objects", () => {
+        it("should create a tangent line between two circles", () => {
+            sketch("xy", () => {
+                const c1 = circle(40);
+                const c2 = circle([80, 0], 40);
+                tLine(c1, c2);
+            });
+            const e = extrude(10);
+            render();
+            // Two circles + tangent line form a closed region when extruded
+            const shapes = e.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+});

package/lib/dist/tests/features/axis.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/axis.test.js

@@ -0,0 +1,143 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import axis from "../../core/axis.js";
+import { rect } from "../../core/2d/index.js";
+describe("axis", () => {
+    setupOC();
+    describe("standard axis creation", () => {
+        it("should create an X axis", () => {
+            const a = axis("x");
+            render();
+            const ax = a.getAxis();
+            expect(ax.origin.x).toBeCloseTo(0);
+            expect(ax.origin.y).toBeCloseTo(0);
+            expect(ax.origin.z).toBeCloseTo(0);
+            expect(ax.direction.x).toBeCloseTo(1);
+            expect(ax.direction.y).toBeCloseTo(0);
+            expect(ax.direction.z).toBeCloseTo(0);
+        });
+        it("should create a Y axis", () => {
+            const a = axis("y");
+            render();
+            const ax = a.getAxis();
+            expect(ax.direction.x).toBeCloseTo(0);
+            expect(ax.direction.y).toBeCloseTo(1);
+            expect(ax.direction.z).toBeCloseTo(0);
+        });
+        it("should create a Z axis", () => {
+            const a = axis("z");
+            render();
+            const ax = a.getAxis();
+            expect(ax.direction.x).toBeCloseTo(0);
+            expect(ax.direction.y).toBeCloseTo(0);
+            expect(ax.direction.z).toBeCloseTo(1);
+        });
+    });
+    describe("axis with transform options", () => {
+        it("should offset the axis origin", () => {
+            const a = axis("z", { offsetX: 10, offsetY: 20, offsetZ: 30 });
+            render();
+            const ax = a.getAxis();
+            expect(ax.origin.x).toBeCloseTo(10);
+            expect(ax.origin.y).toBeCloseTo(20);
+            expect(ax.origin.z).toBeCloseTo(30);
+            // Direction should still be Z
+            expect(ax.direction.z).toBeCloseTo(1);
+        });
+        it("should rotate the axis direction", () => {
+            // Rotate X axis by 90° around Z → should become Y axis
+            const a = axis("x", { rotateZ: Math.PI / 2 });
+            render();
+            const ax = a.getAxis();
+            expect(ax.direction.x).toBeCloseTo(0);
+            expect(ax.direction.y).toBeCloseTo(1);
+            expect(ax.direction.z).toBeCloseTo(0);
+        });
+    });
+    describe("axis from edge", () => {
+        it("should extract axis from a single edge of an extrusion", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const a = axis(e.startEdges(0));
+            render();
+            const ax = a.getAxis();
+            // Edge is on the XY plane at z=0
+            expect(ax.origin.z).toBeCloseTo(0);
+            // Direction should be along X or Y (a line edge of the rect)
+            const isHorizontalOrVertical = Math.abs(ax.direction.z) < 0.01;
+            expect(isHorizontalOrVertical).toBe(true);
+        });
+        it("should extract axis from an end edge", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const a = axis(e.endEdges(0));
+            render();
+            const ax = a.getAxis();
+            // Edge is on the end face at z=30
+            expect(ax.origin.z).toBeCloseTo(30);
+        });
+        it("should apply transform options to extracted axis", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const a = axis(e.startEdges(0), { offsetZ: 15 });
+            render();
+            const ax = a.getAxis();
+            expect(ax.origin.z).toBeCloseTo(15);
+        });
+    });
+    describe("axis middle", () => {
+        it("should create axis midway between two parallel axes", () => {
+            const a1 = axis("z", { offsetX: 0 });
+            const a2 = axis("z", { offsetX: 100 });
+            const mid = axis(a1, a2);
+            render();
+            const ax = mid.getAxis();
+            expect(ax.origin.x).toBeCloseTo(50);
+            expect(ax.direction.z).toBeCloseTo(1);
+        });
+        it("should compute midpoint in all dimensions", () => {
+            const a1 = axis("z", { offsetX: 10, offsetY: 20 });
+            const a2 = axis("z", { offsetX: 50, offsetY: 80 });
+            const mid = axis(a1, a2);
+            render();
+            const ax = mid.getAxis();
+            expect(ax.origin.x).toBeCloseTo(30);
+            expect(ax.origin.y).toBeCloseTo(50);
+        });
+        it("should preserve direction from first axis", () => {
+            const a1 = axis("x", { offsetY: 0 });
+            const a2 = axis("x", { offsetY: 40 });
+            const mid = axis(a1, a2);
+            render();
+            const ax = mid.getAxis();
+            expect(ax.direction.x).toBeCloseTo(1);
+            expect(ax.direction.y).toBeCloseTo(0);
+            expect(ax.origin.y).toBeCloseTo(20);
+        });
+        it("should apply transform options to middle axis", () => {
+            const a1 = axis("z", { offsetX: 0 });
+            const a2 = axis("z", { offsetX: 100 });
+            const mid = axis(a1, a2, { offsetY: 25 });
+            render();
+            const ax = mid.getAxis();
+            expect(ax.origin.x).toBeCloseTo(50);
+            expect(ax.origin.y).toBeCloseTo(25);
+        });
+        it("should work with standard axis shorthand", () => {
+            const mid = axis("x", "x");
+            render();
+            const ax = mid.getAxis();
+            // Both are X-axis at origin → midpoint is origin
+            expect(ax.origin.x).toBeCloseTo(0);
+            expect(ax.direction.x).toBeCloseTo(1);
+        });
+    });
+});

package/lib/dist/tests/features/chamfer.test.d.ts

@@ -0,0 +1 @@
+export {};