brepjs 2.0.2 → 2.0.4

package/dist/brepjs.cjs

@@ -1437,9 +1437,9 @@ function vecRotate(v, axis, angleRad) {
     v[2] * cos + cross[2] * sin + n[2] * dot * (1 - cos)
   ];
 }
-const round3$1 = (v) => Math.round(v * 1e3) / 1e3;
+const round3 = (v) => Math.round(v * 1e3) / 1e3;
 function vecRepr(v) {
-  return `x: ${round3$1(v[0])}, y: ${round3$1(v[1])}, z: ${round3$1(v[2])}`;
+  return `x: ${round3(v[0])}, y: ${round3(v[1])}, z: ${round3(v[2])}`;
 }
 function toOcVec(v) {
   const oc = getKernel().oc;
@@ -1500,7 +1500,11 @@ function makeOcAx2(origin, zDir, xDir) {
   const pnt2 = toOcPnt(origin);
   const z = toOcDir(zDir);
   let ax;
-  {
+  if (xDir) {
+    const x = toOcDir(xDir);
+    ax = new oc.gp_Ax2_2(pnt2, z, x);
+    x.delete();
+  } else {
     ax = new oc.gp_Ax2_3(pnt2, z);
   }
   pnt2.delete();
@@ -1519,148 +1523,11 @@ function makeOcAx3(origin, zDir, xDir) {
   z.delete();
   return ax;
 }
-const round3 = (v) => Math.round(v * 1e3) / 1e3;
 function isPoint(p) {
   if (Array.isArray(p)) return p.length === 3 || p.length === 2;
-  else if (p instanceof Vector) return true;
   else if (p && typeof p?.XYZ === "function") return true;
   return false;
 }
-const makeAx3 = (center, dir, xDir) => {
-  const oc = getKernel().oc;
-  const origin = asPnt(center);
-  const direction = asDir(dir);
-  const xDirection = xDir ? asDir(xDir) : null;
-  try {
-    if (xDirection) {
-      return new oc.gp_Ax3_3(origin, direction, xDirection);
-    } else {
-      return new oc.gp_Ax3_4(origin, direction);
-    }
-  } finally {
-    origin.delete();
-    direction.delete();
-    if (xDirection) xDirection.delete();
-  }
-};
-const makeAx2 = (center, dir, xDir) => {
-  const oc = getKernel().oc;
-  const origin = asPnt(center);
-  const direction = asDir(dir);
-  const xDirection = xDir ? asDir(xDir) : null;
-  try {
-    if (xDirection) {
-      return new oc.gp_Ax2_2(origin, direction, xDirection);
-    } else {
-      return new oc.gp_Ax2_3(origin, direction);
-    }
-  } finally {
-    origin.delete();
-    direction.delete();
-    if (xDirection) xDirection.delete();
-  }
-};
-const makeAx1 = (center, dir) => {
-  const oc = getKernel().oc;
-  const origin = asPnt(center);
-  const direction = asDir(dir);
-  try {
-    return new oc.gp_Ax1_2(origin, direction);
-  } finally {
-    origin.delete();
-    direction.delete();
-  }
-};
-const makeVec = (vector = [0, 0, 0]) => {
-  const oc = getKernel().oc;
-  if (Array.isArray(vector)) {
-    if (vector.length === 3) return new oc.gp_Vec_4(...vector);
-    return new oc.gp_Vec_4(...vector, 0);
-  } else if (vector instanceof Vector) {
-    return new oc.gp_Vec_3(vector.wrapped.XYZ());
-  }
-  return new oc.gp_Vec_3(vector.XYZ());
-};
-class Vector extends WrappingObj {
-  constructor(vector = [0, 0, 0]) {
-    super(makeVec(vector));
-  }
-  get repr() {
-    return `x: ${round3(this.x)}, y: ${round3(this.y)}, z: ${round3(this.z)}`;
-  }
-  get x() {
-    return this.wrapped.X();
-  }
-  get y() {
-    return this.wrapped.Y();
-  }
-  get z() {
-    return this.wrapped.Z();
-  }
-  get Length() {
-    return this.wrapped.Magnitude();
-  }
-  toTuple() {
-    return [this.x, this.y, this.z];
-  }
-  /** Convert to Vec3 tuple */
-  toVec3() {
-    return [this.x, this.y, this.z];
-  }
-  cross(v) {
-    return new Vector(this.wrapped.Crossed(v.wrapped));
-  }
-  dot(v) {
-    return this.wrapped.Dot(v.wrapped);
-  }
-  sub(v) {
-    return new Vector(this.wrapped.Subtracted(v.wrapped));
-  }
-  add(v) {
-    return new Vector(this.wrapped.Added(v.wrapped));
-  }
-  multiply(scale2) {
-    return new Vector(this.wrapped.Multiplied(scale2));
-  }
-  normalized() {
-    return new Vector(this.wrapped.Normalized());
-  }
-  normalize() {
-    this.wrapped.Normalize();
-    return this;
-  }
-  getCenter() {
-    return this;
-  }
-  getAngle(v) {
-    return this.wrapped.Angle(v.wrapped) * RAD2DEG;
-  }
-  projectToPlane(plane) {
-    const base = plane.origin;
-    const normal = plane.zDir;
-    const v1 = this.sub(base);
-    const v2 = normal.multiply(v1.dot(normal) / normal.Length ** 2);
-    const projection = this.sub(v2);
-    v1.delete();
-    v2.delete();
-    return projection;
-  }
-  equals(other) {
-    return this.wrapped.IsEqual(other.wrapped, 1e-5, 1e-5);
-  }
-  toPnt() {
-    return new this.oc.gp_Pnt_2(this.wrapped.XYZ());
-  }
-  toDir() {
-    return new this.oc.gp_Dir_3(this.wrapped.XYZ());
-  }
-  rotate(angle, center = [0, 0, 0], direction = [0, 0, 1]) {
-    const ax = makeAx1(center, direction);
-    this.wrapped.Rotate(ax, angle * DEG2RAD);
-    ax.delete();
-    return this;
-  }
-}
 const DIRECTIONS$2 = {
   X: [1, 0, 0],
   Y: [0, 1, 0],
@@ -1672,221 +1539,24 @@ function makeDirection(p) {
   }
   return p;
 }
-function asPnt(coords) {
-  const v = new Vector(coords);
-  const pnt2 = v.toPnt();
-  v.delete();
-  return pnt2;
-}
-function asDir(coords) {
-  const v = new Vector(coords);
-  const dir = v.toDir();
-  v.delete();
-  return dir;
-}
-class Transformation extends WrappingObj {
-  constructor(transform2) {
-    const oc = getKernel().oc;
-    super(transform2 || new oc.gp_Trsf_1());
-  }
-  translate(xDistOrVector, yDist = 0, zDist = 0) {
-    const translation = new Vector(
-      typeof xDistOrVector === "number" ? [xDistOrVector, yDist, zDist] : xDistOrVector
-    );
-    this.wrapped.SetTranslation_1(translation.wrapped);
-    translation.delete();
-    return this;
-  }
-  rotate(angle, position = [0, 0, 0], direction = [0, 0, 1]) {
-    const dir = asDir(direction);
-    const origin = asPnt(position);
-    const axis = new this.oc.gp_Ax1_2(origin, dir);
-    this.wrapped.SetRotation_1(axis, angle * DEG2RAD);
-    axis.delete();
-    dir.delete();
-    origin.delete();
-    return this;
-  }
-  mirror(inputPlane = "YZ", inputOrigin) {
-    const r = gcWithScope();
-    let origin;
-    let direction;
-    if (typeof inputPlane === "string") {
-      const plane = r(unwrap(createNamedPlane$1(inputPlane, inputOrigin)));
-      origin = plane.origin;
-      direction = plane.zDir;
-    } else if (inputPlane instanceof Plane) {
-      origin = inputOrigin || inputPlane.origin;
-      direction = inputPlane.zDir;
-    } else {
-      origin = inputOrigin || [0, 0, 0];
-      direction = inputPlane;
-    }
-    const mirrorAxis = r(makeAx2(origin, direction));
-    this.wrapped.SetMirror_3(mirrorAxis);
-    return this;
-  }
-  scale(center, scale2) {
-    const pnt2 = asPnt(center);
-    this.wrapped.SetScale(pnt2, scale2);
-    pnt2.delete();
-    return this;
-  }
-  coordSystemChange(fromSystem, toSystem) {
-    const r = gcWithScope();
-    const fromAx = r(
-      fromSystem === "reference" ? new this.oc.gp_Ax3_1() : makeAx3(fromSystem.origin, fromSystem.zDir, fromSystem.xDir)
-    );
-    const toAx = r(
-      toSystem === "reference" ? new this.oc.gp_Ax3_1() : makeAx3(toSystem.origin, toSystem.zDir, toSystem.xDir)
-    );
-    this.wrapped.SetTransformation_1(fromAx, toAx);
-    return this;
-  }
-  transformPoint(point) {
-    const pnt2 = asPnt(point);
-    const newPoint = pnt2.Transformed(this.wrapped);
-    pnt2.delete();
-    return newPoint;
-  }
-  transform(shape) {
-    const transformer = new this.oc.BRepBuilderAPI_Transform_2(shape, this.wrapped, true);
-    const result = transformer.ModifiedShape(shape);
-    transformer.delete();
-    return result;
-  }
-}
-class Plane {
-  oc;
-  xDir;
-  yDir;
-  zDir;
-  // @ts-expect-error -- initialised indirectly via origin setter
-  _origin;
-  // @ts-expect-error -- initialised indirectly via _calcTransforms
-  localToGlobal;
-  // @ts-expect-error -- initialised indirectly via _calcTransforms
-  globalToLocal;
-  constructor(origin, xDirection = null, normal = [0, 0, 1]) {
-    this.oc = getKernel().oc;
-    const zDir = new Vector(normal);
-    if (zDir.Length === 0) {
-      bug("Plane", "Plane normal must be non-zero");
-    }
-    this.zDir = zDir.normalize();
-    let xDir;
-    if (!xDirection) {
-      const ax3 = makeAx3(origin, zDir);
-      xDir = new Vector(ax3.XDirection());
-      ax3.delete();
-    } else {
-      xDir = new Vector(xDirection);
-    }
-    if (xDir.Length === 0) {
-      bug("Plane", "Plane xDir must be non-zero");
-    }
-    this.xDir = xDir.normalize();
-    this.yDir = this.zDir.cross(this.xDir).normalize();
-    this.origin = new Vector(origin);
-  }
-  delete() {
-    this.localToGlobal.delete();
-    this.globalToLocal.delete();
-    this.xDir.delete();
-    this.yDir.delete();
-    this.zDir.delete();
-    this._origin.delete();
-  }
-  clone() {
-    return new Plane(this.origin, this.xDir, this.zDir);
-  }
-  get origin() {
-    return this._origin;
-  }
-  set origin(newOrigin) {
-    if (this._origin) this._origin.delete();
-    this._origin = newOrigin;
-    this._calcTransforms();
-  }
-  translateTo(point) {
-    const newPlane = this.clone();
-    newPlane.origin = new Vector(point);
-    return newPlane;
-  }
-  translate(xDistOrVector, yDist = 0, zDist = 0) {
-    const translation = new Vector(
-      typeof xDistOrVector === "number" ? [xDistOrVector, yDist, zDist] : xDistOrVector
-    );
-    const newOrigin = this.origin.add(translation);
-    translation.delete();
-    const result = this.translateTo(newOrigin);
-    newOrigin.delete();
-    return result;
-  }
-  translateX(xDist) {
-    return this.translate(xDist, 0, 0);
-  }
-  translateY(yDist) {
-    return this.translate(0, yDist, 0);
-  }
-  translateZ(zDist) {
-    return this.translate(0, 0, zDist);
-  }
-  pivot(angle, direction = [1, 0, 0]) {
-    const dir = makeDirection(direction);
-    const zDir = new Vector(this.zDir).rotate(angle, [0, 0, 0], dir);
-    const xDir = new Vector(this.xDir).rotate(angle, [0, 0, 0], dir);
-    try {
-      return new Plane(this.origin, xDir, zDir);
-    } finally {
-      zDir.delete();
-      xDir.delete();
-    }
-  }
-  rotate2DAxes(angle) {
-    const xDir = new Vector(this.xDir).rotate(angle, [0, 0, 0], this.zDir);
-    try {
-      return new Plane(this.origin, xDir, this.zDir);
-    } finally {
-      xDir.delete();
-    }
-  }
-  _calcTransforms() {
-    if (this.globalToLocal) this.globalToLocal.delete();
-    if (this.localToGlobal) this.localToGlobal.delete();
-    this.globalToLocal = new Transformation();
-    this.globalToLocal.coordSystemChange("reference", {
-      origin: this.origin,
-      zDir: this.zDir,
-      xDir: this.xDir
-    });
-    this.localToGlobal = new Transformation();
-    this.localToGlobal.coordSystemChange(
-      {
-        origin: this.origin,
-        zDir: this.zDir,
-        xDir: this.xDir
-      },
-      "reference"
-    );
-  }
-  setOrigin2d(x, y) {
-    this.origin = this.toWorldCoords([x, y]);
-  }
-  toLocalCoords(vec2) {
-    const pnt2 = this.globalToLocal.transformPoint(vec2);
-    const newVec = new Vector(pnt2);
-    pnt2.delete();
-    return newVec;
-  }
-  toWorldCoords(v) {
-    const pnt2 = this.localToGlobal.transformPoint(v);
-    const newVec = new Vector(pnt2);
-    pnt2.delete();
-    return newVec;
+function createPlane(origin, xDirection = null, normal = [0, 0, 1]) {
+  const zDir = vecNormalize(normal);
+  if (vecIsZero(zDir)) throw new Error("Plane normal must be non-zero");
+  let xDir;
+  if (!xDirection) {
+    const ax3 = makeOcAx3(origin, zDir);
+    const ocXDir = ax3.XDirection();
+    xDir = vecNormalize([ocXDir.X(), ocXDir.Y(), ocXDir.Z()]);
+    ocXDir.delete();
+    ax3.delete();
+  } else {
+    xDir = vecNormalize(xDirection);
   }
+  if (vecIsZero(xDir)) throw new Error("Plane xDir must be non-zero");
+  const yDir = vecNormalize(vecCross(zDir, xDir));
+  return { origin, xDir, yDir, zDir };
 }
-const PLANES_CONFIG$1 = {
+const PLANES_CONFIG = {
   XY: { xDir: [1, 0, 0], normal: [0, 0, 1] },
   YZ: { xDir: [0, 1, 0], normal: [1, 0, 0] },
   ZX: { xDir: [0, 0, 1], normal: [0, 1, 0] },
@@ -1900,118 +1570,123 @@ const PLANES_CONFIG$1 = {
   top: { xDir: [1, 0, 0], normal: [0, 1, 0] },
   bottom: { xDir: [1, 0, 0], normal: [0, -1, 0] }
 };
-const createNamedPlane$1 = (plane, sourceOrigin = [0, 0, 0]) => {
-  const config = PLANES_CONFIG$1[plane];
-  if (!config) return err(validationError("UNKNOWN_PLANE", `Could not find plane ${plane}`));
+function createNamedPlane(name, sourceOrigin = [0, 0, 0]) {
+  const config = PLANES_CONFIG[name];
+  if (!config) return err(validationError("UNKNOWN_PLANE", `Could not find plane ${name}`));
   let origin;
   if (typeof sourceOrigin === "number") {
-    origin = config.normal.map((v) => v * sourceOrigin);
+    origin = vecScale(config.normal, sourceOrigin);
   } else {
-    origin = sourceOrigin;
-  }
-  return ok(new Plane(origin, config.xDir, config.normal));
-};
-class BoundingBox extends WrappingObj {
-  constructor(wrapped) {
-    const oc = getKernel().oc;
-    let boundBox = wrapped;
-    if (!boundBox) {
-      boundBox = new oc.Bnd_Box_1();
-    }
-    super(boundBox);
-  }
-  get repr() {
-    const [min, max] = this.bounds;
-    const fmt = ([x, y, z]) => `x: ${round3(x)}, y: ${round3(y)}, z: ${round3(z)}`;
-    return `${fmt(min)} - ${fmt(max)}`;
-  }
-  get bounds() {
-    const xMin = { current: 0 };
-    const yMin = { current: 0 };
-    const zMin = { current: 0 };
-    const xMax = { current: 0 };
-    const yMax = { current: 0 };
-    const zMax = { current: 0 };
-    this.wrapped.Get(xMin, yMin, zMin, xMax, yMax, zMax);
-    return [
-      [xMin.current, yMin.current, zMin.current],
-      [xMax.current, yMax.current, zMax.current]
-    ];
-  }
-  get center() {
-    const [[xmin, ymin, zmin], [xmax, ymax, zmax]] = this.bounds;
-    return [xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2];
-  }
-  get width() {
-    const [[xmin], [xmax]] = this.bounds;
-    return Math.abs(xmax - xmin);
-  }
-  get height() {
-    const [[, ymin], [, ymax]] = this.bounds;
-    return Math.abs(ymax - ymin);
-  }
-  get depth() {
-    const [[, , zmin], [, , zmax]] = this.bounds;
-    return Math.abs(zmax - zmin);
-  }
-  add(other) {
-    this.wrapped.Add_1(other.wrapped);
+    origin = toVec3(sourceOrigin);
   }
-  isOut(other) {
-    return this.wrapped.IsOut_4(other.wrapped);
+  return ok(createPlane(origin, config.xDir, config.normal));
+}
+function resolvePlane(input, origin) {
+  if (typeof input === "string") {
+    const result = createNamedPlane(input, origin);
+    if (!result.ok) throw new Error(result.error.message);
+    return result.value;
   }
+  return input;
+}
+function planeToWorld(plane, local) {
+  const [u, v] = local;
+  return vecAdd(vecAdd(plane.origin, vecScale(plane.xDir, u)), vecScale(plane.yDir, v));
+}
+function planeToLocal(plane, world) {
+  const relative = vecSub(world, plane.origin);
+  return [vecDot(relative, plane.xDir), vecDot(relative, plane.yDir)];
+}
+function translatePlane(plane, offset2) {
+  return { ...plane, origin: vecAdd(plane.origin, offset2) };
+}
+function pivotPlane(plane, angleDeg, axis = [1, 0, 0]) {
+  const angleRad = angleDeg * DEG2RAD;
+  const newZDir = vecRotate(plane.zDir, axis, angleRad);
+  const newXDir = vecRotate(plane.xDir, axis, angleRad);
+  const newYDir = vecNormalize(vecCross(newZDir, newXDir));
+  return { origin: plane.origin, xDir: newXDir, yDir: newYDir, zDir: newZDir };
 }
 const makePlaneFromFace = (face, originOnSurface = [0, 0]) => {
-  const [r, gc] = localGC();
-  const originPoint = r(face.pointOnSurface(...originOnSurface));
-  const normal = r(face.normalAt(originPoint));
-  const v = r(new Vector([0, 0, 1]));
-  let xd = v.cross(normal);
-  if (xd.Length < 1e-8) {
-    xd.delete();
-    xd = new Vector([1, 0, 0]);
-  }
-  r(xd);
-  const plane = new Plane(originPoint, xd, normal);
-  gc();
-  return plane;
-};
-function makePlane(plane = "XY", origin = [0, 0, 0]) {
-  if (plane instanceof Plane) {
-    return plane.clone();
+  const originPoint = face.pointOnSurface(...originOnSurface);
+  const normal = face.normalAt(originPoint);
+  const ref = [0, 0, 1];
+  let xd = vecCross(ref, normal);
+  if (vecLength(xd) < 1e-8) {
+    xd = [1, 0, 0];
+  }
+  xd = vecNormalize(xd);
+  return createPlane(originPoint, xd, normal);
+};
+function makePlane(plane, origin) {
+  if (plane && typeof plane !== "string") {
+    return { ...plane };
   } else {
-    return unwrap(createNamedPlane$1(plane, origin));
+    return resolvePlane(plane ?? "XY", origin);
   }
 }
 function rotate(shape, angle, position = [0, 0, 0], direction = [0, 0, 1]) {
+  const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const transformation = r(new Transformation());
-  transformation.rotate(angle, position, direction);
-  const newShape = transformation.transform(shape);
+  const posVec = toVec3(position);
+  const dirVec = toVec3(direction);
+  const ax = r(makeOcAx1(posVec, dirVec));
+  const trsf = r(new oc.gp_Trsf_1());
+  trsf.SetRotation_1(ax, angle * DEG2RAD);
+  const transformer = r(new oc.BRepBuilderAPI_Transform_2(shape, trsf, true));
+  const newShape = transformer.ModifiedShape(shape);
   gc();
   return newShape;
 }
 function translate(shape, vector) {
+  const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const transformation = r(new Transformation());
-  transformation.translate(vector);
-  const newShape = transformation.transform(shape);
+  const vecArr = toVec3(vector);
+  const ocVec = r(toOcVec(vecArr));
+  const trsf = r(new oc.gp_Trsf_1());
+  trsf.SetTranslation_1(ocVec);
+  const transformer = r(new oc.BRepBuilderAPI_Transform_2(shape, trsf, true));
+  const newShape = transformer.ModifiedShape(shape);
   gc();
   return newShape;
 }
 function mirror(shape, inputPlane, origin) {
+  const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const transformation = r(new Transformation());
-  transformation.mirror(inputPlane, origin);
-  const newShape = transformation.transform(shape);
+  let originVec;
+  let directionVec;
+  if (typeof inputPlane === "string") {
+    const plane = resolvePlane(inputPlane, origin);
+    originVec = plane.origin;
+    directionVec = plane.zDir;
+  } else if (inputPlane && typeof inputPlane === "object" && "origin" in inputPlane && "zDir" in inputPlane) {
+    originVec = origin ? toVec3(origin) : inputPlane.origin;
+    directionVec = inputPlane.zDir;
+  } else if (inputPlane) {
+    originVec = origin ? toVec3(origin) : [0, 0, 0];
+    directionVec = toVec3(inputPlane);
+  } else {
+    const plane = resolvePlane("YZ", origin);
+    originVec = plane.origin;
+    directionVec = plane.zDir;
+  }
+  const mirrorAxis = r(makeOcAx2(originVec, directionVec));
+  const trsf = r(new oc.gp_Trsf_1());
+  trsf.SetMirror_3(mirrorAxis);
+  const transformer = r(new oc.BRepBuilderAPI_Transform_2(shape, trsf, true));
+  const newShape = transformer.ModifiedShape(shape);
   gc();
   return newShape;
 }
 function scale(shape, center, scaleFactor) {
+  const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const transformation = r(new Transformation());
-  transformation.scale(center, scaleFactor);
-  const newShape = transformation.transform(shape);
+  const centerVec = toVec3(center);
+  const pnt2 = r(toOcPnt(centerVec));
+  const trsf = r(new oc.gp_Trsf_1());
+  trsf.SetScale(pnt2, scaleFactor);
+  const transformer = r(new oc.BRepBuilderAPI_Transform_2(shape, trsf, true));
+  const newShape = transformer.ModifiedShape(shape);
   gc();
   return newShape;
 }
@@ -2521,11 +2196,6 @@ class Shape extends WrappingObj {
   get wires() {
     return this._listTopo("wire").map((e) => new Wire(e));
   }
-  get boundingBox() {
-    const bbox = new BoundingBox();
-    this.oc.BRepBndLib.Add(this.wrapped, bbox.wrapped, true);
-    return bbox;
-  }
   _mesh({ tolerance = 1e-3, angularTolerance = 0.1 } = {}) {
     const mesher = new this.oc.BRepMesh_IncrementalMesh_2(
       this.wrapped,
@@ -2641,9 +2311,7 @@ class Vertex extends Shape {
 class Curve extends WrappingObj {
   get repr() {
     const { startPoint, endPoint } = this;
-    const retVal = `start: (${startPoint.repr}) end:(${endPoint.repr})`;
-    startPoint.delete();
-    endPoint.delete();
+    const retVal = `start: (${vecRepr(startPoint)}) end:(${vecRepr(endPoint)})`;
     return retVal;
   }
   get curveType() {
@@ -2652,11 +2320,15 @@ class Curve extends WrappingObj {
   }
   get startPoint() {
     const umin = this.wrapped.Value(this.wrapped.FirstParameter());
-    return new Vector(umin);
+    const result = fromOcPnt(umin);
+    umin.delete();
+    return result;
   }
   get endPoint() {
     const umax = this.wrapped.Value(this.wrapped.LastParameter());
-    return new Vector(umax);
+    const result = fromOcPnt(umax);
+    umax.delete();
+    return result;
   }
   _mapParameter(position) {
     const firstParam = this.wrapped.FirstParameter();
@@ -2664,14 +2336,17 @@ class Curve extends WrappingObj {
     return firstParam + (lastParam - firstParam) * position;
   }
   pointAt(position = 0.5) {
-    return new Vector(this.wrapped.Value(this._mapParameter(position)));
+    const pnt2 = this.wrapped.Value(this._mapParameter(position));
+    const result = fromOcPnt(pnt2);
+    pnt2.delete();
+    return result;
   }
   tangentAt(position = 0.5) {
     const pos = this._mapParameter(position);
     const tmp = new this.oc.gp_Pnt_1();
     const res = new this.oc.gp_Vec_1();
     this.wrapped.D1(pos, tmp, res);
-    const tangent = new Vector(res);
+    const tangent = fromOcVec(res);
     tmp.delete();
     res.delete();
     return tangent;
@@ -2689,9 +2364,7 @@ class Curve extends WrappingObj {
 class _1DShape extends Shape {
   get repr() {
     const { startPoint, endPoint } = this;
-    const retVal = `start: (${startPoint.repr}) end:(${endPoint.repr})`;
-    startPoint.delete();
-    endPoint.delete();
+    const retVal = `start: (${vecRepr(startPoint)}) end:(${vecRepr(endPoint)})`;
     return retVal;
   }
   get curve() {
@@ -2861,7 +2534,7 @@ class Face extends Shape {
     const absoluteU = u * (uMax - uMin) + uMin;
     const absoluteV = v * (vMax - vMin) + vMin;
     surface.D0(absoluteU, absoluteV, p);
-    const point = new Vector(p);
+    const point = fromOcPnt(p);
     surface.delete();
     p.delete();
     return point;
@@ -2871,7 +2544,7 @@ class Face extends Shape {
     const surface = r(this.oc.BRep_Tool.Surface_2(this.wrapped));
     const projectedPoint = r(
       new this.oc.GeomAPI_ProjectPointOnSurf_2(
-        r(asPnt(point)),
+        r(toOcPnt(toVec3(point))),
         surface,
         this.oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad
       )
@@ -2896,13 +2569,15 @@ class Face extends Shape {
     const vn = r(new this.oc.gp_Vec_1());
     const props = r(new this.oc.BRepGProp_Face_2(this.wrapped, false));
     props.Normal(u, v, p, vn);
-    const normal = new Vector(vn);
+    const normal = fromOcVec(vn);
     return normal;
   }
   get center() {
     const properties = new this.oc.GProp_GProps_1();
     this.oc.BRepGProp.SurfaceProperties_2(this.wrapped, properties, 1e-7, true);
-    const center = new Vector(properties.CentreOfMass());
+    const centerPnt = properties.CentreOfMass();
+    const center = fromOcPnt(centerPnt);
+    centerPnt.delete();
     properties.delete();
     return center;
   }
@@ -3241,8 +2916,8 @@ function zip(arrays) {
 const makeLine = (v1, v2) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const p1 = r(asPnt(v1));
-  const p2 = r(asPnt(v2));
+  const p1 = r(toOcPnt(v1));
+  const p2 = r(toOcPnt(v2));
   const maker = r(new oc.BRepBuilderAPI_MakeEdge_3(p1, p2));
   const edge = new Edge(maker.Edge());
   gc();
@@ -3251,7 +2926,7 @@ const makeLine = (v1, v2) => {
 const makeCircle = (radius, center = [0, 0, 0], normal = [0, 0, 1]) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const ax = r(makeAx2(center, normal));
+  const ax = r(makeOcAx2(center, normal));
   const circleGp = r(new oc.gp_Circ_2(ax, radius));
   const edgeMaker = r(new oc.BRepBuilderAPI_MakeEdge_8(circleGp));
   const shape = new Edge(edgeMaker.Edge());
@@ -3261,7 +2936,7 @@ const makeCircle = (radius, center = [0, 0, 0], normal = [0, 0, 1]) => {
 const makeEllipse = (majorRadius, minorRadius, center = [0, 0, 0], normal = [0, 0, 1], xDir) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const ax = r(makeAx2(center, normal, xDir));
+  const ax = r(makeOcAx2(center, normal, xDir));
   if (minorRadius > majorRadius) {
     gc();
     return err(
@@ -3288,7 +2963,7 @@ const makeHelix = (pitch, height, radius, center = [0, 0, 0], dir = [0, 0, 1], l
   const uStart = r(geomLine.Value(0));
   const uStop = r(geomLine.Value(nTurns * Math.sqrt((2 * Math.PI) ** 2 + pitch ** 2)));
   const geomSeg = r(new oc.GCE2d_MakeSegment_1(uStart, uStop));
-  const geomSurf = new oc.Geom_CylindricalSurface_1(r(makeAx3(center, dir)), radius);
+  const geomSurf = new oc.Geom_CylindricalSurface_1(r(makeOcAx3(center, dir)), radius);
   const e = r(
     new oc.BRepBuilderAPI_MakeEdge_30(
       r(new oc.Handle_Geom2d_Curve_2(geomSeg.Value().get())),
@@ -3303,9 +2978,9 @@ const makeHelix = (pitch, height, radius, center = [0, 0, 0], dir = [0, 0, 1], l
 const makeThreePointArc = (v1, v2, v3) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const p1 = r(asPnt(v1));
-  const p2 = r(asPnt(v2));
-  const p3 = r(asPnt(v3));
+  const p1 = r(toOcPnt(v1));
+  const p2 = r(toOcPnt(v2));
+  const p3 = r(toOcPnt(v3));
   const arcMaker = r(new oc.GC_MakeArcOfCircle_4(p1, p2, p3));
   const circleGeom = r(arcMaker.Value());
   const curve = r(new oc.Handle_Geom_Curve_2(circleGeom.get()));
@@ -3317,7 +2992,7 @@ const makeThreePointArc = (v1, v2, v3) => {
 const makeEllipseArc = (majorRadius, minorRadius, startAngle, endAngle, center = [0, 0, 0], normal = [0, 0, 1], xDir) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const ax = r(makeAx2(center, normal, xDir));
+  const ax = r(makeOcAx2(center, normal, xDir));
   if (minorRadius > majorRadius) {
     gc();
     return err(
@@ -3335,7 +3010,7 @@ const makeBSplineApproximation = function makeBSplineApproximation2(points, { to
   const [r, gc] = localGC();
   const pnts = r(new oc.TColgp_Array1OfPnt_2(1, points.length));
   points.forEach((point, index) => {
-    pnts.SetValue(index + 1, r(asPnt(point)));
+    pnts.SetValue(index + 1, r(toOcPnt(point)));
   });
   let splineBuilder;
   if (smoothing) {
@@ -3379,7 +3054,7 @@ const makeBezierCurve = (points) => {
   const [r, gc] = localGC();
   const arrayOfPoints = r(new oc.TColgp_Array1OfPnt_2(1, points.length));
   points.forEach((p, i) => {
-    arrayOfPoints.SetValue(i + 1, r(asPnt(p)));
+    arrayOfPoints.SetValue(i + 1, r(toOcPnt(p)));
   });
   const bezCurve = new oc.Geom_BezierCurve_1(arrayOfPoints);
   const curve = r(new oc.Handle_Geom_Curve_2(bezCurve));
@@ -3393,9 +3068,9 @@ const makeTangentArc = (startPoint, startTgt, endPoint) => {
   const [r, gc] = localGC();
   const circleGeom = r(
     new oc.GC_MakeArcOfCircle_5(
-      r(asPnt(startPoint)),
-      r(new Vector(startTgt)).wrapped,
-      r(asPnt(endPoint))
+      r(toOcPnt(startPoint)),
+      r(toOcVec(startTgt)),
+      r(toOcPnt(endPoint))
     ).Value()
   );
   const curve = r(new oc.Handle_Geom_Curve_2(circleGeom.get()));
@@ -3487,7 +3162,7 @@ const makeNonPlanarFace = (wire) => {
 const makeCylinder = (radius, height, location = [0, 0, 0], direction = [0, 0, 1]) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const axis = r(makeAx2(location, direction));
+  const axis = r(makeOcAx2(location, direction));
   const cylinder = r(new oc.BRepPrimAPI_MakeCylinder_3(axis, radius, height));
   const solid = new Solid(cylinder.Shape());
   gc();
@@ -3508,9 +3183,9 @@ class EllipsoidTransform extends WrappingObj {
     const xyRatio = Math.sqrt(x * y / z);
     const xzRatio = x / xyRatio;
     const yzRatio = y / xyRatio;
-    const ax1 = r(makeAx1([0, 0, 0], [0, 1, 0]));
-    const ax2 = r(makeAx1([0, 0, 0], [0, 0, 1]));
-    const ax3 = r(makeAx1([0, 0, 0], [1, 0, 0]));
+    const ax1 = r(makeOcAx1([0, 0, 0], [0, 1, 0]));
+    const ax2 = r(makeOcAx1([0, 0, 0], [0, 0, 1]));
+    const ax3 = r(makeOcAx1([0, 0, 0], [1, 0, 0]));
     const transform2 = new oc.gp_GTrsf_1();
     transform2.SetAffinity_1(ax1, xzRatio);
     const xy = r(new oc.gp_GTrsf_1());
@@ -3569,8 +3244,8 @@ const makeEllipsoid = (aLength, bLength, cLength) => {
 const makeBox = (corner1, corner2) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const p1 = r(asPnt(corner1));
-  const p2 = r(asPnt(corner2));
+  const p1 = r(toOcPnt(corner1));
+  const p2 = r(toOcPnt(corner2));
   const boxMaker = r(new oc.BRepPrimAPI_MakeBox_4(p1, p2));
   const box = new Solid(boxMaker.Solid());
   gc();
@@ -3579,7 +3254,7 @@ const makeBox = (corner1, corner2) => {
 const makeVertex = (point) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const pnt2 = r(asPnt(point));
+  const pnt2 = r(toOcPnt(point));
   const vertexMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt2));
   const vertex = vertexMaker.Vertex();
   gc();
@@ -4283,9 +3958,9 @@ function buildLawFromProfile(extrusionLength, { profile, endFactor = 1 }) {
 const basicFaceExtrusion = (face, extrusionVec) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const solidBuilder = r(
-    new oc.BRepPrimAPI_MakePrism_1(face.wrapped, extrusionVec.wrapped, false, true)
-  );
+  const vec2 = toVec3(extrusionVec);
+  const ocVec = r(new oc.gp_Vec_4(vec2[0], vec2[1], vec2[2]));
+  const solidBuilder = r(new oc.BRepPrimAPI_MakePrism_1(face.wrapped, ocVec, false, true));
   const solid = new Solid(unwrap(downcast(solidBuilder.Shape())));
   gc();
   return solid;
@@ -4293,7 +3968,9 @@ const basicFaceExtrusion = (face, extrusionVec) => {
 const revolution = (face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const ax = r(makeAx1(center, direction));
+  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$2(shape))
@@ -4367,9 +4044,9 @@ function genericSweep(wire, spine, {
 }
 const supportExtrude$1 = (wire, center, normal, support) => {
   const [r, gc] = localGC();
-  const centerVec = r(new Vector(center));
-  const normalVec = r(new Vector(normal));
-  const endVec = r(centerVec.add(normalVec));
+  const centerVec = toVec3(center);
+  const normalVec = toVec3(normal);
+  const endVec = vecAdd(centerVec, normalVec);
   const mainSpineEdge = r(makeLine(centerVec, endVec));
   const spine = r(unwrap(assembleWire$1([mainSpineEdge])));
   const result = genericSweep(wire, spine, { support });
@@ -4378,27 +4055,27 @@ const supportExtrude$1 = (wire, center, normal, support) => {
 };
 function complexExtrude$1(wire, center, normal, profileShape, shellMode = false) {
   const [r, gc] = localGC();
-  const centerVec = r(new Vector(center));
-  const normalVec = r(new Vector(normal));
-  const endVec = r(centerVec.add(normalVec));
+  const centerVec = toVec3(center);
+  const normalVec = toVec3(normal);
+  const endVec = vecAdd(centerVec, normalVec);
   const mainSpineEdge = r(makeLine(centerVec, endVec));
   const spine = r(unwrap(assembleWire$1([mainSpineEdge])));
-  const law = profileShape ? r(unwrap(buildLawFromProfile(normalVec.Length, profileShape))) : null;
+  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$1(wire, angleDegrees, center, normal, profileShape, shellMode = false) {
   const [r, gc] = localGC();
-  const centerVec = r(new Vector(center));
-  const normalVec = r(new Vector(normal));
-  const endVec = r(centerVec.add(normalVec));
+  const centerVec = toVec3(center);
+  const normalVec = toVec3(normal);
+  const endVec = vecAdd(centerVec, normalVec);
   const mainSpineEdge = r(makeLine(centerVec, endVec));
   const spine = r(unwrap(assembleWire$1([mainSpineEdge])));
-  const extrusionLength = normalVec.Length;
+  const extrusionLength = vecLength(normalVec);
   const pitch = 360 / angleDegrees * extrusionLength;
   const radius = 1;
-  const auxiliarySpine = r(makeHelix(pitch, extrusionLength, radius, center, normal));
+  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();
@@ -4409,11 +4086,11 @@ const loft = (wires, { ruled = true, startPoint, endPoint } = {}, returnShell =
   const [r, gc] = localGC();
   const loftBuilder = r(new oc.BRepOffsetAPI_ThruSections(!returnShell, ruled, 1e-6));
   if (startPoint) {
-    loftBuilder.AddVertex(r(makeVertex(startPoint)).wrapped);
+    loftBuilder.AddVertex(r(makeVertex(toVec3(startPoint))).wrapped);
   }
   wires.forEach((w) => loftBuilder.AddWire(w.wrapped));
   if (endPoint) {
-    loftBuilder.AddVertex(r(makeVertex(endPoint)).wrapped);
+    loftBuilder.AddVertex(r(makeVertex(toVec3(endPoint))).wrapped);
   }
   const progress = r(new oc.Message_ProgressRange_1());
   loftBuilder.Build(progress);
@@ -5888,7 +5565,7 @@ const curvesBoundingBox = (curves) => {
 };
 function curvesAsEdgesOnPlane(curves, plane) {
   const [r, gc] = localGC();
-  const ax = r(makeAx2(plane.origin, plane.zDir, plane.xDir));
+  const ax = r(makeOcAx2(plane.origin, plane.zDir, plane.xDir));
   const oc = getKernel().oc;
   const edges = curves.map((curve) => {
     const curve3d = r(oc.GeomLib.To3d(ax, curve.wrapped));
@@ -6134,7 +5811,7 @@ class Finder {
 }
 const makeVertexOc = (point) => {
   const oc = getKernel().oc;
-  const pnt2 = asPnt(point);
+  const pnt2 = toOcPnt(toVec3(point));
   const vertexMaker = new oc.BRepBuilderAPI_MakeVertex(pnt2);
   const vertex = vertexMaker.Vertex();
   vertexMaker.delete();
@@ -6143,8 +5820,8 @@ const makeVertexOc = (point) => {
 };
 const makeBoxOc = (corner1, corner2) => {
   const oc = getKernel().oc;
-  const p1 = asPnt(corner1);
-  const p2 = asPnt(corner2);
+  const p1 = toOcPnt(toVec3(corner1));
+  const p2 = toOcPnt(toVec3(corner2));
   const boxMaker = new oc.BRepPrimAPI_MakeBox_4(p1, p2);
   const solid = boxMaker.Solid();
   boxMaker.delete();
@@ -6216,13 +5893,14 @@ class Finder3d extends Finder {
   atAngleWith(direction = "Z", angle = 0) {
     let myDirection;
     if (typeof direction === "string") {
-      myDirection = new Vector(DIRECTIONS$1[direction]);
+      myDirection = toVec3(DIRECTIONS$1[direction]);
     } else {
-      myDirection = new Vector(direction);
+      myDirection = toVec3(direction);
     }
+    const normalizedDirection = vecNormalize(myDirection);
     const checkAngle = ({ normal }) => {
       if (!normal) return false;
-      const angleOfNormal = Math.acos(Math.abs(normal.dot(myDirection)));
+      const angleOfNormal = Math.acos(Math.abs(vecDot(normal, normalizedDirection)));
       return Math.abs(angleOfNormal - DEG2RAD * angle) < 1e-6;
     };
     this.filters.push(checkAngle);
@@ -6305,15 +5983,13 @@ class FaceFinder extends Finder3d {
    * @category Filter
    */
   parallelTo(plane) {
-    const [r, gc] = localGC();
     if (typeof plane === "string") return this.atAngleWith(PLANE_TO_DIR[plane]);
-    if (typeof plane !== "string" && plane instanceof Plane)
+    if (typeof plane !== "string" && "zDir" in plane) {
       return this.atAngleWith(plane.zDir);
+    }
     if (typeof plane !== "string" && "normalAt" in plane) {
-      const normal = r(plane.normalAt());
-      const normalPoint = [normal.x, normal.y, normal.z];
-      gc();
-      return this.atAngleWith(normalPoint);
+      const normal = plane.normalAt();
+      return this.atAngleWith(normal);
     }
     return this;
   }
@@ -6337,24 +6013,20 @@ class FaceFinder extends Finder3d {
    * @category Filter
    */
   inPlane(inputPlane, origin) {
-    const plane = inputPlane instanceof Plane ? makePlane(inputPlane) : makePlane(inputPlane, origin);
+    const plane = typeof inputPlane === "string" ? resolvePlane(inputPlane, origin) : inputPlane;
     this.parallelTo(plane);
     const centerInPlane = ({ element }) => {
-      const [r, gc] = localGC();
       const center = element.center;
-      const projected = r(center.projectToPlane(plane));
-      const result = center.equals(projected);
-      gc();
+      const projected = vecProjectToPlane(center, plane.origin, plane.zDir);
+      const result = vecEquals(center, projected);
       return result;
     };
     this.filters.push(centerInPlane);
     return this;
   }
   shouldKeep(element) {
-    const [r, gc] = localGC();
-    const normal = r(element.normalAt());
+    const normal = element.normalAt();
     const shouldKeep = this.filters.every((filter) => filter({ normal, element }));
-    gc();
     return shouldKeep;
   }
   applyFilter(shape) {
@@ -6448,7 +6120,7 @@ class Blueprint {
     return new Blueprint(curves);
   }
   sketchOnPlane(inputPlane, origin) {
-    const plane = inputPlane instanceof Plane ? makePlane(inputPlane) : makePlane(inputPlane, origin);
+    const plane = inputPlane && typeof inputPlane !== "string" ? { ...inputPlane } : makePlane(inputPlane, origin);
     const edges = curvesAsEdgesOnPlane(this.curves, plane);
     const wire = assembleWire(edges);
     return {
@@ -6468,10 +6140,9 @@ class Blueprint {
     return { wire, baseFace: face };
   }
   subFace(face, origin) {
-    const sketch = this.translate(face.uvCoordinates(origin || face.center)).sketchOnFace(
-      face,
-      "original"
-    );
+    const originPoint = origin || [...face.center];
+    const originVec3 = toVec3(originPoint);
+    const sketch = this.translate(face.uvCoordinates(originVec3)).sketchOnFace(face, "original");
     return unwrap(makeFace(sketch.wire));
   }
   punchHole(shape, face, {
@@ -6791,12 +6462,10 @@ class Sketch {
   /**
    * @ignore
    */
-  // @ts-expect-error initialised indirectly
   _defaultOrigin;
   /**
    * @ignore
    */
-  // @ts-expect-error initialised indirectly
   _defaultDirection;
   _baseFace;
   constructor(wire, {
@@ -6804,8 +6473,8 @@ class Sketch {
     defaultDirection = [0, 0, 1]
   } = {}) {
     this.wire = wire;
-    this.defaultOrigin = defaultOrigin;
-    this.defaultDirection = defaultDirection;
+    this._defaultOrigin = toVec3(defaultOrigin);
+    this._defaultDirection = toVec3(defaultDirection);
     this.baseFace = null;
   }
   get baseFace() {
@@ -6817,8 +6486,6 @@ class Sketch {
   }
   delete() {
     this.wire.delete();
-    this._defaultOrigin.delete();
-    this._defaultDirection.delete();
     if (this.baseFace) this.baseFace.delete();
   }
   clone() {
@@ -6833,13 +6500,13 @@ class Sketch {
     return this._defaultOrigin;
   }
   set defaultOrigin(newOrigin) {
-    this._defaultOrigin = new Vector(newOrigin);
+    this._defaultOrigin = toVec3(newOrigin);
   }
   get defaultDirection() {
     return this._defaultDirection;
   }
   set defaultDirection(newDirection) {
-    this._defaultDirection = new Vector(newDirection);
+    this._defaultDirection = toVec3(newDirection);
   }
   /**
    * Transforms the lines into a face. The lines should be closed.
@@ -6886,13 +6553,13 @@ class Sketch {
     twistAngle,
     origin
   } = {}) {
-    const [r, gc] = localGC();
-    const extrusionVec = r(
-      new Vector(extrusionDirection || this.defaultDirection).normalized().multiply(extrusionDistance)
-    );
+    const gc = localGC()[1];
+    const direction = extrusionDirection ? toVec3(extrusionDirection) : this.defaultDirection;
+    const extrusionVec = vecScale(vecNormalize(direction), extrusionDistance);
+    const originVec = origin ? toVec3(origin) : this.defaultOrigin;
     if (extrusionProfile && !twistAngle) {
       const solid2 = unwrap(
-        complexExtrude$1(this.wire, origin || this.defaultOrigin, extrusionVec, extrusionProfile)
+        complexExtrude$1(this.wire, [...originVec], [...extrusionVec], extrusionProfile)
       );
       gc();
       this.delete();
@@ -6900,20 +6567,14 @@ class Sketch {
     }
     if (twistAngle) {
       const solid2 = unwrap(
-        twistExtrude$1(
-          this.wire,
-          twistAngle,
-          origin || this.defaultOrigin,
-          extrusionVec,
-          extrusionProfile
-        )
+        twistExtrude$1(this.wire, twistAngle, [...originVec], [...extrusionVec], extrusionProfile)
       );
       gc();
       this.delete();
       return solid2;
     }
     const face = unwrap(makeFace(this.wire));
-    const solid = basicFaceExtrusion(face, extrusionVec);
+    const solid = basicFaceExtrusion(face, [...extrusionVec]);
     gc();
     this.delete();
     return solid;
@@ -6924,9 +6585,13 @@ class Sketch {
    */
   sweepSketch(sketchOnPlane, sweepConfig = {}) {
     const startPoint = this.wire.startPoint;
-    const normal = this.wire.tangentAt(1e-9).multiply(-1).normalize();
-    const xDir = normal.cross(this.defaultDirection).multiply(-1);
-    const sketch = sketchOnPlane(new Plane(startPoint, xDir, normal), startPoint);
+    const tangent = this.wire.tangentAt(1e-9);
+    const normal = vecNormalize(vecScale(tangent, -1));
+    const defaultDir = this.defaultDirection;
+    const xDir = vecScale(vecCross(normal, defaultDir), -1);
+    const sketch = sketchOnPlane(createPlane([...startPoint], [...xDir], [...normal]), [
+      ...startPoint
+    ]);
     const config = {
       forceProfileSpineOthogonality: true,
       ...sweepConfig
@@ -7449,12 +7114,16 @@ class FaceSketcher extends BaseSketcher2d {
     const sketch = new Sketch(wire);
     if (wire.isClosed) {
       const face = r(sketch.clone().face());
-      sketch.defaultOrigin = r(face.pointOnSurface(0.5, 0.5));
-      sketch.defaultDirection = r(r(face.normalAt()).multiply(-1));
+      const origin = face.pointOnSurface(0.5, 0.5);
+      const normal = face.normalAt();
+      const direction = vecScale(normal, -1);
+      sketch.defaultOrigin = [origin[0], origin[1], origin[2]];
+      sketch.defaultDirection = [direction[0], direction[1], direction[2]];
     } else {
-      const startPoint = r(wire.startPoint);
-      sketch.defaultOrigin = startPoint;
-      sketch.defaultDirection = r(this.face.normalAt(startPoint));
+      const startPoint = wire.startPoint;
+      const normal = this.face.normalAt([startPoint[0], startPoint[1], startPoint[2]]);
+      sketch.defaultOrigin = [startPoint[0], startPoint[1], startPoint[2]];
+      sketch.defaultDirection = [normal[0], normal[1], normal[2]];
     }
     sketch.baseFace = this.face;
     gc();
@@ -8252,15 +7921,13 @@ class EdgeFinder extends Finder3d {
    * @category Filter
    */
   parallelTo(plane) {
-    const [r, gc] = localGC();
     if (typeof plane === "string") return this.atAngleWith(PLANE_TO_DIR[plane], 90);
-    if (typeof plane !== "string" && plane instanceof Plane)
+    if (typeof plane !== "string" && "zDir" in plane) {
       return this.atAngleWith(plane.zDir, 90);
+    }
     if (typeof plane !== "string" && "normalAt" in plane) {
-      const normal = r(plane.normalAt());
-      const normalPoint = [normal.x, normal.y, normal.z];
-      gc();
-      return this.atAngleWith(normalPoint, 90);
+      const normal = plane.normalAt();
+      return this.atAngleWith(normal, 90);
     }
     return this;
   }
@@ -8273,30 +7940,25 @@ class EdgeFinder extends Finder3d {
    * @category Filter
    */
   inPlane(inputPlane, origin) {
-    const plane = inputPlane instanceof Plane ? makePlane(inputPlane) : makePlane(inputPlane, origin);
+    const plane = typeof inputPlane === "string" ? resolvePlane(inputPlane, origin) : inputPlane;
     this.parallelTo(plane);
     const firstPointInPlane = ({ element }) => {
-      const [r, gc] = localGC();
       const startPoint = element.startPoint;
-      const projected = r(startPoint.projectToPlane(plane));
-      const result = startPoint.equals(projected);
-      gc();
+      const projected = vecProjectToPlane(startPoint, plane.origin, plane.zDir);
+      const result = vecEquals(startPoint, projected);
       return result;
     };
     this.filters.push(firstPointInPlane);
     return this;
   }
   shouldKeep(element) {
-    const [r, gc] = localGC();
     let normal = null;
-    let tangent = null;
     try {
-      tangent = r(element.tangentAt());
-      normal = r(tangent.normalized());
+      const tangent = element.tangentAt();
+      normal = vecNormalize(tangent);
     } catch {
     }
     const result = this.filters.every((filter) => filter({ normal, element }));
-    gc();
     return result;
   }
   applyFilter(shape) {
@@ -8578,42 +8240,37 @@ class Sketcher {
   pendingEdges;
   _mirrorWire;
   constructor(plane, origin) {
-    this.plane = plane instanceof Plane ? makePlane(plane) : makePlane(plane, origin);
-    this.pointer = new Vector(this.plane.origin);
-    this.firstPoint = new Vector(this.plane.origin);
+    this.plane = plane && typeof plane !== "string" ? { ...plane } : resolvePlane(plane ?? "XY", origin);
+    this.pointer = [...this.plane.origin];
+    this.firstPoint = [...this.plane.origin];
     this.pendingEdges = [];
     this._mirrorWire = false;
   }
   delete() {
-    this.plane.delete();
-    this.pointer.delete();
-    this.firstPoint.delete();
     for (const edge of this.pendingEdges) {
       edge.delete();
     }
     this.pendingEdges = [];
   }
   _updatePointer(newPointer) {
-    this.pointer.delete();
     this.pointer = newPointer;
   }
   movePointerTo([x, y]) {
     if (this.pendingEdges.length)
       bug("Sketcher.movePointerTo", "You can only move the pointer if there is no edge defined");
-    this._updatePointer(this.plane.toWorldCoords([x, y]));
-    this.firstPoint.delete();
-    this.firstPoint = new Vector(this.pointer);
+    this._updatePointer(planeToWorld(this.plane, [x, y]));
+    this.firstPoint = this.pointer;
     return this;
   }
   lineTo([x, y]) {
-    const endPoint = this.plane.toWorldCoords([x, y]);
+    const endPoint = planeToWorld(this.plane, [x, y]);
     this.pendingEdges.push(makeLine(this.pointer, endPoint));
     this._updatePointer(endPoint);
     return this;
   }
   line(xDist, yDist) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    return this.lineTo([xDist + pointer.x, yDist + pointer.y]);
+    const [px, py] = planeToLocal(this.plane, this.pointer);
+    return this.lineTo([xDist + px, yDist + py]);
   }
   vLine(distance) {
     return this.line(0, distance);
@@ -8622,12 +8279,12 @@ class Sketcher {
     return this.line(distance, 0);
   }
   vLineTo(yPos) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    return this.lineTo([pointer.x, yPos]);
+    const [px] = planeToLocal(this.plane, this.pointer);
+    return this.lineTo([px, yPos]);
   }
   hLineTo(xPos) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    return this.lineTo([xPos, pointer.y]);
+    const [, py] = planeToLocal(this.plane, this.pointer);
+    return this.lineTo([xPos, py]);
   }
   polarLine(distance, angle) {
     const angleInRads = angle * DEG2RAD;
@@ -8640,66 +8297,59 @@ class Sketcher {
     return this.lineTo(point);
   }
   tangentLine(distance) {
-    const [r, gc] = localGC();
     const previousEdge = this.pendingEdges.length ? this.pendingEdges[this.pendingEdges.length - 1] : null;
     if (!previousEdge)
       bug("Sketcher.tangentLine", "You need a previous edge to create a tangent line");
-    const tangent = r(previousEdge.tangentAt(1));
-    const endPoint = r(tangent.normalized().multiply(distance)).add(this.pointer);
+    const tangent = previousEdge.tangentAt(1);
+    const scaledTangent = vecScale(vecNormalize(tangent), distance);
+    const endPoint = vecAdd(scaledTangent, this.pointer);
     this.pendingEdges.push(makeLine(this.pointer, endPoint));
     this._updatePointer(endPoint);
-    gc();
     return this;
   }
   threePointsArcTo(end, innerPoint) {
-    const gpoint1 = this.plane.toWorldCoords(innerPoint);
-    const gpoint2 = this.plane.toWorldCoords(end);
+    const gpoint1 = planeToWorld(this.plane, innerPoint);
+    const gpoint2 = planeToWorld(this.plane, end);
     this.pendingEdges.push(makeThreePointArc(this.pointer, gpoint1, gpoint2));
     this._updatePointer(gpoint2);
     return this;
   }
   threePointsArc(xDist, yDist, viaXDist, viaYDist) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    return this.threePointsArcTo(
-      [pointer.x + xDist, pointer.y + yDist],
-      [pointer.x + viaXDist, pointer.y + viaYDist]
-    );
+    const [px, py] = planeToLocal(this.plane, this.pointer);
+    return this.threePointsArcTo([px + xDist, py + yDist], [px + viaXDist, py + viaYDist]);
   }
   tangentArcTo(end) {
-    const [r, gc] = localGC();
-    const endPoint = this.plane.toWorldCoords(end);
+    const endPoint = planeToWorld(this.plane, end);
     const previousEdge = this.pendingEdges.length ? this.pendingEdges[this.pendingEdges.length - 1] : null;
     if (!previousEdge)
       bug("Sketcher.tangentArcTo", "You need a previous edge to create a tangent arc");
-    const prevEnd = r(previousEdge.endPoint);
-    const prevTangent = r(previousEdge.tangentAt(1));
+    const prevEnd = previousEdge.endPoint;
+    const prevTangent = previousEdge.tangentAt(1);
     this.pendingEdges.push(makeTangentArc(prevEnd, prevTangent, endPoint));
     this._updatePointer(endPoint);
-    gc();
     return this;
   }
   tangentArc(xDist, yDist) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    return this.tangentArcTo([xDist + pointer.x, yDist + pointer.y]);
+    const [px, py] = planeToLocal(this.plane, this.pointer);
+    return this.tangentArcTo([xDist + px, yDist + py]);
   }
   sagittaArcTo(end, sagitta) {
-    const [r, gc] = localGC();
     const startPoint = this.pointer;
-    const endPoint = this.plane.toWorldCoords(end);
-    const sum = r(endPoint.add(startPoint));
-    const midPoint = r(sum.multiply(0.5));
-    const diff = r(endPoint.sub(startPoint));
-    const sagDirection = r(r(diff.cross(this.plane.zDir)).normalized());
-    const sagVector = r(sagDirection.multiply(sagitta));
-    const sagPoint = r(midPoint.add(sagVector));
+    const endPoint = planeToWorld(this.plane, end);
+    const sum = vecAdd(endPoint, startPoint);
+    const midPoint = vecScale(sum, 0.5);
+    const diff = vecSub(endPoint, startPoint);
+    const crossResult = vecCross(diff, this.plane.zDir);
+    const sagDirection = vecNormalize(crossResult);
+    const sagVector = vecScale(sagDirection, sagitta);
+    const sagPoint = vecAdd(midPoint, sagVector);
     this.pendingEdges.push(makeThreePointArc(this.pointer, sagPoint, endPoint));
     this._updatePointer(endPoint);
-    gc();
     return this;
   }
   sagittaArc(xDist, yDist, sagitta) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    return this.sagittaArcTo([xDist + pointer.x, yDist + pointer.y], sagitta);
+    const [px, py] = planeToLocal(this.plane, this.pointer);
+    return this.sagittaArcTo([xDist + px, yDist + py], sagitta);
   }
   vSagittaArc(distance, sagitta) {
     return this.sagittaArc(0, distance, sagitta);
@@ -8709,14 +8359,14 @@ class Sketcher {
   }
   bulgeArcTo(end, bulge) {
     if (!bulge) return this.lineTo(end);
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    const halfChord = distance2d([pointer.x, pointer.y], end) / 2;
+    const [px, py] = planeToLocal(this.plane, this.pointer);
+    const halfChord = distance2d([px, py], end) / 2;
     const bulgeAsSagitta = -bulge * halfChord;
     return this.sagittaArcTo(end, bulgeAsSagitta);
   }
   bulgeArc(xDist, yDist, bulge) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    return this.bulgeArcTo([xDist + pointer.x, yDist + pointer.y], bulge);
+    const [px, py] = planeToLocal(this.plane, this.pointer);
+    return this.bulgeArcTo([xDist + px, yDist + py], bulge);
   }
   vBulgeArc(distance, bulge) {
     return this.bulgeArc(0, distance, bulge);
@@ -8725,8 +8375,8 @@ class Sketcher {
     return this.bulgeArc(distance, 0, bulge);
   }
   ellipseTo(end, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep2 = false) {
-    const [r, gc] = localGC();
-    const start = this.plane.toLocalCoords(this.pointer);
+    const [, gc] = localGC();
+    const [startX, startY] = planeToLocal(this.plane, this.pointer);
     let rotationAngle = rotation;
     let majorRadius = horizontalRadius;
     let minorRadius = verticalRadius;
@@ -8736,7 +8386,7 @@ class Sketcher {
       minorRadius = horizontalRadius;
     }
     const { cx, cy, rx, ry, startAngle, endAngle, clockwise } = convertSvgEllipseParams(
-      [start.x, start.y],
+      [startX, startY],
       end,
       majorRadius,
       minorRadius,
@@ -8744,16 +8394,14 @@ class Sketcher {
       longAxis,
       sweep2
     );
-    const xDir = r(
-      new Vector(this.plane.xDir).rotate(rotationAngle, this.plane.origin, this.plane.zDir)
-    );
+    const xDir = vecRotate(this.plane.xDir, this.plane.zDir, rotationAngle * DEG2RAD);
     const arc = unwrap(
       makeEllipseArc(
         rx,
         ry,
         clockwise ? startAngle : endAngle,
         clockwise ? endAngle : startAngle,
-        r(this.plane.toWorldCoords([cx, cy])),
+        planeToWorld(this.plane, [cx, cy]),
         this.plane.zDir,
         xDir
       )
@@ -8762,14 +8410,14 @@ class Sketcher {
       arc.wrapped.Reverse();
     }
     this.pendingEdges.push(arc);
-    this._updatePointer(this.plane.toWorldCoords(end));
+    this._updatePointer(planeToWorld(this.plane, end));
     gc();
     return this;
   }
   ellipse(xDist, yDist, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep2 = false) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
+    const [px, py] = planeToLocal(this.plane, this.pointer);
     return this.ellipseTo(
-      [xDist + pointer.x, yDist + pointer.y],
+      [xDist + px, yDist + py],
       horizontalRadius,
       verticalRadius,
       rotation,
@@ -8778,15 +8426,15 @@ class Sketcher {
     );
   }
   halfEllipseTo(end, verticalRadius, sweep2 = false) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    const start = [pointer.x, pointer.y];
+    const [px, py] = planeToLocal(this.plane, this.pointer);
+    const start = [px, py];
     const angle = polarAngle2d(end, start);
     const distance = distance2d(end, start);
     return this.ellipseTo(end, distance / 2, verticalRadius, angle * RAD2DEG, false, sweep2);
   }
   halfEllipse(xDist, yDist, verticalRadius, sweep2 = false) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    return this.halfEllipseTo([xDist + pointer.x, yDist + pointer.y], verticalRadius, sweep2);
+    const [px, py] = planeToLocal(this.plane, this.pointer);
+    return this.halfEllipseTo([xDist + px, yDist + py], verticalRadius, sweep2);
   }
   bezierCurveTo(end, controlPoints) {
     let cp;
@@ -8795,8 +8443,8 @@ class Sketcher {
     } else {
       cp = controlPoints;
     }
-    const inWorldPoints = cp.map((p) => this.plane.toWorldCoords(p));
-    const endPoint = this.plane.toWorldCoords(end);
+    const inWorldPoints = cp.map((p) => planeToWorld(this.plane, p));
+    const endPoint = planeToWorld(this.plane, end);
     this.pendingEdges.push(makeBezierCurve([this.pointer, ...inWorldPoints, endPoint]));
     this._updatePointer(endPoint);
     return this;
@@ -8811,35 +8459,35 @@ class Sketcher {
     const [r, gc] = localGC();
     try {
       const { endTangent, startTangent, startFactor, endFactor } = defaultsSplineConfig(config);
-      const endPoint = this.plane.toWorldCoords(end);
+      const endPoint = planeToWorld(this.plane, end);
       const previousEdge = this.pendingEdges.length ? this.pendingEdges[this.pendingEdges.length - 1] : null;
-      const defaultDistance = r(endPoint.sub(this.pointer)).Length * 0.25;
+      const diff = vecSub(endPoint, this.pointer);
+      const defaultDistance = vecLength(diff) * 0.25;
       let startPoleDirection;
       if (startTangent) {
-        startPoleDirection = this.plane.toWorldCoords(startTangent);
+        startPoleDirection = planeToWorld(this.plane, startTangent);
       } else if (!previousEdge) {
-        startPoleDirection = this.plane.toWorldCoords([1, 0]);
+        startPoleDirection = planeToWorld(this.plane, [1, 0]);
       } else if (previousEdge.geomType === "BEZIER_CURVE") {
         const rawCurve = r(previousEdge.curve).wrapped.Bezier().get();
-        const previousPole = r(new Vector(rawCurve.Pole(rawCurve.NbPoles() - 1)));
-        startPoleDirection = r(this.pointer.sub(previousPole));
+        const previousPole = toVec3(rawCurve.Pole(rawCurve.NbPoles() - 1));
+        startPoleDirection = vecSub(this.pointer, previousPole);
       } else {
-        startPoleDirection = r(previousEdge.tangentAt(1));
+        startPoleDirection = previousEdge.tangentAt(1);
       }
-      const poleDistance = r(
-        startPoleDirection.normalized().multiply(startFactor * defaultDistance)
+      const poleDistance = vecScale(
+        vecNormalize(startPoleDirection),
+        startFactor * defaultDistance
       );
-      const startControl = r(this.pointer.add(poleDistance));
+      const startControl = vecAdd(this.pointer, poleDistance);
       let endPoleDirection;
       if (endTangent === "symmetric") {
-        endPoleDirection = r(startPoleDirection.multiply(-1));
+        endPoleDirection = vecScale(startPoleDirection, -1);
       } else {
-        endPoleDirection = r(this.plane.toWorldCoords(endTangent));
+        endPoleDirection = planeToWorld(this.plane, endTangent);
       }
-      const endPoleDistance = r(
-        endPoleDirection.normalized().multiply(endFactor * defaultDistance)
-      );
-      const endControl = r(endPoint.sub(endPoleDistance));
+      const endPoleDistance = vecScale(vecNormalize(endPoleDirection), endFactor * defaultDistance);
+      const endControl = vecSub(endPoint, endPoleDistance);
       this.pendingEdges.push(makeBezierCurve([this.pointer, startControl, endControl, endPoint]));
       this._updatePointer(endPoint);
       return this;
@@ -8848,17 +8496,15 @@ class Sketcher {
     }
   }
   smoothSpline(xDist, yDist, splineConfig = {}) {
-    const pointer = this.plane.toLocalCoords(this.pointer);
-    return this.smoothSplineTo([xDist + pointer.x, yDist + pointer.y], splineConfig);
+    const [px, py] = planeToLocal(this.plane, this.pointer);
+    return this.smoothSplineTo([xDist + px, yDist + py], splineConfig);
   }
   _mirrorWireOnStartEnd(wire) {
-    const [r, gc] = localGC();
-    const diff = r(this.pointer.sub(this.firstPoint));
-    const startToEndVector = r(diff.normalize());
-    const normal = r(startToEndVector.cross(this.plane.zDir));
+    const diff = vecSub(this.pointer, this.firstPoint);
+    const startToEndVector = vecNormalize(diff);
+    const normal = vecCross(startToEndVector, this.plane.zDir);
     const mirroredWire = wire.clone().mirror(normal, this.pointer);
     const combinedWire = unwrap(assembleWire$1([wire, mirroredWire]));
-    gc();
     return combinedWire;
   }
   buildWire() {
@@ -8870,9 +8516,9 @@ class Sketcher {
     return wire;
   }
   _closeSketch() {
-    if (!this.pointer.equals(this.firstPoint) && !this._mirrorWire) {
-      const endpoint = this.plane.toLocalCoords(this.firstPoint);
-      this.lineTo([endpoint.x, endpoint.y]);
+    if (!vecEquals(this.pointer, this.firstPoint) && !this._mirrorWire) {
+      const [endX, endY] = planeToLocal(this.plane, this.firstPoint);
+      this.lineTo([endX, endY]);
     }
   }
   done() {
@@ -8984,17 +8630,17 @@ class CompoundSketch {
     twistAngle,
     origin
   } = {}) {
-    const [r, gc] = localGC();
-    const rawVec = r(new Vector(extrusionDirection || this.outerSketch.defaultDirection));
-    const normVec = r(rawVec.normalized());
-    const extrusionVec = r(normVec.multiply(extrusionDistance));
+    const [, gc] = localGC();
+    const rawVec = extrusionDirection ? toVec3(extrusionDirection) : this.outerSketch.defaultDirection;
+    const normVec = vecNormalize(rawVec);
+    const extrusionVec = vecScale(normVec, extrusionDistance);
     let result;
     if (extrusionProfile && !twistAngle) {
       result = solidFromShellGenerator(
         this.sketches,
         (sketch) => complexExtrude$1(
           sketch.wire,
-          origin || this.outerSketch.defaultOrigin,
+          origin ? toVec3(origin) : this.outerSketch.defaultOrigin,
           extrusionVec,
           extrusionProfile,
           true
@@ -9006,7 +8652,7 @@ class CompoundSketch {
         (sketch) => twistExtrude$1(
           sketch.wire,
           twistAngle,
-          origin || this.outerSketch.defaultOrigin,
+          origin ? toVec3(origin) : this.outerSketch.defaultOrigin,
           extrusionVec,
           extrusionProfile,
           true
@@ -9024,7 +8670,11 @@ class CompoundSketch {
    */
   revolve(revolutionAxis, { origin } = {}) {
     return unwrap(
-      revolution(this.face(), origin || this.outerSketch.defaultOrigin, revolutionAxis)
+      revolution(
+        this.face(),
+        origin ? toVec3(origin) : this.outerSketch.defaultOrigin,
+        revolutionAxis
+      )
     );
   }
   loftWith(otherCompound, loftConfig) {
@@ -9078,38 +8728,35 @@ class Sketches {
   }
 }
 const sketchCircle = (radius, planeConfig = {}) => {
-  const plane = planeConfig.plane instanceof Plane ? makePlane(planeConfig.plane) : makePlane(planeConfig.plane, planeConfig.origin);
+  const plane = planeConfig.plane && typeof planeConfig.plane !== "string" ? { ...planeConfig.plane } : resolvePlane(planeConfig.plane ?? "XY", planeConfig.origin);
   const wire = unwrap(assembleWire$1([makeCircle(radius, plane.origin, plane.zDir)]));
   const sketch = new Sketch(wire, {
-    defaultOrigin: plane.origin,
-    defaultDirection: plane.zDir
+    defaultOrigin: [...plane.origin],
+    defaultDirection: [...plane.zDir]
   });
-  plane.delete();
   return sketch;
 };
 const sketchEllipse = (xRadius = 1, yRadius = 2, planeConfig = {}) => {
-  const plane = planeConfig.plane instanceof Plane ? makePlane(planeConfig.plane) : makePlane(planeConfig.plane, planeConfig.origin);
-  const xDir = new Vector(plane.xDir);
+  const plane = planeConfig.plane && typeof planeConfig.plane !== "string" ? { ...planeConfig.plane } : resolvePlane(planeConfig.plane ?? "XY", planeConfig.origin);
+  let xDir = plane.xDir;
   let majR = xRadius;
   let minR = yRadius;
   if (yRadius > xRadius) {
-    xDir.rotate(90, plane.origin, plane.zDir);
+    xDir = vecRotate(xDir, plane.zDir, 90 * DEG2RAD);
     majR = yRadius;
     minR = xRadius;
   }
   const wire = unwrap(
     assembleWire$1([unwrap(makeEllipse(majR, minR, plane.origin, plane.zDir, xDir))])
   );
-  xDir.delete();
   const sketch = new Sketch(wire, {
-    defaultOrigin: plane.origin,
-    defaultDirection: plane.zDir
+    defaultOrigin: [...plane.origin],
+    defaultDirection: [...plane.zDir]
   });
-  plane.delete();
   return sketch;
 };
 const sketchRectangle = (xLength, yLength, planeConfig = {}) => {
-  const sketcher = planeConfig.plane instanceof Plane ? new Sketcher(planeConfig.plane) : new Sketcher(planeConfig.plane, planeConfig.origin);
+  const sketcher = planeConfig.plane && typeof planeConfig.plane !== "string" ? new Sketcher(planeConfig.plane) : new Sketcher(planeConfig.plane, planeConfig.origin);
   return sketcher.movePointerTo([-xLength / 2, -yLength / 2]).hLine(xLength).vLine(yLength).hLine(-xLength).vLine(-yLength).done();
 };
 const sketchRoundedRectangle = (width, height, r = 0, planeConfig = {}) => {
@@ -9125,7 +8772,7 @@ const sketchPolysides = (radius, sidesCount, sagitta = 0, planeConfig = {}) => {
     const theta = -(Math.PI * 2 / sidesCount) * i;
     return [radius * Math.sin(theta), radius * Math.cos(theta)];
   });
-  const sketcher = planeConfig.plane instanceof Plane ? new Sketcher(planeConfig.plane) : new Sketcher(planeConfig.plane, planeConfig.origin);
+  const sketcher = planeConfig.plane && typeof planeConfig.plane !== "string" ? new Sketcher(planeConfig.plane) : new Sketcher(planeConfig.plane, planeConfig.origin);
   const lastPoint = points[points.length - 1];
   const sketch = sketcher.movePointerTo([
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -9147,37 +8794,35 @@ const polysideInnerRadius = (outerRadius, sidesCount, sagitta = 0) => {
   return innerRadius + sagitta;
 };
 const sketchFaceOffset = (face, offset2) => {
-  const defaultOrigin = face.center;
-  const defaultDirection = face.normalAt();
+  const defaultOrigin = [...face.center];
+  const defaultDirection = [...face.normalAt()];
   const wire = unwrap(face.outerWire().offset2D(offset2));
   const sketch = new Sketch(wire, { defaultOrigin, defaultDirection });
-  defaultOrigin.delete();
-  defaultDirection.delete();
   return sketch;
 };
 const sketchParametricFunction = (func, planeConfig = {}, { pointsCount = 400, start = 0, stop = 1 } = {}, approximationConfig = {}) => {
   const [r, gc] = localGC();
-  const plane = r(
-    planeConfig.plane instanceof Plane ? makePlane(planeConfig.plane) : makePlane(planeConfig.plane, planeConfig.origin)
-  );
+  const plane = planeConfig.plane && typeof planeConfig.plane !== "string" ? { ...planeConfig.plane } : resolvePlane(planeConfig.plane ?? "XY", planeConfig.origin);
   const stepSize = (stop - start) / pointsCount;
   const points = [...Array(pointsCount + 1).keys()].map((t) => {
     const point = func(start + t * stepSize);
-    return r(plane.toWorldCoords(point));
+    return planeToWorld(plane, point);
   });
   const wire = unwrap(
     assembleWire$1([r(unwrap(makeBSplineApproximation(points, approximationConfig)))])
   );
   const sketch = new Sketch(wire, {
-    defaultOrigin: plane.origin,
-    defaultDirection: plane.zDir
+    defaultOrigin: [...plane.origin],
+    defaultDirection: [...plane.zDir]
   });
   gc();
   return sketch;
 };
 const sketchHelix = (pitch, height, radius, center = [0, 0, 0], dir = [0, 0, 1], lefthand = false) => {
+  const centerVec3 = toVec3(center);
+  const dirVec3 = toVec3(dir);
   return new Sketch(
-    unwrap(assembleWire$1(makeHelix(pitch, height, radius, center, dir, lefthand).wires))
+    unwrap(assembleWire$1(makeHelix(pitch, height, radius, centerVec3, dirVec3, lefthand).wires))
   );
 };
 const makeBaseBox = (xLength, yLength, zLength) => {
@@ -9558,78 +9203,84 @@ function lookFromPlane(projectionPlane) {
   );
 }
 function defaultXDir(direction) {
-  const [r, gc] = localGC();
-  const dir = r(new Vector(direction));
-  let yAxis = r(new Vector([0, 0, 1]));
-  let xAxis = yAxis.cross(dir);
-  if (xAxis.Length === 0) {
-    xAxis.delete();
-    yAxis = r(new Vector([0, 1, 0]));
-    xAxis = yAxis.cross(dir);
+  const dir = toVec3(direction);
+  const yAxis = [0, 0, 1];
+  let xAxis = vecCross(yAxis, dir);
+  if (vecLength(xAxis) === 0) {
+    const yAxis2 = [0, 1, 0];
+    xAxis = vecCross(yAxis2, dir);
   }
-  gc();
-  return xAxis.normalize();
+  return vecNormalize(xAxis);
 }
 class ProjectionCamera extends WrappingObj {
   constructor(position = [0, 0, 0], direction = [0, 0, 1], xAxis) {
-    const [r, gc] = localGC();
-    const xDir = xAxis ? r(new Vector(xAxis)) : r(defaultXDir(direction));
-    const ax2 = makeAx2(position, direction, xDir);
-    gc();
+    const pos = toVec3(position);
+    const dir = toVec3(direction);
+    const xDir = xAxis ? toVec3(xAxis) : defaultXDir(direction);
+    const ax2 = makeOcAx2(pos, dir, xDir);
     super(ax2);
   }
   get position() {
-    return new Vector(this.wrapped.Location());
+    return fromOcPnt(this.wrapped.Location());
   }
   get direction() {
-    return new Vector(this.wrapped.Direction());
+    return fromOcDir(this.wrapped.Direction());
   }
   get xAxis() {
-    return new Vector(this.wrapped.XDirection());
+    return fromOcDir(this.wrapped.XDirection());
   }
   get yAxis() {
-    return new Vector(this.wrapped.YDirection());
+    return fromOcDir(this.wrapped.YDirection());
   }
   autoAxes() {
     const [r, gc] = localGC();
-    const dir = r(this.direction);
-    const xAxis = r(defaultXDir(dir));
-    const ocDir = r(asDir(xAxis));
+    const dir = this.direction;
+    const xAxis = defaultXDir(dir);
+    const ocDir = r(toOcDir(xAxis));
     this.wrapped.SetXDirection(ocDir);
     gc();
   }
   setPosition(position) {
     const [r, gc] = localGC();
-    const pnt2 = r(asPnt(position));
+    const pnt2 = r(toOcPnt(toVec3(position)));
     this.wrapped.SetLocation(pnt2);
     gc();
     return this;
   }
   setXAxis(xAxis) {
     const [r, gc] = localGC();
-    const dir = r(asDir(xAxis));
+    const dir = r(toOcDir(toVec3(xAxis)));
     this.wrapped.SetXDirection(dir);
     gc();
     return this;
   }
   setYAxis(yAxis) {
     const [r, gc] = localGC();
-    const dir = r(asDir(yAxis));
+    const dir = r(toOcDir(toVec3(yAxis)));
     this.wrapped.SetYDirection(dir);
     gc();
     return this;
   }
   lookAt(shape) {
     const [r, gc] = localGC();
-    const lookAtPoint = r(
-      new Vector(
-        "boundingBox" in shape ? shape.boundingBox.center : shape
-      )
-    );
-    const pos = r(this.position);
-    const diff = r(pos.sub(lookAtPoint));
-    const direction = r(diff.normalized());
-    const ocDir = r(direction.toDir());
+    let lookAtPoint;
+    if (typeof shape === "object" && "wrapped" in shape) {
+      const bounds = getBounds(shape);
+      lookAtPoint = [
+        (bounds.xMin + bounds.xMax) / 2,
+        (bounds.yMin + bounds.yMax) / 2,
+        (bounds.zMin + bounds.zMax) / 2
+      ];
+    } else {
+      lookAtPoint = toVec3(shape);
+    }
+    const pos = this.position;
+    const diff = vecNormalize([
+      pos[0] - lookAtPoint[0],
+      pos[1] - lookAtPoint[1],
+      pos[2] - lookAtPoint[2]
+    ]);
+    const ocDir = r(toOcDir(diff));
     this.wrapped.SetDirection(ocDir);
     gc();
     this.autoAxes();
@@ -10017,66 +9668,6 @@ function scaleDrawing(drawing, factor, center) {
 function mirrorDrawing(drawing, centerOrDirection, origin, mode) {
   return drawing.mirror(centerOrDirection, origin, mode);
 }
-function createPlane(origin, xDirection = null, normal = [0, 0, 1]) {
-  const zDir = vecNormalize(normal);
-  if (vecIsZero(zDir)) throw new Error("Plane normal must be non-zero");
-  let xDir;
-  if (!xDirection) {
-    const ax3 = makeOcAx3(origin, zDir);
-    const ocXDir = ax3.XDirection();
-    xDir = vecNormalize([ocXDir.X(), ocXDir.Y(), ocXDir.Z()]);
-    ocXDir.delete();
-    ax3.delete();
-  } else {
-    xDir = vecNormalize(xDirection);
-  }
-  if (vecIsZero(xDir)) throw new Error("Plane xDir must be non-zero");
-  const yDir = vecNormalize(vecCross(zDir, xDir));
-  return { origin, xDir, yDir, zDir };
-}
-const PLANES_CONFIG = {
-  XY: { xDir: [1, 0, 0], normal: [0, 0, 1] },
-  YZ: { xDir: [0, 1, 0], normal: [1, 0, 0] },
-  ZX: { xDir: [0, 0, 1], normal: [0, 1, 0] },
-  XZ: { xDir: [1, 0, 0], normal: [0, -1, 0] },
-  YX: { xDir: [0, 1, 0], normal: [0, 0, -1] },
-  ZY: { xDir: [0, 0, 1], normal: [-1, 0, 0] },
-  front: { xDir: [1, 0, 0], normal: [0, 0, 1] },
-  back: { xDir: [-1, 0, 0], normal: [0, 0, -1] },
-  left: { xDir: [0, 0, 1], normal: [-1, 0, 0] },
-  right: { xDir: [0, 0, -1], normal: [1, 0, 0] },
-  top: { xDir: [1, 0, 0], normal: [0, 1, 0] },
-  bottom: { xDir: [1, 0, 0], normal: [0, -1, 0] }
-};
-function createNamedPlane(name, sourceOrigin = [0, 0, 0]) {
-  const config = PLANES_CONFIG[name];
-  if (!config) return err(validationError("UNKNOWN_PLANE", `Could not find plane ${name}`));
-  let origin;
-  if (typeof sourceOrigin === "number") {
-    origin = vecScale(config.normal, sourceOrigin);
-  } else {
-    origin = toVec3(sourceOrigin);
-  }
-  return ok(createPlane(origin, config.xDir, config.normal));
-}
-function resolvePlane(input, origin) {
-  if (typeof input === "string") {
-    const result = createNamedPlane(input, origin);
-    if (!result.ok) throw new Error(result.error.message);
-    return result.value;
-  }
-  return input;
-}
-function translatePlane(plane, offset2) {
-  return { ...plane, origin: vecAdd(plane.origin, offset2) };
-}
-function pivotPlane(plane, angleDeg, axis = [1, 0, 0]) {
-  const angleRad = angleDeg * DEG2RAD;
-  const newZDir = vecRotate(plane.zDir, axis, angleRad);
-  const newXDir = vecRotate(plane.xDir, axis, angleRad);
-  const newYDir = vecNormalize(vecCross(newZDir, newXDir));
-  return { origin: plane.origin, xDir: newXDir, yDir: newYDir, zDir: newZDir };
-}
 function makeSpineWire(start, end) {
   const oc = getKernel().oc;
   const r = gcWithScope();
@@ -10586,7 +10177,6 @@ exports.BaseSketcher2d = BaseSketcher2d;
 exports.Blueprint = Blueprint;
 exports.BlueprintSketcher = BlueprintSketcher;
 exports.Blueprints = Blueprints;
-exports.BoundingBox = BoundingBox;
 exports.BoundingBox2d = BoundingBox2d;
 exports.BrepBugError = BrepBugError;
 exports.CompSolid = CompSolid;
@@ -10613,7 +10203,6 @@ exports.HASH_CODE_MAX = HASH_CODE_MAX;
 exports.LinearPhysicalProperties = LinearPhysicalProperties;
 exports.LinearShape = _1DShape;
 exports.OK = OK;
-exports.Plane = Plane;
 exports.ProjectionCamera = ProjectionCamera;
 exports.RAD2DEG = RAD2DEG;
 exports.Shape = Shape;
@@ -10625,8 +10214,6 @@ exports.Solid = Solid;
 exports.SolidShape = _3DShape;
 exports.Surface = Surface;
 exports.SurfacePhysicalProperties = SurfacePhysicalProperties;
-exports.Transformation = Transformation;
-exports.Vector = Vector;
 exports.Vertex = Vertex;
 exports.VolumePhysicalProperties = VolumePhysicalProperties;
 exports.Wire = Wire;
@@ -10636,8 +10223,6 @@ exports._3DShape = _3DShape;
 exports.addHolesInFace = addHolesInFace;
 exports.andThen = andThen;
 exports.applyGlue = applyGlue$1;
-exports.asDir = asDir;
-exports.asPnt = asPnt;
 exports.asTopo = asTopo;
 exports.assembleWire = assembleWire$1;
 exports.axis2d = axis2d;
@@ -10670,7 +10255,6 @@ exports.createBlueprint = createBlueprint;
 exports.createCamera = createCamera;
 exports.createDistanceQuery = createDistanceQuery;
 exports.createHandle = createHandle;
-exports.createNamedPlane = createNamedPlane$1;
 exports.createOcHandle = createOcHandle;
 exports.createPlane = createPlane;
 exports.curve2dBoundingBox = curve2dBoundingBox;
@@ -10818,9 +10402,6 @@ exports.localGC = localGC;
 exports.loft = loft;
 exports.loftWires = loftWires;
 exports.lookFromPlane = lookFromPlane;
-exports.makeAx1 = makeAx1;
-exports.makeAx2 = makeAx2;
-exports.makeAx3 = makeAx3;
 exports.makeBSplineApproximation = makeBSplineApproximation;
 exports.makeBaseBox = makeBaseBox;
 exports.makeBezierCurve = makeBezierCurve;