brepjs 8.0.0 → 8.0.2

package/dist/loft-CtG5nMq5.js

@@ -1,179 +0,0 @@
-import { g as getKernel, a as toVec3, m as makeOcAx1 } from "./occtBoundary-CwegMzqc.js";
-import { D as DEG2RAD, v as vecAdd, g as vecLength } from "./vecOps-ZDdZWbwT.js";
-import { d as downcast, c as cast, a as isShape3D, b as isWire } from "./cast-DQaUibmm.js";
-import { e as err, x as validationError, l as ok, u as unwrap, a as andThen, o as occtError, p as typeCastError } from "./errors-wGhcJMpB.js";
-import { n as gcWithScope, o as localGC, p as createSolid } from "./shapeTypes-BlSElW8z.js";
-import { m as makeLine, a as assembleWire, b as makeHelix, c as makeVertex } from "./shapeHelpers-BcoZf2N9.js";
-function buildLawFromProfile(extrusionLength, { profile, endFactor = 1 }) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  let law;
-  if (profile === "s-curve") {
-    law = r(new oc.Law_S());
-    law.Set_1(0, 1, extrusionLength, endFactor);
-  } else if (profile === "linear") {
-    law = r(new oc.Law_Linear());
-    law.Set(0, 1, extrusionLength, endFactor);
-  } else {
-    return err(
-      validationError("UNSUPPORTED_PROFILE", `Unsupported extrusion profile: ${String(profile)}`)
-    );
-  }
-  return ok(law.Trim(0, extrusionLength, 1e-6));
-}
-const basicFaceExtrusion = (face, extrusionVec) => {
-  const oc = getKernel().oc;
-  const [r, gc] = localGC();
-  const vec = toVec3(extrusionVec);
-  const ocVec = r(new oc.gp_Vec_4(vec[0], vec[1], vec[2]));
-  const solidBuilder = r(new oc.BRepPrimAPI_MakePrism_1(face.wrapped, ocVec, false, true));
-  const solid = createSolid(unwrap(downcast(solidBuilder.Shape())));
-  gc();
-  return solid;
-};
-const revolution = (face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) => {
-  const oc = getKernel().oc;
-  const [r, gc] = localGC();
-  const centerVec = toVec3(center);
-  const directionVec = toVec3(direction);
-  const ax = r(makeOcAx1(centerVec, directionVec));
-  const revolBuilder = r(new oc.BRepPrimAPI_MakeRevol_1(face.wrapped, ax, angle * DEG2RAD, false));
-  const result = andThen(cast(revolBuilder.Shape()), (shape) => {
-    if (!isShape3D(shape))
-      return err(typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
-    return ok(shape);
-  });
-  gc();
-  return result;
-};
-function genericSweep(wire, spine, {
-  frenet = false,
-  auxiliarySpine,
-  law = null,
-  transitionMode = "right",
-  withContact,
-  support,
-  forceProfileSpineOthogonality
-} = {}, shellMode = false) {
-  const oc = getKernel().oc;
-  const [r, gc] = localGC();
-  const withCorrection = transitionMode === "round" ? true : !!forceProfileSpineOthogonality;
-  const sweepBuilder = r(new oc.BRepOffsetAPI_MakePipeShell(spine.wrapped));
-  {
-    const mode = {
-      transformed: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_Transformed,
-      round: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_RoundCorner,
-      right: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_RightCorner
-    }[transitionMode];
-    if (mode) sweepBuilder.SetTransitionMode(mode);
-  }
-  if (support) {
-    sweepBuilder.SetMode_4(support);
-  } else if (frenet) {
-    sweepBuilder.SetMode_1(frenet);
-  }
-  if (auxiliarySpine) {
-    sweepBuilder.SetMode_5(
-      auxiliarySpine.wrapped,
-      false,
-      oc.BRepFill_TypeOfContact.BRepFill_NoContact
-    );
-  }
-  if (!law) sweepBuilder.Add_1(wire.wrapped, !!withContact, withCorrection);
-  else sweepBuilder.SetLaw_1(wire.wrapped, law, !!withContact, withCorrection);
-  const progress = r(new oc.Message_ProgressRange_1());
-  sweepBuilder.Build(progress);
-  if (!sweepBuilder.IsDone()) {
-    gc();
-    return err(occtError("SWEEP_FAILED", "Sweep operation failed"));
-  }
-  if (!shellMode) {
-    sweepBuilder.MakeSolid();
-  }
-  const shape = unwrap(cast(sweepBuilder.Shape()));
-  if (!isShape3D(shape)) {
-    gc();
-    return err(typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
-  }
-  if (shellMode) {
-    const startWire = unwrap(cast(sweepBuilder.FirstShape()));
-    const endWire = unwrap(cast(sweepBuilder.LastShape()));
-    if (!isWire(startWire)) {
-      gc();
-      return err(typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
-    }
-    if (!isWire(endWire)) {
-      gc();
-      return err(typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
-    }
-    gc();
-    return ok([shape, startWire, endWire]);
-  }
-  gc();
-  return ok(shape);
-}
-function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
-  const [r, gc] = localGC();
-  const centerVec = toVec3(center);
-  const normalVec = toVec3(normal);
-  const endVec = vecAdd(centerVec, normalVec);
-  const mainSpineEdge = r(makeLine(centerVec, endVec));
-  const spine = r(unwrap(assembleWire([mainSpineEdge])));
-  const law = profileShape ? r(unwrap(buildLawFromProfile(vecLength(normalVec), profileShape))) : null;
-  const result = shellMode ? genericSweep(wire, spine, { law }, shellMode) : genericSweep(wire, spine, { law }, shellMode);
-  gc();
-  return result;
-}
-function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMode = false) {
-  const [r, gc] = localGC();
-  const centerVec = toVec3(center);
-  const normalVec = toVec3(normal);
-  const endVec = vecAdd(centerVec, normalVec);
-  const mainSpineEdge = r(makeLine(centerVec, endVec));
-  const spine = r(unwrap(assembleWire([mainSpineEdge])));
-  const extrusionLength = vecLength(normalVec);
-  const pitch = 360 / angleDegrees * extrusionLength;
-  const radius = 1;
-  const auxiliarySpine = r(makeHelix(pitch, extrusionLength, radius, centerVec, normalVec));
-  const law = profileShape ? r(unwrap(buildLawFromProfile(extrusionLength, profileShape))) : null;
-  const result = shellMode ? genericSweep(wire, spine, { auxiliarySpine, law }, shellMode) : genericSweep(wire, spine, { auxiliarySpine, law }, shellMode);
-  gc();
-  return result;
-}
-const loft = (wires, { ruled = true, startPoint, endPoint } = {}, returnShell = false) => {
-  if (wires.length === 0 && !startPoint && !endPoint) {
-    return err(validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
-  }
-  const oc = getKernel().oc;
-  const [r, gc] = localGC();
-  const loftBuilder = r(new oc.BRepOffsetAPI_ThruSections(!returnShell, ruled, 1e-6));
-  if (startPoint) {
-    loftBuilder.AddVertex(r(makeVertex(toVec3(startPoint))).wrapped);
-  }
-  wires.forEach((w) => loftBuilder.AddWire(w.wrapped));
-  if (endPoint) {
-    loftBuilder.AddVertex(r(makeVertex(toVec3(endPoint))).wrapped);
-  }
-  const progress = r(new oc.Message_ProgressRange_1());
-  loftBuilder.Build(progress);
-  if (!loftBuilder.IsDone()) {
-    gc();
-    return err(occtError("LOFT_FAILED", "Loft operation failed"));
-  }
-  const result = andThen(cast(loftBuilder.Shape()), (shape) => {
-    if (!isShape3D(shape))
-      return err(typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
-    return ok(shape);
-  });
-  gc();
-  return result;
-};
-export {
-  buildLawFromProfile as a,
-  basicFaceExtrusion as b,
-  complexExtrude as c,
-  genericSweep as g,
-  loft as l,
-  revolution as r,
-  twistExtrude as t
-};

package/dist/query-V6nV-VfL.js

@@ -1,396 +0,0 @@
-import { g as getKernel, d as toOcPnt } from "./occtBoundary-CwegMzqc.js";
-import { c as castShape, n as gcWithScope, e as isFace } from "./shapeTypes-BlSElW8z.js";
-import { j as vecNormalize, c as vecDistance, d as vecDot, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { bug } from "./result.js";
-import { i as iterTopo, d as downcast } from "./cast-DQaUibmm.js";
-import { v as vertexPosition, k as getHashCode, n as isSameShape } from "./shapeFns-BrF97sKt.js";
-import { g as getSurfaceType, n as normalAt } from "./faceFns-DHu-2JpA.js";
-import { m as measureArea } from "./measurement-C5JGCuUP.js";
-import { l as getCurveType, f as curveLength, c as curveIsClosed } from "./curveFns-CdVE4da7.js";
-import { e as err, q as queryError, l as ok, u as unwrap } from "./errors-wGhcJMpB.js";
-const PRECISION_INTERSECTION = 1e-9;
-const PRECISION_OFFSET = 1e-8;
-const PRECISION_POINT = 1e-6;
-const samePoint = ([x0, y0], [x1, y1], precision = PRECISION_POINT) => {
-  return Math.abs(x0 - x1) <= precision && Math.abs(y0 - y1) <= precision;
-};
-const add2d = ([x0, y0], [x1, y1]) => {
-  return [x0 + x1, y0 + y1];
-};
-const subtract2d = ([x0, y0], [x1, y1]) => {
-  return [x0 - x1, y0 - y1];
-};
-const scalarMultiply2d = ([x0, y0], scalar) => {
-  return [x0 * scalar, y0 * scalar];
-};
-const distance2d = ([x0, y0], [x1, y1] = [0, 0]) => {
-  return Math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2);
-};
-const squareDistance2d = ([x0, y0], [x1, y1] = [0, 0]) => {
-  return (x0 - x1) ** 2 + (y0 - y1) ** 2;
-};
-function crossProduct2d([x0, y0], [x1, y1]) {
-  return x0 * y1 - y0 * x1;
-}
-const angle2d = ([x0, y0], [x1, y1] = [0, 0]) => {
-  return Math.atan2(y1 * x0 - y0 * x1, x0 * x1 + y0 * y1);
-};
-const polarAngle2d = ([x0, y0], [x1, y1] = [0, 0]) => {
-  return Math.atan2(y1 - y0, x1 - x0);
-};
-const normalize2d = ([x0, y0]) => {
-  const l = distance2d([x0, y0]);
-  if (l < 1e-12) {
-    bug("normalize2d", "Cannot normalize zero-length vector");
-  }
-  return [x0 / l, y0 / l];
-};
-const rotate2d = (point, angle, center = [0, 0]) => {
-  const [px0, py0] = point;
-  const [cx, cy] = center;
-  const px = px0 - cx;
-  const py = py0 - cy;
-  const sinA = Math.sin(angle);
-  const cosA = Math.cos(angle);
-  const xnew = px * cosA - py * sinA;
-  const ynew = px * sinA + py * cosA;
-  return [xnew + cx, ynew + cy];
-};
-const polarToCartesian = (r, theta) => {
-  const x = Math.cos(theta) * r;
-  const y = Math.sin(theta) * r;
-  return [x, y];
-};
-const cartesianToPolar = ([x, y]) => {
-  const r = distance2d([x, y]);
-  const theta = Math.atan2(y, x);
-  return [r, theta];
-};
-function createFinder(topoKind, filters, getNormal) {
-  const withFilter = (pred) => createFinder(topoKind, [...filters, pred]);
-  const shouldKeep = (element) => filters.every((f) => f(element));
-  const extractElements = (shape) => {
-    const result = [];
-    for (const raw of iterTopo(shape.wrapped, topoKind)) {
-      const element = castShape(unwrap(downcast(raw)));
-      if (shouldKeep(element)) {
-        result.push(element);
-      }
-    }
-    return result;
-  };
-  const finder = {
-    _filters: filters,
-    _topoKind: topoKind,
-    when: (pred) => withFilter(pred),
-    inList: (elements) => {
-      const hashSet = /* @__PURE__ */ new Map();
-      for (const e of elements) {
-        const h = getHashCode(e);
-        const bucket = hashSet.get(h);
-        if (bucket) bucket.push(e);
-        else hashSet.set(h, [e]);
-      }
-      return withFilter((el) => {
-        const bucket = hashSet.get(getHashCode(el));
-        return !!bucket && bucket.some((e) => isSameShape(e, el));
-      });
-    },
-    not: (builderFn) => {
-      const inner = builderFn(createFinder(topoKind, []));
-      return withFilter((el) => !inner.shouldKeep(el));
-    },
-    either: (fns) => {
-      const builtFinders = fns.map((fn) => fn(createFinder(topoKind, [])));
-      return withFilter((el) => builtFinders.some((f) => f.shouldKeep(el)));
-    },
-    findAll: (shape) => extractElements(shape),
-    findUnique: (shape) => {
-      const elements = extractElements(shape);
-      if (elements.length !== 1) {
-        return err(
-          queryError(
-            "FINDER_NOT_UNIQUE",
-            `Finder expected a unique match but found ${elements.length} element(s)`
-          )
-        );
-      }
-      return ok(elements[0]);
-    },
-    shouldKeep
-  };
-  return finder;
-}
-const DIRECTIONS = {
-  X: [1, 0, 0],
-  Y: [0, 1, 0],
-  Z: [0, 0, 1]
-};
-function resolveDir(dir) {
-  if (typeof dir === "string") return DIRECTIONS[dir] ?? [0, 0, 1];
-  return dir;
-}
-function edgeFinder() {
-  return createEdgeFinder([]);
-}
-function createEdgeFinder(filters) {
-  const base = createFinder("edge", filters);
-  const withFilter = (pred) => createEdgeFinder([...filters, pred]);
-  return {
-    ...base,
-    when: (pred) => createEdgeFinder([...filters, pred]),
-    inList: (elements) => createEdgeFinder([...base.inList(elements)._filters]),
-    not: (fn) => createEdgeFinder([...base.not(fn)._filters]),
-    either: (fns) => createEdgeFinder([
-      ...base.either(fns)._filters
-    ]),
-    inDirection: (dir = "Z", angle = 0) => {
-      const d = vecNormalize(resolveDir(dir));
-      return withFilter((edge) => {
-        const oc = getKernel().oc;
-        const r = gcWithScope();
-        const adaptor = r(new oc.BRepAdaptor_Curve_2(edge.wrapped));
-        const tmpPnt = r(new oc.gp_Pnt_1());
-        const tmpVec = r(new oc.gp_Vec_1());
-        const mid = (Number(adaptor.FirstParameter()) + Number(adaptor.LastParameter())) / 2;
-        adaptor.D1(mid, tmpPnt, tmpVec);
-        const tangent = vecNormalize([tmpVec.X(), tmpVec.Y(), tmpVec.Z()]);
-        const ang = Math.acos(Math.min(1, Math.abs(vecDot(tangent, d))));
-        return Math.abs(ang - DEG2RAD * angle) < 1e-6;
-      });
-    },
-    ofLength: (length, tolerance = 1e-3) => withFilter((edge) => Math.abs(curveLength(edge) - length) < tolerance),
-    ofCurveType: (curveType) => withFilter((edge) => getCurveType(edge) === curveType),
-    parallelTo: (dir = "Z") => createEdgeFinder([...filters]).inDirection(dir, 0),
-    atDistance: (distance, point = [0, 0, 0]) => withFilter((edge) => {
-      const oc = getKernel().oc;
-      const r = gcWithScope();
-      const pnt = r(toOcPnt(point));
-      const vtxMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt));
-      const vtx = vtxMaker.Vertex();
-      const distTool = r(new oc.BRepExtrema_DistShapeShape_1());
-      distTool.LoadS1(vtx);
-      distTool.LoadS2(edge.wrapped);
-      const progress = r(new oc.Message_ProgressRange_1());
-      distTool.Perform(progress);
-      const d = distTool.Value();
-      return Math.abs(d - distance) < 1e-6;
-    })
-  };
-}
-function faceFinder() {
-  return createFaceFinder([]);
-}
-function createFaceFinder(filters) {
-  const base = createFinder("face", filters);
-  const withFilter = (pred) => createFaceFinder([...filters, pred]);
-  return {
-    ...base,
-    when: (pred) => createFaceFinder([...filters, pred]),
-    inList: (elements) => createFaceFinder([...base.inList(elements)._filters]),
-    not: (fn) => createFaceFinder([...base.not(fn)._filters]),
-    either: (fns) => createFaceFinder([
-      ...base.either(fns)._filters
-    ]),
-    inDirection: (dir = "Z", angle = 0) => {
-      const d = vecNormalize(resolveDir(dir));
-      return withFilter((face) => {
-        const n = normalAt(face);
-        const ang = Math.acos(Math.min(1, Math.abs(vecDot(vecNormalize(n), d))));
-        return Math.abs(ang - DEG2RAD * angle) < 1e-6;
-      });
-    },
-    parallelTo: (dir = "Z") => createFaceFinder([...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),
-    atDistance: (distance, point = [0, 0, 0]) => withFilter((face) => {
-      const oc = getKernel().oc;
-      const r = gcWithScope();
-      const pnt = r(toOcPnt(point));
-      const vtxMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt));
-      const vtx = vtxMaker.Vertex();
-      const distTool = r(new oc.BRepExtrema_DistShapeShape_1());
-      distTool.LoadS1(vtx);
-      distTool.LoadS2(face.wrapped);
-      const progress = r(new oc.Message_ProgressRange_1());
-      distTool.Perform(progress);
-      const d = distTool.Value();
-      return Math.abs(d - distance) < 1e-6;
-    })
-  };
-}
-function wireFinder() {
-  return createWireFinder([]);
-}
-function createWireFinder(filters) {
-  const base = createFinder("wire", filters);
-  const withFilter = (pred) => createWireFinder([...filters, pred]);
-  return {
-    ...base,
-    when: (pred) => createWireFinder([...filters, pred]),
-    inList: (elements) => createWireFinder([...base.inList(elements)._filters]),
-    not: (fn) => createWireFinder([...base.not(fn)._filters]),
-    either: (fns) => createWireFinder([
-      ...base.either(fns)._filters
-    ]),
-    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 vertexFinder() {
-  return createVertexFinder([]);
-}
-function createVertexFinder(filters) {
-  const base = createFinder("vertex", filters);
-  const withFilter = (pred) => createVertexFinder([...filters, pred]);
-  return {
-    ...base,
-    when: (pred) => createVertexFinder([...filters, pred]),
-    inList: (elements) => createVertexFinder([...base.inList(elements)._filters]),
-    not: (fn) => createVertexFinder([
-      ...base.not(fn)._filters
-    ]),
-    either: (fns) => createVertexFinder([
-      ...base.either(fns)._filters
-    ]),
-    nearestTo: (point) => {
-      const newFilters = [...filters];
-      const finderWithNearestTo = createVertexFinderWithNearest(newFilters, point);
-      return finderWithNearestTo;
-    },
-    atPosition: (point, tolerance = 1e-4) => withFilter((vertex) => {
-      const pos = vertexPosition(vertex);
-      return vecDistance(pos, point) < tolerance;
-    }),
-    withinBox: (min, max) => withFilter((vertex) => {
-      const pos = vertexPosition(vertex);
-      return pos[0] >= min[0] - 1e-6 && pos[0] <= max[0] + 1e-6 && pos[1] >= min[1] - 1e-6 && pos[1] <= max[1] + 1e-6 && pos[2] >= min[2] - 1e-6 && pos[2] <= max[2] + 1e-6;
-    }),
-    atDistance: (distance, point = [0, 0, 0], tolerance = 1e-4) => withFilter((vertex) => {
-      const pos = vertexPosition(vertex);
-      return Math.abs(vecDistance(pos, point) - distance) < tolerance;
-    })
-  };
-}
-function createVertexFinderWithNearest(filters, nearestPoint) {
-  const baseFinder = createVertexFinder(filters);
-  const findAllNearest = (shape) => {
-    const candidates = baseFinder.findAll(shape);
-    if (candidates.length === 0) return [];
-    let bestIdx = 0;
-    let bestDist = vecDistance(vertexPosition(candidates[0]), nearestPoint);
-    for (let i = 1; i < candidates.length; i++) {
-      const d = vecDistance(vertexPosition(candidates[i]), nearestPoint);
-      if (d < bestDist) {
-        bestDist = d;
-        bestIdx = i;
-      }
-    }
-    return [candidates[bestIdx]];
-  };
-  const findUniqueNearest = (shape) => {
-    const nearest = findAllNearest(shape);
-    if (nearest.length === 0) {
-      return err(
-        queryError("FINDER_NOT_UNIQUE", "Finder expected a unique match but found 0 element(s)")
-      );
-    }
-    return ok(nearest[0]);
-  };
-  return {
-    ...baseFinder,
-    findAll: findAllNearest,
-    findUnique: findUniqueNearest
-  };
-}
-const PI_2 = 2 * Math.PI;
-const positiveHalfAngle = (angle) => {
-  const limitedAngle = angle % PI_2;
-  const coterminalAngle = limitedAngle < 0 ? limitedAngle + PI_2 : limitedAngle;
-  if (coterminalAngle < Math.PI) return coterminalAngle;
-  if (coterminalAngle === Math.PI) return 0;
-  return Math.abs(coterminalAngle - PI_2);
-};
-function blueprintCorners(blueprint) {
-  return blueprint.curves.map((curve, index) => ({
-    firstCurve: curve,
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    secondCurve: blueprint.curves[(index + 1) % blueprint.curves.length],
-    point: curve.lastPoint
-  }));
-}
-function cornerFinder() {
-  return createCornerFinder([]);
-}
-function createCornerFinder(filters) {
-  const withFilter = (pred) => createCornerFinder([...filters, pred]);
-  const shouldKeep = (corner) => filters.every((f) => f(corner));
-  return {
-    shouldKeep,
-    when: (pred) => withFilter(pred),
-    inList: (points) => withFilter((corner) => points.some((p) => samePoint(p, corner.point))),
-    atDistance: (distance, point = [0, 0]) => withFilter((corner) => Math.abs(distance2d(point, corner.point) - distance) < 1e-9),
-    atPoint: (point) => withFilter((corner) => samePoint(point, corner.point)),
-    inBox: (corner1, corner2) => {
-      const minX = Math.min(corner1[0], corner2[0]);
-      const maxX = Math.max(corner1[0], corner2[0]);
-      const minY = Math.min(corner1[1], corner2[1]);
-      const maxY = Math.max(corner1[1], corner2[1]);
-      return withFilter((corner) => {
-        const [x, y] = corner.point;
-        return x >= minX && x <= maxX && y >= minY && y <= maxY;
-      });
-    },
-    ofAngle: (angle) => withFilter((corner) => {
-      const tgt1 = corner.firstCurve.tangentAt(1);
-      const tgt2 = corner.secondCurve.tangentAt(0);
-      return Math.abs(positiveHalfAngle(angle2d(tgt1, tgt2)) - positiveHalfAngle(DEG2RAD * angle)) < 1e-9;
-    }),
-    not: (fn) => {
-      const inner = fn(createCornerFinder([]));
-      return withFilter((corner) => !inner.shouldKeep(corner));
-    },
-    either: (fns) => {
-      const builtFinders = fns.map((fn) => fn(createCornerFinder([])));
-      return withFilter((corner) => builtFinders.some((f) => f.shouldKeep(corner)));
-    },
-    find: (blueprint) => blueprintCorners(blueprint).filter(shouldKeep)
-  };
-}
-function getSingleFace(f, shape) {
-  if (typeof f === "object" && "_topoKind" in f) {
-    return f.findUnique(shape);
-  }
-  if (typeof f !== "function" && isFace(f)) return ok(f);
-  const fnResult = f(faceFinder());
-  return fnResult.findUnique(shape);
-}
-export {
-  PRECISION_INTERSECTION as P,
-  subtract2d as a,
-  add2d as b,
-  cornerFinder as c,
-  crossProduct2d as d,
-  edgeFinder as e,
-  faceFinder as f,
-  getSingleFace as g,
-  scalarMultiply2d as h,
-  distance2d as i,
-  cartesianToPolar as j,
-  polarAngle2d as k,
-  PRECISION_OFFSET as l,
-  squareDistance2d as m,
-  normalize2d as n,
-  polarToCartesian as p,
-  rotate2d as r,
-  samePoint as s,
-  vertexFinder as v,
-  wireFinder as w
-};