brepjs 12.8.2 → 12.10.0

package/dist/{drawFns-CjRc1NfQ.cjs → drawFns-voV2wEp8.cjs}

@@ -44,22 +44,22 @@ var __callDispose = (stack, error, hasError) => {
   };
   return next();
 };
-const result = require("./result-fAX0OZzI.cjs");
-const vectors = require("./vectors-D_IiZx0q.cjs");
+const result = require("./result-DULetAht.cjs");
+const vectors = require("./vectors-I_0zdD3O.cjs");
 const types = require("./types-CA_xrgDq.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const boolean2D = require("./boolean2D-0blbVtJ8.cjs");
-const faceFns = require("./faceFns-DB1Fc5gy.cjs");
-const curveFns = require("./curveFns-BZngcnQ1.cjs");
-const surfaceBuilders = require("./surfaceBuilders-5VA34a3_.cjs");
-const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const Blueprint = require("./Blueprint-CQ28WJhz.cjs");
-const helpers = require("./helpers-C8NoT0Wu.cjs");
-const shapeFns = require("./shapeFns-C2SnNvdH.cjs");
-const solidBuilders = require("./solidBuilders-994_MQwB.cjs");
-const loft = require("./loft-hp3pc1M7.cjs");
+const boolean2D = require("./boolean2D-N9Pgumgg.cjs");
+const faceFns = require("./faceFns-CmIrjdt1.cjs");
+const curveFns = require("./curveFns-CWZRuXQ3.cjs");
+const shapeTypes = require("./shapeTypes-T0n6mRmt.cjs");
+const surfaceBuilders = require("./surfaceBuilders-DYS8AMSS.cjs");
+const Blueprint = require("./Blueprint-BoC0DsDm.cjs");
+const helpers = require("./helpers-mipaxDTy.cjs");
+const topologyQueryFns = require("./topologyQueryFns-0IptTUCo.cjs");
+const solidBuilders = require("./solidBuilders-BEAoLYvr.cjs");
+const sweepFns = require("./sweepFns-COqeYIUp.cjs");
 const opentype = require("opentype.js");
-const cornerFinder = require("./cornerFinder-ZmOyOOsh.cjs");
+const query = require("./query.cjs");
 const stitchCurves = (curves, precision = 1e-7) => {
   const startPoints = new boolean2D.Flatbush(curves.length);
   curves.forEach((c) => {
@@ -175,7 +175,7 @@ class Sketcher extends boolean2D.BaseSketcher2d {
     const startToEndVector = vecOps.vecNormalize(diff);
     const normal = vecOps.vecCross(startToEndVector, this.plane.zDir);
     const clonedWrapped = result.unwrap(faceFns.downcast(wire.wrapped));
-    const mirroredRaw = Blueprint.mirror(clonedWrapped, normal, pointer3d);
+    const mirroredRaw = shapeTypes.getKernel().mirror(clonedWrapped, types.toVec3(pointer3d), types.toVec3(normal));
     const mirroredWrapped = result.unwrap(faceFns.downcast(mirroredRaw));
     const mirroredWire = shapeTypes.createWire(mirroredWrapped);
     const combinedWire = result.unwrap(surfaceBuilders.assembleWire([wire, mirroredWire]));
@@ -288,11 +288,11 @@ class CompoundSketch {
     const rawVec = extrusionDirection ? types.toVec3(extrusionDirection) : this.outerSketch.defaultDirection;
     const normVec = vecOps.vecNormalize(rawVec);
     const extrusionVec = vecOps.vecScale(normVec, extrusionDistance);
-    let result2;
+    let result$1;
     if (extrusionProfile && !twistAngle) {
-      result2 = solidFromShellGenerator(
+      result$1 = solidFromShellGenerator(
         this.sketches,
-        (sketch) => loft.complexExtrude(
+        (sketch) => sweepFns.complexExtrude(
           sketch.wire,
           origin ? types.toVec3(origin) : this.outerSketch.defaultOrigin,
           extrusionVec,
@@ -301,9 +301,9 @@ class CompoundSketch {
         )
       );
     } else if (twistAngle) {
-      result2 = solidFromShellGenerator(
+      result$1 = solidFromShellGenerator(
         this.sketches,
-        (sketch) => loft.twistExtrude(
+        (sketch) => sweepFns.twistExtrude(
           sketch.wire,
           twistAngle,
           origin ? types.toVec3(origin) : this.outerSketch.defaultOrigin,
@@ -313,22 +313,18 @@ class CompoundSketch {
         )
       );
     } else {
-      result2 = loft.basicFaceExtrusion(this.face(), extrusionVec);
+      result$1 = result.unwrap(boolean2D.extrude(this.face(), extrusionVec));
     }
-    return result2;
+    return result$1;
   }
   /**
    * Revolves the drawing on an axis (defined by its direction and an origin
    * (defaults to the sketch origin)
    */
   revolve(revolutionAxis, { origin } = {}) {
-    return result.unwrap(
-      loft.revolution(
-        this.face(),
-        origin ? types.toVec3(origin) : this.outerSketch.defaultOrigin,
-        revolutionAxis
-      )
-    );
+    const center = origin ? types.toVec3(origin) : this.outerSketch.defaultOrigin;
+    const dir = revolutionAxis ? types.toVec3(revolutionAxis) : [0, 0, 1];
+    return result.unwrap(boolean2D.revolve(this.face(), center, dir));
   }
   /** Loft between this compound sketch and another with matching sub-sketch counts. */
   loftWith(otherCompound, loftConfig) {
@@ -339,7 +335,9 @@ class CompoundSketch {
       );
     const shells = this.sketches.map((base, cIndex) => {
       const outer = otherCompound.sketches[cIndex];
-      return base.clone().loftWith(outer.clone(), { ruled: loftConfig.ruled }, true);
+      const loftOpts = {};
+      if (loftConfig.ruled !== void 0) loftOpts.ruled = loftConfig.ruled;
+      return base.clone().loftWith(outer.clone(), loftOpts, true);
     });
     const baseFaceRaw = this.face();
     const baseFace = shapeTypes.createFace(result.unwrap(faceFns.downcast(baseFaceRaw.wrapped)));
@@ -792,7 +790,7 @@ function wrapSketchDataArray(dataArr) {
 const FONT_REGISTER = {};
 async function loadFont(fontPath, fontFamily = "default", force = false) {
   if (!force && FONT_REGISTER[fontFamily]) {
-    return FONT_REGISTER[fontFamily];
+    return result.ok(FONT_REGISTER[fontFamily]);
   }
   let fontData;
   if (typeof fontPath === "string") {
@@ -800,14 +798,20 @@ async function loadFont(fontPath, fontFamily = "default", force = false) {
     try {
       response = await fetch(fontPath);
     } catch (e) {
-      throw new Error(
-        `Failed to fetch font from ${fontPath}: ${e instanceof Error ? e.message : String(e)}`,
-        { cause: e }
+      return result.err(
+        result.ioError(
+          result.BrepErrorCode.FONT_FETCH_FAILED,
+          `Failed to fetch font from ${fontPath}: ${e instanceof Error ? e.message : String(e)}`,
+          e
+        )
       );
     }
     if (!response.ok) {
-      throw new Error(
-        `Failed to fetch font from ${fontPath}: HTTP ${response.status} ${response.statusText}`
+      return result.err(
+        result.ioError(
+          result.BrepErrorCode.FONT_FETCH_FAILED,
+          `Failed to fetch font from ${fontPath}: HTTP ${response.status} ${response.statusText}`
+        )
       );
     }
     fontData = await response.arrayBuffer();
@@ -818,13 +822,17 @@ async function loadFont(fontPath, fontFamily = "default", force = false) {
   try {
     font = opentype.parse(fontData);
   } catch (e) {
-    throw new Error(`Failed to parse font data: ${e instanceof Error ? e.message : String(e)}`, {
-      cause: e
-    });
+    return result.err(
+      result.ioError(
+        result.BrepErrorCode.FONT_PARSE_FAILED,
+        `Failed to parse font data: ${e instanceof Error ? e.message : String(e)}`,
+        e
+      )
+    );
   }
   FONT_REGISTER[fontFamily] = font;
   if (!FONT_REGISTER["default"]) FONT_REGISTER["default"] = font;
-  return font;
+  return result.ok(font);
 }
 const getFont = (fontFamily = "default") => {
   return FONT_REGISTER[fontFamily];
@@ -884,107 +892,48 @@ function sketchText(text, textConfig, planeConfig = {}) {
 function textMetrics(text, options) {
   const fontSize = options?.fontSize ?? 1;
   const font = getFont(options?.fontFamily);
-  if (!font) throw new Error("No font loaded. Call loadFont() first.");
+  if (!font) {
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.NO_FONT_LOADED,
+        "No font loaded. Call loadFont() first.",
+        void 0,
+        void 0,
+        "Load a font with loadFont() before calling textMetrics()"
+      )
+    );
+  }
   const width = font.getAdvanceWidth(text, fontSize);
   const scale = fontSize / font.unitsPerEm;
   const ascender = font.ascender * scale;
   const descender = font.descender * scale;
-  return { width, height: ascender - descender, ascender, descender };
+  return result.ok({ width, height: ascender - descender, ascender, descender });
 }
 function fontMetrics(options) {
   const fontSize = options?.fontSize ?? 1;
   const font = getFont(options?.fontFamily);
-  if (!font) throw new Error("No font loaded. Call loadFont() first.");
+  if (!font) {
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.NO_FONT_LOADED,
+        "No font loaded. Call loadFont() first.",
+        void 0,
+        void 0,
+        "Load a font with loadFont() before calling fontMetrics()"
+      )
+    );
+  }
   const scale = fontSize / font.unitsPerEm;
   const ascender = font.ascender * scale;
   const descender = font.descender * scale;
   const lineGap = (font.tables?.os2?.sTypoLineGap ?? 0) * scale;
-  return {
+  return result.ok({
     ascender,
     descender,
     unitsPerEm: font.unitsPerEm,
     lineHeight: ascender - descender + lineGap
-  };
-}
-const PROJECTION_PLANES = {
-  XY: { dir: [0, 0, 1], xAxis: [1, 0, 0] },
-  XZ: { dir: [0, -1, 0], xAxis: [1, 0, 0] },
-  YZ: { dir: [1, 0, 0], xAxis: [0, 1, 0] },
-  YX: { dir: [0, 0, -1], xAxis: [0, 1, 0] },
-  ZX: { dir: [0, 1, 0], xAxis: [0, 0, 1] },
-  ZY: { dir: [-1, 0, 0], xAxis: [0, 0, 1] },
-  front: { dir: [0, -1, 0], xAxis: [1, 0, 0] },
-  back: { dir: [0, 1, 0], xAxis: [-1, 0, 0] },
-  right: { dir: [-1, 0, 0], xAxis: [0, -1, 0] },
-  left: { dir: [1, 0, 0], xAxis: [0, 1, 0] },
-  bottom: { dir: [0, 0, 1], xAxis: [1, 0, 0] },
-  top: { dir: [0, 0, -1], xAxis: [1, 0, 0] }
-};
-function isProjectionPlane(plane) {
-  return typeof plane === "string" && plane in PROJECTION_PLANES;
-}
-const getEdgesFromOc = (shape) => {
-  if (shape.IsNull()) return [];
-  return shapeFns.getEdges(shapeTypes.castShape(shape));
-};
-function makeProjectedEdges(shape, camera, withHiddenLines = true) {
-  const projected = shapeTypes.getKernel().projectEdges(
-    shape.wrapped,
-    [...camera.position],
-    [...camera.direction],
-    [...camera.xAxis]
-  );
-  const visible = [
-    ...getEdgesFromOc(projected.visible.sharp),
-    ...getEdgesFromOc(projected.visible.smooth),
-    ...getEdgesFromOc(projected.visible.outline)
-  ];
-  const hidden = withHiddenLines ? [
-    ...getEdgesFromOc(projected.hidden.sharp),
-    ...getEdgesFromOc(projected.hidden.smooth),
-    ...getEdgesFromOc(projected.hidden.outline)
-  ] : [];
-  return { visible, hidden };
-}
-function createCamera(position = [0, 0, 0], direction = [0, 0, 1], xAxis) {
-  const dirLength = vecOps.vecLength(direction);
-  if (dirLength < 1e-12) {
-    return result.err(
-      result.validationError("CAMERA_ZERO_DIRECTION", "Camera direction cannot be a zero-length vector")
-    );
-  }
-  let resolvedXAxis;
-  if (xAxis) {
-    resolvedXAxis = vecOps.vecNormalize(xAxis);
-  } else {
-    let cross = vecOps.vecCross([0, 0, 1], direction);
-    if (vecOps.vecLength(cross) < 1e-12) {
-      cross = vecOps.vecCross([0, 1, 0], direction);
-    }
-    if (vecOps.vecLength(cross) < 1e-12) {
-      cross = vecOps.vecCross([1, 0, 0], direction);
-    }
-    resolvedXAxis = vecOps.vecNormalize(cross);
-  }
-  const yAxis = vecOps.vecNormalize(vecOps.vecCross(direction, resolvedXAxis));
-  return result.ok({
-    position,
-    direction: vecOps.vecNormalize(direction),
-    xAxis: resolvedXAxis,
-    yAxis
   });
 }
-function cameraLookAt(camera, target) {
-  const direction = vecOps.vecNormalize(vecOps.vecSub(camera.position, target));
-  return createCamera(camera.position, direction);
-}
-function cameraFromPlane(planeName) {
-  const config = PROJECTION_PLANES[planeName];
-  return createCamera([0, 0, 0], config.dir, config.xAxis);
-}
-function projectEdges(shape, camera, withHiddenLines = true) {
-  return makeProjectedEdges(shape, camera, withHiddenLines);
-}
 function wrapBlueprintResult(shape, result2) {
   if (shape instanceof Blueprint.Blueprint) {
     return wrapSketchData(result2);
@@ -1098,7 +1047,7 @@ class Drawing {
    * @category Drawing Modifications
    */
   fillet(radius, filter) {
-    const finder = filter && filter(cornerFinder.cornerFinder());
+    const finder = filter && filter(query.cornerFinder());
     return new Drawing(fillet2D(this.innerShape, radius, finder));
   }
   /**
@@ -1108,7 +1057,7 @@ class Drawing {
    * @category Drawing Modifications
    */
   chamfer(radius, filter) {
-    const finder = filter && filter(cornerFinder.cornerFinder());
+    const finder = filter && filter(query.cornerFinder());
     return new Drawing(chamfer2D(this.innerShape, radius, finder));
   }
   sketchOnPlane(inputPlane, origin) {
@@ -1267,6 +1216,85 @@ const drawParametricFunction = (func, { pointsCount = 400, start = 0, stop = 1,
   });
   return drawPointsInterpolation(points, approximationConfig, { closeShape });
 };
+const PROJECTION_PLANES = {
+  XY: { dir: [0, 0, 1], xAxis: [1, 0, 0] },
+  XZ: { dir: [0, -1, 0], xAxis: [1, 0, 0] },
+  YZ: { dir: [1, 0, 0], xAxis: [0, 1, 0] },
+  YX: { dir: [0, 0, -1], xAxis: [0, 1, 0] },
+  ZX: { dir: [0, 1, 0], xAxis: [0, 0, 1] },
+  ZY: { dir: [-1, 0, 0], xAxis: [0, 0, 1] },
+  front: { dir: [0, -1, 0], xAxis: [1, 0, 0] },
+  back: { dir: [0, 1, 0], xAxis: [-1, 0, 0] },
+  right: { dir: [-1, 0, 0], xAxis: [0, -1, 0] },
+  left: { dir: [1, 0, 0], xAxis: [0, 1, 0] },
+  bottom: { dir: [0, 0, 1], xAxis: [1, 0, 0] },
+  top: { dir: [0, 0, -1], xAxis: [1, 0, 0] }
+};
+function isProjectionPlane(plane) {
+  return typeof plane === "string" && plane in PROJECTION_PLANES;
+}
+const getEdgesFromOc = (shape) => {
+  if (shape.IsNull()) return [];
+  return topologyQueryFns.getEdges(shapeTypes.castShape(shape));
+};
+function makeProjectedEdges(shape, camera, withHiddenLines = true) {
+  const projected = shapeTypes.getKernel().projectEdges(
+    shape.wrapped,
+    [...camera.position],
+    [...camera.direction],
+    [...camera.xAxis]
+  );
+  const visible = [
+    ...getEdgesFromOc(projected.visible.sharp),
+    ...getEdgesFromOc(projected.visible.smooth),
+    ...getEdgesFromOc(projected.visible.outline)
+  ];
+  const hidden = withHiddenLines ? [
+    ...getEdgesFromOc(projected.hidden.sharp),
+    ...getEdgesFromOc(projected.hidden.smooth),
+    ...getEdgesFromOc(projected.hidden.outline)
+  ] : [];
+  return { visible, hidden };
+}
+function createCamera(position = [0, 0, 0], direction = [0, 0, 1], xAxis) {
+  const dirLength = vecOps.vecLength(direction);
+  if (dirLength < 1e-12) {
+    return result.err(
+      result.validationError("CAMERA_ZERO_DIRECTION", "Camera direction cannot be a zero-length vector")
+    );
+  }
+  let resolvedXAxis;
+  if (xAxis) {
+    resolvedXAxis = vecOps.vecNormalize(xAxis);
+  } else {
+    let cross = vecOps.vecCross([0, 0, 1], direction);
+    if (vecOps.vecLength(cross) < 1e-12) {
+      cross = vecOps.vecCross([0, 1, 0], direction);
+    }
+    if (vecOps.vecLength(cross) < 1e-12) {
+      cross = vecOps.vecCross([1, 0, 0], direction);
+    }
+    resolvedXAxis = vecOps.vecNormalize(cross);
+  }
+  const yAxis = vecOps.vecNormalize(vecOps.vecCross(direction, resolvedXAxis));
+  return result.ok({
+    position,
+    direction: vecOps.vecNormalize(direction),
+    xAxis: resolvedXAxis,
+    yAxis
+  });
+}
+function cameraLookAt(camera, target) {
+  const direction = vecOps.vecNormalize(vecOps.vecSub(camera.position, target));
+  return createCamera(camera.position, direction);
+}
+function cameraFromPlane(planeName) {
+  const config = PROJECTION_PLANES[planeName];
+  return createCamera([0, 0, 0], config.dir, config.xAxis);
+}
+function projectEdges(shape, camera, withHiddenLines = true) {
+  return makeProjectedEdges(shape, camera, withHiddenLines);
+}
 const edgesToDrawing = (edges) => {
   var _stack = [];
   try {
@@ -1303,7 +1331,7 @@ function drawFaceOutline(face) {
     const scope = __using(_stack, new shapeTypes.DisposalScope());
     const clonedFace = scope.register(shapeTypes.createFace(result.unwrap(faceFns.downcast(face.wrapped))));
     const faceOuterWire = scope.register(faceFns.outerWire(clonedFace));
-    const curves = shapeFns.getEdges(faceOuterWire).map((e) => Blueprint.edgeToCurve(e, face));
+    const curves = topologyQueryFns.getEdges(faceOuterWire).map((e) => Blueprint.edgeToCurve(e, face));
     const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint.Blueprint(s));
     if (stitchedCurves.length === 0) return new Drawing();
     if (stitchedCurves.length === 1) return new Drawing(stitchedCurves[0]);

package/dist/{faceFns-B8GnxjdY.js → faceFns-Bn2seBfp.js}

@@ -1,6 +1,6 @@
-import { B as getKernel, c as castShape, p as isShape3D$1, u as isWire$1 } from "./shapeTypes-CpSaBLDv.js";
-import { a as toVec3 } from "./types-CWDdqcrq.js";
-import { e as err, r as typeCastError, o as ok, v as unwrap } from "./result-BaSD1fqR.js";
+import { g as getKernel, c as castShape } from "./shapeTypes-dhhm-T5A.js";
+import { t as toVec3 } from "./types-CcKqsmd0.js";
+import { e as err, t as typeCastError, o as ok, u as unwrap } from "./result-CoDaWsvc.js";
 const TOPO_ENUM = {
   compound: 0,
   solidCompound: 1,
@@ -55,12 +55,6 @@ function cast(shape) {
   }
   return ok(castShape(shape));
 }
-function isShape3D(shape) {
-  return isShape3D$1(shape);
-}
-function isWire(shape) {
-  return isWire$1(shape);
-}
 function isCompSolid(shape) {
   return getKernel().shapeType(shape.wrapped) === "compsolid";
 }
@@ -172,27 +166,25 @@ function innerWires(face) {
   return result;
 }
 export {
-  isShape3D as a,
-  isWire as b,
+  faceCenter as a,
+  uvCoordinates as b,
   cast as c,
   downcast as d,
-  faceCenter as e,
+  fromBREP as e,
   faceGeomType as f,
   getSurfaceType as g,
-  uvCoordinates as h,
+  innerWires as h,
   iterTopo as i,
-  fromBREP as j,
-  innerWires as k,
-  asTopo as l,
-  classifyPointOnFace as m,
+  asTopo as j,
+  classifyPointOnFace as k,
+  faceOrientation as l,
+  flipFaceOrientation as m,
   normalAt as n,
   outerWire as o,
   pointOnSurface as p,
-  faceOrientation as q,
-  flipFaceOrientation as r,
-  isCompSolid as s,
-  projectPointOnFace as t,
-  uvBounds as u,
-  removeHolesFromFace as v,
-  shapeType as w
+  isCompSolid as q,
+  projectPointOnFace as r,
+  removeHolesFromFace as s,
+  shapeType as t,
+  uvBounds as u
 };

package/dist/{faceFns-DB1Fc5gy.cjs → faceFns-CmIrjdt1.cjs}

@@ -1,7 +1,7 @@
 "use strict";
-const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
+const shapeTypes = require("./shapeTypes-T0n6mRmt.cjs");
 const types = require("./types-CA_xrgDq.cjs");
-const result = require("./result-fAX0OZzI.cjs");
+const result = require("./result-DULetAht.cjs");
 const TOPO_ENUM = {
   compound: 0,
   solidCompound: 1,
@@ -56,12 +56,6 @@ function cast(shape) {
   }
   return result.ok(shapeTypes.castShape(shape));
 }
-function isShape3D(shape) {
-  return shapeTypes.isShape3D(shape);
-}
-function isWire(shape) {
-  return shapeTypes.isWire(shape);
-}
 function isCompSolid(shape) {
   return shapeTypes.getKernel().shapeType(shape.wrapped) === "compsolid";
 }
@@ -184,8 +178,6 @@ exports.fromBREP = fromBREP;
 exports.getSurfaceType = getSurfaceType;
 exports.innerWires = innerWires;
 exports.isCompSolid = isCompSolid;
-exports.isShape3D = isShape3D;
-exports.isWire = isWire;
 exports.iterTopo = iterTopo;
 exports.normalAt = normalAt;
 exports.outerWire = outerWire;

package/dist/{helpers-X0juxnwj.js → helpers-CEn618MW.js}

@@ -1,9 +1,10 @@
-import { c as castShape, B as getKernel, k as isFace } from "./shapeTypes-CpSaBLDv.js";
-import { v as unwrap, e as err, q as queryError, o as ok } from "./result-BaSD1fqR.js";
-import { j as vecNormalize, d as vecDot, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { i as iterTopo, d as downcast, g as getSurfaceType, n as normalAt } from "./faceFns-B8GnxjdY.js";
-import { m as measureArea } from "./measurement-D8EJ694A.js";
-import { f as getHashCode, i as isSameShape } from "./shapeFns-FDuKkrDR.js";
+import { c as castShape, g as getKernel, o as isFace } from "./shapeTypes-dhhm-T5A.js";
+import { u as unwrap, e as err, q as queryError, o as ok, c as isOk } from "./result-CoDaWsvc.js";
+import { c as vecNormalize, d as vecDot, D as DEG2RAD } from "./vecOps-LTN--A58.js";
+import { g as getCurveType, c as curveLength, a as curveIsClosed } from "./curveFns-OmbtFSG8.js";
+import { i as iterTopo, d as downcast, g as getSurfaceType, n as normalAt } from "./faceFns-Bn2seBfp.js";
+import { m as measureArea } from "./measurement-fJWDEpz0.js";
+import { g as getHashCode, i as isSameShape } from "./shapeFns-BZ6zk7nd.js";
 const PRECISION_INTERSECTION = 1e-9;
 const PRECISION_OFFSET = 1e-8;
 const PRECISION_POINT = 1e-6;
@@ -45,6 +46,10 @@ const rotate2d = (point, angle, center = [0, 0]) => {
   const ynew = px * sinA + py * cosA;
   return [xnew + cx, ynew + cy];
 };
+function normalize2d([x, y]) {
+  const l = Math.sqrt(x * x + y * y);
+  return l < 1e-12 ? [0, 0] : [x / l, y / l];
+}
 const polarToCartesian = (r, theta) => {
   const x = Math.cos(theta) * r;
   const y = Math.sin(theta) * r;
@@ -116,7 +121,16 @@ function createTypedFinder(topoKind, filters, rebuild, extend) {
       }
       return ok(match);
     },
-    shouldKeep
+    shouldKeep,
+    and: (other) => withFilter((el) => other.shouldKeep(el)),
+    or: (other) => {
+      const selfKeep = shouldKeep;
+      return rebuild([(el) => selfKeep(el) || other.shouldKeep(el)]);
+    },
+    negate: () => {
+      const selfKeep = shouldKeep;
+      return rebuild([(el) => !selfKeep(el)]);
+    }
   };
   const extensions = extend(base, withFilter);
   return { ...base, ...extensions };
@@ -138,6 +152,35 @@ function distanceFromPointFilter(distance, point, tolerance) {
     return Math.abs(d - distance) < tolerance;
   };
 }
+function edgeDirectionFilter(dir, angle) {
+  const d = vecNormalize(resolveDir(dir));
+  return (edge) => {
+    const kernel = getKernel();
+    const [firstParam, lastParam] = kernel.curveParameters(edge.wrapped);
+    const midParam = (firstParam + lastParam) / 2;
+    const { tangent: rawTangent } = kernel.curveTangent(edge.wrapped, midParam);
+    const tangent = vecNormalize(rawTangent);
+    const ang = Math.acos(Math.min(1, Math.abs(vecDot(tangent, d))));
+    return Math.abs(ang - DEG2RAD * angle) < 1e-6;
+  };
+}
+function buildEdgeFinder(filters) {
+  return createTypedFinder(
+    "edge",
+    filters,
+    buildEdgeFinder,
+    (_base, withFilter) => ({
+      inDirection: (dir = "Z", angle = 0) => withFilter(edgeDirectionFilter(dir, angle)),
+      ofLength: (length, tolerance = 1e-3) => withFilter((edge) => Math.abs(curveLength(edge) - length) < tolerance),
+      ofCurveType: (curveType) => withFilter((edge) => getCurveType(edge) === curveType),
+      parallelTo: (dir = "Z") => buildEdgeFinder(filters).inDirection(dir, 0),
+      atDistance: (distance, point = [0, 0, 0]) => withFilter(distanceFromPointFilter(distance, point, 1e-6))
+    })
+  );
+}
+function edgeFinder() {
+  return buildEdgeFinder([]);
+}
 function faceDirectionFilter(dir, angle) {
   const d = vecNormalize(resolveDir(dir));
   return (face) => {
@@ -155,7 +198,10 @@ function buildFaceFinder(filters) {
       inDirection: (dir = "Z", angle = 0) => withFilter(faceDirectionFilter(dir, angle)),
       parallelTo: (dir = "Z") => buildFaceFinder(filters).inDirection(dir, 0),
       ofSurfaceType: (surfaceType) => withFilter((face) => unwrap(getSurfaceType(face)) === surfaceType),
-      ofArea: (area, tolerance = 1e-3) => withFilter((face) => Math.abs(measureArea(face) - area) < tolerance),
+      ofArea: (area, tolerance = 1e-3) => withFilter((face) => {
+        const r = measureArea(face);
+        return isOk(r) && Math.abs(r.value - area) < tolerance;
+      }),
       atDistance: (distance, point = [0, 0, 0]) => withFilter(distanceFromPointFilter(distance, point, 1e-6))
     })
   );
@@ -163,6 +209,27 @@ function buildFaceFinder(filters) {
 function faceFinder() {
   return buildFaceFinder([]);
 }
+function buildWireFinder(filters) {
+  return createTypedFinder(
+    "wire",
+    filters,
+    buildWireFinder,
+    (_base, withFilter) => ({
+      isClosed: () => withFilter((wire) => curveIsClosed(wire)),
+      isOpen: () => withFilter((wire) => !curveIsClosed(wire)),
+      ofEdgeCount: (count) => withFilter((wire) => {
+        let edgeCount = 0;
+        for (const _raw of iterTopo(wire.wrapped, "edge")) {
+          edgeCount++;
+        }
+        return edgeCount === count;
+      })
+    })
+  );
+}
+function wireFinder() {
+  return buildWireFinder([]);
+}
 function getSingleFace(f, shape) {
   if (typeof f === "object" && "_topoKind" in f) {
     return f.findUnique(shape);
@@ -173,22 +240,23 @@ function getSingleFace(f, shape) {
 }
 export {
   PRECISION_OFFSET as P,
-  angle2d as a,
-  scalarMultiply2d as b,
-  add2d as c,
+  scalarMultiply2d as a,
+  add2d as b,
+  subtract2d as c,
   distance2d as d,
-  subtract2d as e,
-  squareDistance2d as f,
+  squareDistance2d as e,
+  crossProduct2d as f,
   getSingleFace as g,
-  crossProduct2d as h,
-  cartesianToPolar as i,
-  polarAngle2d as j,
-  PRECISION_INTERSECTION as k,
-  createTypedFinder as l,
+  cartesianToPolar as h,
+  polarAngle2d as i,
+  PRECISION_INTERSECTION as j,
+  createTypedFinder as k,
+  edgeFinder as l,
   faceFinder as m,
-  distanceFromPointFilter as n,
-  resolveDir as o,
+  normalize2d as n,
+  angle2d as o,
   polarToCartesian as p,
   rotate2d as r,
-  samePoint as s
+  samePoint as s,
+  wireFinder as w
 };