opengeometry 2.0.10 → 2.0.13

package/index.js

@@ -239,9 +239,245 @@ function passArrayJsValueToWasm0(array, malloc) {
   WASM_VECTOR_LEN = array.length;
   return ptr;
 }
+function passArrayF64ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 8, 8) >>> 0;
+  getFloat64ArrayMemory0().set(arg, ptr / 8);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function getArrayJsValueFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  const mem = getDataViewMemory0();
+  const result = [];
+  for (let i = ptr; i < ptr + 4 * len; i += 4) {
+    result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+  }
+  wasm.__externref_drop_slice(ptr, len);
+  return result;
+}
 function isLikeNone(x) {
   return x === undefined || x === null;
 }
+/**
+ * Wasm entry point: analyze a flat `[x0,y0,z0,…]` loop, returning the report as
+ * JSON (the corrected points are not returned here; use the kernel API).
+ * @param {Float64Array} flat_points
+ * @returns {string}
+ */
+function analyzeProfile(flat_points) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArrayF64ToWasm0(flat_points, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.analyzeProfile(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Wasm entry point: check a serialized B-rep's geometric validity, returning
+ * the [`ValidityReport`] as JSON.
+ * @param {string} brep_json
+ * @returns {string}
+ */
+function checkBrepValidity(brep_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.checkBrepValidity(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Wasm entry point: heal a serialized B-rep, returning JSON
+ * `{ "brep": <healed brep>, "report": <heal report> }`.
+ * @param {string} brep_json
+ * @param {number} tolerance
+ * @returns {string}
+ */
+function healBrep(brep_json, tolerance) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.healBrep(ptr0, len0, tolerance);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Wasm entry point: offset a centreline by `width` into stroked regions via the
+ * deterministic analytic offset. `centreline_flat` is `[x0,y0,z0, …]`. Returns
+ * CW-outer / CCW-hole regions, canonicalised; empty (does NOT throw) when degenerate.
+ * @param {Float64Array} centreline_flat
+ * @param {number} width
+ * @param {boolean} closed
+ * @param {number} miter_limit
+ * @returns {OGOffsetRegionsResult}
+ */
+function offsetPolylineRegions$1(centreline_flat, width, closed, miter_limit) {
+  const ptr0 = passArrayF64ToWasm0(centreline_flat, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.offsetPolylineRegions(ptr0, len0, width, closed, miter_limit);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return OGOffsetRegionsResult.__wrap(ret[0]);
+}
+
+/**
+ * Wasm entry point: merge a GROUP of separate polylines (a crossing T / X / L
+ * overlap) into one clean stroked region by nonzero-winding union of their mitered
+ * bands. `polylines_json` is `[{centreline:[x,y,z,…], width, closed}, …]`. Returns
+ * CW-outer / CCW-hole regions (one or more); empty when nothing is buildable.
+ * @param {string} polylines_json
+ * @returns {OGOffsetRegionsResult}
+ */
+function offsetPolylineGroupRegions$1(polylines_json) {
+  const ptr0 = passStringToWasm0(polylines_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.offsetPolylineGroupRegions(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return OGOffsetRegionsResult.__wrap(ret[0]);
+}
+
+/**
+ * Wasm entry point: inset a CLOSED ring inward with one distance per edge
+ * (edge i = ring[i] → ring[i+1]). `ring_flat` is `[x0,y0,z0, …]`;
+ * `holes_json` is `[{ring:[x,y,z,…], distances:[…]}, …]` (`"[]"` = none) —
+ * excluded interior rings, each grown outward by its own per-edge distances.
+ * Returns CW-outer / CCW-hole regions, canonicalised; possibly several when a
+ * deep inset (or a hole) splits the ring, and empty (does NOT throw) when the
+ * inset collapses or the outer ring is degenerate. THROWS on malformed
+ * arguments: a distance count that does not match an edge count, a negative /
+ * non-finite distance, a degenerate hole, or unparsable `holes_json`. Corners
+ * where distances differ are circumscribed clearance arcs (conservative), so
+ * no output point is ever closer to an edge than that edge's distance —
+ * there is no miter-limit knob because there are no miters.
+ * @param {Float64Array} ring_flat
+ * @param {Float64Array} distances
+ * @param {string} holes_json
+ * @returns {OGOffsetRegionsResult}
+ */
+function offsetRingVariable$1(ring_flat, distances, holes_json) {
+  const ptr0 = passArrayF64ToWasm0(ring_flat, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(distances, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(holes_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.offsetRingVariable(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return OGOffsetRegionsResult.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} local_brep_serialized
+ * @param {number} height
+ * @returns {string}
+ */
+function extrudeBrepFace$1(local_brep_serialized, height) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.extrudeBrepFace(ptr0, len0, height);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Wasm entry point for general extrude. `direction` is `[x,y,z]`; `extent_kind`
+ * is `"one_sided" | "symmetric" | "two_sided"`; `d_plus`/`d_minus` are the
+ * extent distances (`d_minus` ignored unless two-sided, `d_plus` is the
+ * distance for one-sided/symmetric).
+ * @param {string} local_brep_serialized
+ * @param {Float64Array} direction
+ * @param {string} extent_kind
+ * @param {number} d_plus
+ * @param {number} d_minus
+ * @returns {string}
+ */
+function extrudeBrepFaceDirectional(local_brep_serialized, direction, extent_kind, d_plus, d_minus) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(direction, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(extent_kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.extrudeBrepFaceDirectional(ptr0, len0, ptr1, len1, ptr2, len2, d_plus, d_minus);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+
 /**
  * Wasm entry point for union.
  * @param {string} lhs_brep_serialized
@@ -327,40 +563,22 @@ function booleanSubtractionMany(lhs_brep_serialized, cutters_brep_serialized, op
 }
 
 /**
- * @param {string} local_brep_serialized
- * @param {number} height
- * @returns {string}
+ * Wasm entry point for array-backed batched union. Accepts a JSON array of
+ * serialized BReps and folds them with `batch_union` in one boundary crossing.
+ * @param {string} operands_brep_serialized
+ * @param {string | null} [options_json]
+ * @returns {OGBooleanResult}
  */
-function extrudeBrepFace$1(local_brep_serialized, height) {
-  let deferred3_0;
-  let deferred3_1;
-  try {
-    const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.extrudeBrepFace(ptr0, len0, height);
-    var ptr2 = ret[0];
-    var len2 = ret[1];
-    if (ret[3]) {
-      ptr2 = 0;
-      len2 = 0;
-      throw takeFromExternrefTable0(ret[2]);
-    }
-    deferred3_0 = ptr2;
-    deferred3_1 = len2;
-    return getStringFromWasm0(ptr2, len2);
-  } finally {
-    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
-  }
-}
-function getArrayJsValueFromWasm0(ptr, len) {
-  ptr = ptr >>> 0;
-  const mem = getDataViewMemory0();
-  const result = [];
-  for (let i = ptr; i < ptr + 4 * len; i += 4) {
-    result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+function batchUnion(operands_brep_serialized, options_json) {
+  const ptr0 = passStringToWasm0(operands_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  var ptr1 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  var len1 = WASM_VECTOR_LEN;
+  const ret = wasm.batchUnion(ptr0, len0, ptr1, len1);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
   }
-  wasm.__externref_drop_slice(ptr, len);
-  return result;
+  return OGBooleanResult.__wrap(ret[0]);
 }
 const Matrix3Finalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
@@ -1731,6 +1949,221 @@ class OGCylinder {
     return Vector3.__wrap(ret);
   }
 }
+const OGEllipticalArcFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogellipticalarc_free(ptr >>> 0, 1));
+class OGEllipticalArc {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OGEllipticalArcFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_ogellipticalarc_free(ptr, 0);
+  }
+  /**
+   * @param {string} id
+   */
+  set id(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.ogellipticalarc_set_id(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @returns {string}
+   */
+  get id() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogellipticalarc_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {string} id
+   */
+  constructor(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ogellipticalarc_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    OGEllipticalArcFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {Vector3} center
+   * @param {number} radius_x
+   * @param {number} radius_z
+   * @param {number} start_angle
+   * @param {number} end_angle
+   * @param {number} segments
+   */
+  set_config(center, radius_x, radius_z, start_angle, end_angle, segments) {
+    _assertClass(center, Vector3);
+    var ptr0 = center.__destroy_into_raw();
+    const ret = wasm.ogellipticalarc_set_config(this.__wbg_ptr, ptr0, radius_x, radius_z, start_angle, end_angle, segments);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {Vector3} center
+   */
+  set_center(center) {
+    _assertClass(center, Vector3);
+    var ptr0 = center.__destroy_into_raw();
+    wasm.ogellipticalarc_set_center(this.__wbg_ptr, ptr0);
+  }
+  /**
+   * @param {Vector3} position
+   * @param {Vector3} rotation
+   * @param {Vector3} scale
+   */
+  set_transform(position, rotation, scale) {
+    _assertClass(position, Vector3);
+    var ptr0 = position.__destroy_into_raw();
+    _assertClass(rotation, Vector3);
+    var ptr1 = rotation.__destroy_into_raw();
+    _assertClass(scale, Vector3);
+    var ptr2 = scale.__destroy_into_raw();
+    const ret = wasm.ogellipticalarc_set_transform(this.__wbg_ptr, ptr0, ptr1, ptr2);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {Vector3} translation
+   */
+  set_translation(translation) {
+    _assertClass(translation, Vector3);
+    var ptr0 = translation.__destroy_into_raw();
+    wasm.ogellipticalarc_set_translation(this.__wbg_ptr, ptr0);
+  }
+  /**
+   * @param {Vector3} rotation
+   */
+  set_rotation(rotation) {
+    _assertClass(rotation, Vector3);
+    var ptr0 = rotation.__destroy_into_raw();
+    wasm.ogellipticalarc_set_rotation(this.__wbg_ptr, ptr0);
+  }
+  /**
+   * @param {Vector3} scale
+   */
+  set_scale(scale) {
+    _assertClass(scale, Vector3);
+    var ptr0 = scale.__destroy_into_raw();
+    const ret = wasm.ogellipticalarc_set_scale(this.__wbg_ptr, ptr0);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  generate_geometry() {
+    const ret = wasm.ogellipticalarc_generate_geometry(this.__wbg_ptr);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  dispose_points() {
+    wasm.ogellipticalarc_dispose_points(this.__wbg_ptr);
+  }
+  destroy() {
+    wasm.ogellipticalarc_destroy(this.__wbg_ptr);
+  }
+  /**
+   * @returns {string}
+   */
+  get_brep_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogellipticalarc_get_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get_local_brep_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogellipticalarc_get_local_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogellipticalarc_get_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get_local_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogellipticalarc_get_local_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {Float64Array}
+   */
+  get_geometry_buffer() {
+    const ret = wasm.ogellipticalarc_get_geometry_buffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   * @returns {Float64Array}
+   */
+  get_local_geometry_buffer() {
+    const ret = wasm.ogellipticalarc_get_local_geometry_buffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   * @returns {Vector3}
+   */
+  get_anchor() {
+    const ret = wasm.ogellipticalarc_get_anchor(this.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+}
 const OGEntityRegistryFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
@@ -2818,7 +3251,7 @@ class OGLine {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -2872,6 +3305,50 @@ class OGLine {
     }
   }
 }
+const OGOffsetRegionsResultFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogoffsetregionsresult_free(ptr >>> 0, 1));
+/**
+ * Result payload for a polyline offset: a list of regions (each an outer ring +
+ * inner-void holes). Normally one region; a self-crossing closed centreline (e.g.
+ * a figure-8) yields one per simple sub-loop. The deterministic analytic offset —
+ * no extrude/solid. Used to build the plan polygons + extruded base solids in JS.
+ */
+class OGOffsetRegionsResult {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(OGOffsetRegionsResult.prototype);
+    obj.__wbg_ptr = ptr;
+    OGOffsetRegionsResultFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OGOffsetRegionsResultFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_ogoffsetregionsresult_free(ptr, 0);
+  }
+  /**
+   * @returns {string}
+   */
+  get regionsSerialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogoffsetregionsresult_regionsSerialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+}
 const OGPolygonFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
@@ -3444,7 +3921,7 @@ class OGPolyline {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -4772,7 +5249,7 @@ class OGSphere {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogsphere_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
 }
@@ -5154,7 +5631,7 @@ class OGSweep {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogsweep_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogellipticalarc_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -5686,46 +6163,140 @@ class Vector3 {
    *
    * @returns {Vector3}
    */
-  normalize() {
-    const ret = wasm.vector3_normalize(this.__wbg_ptr);
+  normalize() {
+    const ret = wasm.vector3_normalize(this.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   *
+   *  * Calculate the cross product and return the result as a new Vector3
+   *
+   * @param {Vector3} other
+   * @returns {Vector3}
+   */
+  cross(other) {
+    _assertClass(other, Vector3);
+    const ret = wasm.vector3_cross(this.__wbg_ptr, other.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   *
+   *  * Calculate the distance between this vector and another Vector3 instance.
+   *  * Return the distance as a f64 value in Euclidean space.
+   *
+   * @param {Vector3} other
+   * @returns {number}
+   */
+  distance(other) {
+    _assertClass(other, Vector3);
+    const ret = wasm.vector3_distance(this.__wbg_ptr, other.__wbg_ptr);
+    return ret;
+  }
+  /**
+   *
+   *  * Apply a transformation matrix to the vector.
+   *  * This method assumes the transformation matrix is a 4x4 matrix.
+   *
+   * @param {Matrix4} matrix
+   */
+  apply_matrix4(matrix) {
+    _assertClass(matrix, Matrix4);
+    var ptr0 = matrix.__destroy_into_raw();
+    wasm.vector3_apply_matrix4(this.__wbg_ptr, ptr0);
+  }
+}
+const WorkPlaneFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_workplane_free(ptr >>> 0, 1));
+class WorkPlane {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(WorkPlane.prototype);
+    obj.__wbg_ptr = ptr;
+    WorkPlaneFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    WorkPlaneFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_workplane_free(ptr, 0);
+  }
+  /**
+   * Builds a work plane from an origin and normal, choosing a stable in-plane
+   * `u` axis automatically (`v = normal × u`).
+   * @param {Vector3} origin
+   * @param {Vector3} normal
+   * @returns {WorkPlane}
+   */
+  static fromOriginNormal(origin, normal) {
+    _assertClass(origin, Vector3);
+    var ptr0 = origin.__destroy_into_raw();
+    _assertClass(normal, Vector3);
+    var ptr1 = normal.__destroy_into_raw();
+    const ret = wasm.workplane_fromOriginNormal(ptr0, ptr1);
+    return WorkPlane.__wrap(ret);
+  }
+  /**
+   * Builds a work plane from an origin, normal, and a preferred `u` axis. The
+   * `u` axis is projected onto the plane and orthonormalized; `v = normal × u`.
+   * @param {Vector3} origin
+   * @param {Vector3} normal
+   * @param {Vector3} u_hint
+   */
+  constructor(origin, normal, u_hint) {
+    _assertClass(origin, Vector3);
+    var ptr0 = origin.__destroy_into_raw();
+    _assertClass(normal, Vector3);
+    var ptr1 = normal.__destroy_into_raw();
+    _assertClass(u_hint, Vector3);
+    var ptr2 = u_hint.__destroy_into_raw();
+    const ret = wasm.workplane_new(ptr0, ptr1, ptr2);
+    this.__wbg_ptr = ret >>> 0;
+    WorkPlaneFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Lifts a single 2D in-plane coordinate to 3D world space.
+   * @param {number} u
+   * @param {number} v
+   * @returns {Vector3}
+   */
+  liftPoint(u, v) {
+    const ret = wasm.workplane_liftPoint(this.__wbg_ptr, u, v);
     return Vector3.__wrap(ret);
   }
   /**
-   *
-   *  * Calculate the cross product and return the result as a new Vector3
-   *
-   * @param {Vector3} other
-   * @returns {Vector3}
+   * Lifts a flat `[u0,v0,u1,v1,…]` buffer to a flat `[x0,y0,z0,…]` world buffer.
+   * @param {Float64Array} uv
+   * @returns {Float64Array}
    */
-  cross(other) {
-    _assertClass(other, Vector3);
-    const ret = wasm.vector3_cross(this.__wbg_ptr, other.__wbg_ptr);
-    return Vector3.__wrap(ret);
+  liftPoints(uv) {
+    const ptr0 = passArrayF64ToWasm0(uv, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.workplane_liftPoints(this.__wbg_ptr, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
   }
   /**
-   *
-   *  * Calculate the distance between this vector and another Vector3 instance.
-   *  * Return the distance as a f64 value in Euclidean space.
-   *
-   * @param {Vector3} other
-   * @returns {number}
+   * @returns {Vector3}
    */
-  distance(other) {
-    _assertClass(other, Vector3);
-    const ret = wasm.vector3_distance(this.__wbg_ptr, other.__wbg_ptr);
-    return ret;
+  get origin() {
+    const ret = wasm.workplane_origin(this.__wbg_ptr);
+    return Vector3.__wrap(ret);
   }
   /**
-   *
-   *  * Apply a transformation matrix to the vector.
-   *  * This method assumes the transformation matrix is a 4x4 matrix.
-   *
-   * @param {Matrix4} matrix
+   * @returns {Vector3}
    */
-  apply_matrix4(matrix) {
-    _assertClass(matrix, Matrix4);
-    var ptr0 = matrix.__destroy_into_raw();
-    wasm.vector3_apply_matrix4(this.__wbg_ptr, ptr0);
+  get normal() {
+    const ret = wasm.workplane_normal(this.__wbg_ptr);
+    return Vector3.__wrap(ret);
   }
 }
 async function __wbg_load(module, imports) {
@@ -5857,11 +6428,13 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     OGCuboid: OGCuboid,
     OGCurve: OGCurve,
     OGCylinder: OGCylinder,
+    OGEllipticalArc: OGEllipticalArc,
     OGEntityRegistry: OGEntityRegistry,
     OGFreeformEditor: OGFreeformEditor,
     OGFreeformGeometry: OGFreeformGeometry,
     OGIfcExportResult: OGIfcExportResult,
     OGLine: OGLine,
+    OGOffsetRegionsResult: OGOffsetRegionsResult,
     OGPolygon: OGPolygon,
     OGPolyline: OGPolyline,
     OGRectangle: OGRectangle,
@@ -5872,13 +6445,22 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     OGSweep: OGSweep,
     OGWedge: OGWedge,
     Vector3: Vector3,
+    WorkPlane: WorkPlane,
+    analyzeProfile: analyzeProfile,
+    batchUnion: batchUnion,
     booleanIntersection: booleanIntersection$1,
     booleanSubtraction: booleanSubtraction$1,
     booleanSubtractionMany: booleanSubtractionMany,
     booleanUnion: booleanUnion$1,
+    checkBrepValidity: checkBrepValidity,
     default: __wbg_init,
     extrudeBrepFace: extrudeBrepFace$1,
-    initSync: initSync
+    extrudeBrepFaceDirectional: extrudeBrepFaceDirectional,
+    healBrep: healBrep,
+    initSync: initSync,
+    offsetPolylineGroupRegions: offsetPolylineGroupRegions$1,
+    offsetPolylineRegions: offsetPolylineRegions$1,
+    offsetRingVariable: offsetRingVariable$1
 });
 
 function spotLabelElement() {
@@ -7469,6 +8051,214 @@ class Curve extends THREE.Line {
     }
 }
 
+/**
+ * EllipticalArc wrapper backed by the kernel OGEllipticalArc primitive.
+ */
+class EllipticalArc extends THREE.Line {
+    set color(color) {
+        this.options.color = color;
+        if (this.material instanceof THREE.LineBasicMaterial) {
+            this.material.color.set(color);
+        }
+        if (this.fatLine && this.fatLine.material instanceof LineMaterial) {
+            this.fatLine.material.color.set(color);
+        }
+    }
+    constructor(options) {
+        var _a, _b, _c, _d;
+        super();
+        this.options = {
+            center: new Vector3(0, 0, 0),
+            radiusX: 1.0,
+            radiusZ: 0.5,
+            startAngle: 0,
+            endAngle: Math.PI * 2,
+            segments: 32,
+            color: 0x00ff00,
+            fatLines: false,
+            width: 20,
+            translation: new Vector3(0, 0, 0),
+            rotation: new Vector3(0, 0, 0),
+            scale: new Vector3(1, 1, 1),
+        };
+        this.fatLine = null;
+        this.ogid = (_a = options === null || options === void 0 ? void 0 : options.ogid) !== null && _a !== void 0 ? _a : getUUID();
+        this.ellipticalArc = new OGEllipticalArc(this.ogid);
+        this.options = Object.assign(Object.assign({}, this.options), options);
+        this.options.ogid = this.ogid;
+        this.setConfig({
+            center: this.options.center.clone(),
+            radiusX: this.options.radiusX,
+            radiusZ: this.options.radiusZ,
+            startAngle: this.options.startAngle,
+            endAngle: this.options.endAngle,
+            segments: this.options.segments,
+            color: this.options.color,
+            fatLines: this.options.fatLines,
+            width: this.options.width,
+        });
+        this.setPlacement({
+            translation: (_b = this.options.translation) === null || _b === void 0 ? void 0 : _b.clone(),
+            rotation: (_c = this.options.rotation) === null || _c === void 0 ? void 0 : _c.clone(),
+            scale: (_d = this.options.scale) === null || _d === void 0 ? void 0 : _d.clone(),
+        });
+    }
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for EllipticalArc");
+        }
+    }
+    setConfig(options) {
+        this.validateOptions();
+        const nextOptions = Object.assign(Object.assign({}, this.options), options);
+        const geometryChanged = "center" in options ||
+            "radiusX" in options ||
+            "radiusZ" in options ||
+            "segments" in options ||
+            "startAngle" in options ||
+            "endAngle" in options;
+        const renderChanged = "color" in options ||
+            "fatLines" in options ||
+            "width" in options;
+        this.options = nextOptions;
+        if (geometryChanged) {
+            this.ellipticalArc.set_config(nextOptions.center.clone(), nextOptions.radiusX, nextOptions.radiusZ, nextOptions.startAngle, nextOptions.endAngle, nextOptions.segments);
+            this.generateGeometry();
+            return;
+        }
+        if (renderChanged) {
+            this.updateRenderStyle();
+        }
+    }
+    getAnchor() {
+        const anchor = this.ellipticalArc.get_anchor();
+        return new Vector3(anchor.x, anchor.y, anchor.z);
+    }
+    setPlacement(placement) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        this.options.translation = (_b = (_a = placement.translation) === null || _a === void 0 ? void 0 : _a.clone()) !== null && _b !== void 0 ? _b : this.options.translation;
+        this.options.rotation = (_d = (_c = placement.rotation) === null || _c === void 0 ? void 0 : _c.clone()) !== null && _d !== void 0 ? _d : this.options.rotation;
+        this.options.scale = (_f = (_e = placement.scale) === null || _e === void 0 ? void 0 : _e.clone()) !== null && _f !== void 0 ? _f : this.options.scale;
+        this.ellipticalArc.set_transform((_h = (_g = this.options.translation) === null || _g === void 0 ? void 0 : _g.clone()) !== null && _h !== void 0 ? _h : new Vector3(0, 0, 0), (_k = (_j = this.options.rotation) === null || _j === void 0 ? void 0 : _j.clone()) !== null && _k !== void 0 ? _k : new Vector3(0, 0, 0), (_m = (_l = this.options.scale) === null || _l === void 0 ? void 0 : _l.clone()) !== null && _m !== void 0 ? _m : new Vector3(1, 1, 1));
+        this.generateGeometry();
+    }
+    setTransform(translation, rotation, scale) {
+        this.setPlacement({ translation, rotation, scale });
+    }
+    setTranslation(translation) {
+        this.setPlacement({ translation });
+    }
+    setRotation(rotation) {
+        this.setPlacement({ rotation });
+    }
+    setScale(scale) {
+        this.setPlacement({ scale });
+    }
+    getConfig() {
+        return this.options;
+    }
+    getPlacement() {
+        return clonePlacement({
+            translation: this.options.translation,
+            rotation: this.options.rotation,
+            scale: this.options.scale,
+        });
+    }
+    getEditCapabilities() {
+        return createParametricEditCapabilities("elliptical_arc", "curve");
+    }
+    canConvertToFreeform() {
+        return true;
+    }
+    toFreeform(id = this.ogid) {
+        if (!this.canConvertToFreeform()) {
+            throw new Error("This entity cannot be converted to freeform.");
+        }
+        return createFreeformGeometry(this.ellipticalArc.get_local_brep_serialized(), {
+            id,
+            placement: this.getPlacement(),
+        });
+    }
+    getCurrentPositions() {
+        const attribute = this.geometry.getAttribute("position");
+        if (!attribute || attribute.itemSize !== 3) {
+            return [];
+        }
+        const positions = [];
+        for (let index = 0; index < attribute.count; index += 1) {
+            positions.push(attribute.getX(index), attribute.getY(index), attribute.getZ(index));
+        }
+        return positions;
+    }
+    updateRenderStyle(bufferData) {
+        var _a;
+        const positions = bufferData !== null && bufferData !== void 0 ? bufferData : this.getCurrentPositions();
+        if (this.options.fatLines) {
+            if (!this.fatLine) {
+                this.fatLine = new Line2(new LineGeometry(), new LineMaterial({
+                    color: this.options.color,
+                    linewidth: this.options.width,
+                    resolution: new THREE.Vector2(window.innerWidth, window.innerHeight),
+                }));
+                this.add(this.fatLine);
+            }
+            this.fatLine.geometry.setPositions(positions);
+            this.fatLine.material.color.set(this.options.color);
+            this.fatLine.material.linewidth = (_a = this.options.width) !== null && _a !== void 0 ? _a : 5;
+            this.fatLine.material.resolution.set(window.innerWidth, window.innerHeight);
+            this.fatLine.visible = true;
+        }
+        else if (this.fatLine) {
+            this.fatLine.visible = false;
+        }
+        if (this.material instanceof THREE.LineBasicMaterial) {
+            this.material.color.set(this.options.color);
+            this.material.visible = !this.options.fatLines;
+        }
+    }
+    generateGeometry() {
+        const bufferData = Array.from(this.ellipticalArc.get_geometry_buffer());
+        this.writePositionsToGeometry(this.geometry, bufferData);
+        this.geometry.computeBoundingBox();
+        this.geometry.computeBoundingSphere();
+        if (this.material instanceof THREE.LineBasicMaterial) {
+            this.material.color.set(this.options.color);
+        }
+        else {
+            if (Array.isArray(this.material)) {
+                this.material.forEach((material) => material.dispose());
+            }
+            else {
+                this.material.dispose();
+            }
+            this.material = new THREE.LineBasicMaterial({ color: this.options.color });
+        }
+        this.updateRenderStyle(bufferData);
+    }
+    getBrep() {
+        const brepData = this.ellipticalArc.get_brep_serialized();
+        if (!brepData) {
+            throw new Error("Brep data is not available for EllipticalArc");
+        }
+        return JSON.parse(brepData);
+    }
+    discardGeometry() {
+        this.geometry.dispose();
+    }
+    writePositionsToGeometry(geometry, positions) {
+        const existing = geometry.getAttribute("position");
+        if (!(existing instanceof THREE.BufferAttribute) ||
+            existing.itemSize !== 3 ||
+            existing.count !== positions.length / 3) {
+            geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+            return;
+        }
+        const array = existing.array;
+        array.set(positions);
+        existing.needsUpdate = true;
+    }
+}
+
 const DEFAULT_OUTLINE_COLOR = 0x000000;
 const DEFAULT_OUTLINE_WIDTH = 1;
 function getOutlineResolution() {
@@ -10697,6 +11487,139 @@ function createOffsetExample(scene) {
     };
 }
 
+/**
+ * Offset a centreline by ±half-width into one or more filled REGIONS, via the
+ * deterministic analytic offset — miters / flat bevels at `miterLimit`, concave
+ * trims, and nonzero-winding resolution of reflex / closed loops. NO boolean union
+ * (so it is deterministic, unlike the 3D-mesh CSG path). A simple centreline returns
+ * one region; a self-crossing closed centreline (e.g. a figure-8) returns one per
+ * simple sub-loop. Returns an EMPTY array for a genuinely unbuildable input (does
+ * not throw, so it never looks like a kernel crash). Rings are CW-outer / CCW-holes.
+ *
+ * @param centrelineFlat centreline points as `[x,y,z, …]`.
+ * @param width full stroke width (offset ±width/2 on each side).
+ * @param miterLimit SVG stroke-miterlimit; corners sharper than this bevel. Default 4.
+ */
+function offsetPolylineRegions(centrelineFlat, width, closed, miterLimit = 4) {
+    const buildExport = offsetPolylineRegions$1;
+    if (typeof buildExport !== "function") {
+        throw new Error("offsetPolylineRegions is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
+    }
+    const flat = centrelineFlat instanceof Float64Array ? centrelineFlat : new Float64Array(centrelineFlat);
+    const result = buildExport(flat, width, closed, miterLimit);
+    return JSON.parse(result.regionsSerialized);
+}
+/**
+ * Inset a CLOSED ring inward with one distance per edge (edge i =
+ * `ring[i] → ring[i+1]`; an explicit closing duplicate point is accepted and
+ * stripped, the distance count stays one per unique edge). Built for setback
+ * envelopes: the result is the CLEARANCE-EXACT buildable region — the ring's
+ * interior minus every point within `distances[i]` of edge i's SEGMENT, so
+ * distant lot lines are honoured across notches and corners where distances
+ * differ become circumscribed clearance arcs (conservative). There is no
+ * `miterLimit` parameter, deliberately: miters and bevels only approximate the
+ * clearance arc, and a bevel would claim points inside the required distance.
+ *
+ * `holes` are excluded interior rings, each grown outward by its own per-edge
+ * distances — the region keeps clear of a hole's edges exactly as it keeps
+ * clear of the lot lines, so a hole can split the region or swallow it.
+ *
+ * Returns CW-outer / CCW-hole regions (canonical start vertex), possibly
+ * SEVERAL when a deep inset (or a hole) splits a waisted ring into disjoint
+ * lobes, and an EMPTY array when the inset collapses or the outer ring is
+ * degenerate (< 3 unique points, zero area, self-intersecting). THROWS on
+ * malformed arguments: a distance count that does not match an edge count, a
+ * negative / non-finite distance, or a degenerate hole — those are caller
+ * bugs, not geometry.
+ *
+ * @param ring closed ring points as `[x,y,z, …]` (Y is carried through).
+ * @param distances inward inset distance per edge, metres, each >= 0
+ *                  (0 = the edge stays in place, e.g. lot-line construction).
+ * @param holes excluded interior rings with their own per-edge distances.
+ */
+function offsetRingVariable(ring, distances, holes = []) {
+    const buildExport = offsetRingVariable$1;
+    if (typeof buildExport !== "function") {
+        throw new Error("offsetRingVariable is not available in the loaded wasm package. It requires opengeometry >= 2.0.12 — rebuild or upgrade the opengeometry wasm bindings.");
+    }
+    const flatRing = ring instanceof Float64Array ? ring : new Float64Array(ring);
+    const flatDistances = distances instanceof Float64Array ? distances : new Float64Array(distances);
+    const holesJson = JSON.stringify(holes.map((hole) => ({ ring: Array.from(hole.ring), distances: Array.from(hole.distances) })));
+    const result = buildExport(flatRing, flatDistances, holesJson);
+    return JSON.parse(result.regionsSerialized);
+}
+/**
+ * Merge a GROUP of separate polylines (a crossing T / X / L overlap) into one clean
+ * region by nonzero-winding union of their mitered bands — the overlapping strokes
+ * merge into a single region with mitered/bevelled corners, no internal edges.
+ * Returns CW-outer / CCW-hole regions (one or more); empty if nothing is buildable.
+ * No CSG. Used to render/extrude an overlapping crossing as one joined mass.
+ */
+function offsetPolylineGroupRegions(polylines) {
+    const buildExport = offsetPolylineGroupRegions$1;
+    if (typeof buildExport !== "function") {
+        throw new Error("offsetPolylineGroupRegions is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
+    }
+    const result = buildExport(JSON.stringify(polylines));
+    return JSON.parse(result.regionsSerialized);
+}
+
+/** Close a kernel ring for Polyline rendering (repeat the first point). */
+function closedRingPoints(ring) {
+    const points = ring.map((point) => new Vector3(point.x, point.y, point.z));
+    if (points.length > 0) {
+        const first = ring[0];
+        points.push(new Vector3(first.x, first.y, first.z));
+    }
+    return points;
+}
+/**
+ * Variable (per-edge) ring inset: a rectangular "parcel" inset by front 6 /
+ * side 1.5 / rear 3 setbacks, and a waisted (dumbbell) parcel whose uniform
+ * 3 m inset SPLITS into two disjoint buildable envelopes — the case a uniform
+ * offset cannot express.
+ */
+function createOffsetRingVariableExample(scene) {
+    const scale = 0.2; // metres → scene units, keeps both parcels in frame
+    const parcel = [0, 0, 0, 20, 0, 0, 20, 0, 30, 0, 0, 30].map((v) => v * scale);
+    const parcelSetbacks = [6, 1.5, 3, 1.5].map((v) => v * scale);
+    const dumbbell = [
+        0, 0, 0, 20, 0, 0, 20, 0, 14, 12, 0, 14, 12, 0, 26, 20, 0, 26, 20, 0, 40, 0, 0, 40, 0, 0, 26,
+        8, 0, 26, 8, 0, 14, 0, 0, 14,
+    ].map((v, index) => (index % 3 === 0 ? v * scale + 6 : v * scale)); // shifted +x
+    const dumbbellSetbacks = new Array(12).fill(3 * scale);
+    const parcelOutline = new Polyline({
+        points: closedRingPoints(Array.from({ length: parcel.length / 3 }, (_, i) => ({
+            x: parcel[i * 3],
+            y: parcel[i * 3 + 1],
+            z: parcel[i * 3 + 2],
+        }))),
+        color: 0x1f2937,
+    });
+    scene.add(parcelOutline);
+    const dumbbellOutline = new Polyline({
+        points: closedRingPoints(Array.from({ length: dumbbell.length / 3 }, (_, i) => ({
+            x: dumbbell[i * 3],
+            y: dumbbell[i * 3 + 1],
+            z: dumbbell[i * 3 + 2],
+        }))),
+        color: 0x1f2937,
+    });
+    scene.add(dumbbellOutline);
+    const envelopes = [];
+    for (const region of offsetRingVariable(parcel, parcelSetbacks)) {
+        const envelope = new Polyline({ points: closedRingPoints(region.outer), color: 0x16a34a });
+        envelopes.push(envelope);
+        scene.add(envelope);
+    }
+    for (const region of offsetRingVariable(dumbbell, dumbbellSetbacks)) {
+        const envelope = new Polyline({ points: closedRingPoints(region.outer), color: 0xdc2626 });
+        envelopes.push(envelope);
+        scene.add(envelope);
+    }
+    return { parcelOutline, dumbbellOutline, envelopes };
+}
+
 const EPSILON = 1.0e-9;
 function areClose(a, b) {
     const dx = a.x - b.x;
@@ -11209,5 +12132,5 @@ class OpenGeometry {
 OpenGeometry.version = OPEN_GEOMETRY_THREE_VERSION;
 OpenGeometry.instance = null;
 
-export { Arc, BooleanError, BooleanResult, CoincidentFacesError, Cuboid, Curve, CutterExceedsHostError, Cylinder, FreeformEditor, FreeformGeometry, Line, NonManifoldOutputError, OGSceneManager, OpenGeometry, Opening, OverlappingCuttersError, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, describeWallSubtractError, executeBooleanSubtractionMany, extrudeBrepFace, parseBooleanError, toObjectTransformation$1 as toObjectTransformation };
+export { Arc, BooleanError, BooleanResult, CoincidentFacesError, Cuboid, Curve, CutterExceedsHostError, Cylinder, EllipticalArc, FreeformEditor, FreeformGeometry, Line, NonManifoldOutputError, OGSceneManager, OpenGeometry, Opening, OverlappingCuttersError, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createOffsetRingVariableExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, describeWallSubtractError, executeBooleanSubtractionMany, extrudeBrepFace, offsetPolylineGroupRegions, offsetPolylineRegions, offsetRingVariable, parseBooleanError, toObjectTransformation$1 as toObjectTransformation };
 //# sourceMappingURL=index.js.map