brepjs 8.8.2 → 8.8.3

package/dist/faceFns-DNQss51F.cjs

@@ -0,0 +1,358 @@
+"use strict";
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+const occtBoundary = require("./occtBoundary-Cqfsau2c.cjs");
+const shapeTypes = require("./shapeTypes-CWuX602K.cjs");
+const errors = require("./errors-NNmTtM5u.cjs");
+let _topoMap = null;
+const asTopo = (entity) => {
+  if (!_topoMap) {
+    const oc = occtBoundary.getKernel().oc;
+    const ta = oc.TopAbs_ShapeEnum;
+    _topoMap = /* @__PURE__ */ new Map([
+      ["vertex", ta.TopAbs_VERTEX],
+      ["edge", ta.TopAbs_EDGE],
+      ["wire", ta.TopAbs_WIRE],
+      ["face", ta.TopAbs_FACE],
+      ["shell", ta.TopAbs_SHELL],
+      ["solid", ta.TopAbs_SOLID],
+      ["solidCompound", ta.TopAbs_COMPSOLID],
+      ["compound", ta.TopAbs_COMPOUND],
+      ["shape", ta.TopAbs_SHAPE]
+    ]);
+  }
+  return _topoMap.get(entity);
+};
+const iterTopo = function* iterTopo2(shape, topo) {
+  const topoToShapeType = {
+    vertex: "vertex",
+    edge: "edge",
+    wire: "wire",
+    face: "face",
+    shell: "shell",
+    solid: "solid",
+    solidCompound: "compsolid",
+    compound: "compound",
+    shape: "compound"
+    // fallback; 'shape' isn't used in iterShapes
+  };
+  const shapeType2 = topoToShapeType[topo];
+  if (shapeType2) {
+    const shapes = occtBoundary.getKernel().iterShapes(shape, shapeType2);
+    for (const s of shapes) yield s;
+  }
+};
+const shapeType = (shape) => {
+  if (shape.IsNull()) return errors.err(errors.typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
+  return errors.ok(shape.ShapeType());
+};
+let _downcastMap = null;
+function getDowncastMap() {
+  if (!_downcastMap) {
+    const oc = occtBoundary.getKernel().oc;
+    const ta = oc.TopAbs_ShapeEnum;
+    _downcastMap = /* @__PURE__ */ new Map([
+      [ta.TopAbs_VERTEX, oc.TopoDS.Vertex_1],
+      [ta.TopAbs_EDGE, oc.TopoDS.Edge_1],
+      [ta.TopAbs_WIRE, oc.TopoDS.Wire_1],
+      [ta.TopAbs_FACE, oc.TopoDS.Face_1],
+      [ta.TopAbs_SHELL, oc.TopoDS.Shell_1],
+      [ta.TopAbs_SOLID, oc.TopoDS.Solid_1],
+      [ta.TopAbs_COMPSOLID, oc.TopoDS.CompSolid_1],
+      [ta.TopAbs_COMPOUND, oc.TopoDS.Compound_1]
+    ]);
+  }
+  return _downcastMap;
+}
+function downcast(shape) {
+  return errors.andThen(shapeType(shape), (myType) => {
+    const caster = getDowncastMap().get(myType);
+    if (!caster)
+      return errors.err(errors.typeCastError("NO_WRAPPER", "Could not find a wrapper for this shape type"));
+    return errors.ok(caster(shape));
+  });
+}
+function cast(shape) {
+  if (shape.IsNull()) {
+    return errors.err(errors.typeCastError("NULL_SHAPE", "Cannot cast a null shape"));
+  }
+  return errors.ok(shapeTypes.castShape(shape));
+}
+function isShape3D(shape) {
+  return shapeTypes.isShape3D(shape);
+}
+function isWire(shape) {
+  return shapeTypes.isWire(shape);
+}
+function isCompSolid(shape) {
+  const st = shape.wrapped.ShapeType();
+  const oc = occtBoundary.getKernel().oc;
+  return st === oc.TopAbs_ShapeEnum.TopAbs_COMPSOLID;
+}
+function fromBREP(data) {
+  const oc = occtBoundary.getKernel().oc;
+  return cast(oc.BRepToolsWrapper.Read(data));
+}
+function getSurfaceType(face) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const adaptor = scope.register(new oc.BRepAdaptor_Surface_2(face.wrapped, false));
+    const ga = oc.GeomAbs_SurfaceType;
+    const CAST_MAP = /* @__PURE__ */ new Map([
+      [ga.GeomAbs_Plane, "PLANE"],
+      [ga.GeomAbs_Cylinder, "CYLINDRE"],
+      [ga.GeomAbs_Cone, "CONE"],
+      [ga.GeomAbs_Sphere, "SPHERE"],
+      [ga.GeomAbs_Torus, "TORUS"],
+      [ga.GeomAbs_BezierSurface, "BEZIER_SURFACE"],
+      [ga.GeomAbs_BSplineSurface, "BSPLINE_SURFACE"],
+      [ga.GeomAbs_SurfaceOfRevolution, "REVOLUTION_SURFACE"],
+      [ga.GeomAbs_SurfaceOfExtrusion, "EXTRUSION_SURFACE"],
+      [ga.GeomAbs_OffsetSurface, "OFFSET_SURFACE"],
+      [ga.GeomAbs_OtherSurface, "OTHER_SURFACE"]
+    ]);
+    const surfType = CAST_MAP.get(adaptor.GetType());
+    if (!surfType) {
+      return errors.err(
+        errors.typeCastError("UNKNOWN_SURFACE_TYPE", "Unrecognized surface type from OCCT adapter")
+      );
+    }
+    return errors.ok(surfType);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function faceGeomType(face) {
+  return errors.unwrap(getSurfaceType(face));
+}
+function faceOrientation(face) {
+  const oc = occtBoundary.getKernel().oc;
+  const orient = face.wrapped.Orientation_1();
+  return orient === oc.TopAbs_Orientation.TopAbs_FORWARD ? "forward" : "backward";
+}
+function flipFaceOrientation(face) {
+  return shapeTypes.castShape(face.wrapped.Reversed());
+}
+function uvBounds(face) {
+  const oc = occtBoundary.getKernel().oc;
+  const uMin = { current: 0 };
+  const uMax = { current: 0 };
+  const vMin = { current: 0 };
+  const vMax = { current: 0 };
+  oc.BRepTools.UVBounds_1(face.wrapped, uMin, uMax, vMin, vMax);
+  return {
+    uMin: uMin.current,
+    uMax: uMax.current,
+    vMin: vMin.current,
+    vMax: vMax.current
+  };
+}
+function pointOnSurface(face, u, v) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const bounds = uvBounds(face);
+    const adaptor = scope.register(new oc.BRepAdaptor_Surface_2(face.wrapped, false));
+    const p = scope.register(new oc.gp_Pnt_1());
+    const absU = u * (bounds.uMax - bounds.uMin) + bounds.uMin;
+    const absV = v * (bounds.vMax - bounds.vMin) + bounds.vMin;
+    adaptor.D0(absU, absV, p);
+    return [p.X(), p.Y(), p.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function uvCoordinates(face, point) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const v = occtBoundary.toVec3(point);
+    const surface = scope.register(oc.BRep_Tool.Surface_2(face.wrapped));
+    const projected = scope.register(
+      new oc.GeomAPI_ProjectPointOnSurf_2(
+        scope.register(occtBoundary.toOcPnt(v)),
+        surface,
+        oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad
+      )
+    );
+    const uPtr = { current: 0 };
+    const vPtr = { current: 0 };
+    projected.LowerDistanceParameters(uPtr, vPtr);
+    return [uPtr.current, vPtr.current];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function projectPointOnFace(face, point) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const v = occtBoundary.toVec3(point);
+    try {
+      const surface = scope.register(oc.BRep_Tool.Surface_2(face.wrapped));
+      const projected = scope.register(
+        new oc.GeomAPI_ProjectPointOnSurf_2(
+          scope.register(occtBoundary.toOcPnt(v)),
+          surface,
+          oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad
+        )
+      );
+      if (projected.NbPoints() === 0) {
+        return errors.err(errors.typeCastError("PROJECTION_FAILED", "No projection found on the face"));
+      }
+      const uPtr = { current: 0 };
+      const vPtr = { current: 0 };
+      projected.LowerDistanceParameters(uPtr, vPtr);
+      const nearestPnt = scope.register(projected.NearestPoint());
+      const projectedPoint = [nearestPnt.X(), nearestPnt.Y(), nearestPnt.Z()];
+      return errors.ok({
+        uv: [uPtr.current, vPtr.current],
+        point: projectedPoint,
+        distance: projected.LowerDistance()
+      });
+    } catch (e) {
+      return errors.err(
+        errors.typeCastError(
+          "PROJECTION_FAILED",
+          `Point projection failed: ${e instanceof Error ? e.message : String(e)}`
+        )
+      );
+    }
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function normalAt(face, locationPoint) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    let u;
+    let v;
+    if (!locationPoint) {
+      const bounds = uvBounds(face);
+      u = 0.5 * (bounds.uMin + bounds.uMax);
+      v = 0.5 * (bounds.vMin + bounds.vMax);
+    } else {
+      [u, v] = uvCoordinates(face, locationPoint);
+    }
+    const p = scope.register(new oc.gp_Pnt_1());
+    const vn = scope.register(new oc.gp_Vec_1());
+    const props = scope.register(new oc.BRepGProp_Face_2(face.wrapped, false));
+    props.Normal(u, v, p, vn);
+    return [vn.X(), vn.Y(), vn.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function faceCenter(face) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const props = scope.register(new oc.GProp_GProps_1());
+    oc.BRepGProp.SurfaceProperties_2(face.wrapped, props, 1e-7, true);
+    const center = scope.register(props.CentreOfMass());
+    return [center.X(), center.Y(), center.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function classifyPointOnFace(face, point, tolerance = 1e-6) {
+  const [u, v] = uvCoordinates(face, point);
+  return occtBoundary.getKernel().classifyPointOnFace(face.wrapped, u, v, tolerance);
+}
+function outerWire(face) {
+  const oc = occtBoundary.getKernel().oc;
+  return shapeTypes.castShape(oc.BRepTools.OuterWire(face.wrapped));
+}
+function innerWires(face) {
+  const outer = outerWire(face);
+  const allWires = Array.from(iterTopo(face.wrapped, "wire")).map(
+    (w) => shapeTypes.castShape(errors.unwrap(downcast(w)))
+  );
+  const result = allWires.filter((w) => !w.wrapped.IsSame(outer.wrapped));
+  return result;
+}
+exports.asTopo = asTopo;
+exports.cast = cast;
+exports.classifyPointOnFace = classifyPointOnFace;
+exports.downcast = downcast;
+exports.faceCenter = faceCenter;
+exports.faceGeomType = faceGeomType;
+exports.faceOrientation = faceOrientation;
+exports.flipFaceOrientation = flipFaceOrientation;
+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;
+exports.pointOnSurface = pointOnSurface;
+exports.projectPointOnFace = projectPointOnFace;
+exports.shapeType = shapeType;
+exports.uvBounds = uvBounds;
+exports.uvCoordinates = uvCoordinates;

package/dist/faceFns-q5CR9pOW.js

@@ -0,0 +1,359 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+import { g as getKernel, a as toVec3, d as toOcPnt } from "./occtBoundary-DvBywHyU.js";
+import { c as castShape, j as isShape3D$1, n as isWire$1, D as DisposalScope } from "./shapeTypes-Bi_9RZa2.js";
+import { e as err, p as typeCastError, l as ok, a as andThen, u as unwrap } from "./errors-DJ92ermb.js";
+let _topoMap = null;
+const asTopo = (entity) => {
+  if (!_topoMap) {
+    const oc = getKernel().oc;
+    const ta = oc.TopAbs_ShapeEnum;
+    _topoMap = /* @__PURE__ */ new Map([
+      ["vertex", ta.TopAbs_VERTEX],
+      ["edge", ta.TopAbs_EDGE],
+      ["wire", ta.TopAbs_WIRE],
+      ["face", ta.TopAbs_FACE],
+      ["shell", ta.TopAbs_SHELL],
+      ["solid", ta.TopAbs_SOLID],
+      ["solidCompound", ta.TopAbs_COMPSOLID],
+      ["compound", ta.TopAbs_COMPOUND],
+      ["shape", ta.TopAbs_SHAPE]
+    ]);
+  }
+  return _topoMap.get(entity);
+};
+const iterTopo = function* iterTopo2(shape, topo) {
+  const topoToShapeType = {
+    vertex: "vertex",
+    edge: "edge",
+    wire: "wire",
+    face: "face",
+    shell: "shell",
+    solid: "solid",
+    solidCompound: "compsolid",
+    compound: "compound",
+    shape: "compound"
+    // fallback; 'shape' isn't used in iterShapes
+  };
+  const shapeType2 = topoToShapeType[topo];
+  if (shapeType2) {
+    const shapes = getKernel().iterShapes(shape, shapeType2);
+    for (const s of shapes) yield s;
+  }
+};
+const shapeType = (shape) => {
+  if (shape.IsNull()) return err(typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
+  return ok(shape.ShapeType());
+};
+let _downcastMap = null;
+function getDowncastMap() {
+  if (!_downcastMap) {
+    const oc = getKernel().oc;
+    const ta = oc.TopAbs_ShapeEnum;
+    _downcastMap = /* @__PURE__ */ new Map([
+      [ta.TopAbs_VERTEX, oc.TopoDS.Vertex_1],
+      [ta.TopAbs_EDGE, oc.TopoDS.Edge_1],
+      [ta.TopAbs_WIRE, oc.TopoDS.Wire_1],
+      [ta.TopAbs_FACE, oc.TopoDS.Face_1],
+      [ta.TopAbs_SHELL, oc.TopoDS.Shell_1],
+      [ta.TopAbs_SOLID, oc.TopoDS.Solid_1],
+      [ta.TopAbs_COMPSOLID, oc.TopoDS.CompSolid_1],
+      [ta.TopAbs_COMPOUND, oc.TopoDS.Compound_1]
+    ]);
+  }
+  return _downcastMap;
+}
+function downcast(shape) {
+  return andThen(shapeType(shape), (myType) => {
+    const caster = getDowncastMap().get(myType);
+    if (!caster)
+      return err(typeCastError("NO_WRAPPER", "Could not find a wrapper for this shape type"));
+    return ok(caster(shape));
+  });
+}
+function cast(shape) {
+  if (shape.IsNull()) {
+    return err(typeCastError("NULL_SHAPE", "Cannot cast a null shape"));
+  }
+  return ok(castShape(shape));
+}
+function isShape3D(shape) {
+  return isShape3D$1(shape);
+}
+function isWire(shape) {
+  return isWire$1(shape);
+}
+function isCompSolid(shape) {
+  const st = shape.wrapped.ShapeType();
+  const oc = getKernel().oc;
+  return st === oc.TopAbs_ShapeEnum.TopAbs_COMPSOLID;
+}
+function fromBREP(data) {
+  const oc = getKernel().oc;
+  return cast(oc.BRepToolsWrapper.Read(data));
+}
+function getSurfaceType(face) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const adaptor = scope.register(new oc.BRepAdaptor_Surface_2(face.wrapped, false));
+    const ga = oc.GeomAbs_SurfaceType;
+    const CAST_MAP = /* @__PURE__ */ new Map([
+      [ga.GeomAbs_Plane, "PLANE"],
+      [ga.GeomAbs_Cylinder, "CYLINDRE"],
+      [ga.GeomAbs_Cone, "CONE"],
+      [ga.GeomAbs_Sphere, "SPHERE"],
+      [ga.GeomAbs_Torus, "TORUS"],
+      [ga.GeomAbs_BezierSurface, "BEZIER_SURFACE"],
+      [ga.GeomAbs_BSplineSurface, "BSPLINE_SURFACE"],
+      [ga.GeomAbs_SurfaceOfRevolution, "REVOLUTION_SURFACE"],
+      [ga.GeomAbs_SurfaceOfExtrusion, "EXTRUSION_SURFACE"],
+      [ga.GeomAbs_OffsetSurface, "OFFSET_SURFACE"],
+      [ga.GeomAbs_OtherSurface, "OTHER_SURFACE"]
+    ]);
+    const surfType = CAST_MAP.get(adaptor.GetType());
+    if (!surfType) {
+      return err(
+        typeCastError("UNKNOWN_SURFACE_TYPE", "Unrecognized surface type from OCCT adapter")
+      );
+    }
+    return ok(surfType);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function faceGeomType(face) {
+  return unwrap(getSurfaceType(face));
+}
+function faceOrientation(face) {
+  const oc = getKernel().oc;
+  const orient = face.wrapped.Orientation_1();
+  return orient === oc.TopAbs_Orientation.TopAbs_FORWARD ? "forward" : "backward";
+}
+function flipFaceOrientation(face) {
+  return castShape(face.wrapped.Reversed());
+}
+function uvBounds(face) {
+  const oc = getKernel().oc;
+  const uMin = { current: 0 };
+  const uMax = { current: 0 };
+  const vMin = { current: 0 };
+  const vMax = { current: 0 };
+  oc.BRepTools.UVBounds_1(face.wrapped, uMin, uMax, vMin, vMax);
+  return {
+    uMin: uMin.current,
+    uMax: uMax.current,
+    vMin: vMin.current,
+    vMax: vMax.current
+  };
+}
+function pointOnSurface(face, u, v) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const bounds = uvBounds(face);
+    const adaptor = scope.register(new oc.BRepAdaptor_Surface_2(face.wrapped, false));
+    const p = scope.register(new oc.gp_Pnt_1());
+    const absU = u * (bounds.uMax - bounds.uMin) + bounds.uMin;
+    const absV = v * (bounds.vMax - bounds.vMin) + bounds.vMin;
+    adaptor.D0(absU, absV, p);
+    return [p.X(), p.Y(), p.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function uvCoordinates(face, point) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const v = toVec3(point);
+    const surface = scope.register(oc.BRep_Tool.Surface_2(face.wrapped));
+    const projected = scope.register(
+      new oc.GeomAPI_ProjectPointOnSurf_2(
+        scope.register(toOcPnt(v)),
+        surface,
+        oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad
+      )
+    );
+    const uPtr = { current: 0 };
+    const vPtr = { current: 0 };
+    projected.LowerDistanceParameters(uPtr, vPtr);
+    return [uPtr.current, vPtr.current];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function projectPointOnFace(face, point) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const v = toVec3(point);
+    try {
+      const surface = scope.register(oc.BRep_Tool.Surface_2(face.wrapped));
+      const projected = scope.register(
+        new oc.GeomAPI_ProjectPointOnSurf_2(
+          scope.register(toOcPnt(v)),
+          surface,
+          oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad
+        )
+      );
+      if (projected.NbPoints() === 0) {
+        return err(typeCastError("PROJECTION_FAILED", "No projection found on the face"));
+      }
+      const uPtr = { current: 0 };
+      const vPtr = { current: 0 };
+      projected.LowerDistanceParameters(uPtr, vPtr);
+      const nearestPnt = scope.register(projected.NearestPoint());
+      const projectedPoint = [nearestPnt.X(), nearestPnt.Y(), nearestPnt.Z()];
+      return ok({
+        uv: [uPtr.current, vPtr.current],
+        point: projectedPoint,
+        distance: projected.LowerDistance()
+      });
+    } catch (e) {
+      return err(
+        typeCastError(
+          "PROJECTION_FAILED",
+          `Point projection failed: ${e instanceof Error ? e.message : String(e)}`
+        )
+      );
+    }
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function normalAt(face, locationPoint) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    let u;
+    let v;
+    if (!locationPoint) {
+      const bounds = uvBounds(face);
+      u = 0.5 * (bounds.uMin + bounds.uMax);
+      v = 0.5 * (bounds.vMin + bounds.vMax);
+    } else {
+      [u, v] = uvCoordinates(face, locationPoint);
+    }
+    const p = scope.register(new oc.gp_Pnt_1());
+    const vn = scope.register(new oc.gp_Vec_1());
+    const props = scope.register(new oc.BRepGProp_Face_2(face.wrapped, false));
+    props.Normal(u, v, p, vn);
+    return [vn.X(), vn.Y(), vn.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function faceCenter(face) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const props = scope.register(new oc.GProp_GProps_1());
+    oc.BRepGProp.SurfaceProperties_2(face.wrapped, props, 1e-7, true);
+    const center = scope.register(props.CentreOfMass());
+    return [center.X(), center.Y(), center.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function classifyPointOnFace(face, point, tolerance = 1e-6) {
+  const [u, v] = uvCoordinates(face, point);
+  return getKernel().classifyPointOnFace(face.wrapped, u, v, tolerance);
+}
+function outerWire(face) {
+  const oc = getKernel().oc;
+  return castShape(oc.BRepTools.OuterWire(face.wrapped));
+}
+function innerWires(face) {
+  const outer = outerWire(face);
+  const allWires = Array.from(iterTopo(face.wrapped, "wire")).map(
+    (w) => castShape(unwrap(downcast(w)))
+  );
+  const result = allWires.filter((w) => !w.wrapped.IsSame(outer.wrapped));
+  return result;
+}
+export {
+  isShape3D as a,
+  isWire as b,
+  cast as c,
+  downcast as d,
+  faceCenter as e,
+  faceGeomType as f,
+  getSurfaceType as g,
+  uvCoordinates as h,
+  iterTopo as i,
+  fromBREP as j,
+  innerWires as k,
+  asTopo as l,
+  classifyPointOnFace 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,
+  shapeType as v
+};