opengeometry 0.0.3 → 0.0.5

package/index.js

@@ -44,6 +44,30 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 let wasm;
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_export_2.set(idx, obj);
+  return idx;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
 const cachedTextDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', {
   ignoreBOM: true,
   fatal: true
@@ -55,32 +79,14 @@ const cachedTextDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('
 if (typeof TextDecoder !== 'undefined') {
   cachedTextDecoder.decode();
 }
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-  }
-  return cachedUint8ArrayMemory0;
-}
 function getStringFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
-const heap = new Array(128).fill(undefined);
-heap.push(undefined, null, true, false);
-let heap_next = heap.length;
-function addHeapObject(obj) {
-  if (heap_next === heap.length) heap.push(heap.length + 1);
-  const idx = heap_next;
-  heap_next = heap[idx];
-  heap[idx] = obj;
-  return idx;
-}
 function _assertClass(instance, klass) {
   if (!(instance instanceof klass)) {
     throw new Error(`expected instance of ${klass.name}`);
   }
-  return instance.ptr;
 }
 let WASM_VECTOR_LEN = 0;
 const cachedTextEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : {
@@ -137,41 +143,44 @@ function getDataViewMemory0() {
 }
 function passArrayJsValueToWasm0(array, malloc) {
   const ptr = malloc(array.length * 4, 4) >>> 0;
-  const mem = getDataViewMemory0();
   for (let i = 0; i < array.length; i++) {
-    mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    const add = addToExternrefTable0(array[i]);
+    getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
   }
   WASM_VECTOR_LEN = array.length;
   return ptr;
 }
-function getObject(idx) {
-  return heap[idx];
-}
-function dropObject(idx) {
-  if (idx < 132) return;
-  heap[idx] = heap_next;
-  heap_next = idx;
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+  if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+    cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+  }
+  return cachedFloat64ArrayMemory0;
 }
-function takeObject(idx) {
-  const ret = getObject(idx);
-  dropObject(idx);
-  return ret;
+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(takeObject(mem.getUint32(i, true)));
+    result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
   }
+  wasm.__externref_drop_slice(ptr, len);
   return result;
 }
+function getArrayF64FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
 const BaseFlatMeshFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
 } : new FinalizationRegistry(ptr => wasm.__wbg_baseflatmesh_free(ptr >>> 0, 1));
-/**
-*/
 class BaseFlatMesh {
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
@@ -184,106 +193,102 @@ class BaseFlatMesh {
     wasm.__wbg_baseflatmesh_free(ptr, 0);
   }
   /**
-  * @returns {boolean}
-  */
+   * @returns {boolean}
+   */
   get extruded() {
     const ret = wasm.__wbg_get_baseflatmesh_extruded(this.__wbg_ptr);
     return ret !== 0;
   }
   /**
-  * @param {boolean} arg0
-  */
+   * @param {boolean} arg0
+   */
   set extruded(arg0) {
     wasm.__wbg_set_baseflatmesh_extruded(this.__wbg_ptr, arg0);
   }
   /**
-  * @returns {boolean}
-  */
+   * @returns {boolean}
+   */
   get is_mesh() {
     const ret = wasm.__wbg_get_baseflatmesh_is_mesh(this.__wbg_ptr);
     return ret !== 0;
   }
   /**
-  * @param {boolean} arg0
-  */
+   * @param {boolean} arg0
+   */
   set is_mesh(arg0) {
     wasm.__wbg_set_baseflatmesh_is_mesh(this.__wbg_ptr, arg0);
   }
   /**
-  * @returns {Vector3D}
-  */
+   * @returns {Vector3}
+   */
   get position() {
     const ret = wasm.__wbg_get_baseflatmesh_position(this.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+    return Vector3$1.__wrap(ret);
   }
   /**
-  * @param {Vector3D} arg0
-  */
+   * @param {Vector3} arg0
+   */
   set position(arg0) {
-    _assertClass(arg0, Vector3D);
+    _assertClass(arg0, Vector3$1);
     var ptr0 = arg0.__destroy_into_raw();
     wasm.__wbg_set_baseflatmesh_position(this.__wbg_ptr, ptr0);
   }
   /**
-  * @returns {Vector3D}
-  */
+   * @returns {Vector3}
+   */
   get rotation() {
     const ret = wasm.__wbg_get_baseflatmesh_rotation(this.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+    return Vector3$1.__wrap(ret);
   }
   /**
-  * @param {Vector3D} arg0
-  */
+   * @param {Vector3} arg0
+   */
   set rotation(arg0) {
-    _assertClass(arg0, Vector3D);
+    _assertClass(arg0, Vector3$1);
     var ptr0 = arg0.__destroy_into_raw();
     wasm.__wbg_set_baseflatmesh_rotation(this.__wbg_ptr, ptr0);
   }
   /**
-  * @returns {Vector3D}
-  */
+   * @returns {Vector3}
+   */
   get scale() {
     const ret = wasm.__wbg_get_baseflatmesh_scale(this.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+    return Vector3$1.__wrap(ret);
   }
   /**
-  * @param {Vector3D} arg0
-  */
+   * @param {Vector3} arg0
+   */
   set scale(arg0) {
-    _assertClass(arg0, Vector3D);
+    _assertClass(arg0, Vector3$1);
     var ptr0 = arg0.__destroy_into_raw();
     wasm.__wbg_set_baseflatmesh_scale(this.__wbg_ptr, ptr0);
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   set id(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     wasm.baseflatmesh_set_id(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.baseflatmesh_id(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.baseflatmesh_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   constructor(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
@@ -293,61 +298,51 @@ class BaseFlatMesh {
     return this;
   }
   /**
-  * @param {(Vector3D)[]} vertices
-  */
+   * @param {Vector3[]} vertices
+   */
   add_vertices(vertices) {
     const ptr0 = passArrayJsValueToWasm0(vertices, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     wasm.baseflatmesh_add_vertices(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @param {Vector3D} vertex
-  */
+   * @param {Vector3} vertex
+   */
   add_vertex(vertex) {
-    _assertClass(vertex, Vector3D);
+    _assertClass(vertex, Vector3$1);
     var ptr0 = vertex.__destroy_into_raw();
     wasm.baseflatmesh_add_vertex(this.__wbg_ptr, ptr0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   triangulate() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.baseflatmesh_triangulate(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.baseflatmesh_triangulate(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get_buffer_flush() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.baseflatmesh_get_buffer_flush(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.baseflatmesh_get_buffer_flush(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
-  /**
-  */
   reset_mesh() {
     wasm.baseflatmesh_reset_mesh(this.__wbg_ptr);
   }
@@ -358,16 +353,7 @@ const BasePolygonFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
 } : new FinalizationRegistry(ptr => wasm.__wbg_basepolygon_free(ptr >>> 0, 1));
-/**
-*/
 class BasePolygon {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(BasePolygon.prototype);
-    obj.__wbg_ptr = ptr;
-    BasePolygonFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
@@ -379,119 +365,115 @@ class BasePolygon {
     wasm.__wbg_basepolygon_free(ptr, 0);
   }
   /**
-  * @returns {boolean}
-  */
+   * @returns {boolean}
+   */
   get extruded() {
     const ret = wasm.__wbg_get_basepolygon_extruded(this.__wbg_ptr);
     return ret !== 0;
   }
   /**
-  * @param {boolean} arg0
-  */
+   * @param {boolean} arg0
+   */
   set extruded(arg0) {
     wasm.__wbg_set_basepolygon_extruded(this.__wbg_ptr, arg0);
   }
   /**
-  * @returns {number}
-  */
+   * @returns {number}
+   */
   get extruded_height() {
     const ret = wasm.__wbg_get_basepolygon_extruded_height(this.__wbg_ptr);
     return ret;
   }
   /**
-  * @param {number} arg0
-  */
+   * @param {number} arg0
+   */
   set extruded_height(arg0) {
     wasm.__wbg_set_basepolygon_extruded_height(this.__wbg_ptr, arg0);
   }
   /**
-  * @returns {boolean}
-  */
+   * @returns {boolean}
+   */
   get is_polygon() {
     const ret = wasm.__wbg_get_basepolygon_is_polygon(this.__wbg_ptr);
     return ret !== 0;
   }
   /**
-  * @param {boolean} arg0
-  */
+   * @param {boolean} arg0
+   */
   set is_polygon(arg0) {
     wasm.__wbg_set_basepolygon_is_polygon(this.__wbg_ptr, arg0);
   }
   /**
-  * @returns {Vector3D}
-  */
+   * @returns {Vector3}
+   */
   get position() {
     const ret = wasm.__wbg_get_basepolygon_position(this.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+    return Vector3$1.__wrap(ret);
   }
   /**
-  * @param {Vector3D} arg0
-  */
+   * @param {Vector3} arg0
+   */
   set position(arg0) {
-    _assertClass(arg0, Vector3D);
+    _assertClass(arg0, Vector3$1);
     var ptr0 = arg0.__destroy_into_raw();
     wasm.__wbg_set_basepolygon_position(this.__wbg_ptr, ptr0);
   }
   /**
-  * @returns {Vector3D}
-  */
+   * @returns {Vector3}
+   */
   get rotation() {
     const ret = wasm.__wbg_get_basepolygon_rotation(this.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+    return Vector3$1.__wrap(ret);
   }
   /**
-  * @param {Vector3D} arg0
-  */
+   * @param {Vector3} arg0
+   */
   set rotation(arg0) {
-    _assertClass(arg0, Vector3D);
+    _assertClass(arg0, Vector3$1);
     var ptr0 = arg0.__destroy_into_raw();
     wasm.__wbg_set_basepolygon_rotation(this.__wbg_ptr, ptr0);
   }
   /**
-  * @returns {Vector3D}
-  */
+   * @returns {Vector3}
+   */
   get scale() {
     const ret = wasm.__wbg_get_basepolygon_scale(this.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+    return Vector3$1.__wrap(ret);
   }
   /**
-  * @param {Vector3D} arg0
-  */
+   * @param {Vector3} arg0
+   */
   set scale(arg0) {
-    _assertClass(arg0, Vector3D);
+    _assertClass(arg0, Vector3$1);
     var ptr0 = arg0.__destroy_into_raw();
     wasm.__wbg_set_basepolygon_scale(this.__wbg_ptr, ptr0);
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   set id(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     wasm.basepolygon_set_id(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.basepolygon_id(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.basepolygon_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   constructor(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
@@ -501,1291 +483,1285 @@ class BasePolygon {
     return this;
   }
   /**
-  * @param {CircleArc} circle_arc
-  * @returns {BasePolygon}
-  */
-  static new_with_circle(circle_arc) {
-    _assertClass(circle_arc, CircleArc);
-    var ptr0 = circle_arc.__destroy_into_raw();
-    const ret = wasm.basepolygon_new_with_circle(ptr0);
-    return BasePolygon.__wrap(ret);
-  }
-  /**
-  * @param {OGRectangle} rectangle
-  * @returns {BasePolygon}
-  */
-  static new_with_rectangle(rectangle) {
-    _assertClass(rectangle, OGRectangle);
-    var ptr0 = rectangle.__destroy_into_raw();
-    const ret = wasm.basepolygon_new_with_rectangle(ptr0);
-    return BasePolygon.__wrap(ret);
-  }
-  /**
-  * @param {(Vector3D)[]} vertices
-  */
+   * @param {Vector3[]} vertices
+   */
   add_vertices(vertices) {
     const ptr0 = passArrayJsValueToWasm0(vertices, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     wasm.basepolygon_add_vertices(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @param {Vector3D} vertex
-  */
+   * @param {Vector3} vertex
+   */
   add_vertex(vertex) {
-    _assertClass(vertex, Vector3D);
+    _assertClass(vertex, Vector3$1);
     var ptr0 = vertex.__destroy_into_raw();
     wasm.basepolygon_add_vertex(this.__wbg_ptr, ptr0);
   }
   /**
-  * @param {(Vector3D)[]} holes
-  */
+   * @param {Vector3[]} holes
+   */
   add_holes(holes) {
     const ptr0 = passArrayJsValueToWasm0(holes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     wasm.basepolygon_add_holes(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   triangulate() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.basepolygon_triangulate(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.basepolygon_triangulate(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   new_triangulate() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.basepolygon_new_triangulate(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.basepolygon_new_triangulate(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get_buffer_flush() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.basepolygon_get_buffer_flush(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.basepolygon_get_buffer_flush(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
-  /**
-  */
   clear_vertices() {
     wasm.basepolygon_clear_vertices(this.__wbg_ptr);
   }
-  /**
-  */
   reset_polygon() {
     wasm.basepolygon_reset_polygon(this.__wbg_ptr);
   }
   /**
-  * @param {number} height
-  * @returns {string}
-  */
+   * @param {number} height
+   * @returns {string}
+   */
   extrude_by_height(height) {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.basepolygon_extrude_by_height(retptr, this.__wbg_ptr, height);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.basepolygon_extrude_by_height(this.__wbg_ptr, height);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get_outlines() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.basepolygon_get_outlines(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.basepolygon_get_outlines(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get_geometry() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.basepolygon_get_geometry(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.basepolygon_get_geometry(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
 }
-const CircleArcFinalization = typeof FinalizationRegistry === 'undefined' ? {
+typeof FinalizationRegistry === 'undefined' ? {
+  } : new FinalizationRegistry(ptr => wasm.__wbg_color_free(ptr >>> 0, 1));
+typeof FinalizationRegistry === 'undefined' ? {
+  } : new FinalizationRegistry(ptr => wasm.__wbg_colorrgb_free(ptr >>> 0, 1));
+typeof FinalizationRegistry === 'undefined' ? {
+  } : new FinalizationRegistry(ptr => wasm.__wbg_matrix3_free(ptr >>> 0, 1));
+const Matrix4Finalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
-} : new FinalizationRegistry(ptr => wasm.__wbg_circlearc_free(ptr >>> 0, 1));
+} : new FinalizationRegistry(ptr => wasm.__wbg_matrix4_free(ptr >>> 0, 1));
 /**
-*/
-class CircleArc {
+ *
+ * * Matrix4 Module
+ * * 2D Representation of a 4x4 Matrix
+ * * It's a row-major matrix.
+ *
+ */
+let Matrix4$1 = class Matrix4 {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
-    const obj = Object.create(CircleArc.prototype);
+    const obj = Object.create(Matrix4.prototype);
     obj.__wbg_ptr = ptr;
-    CircleArcFinalization.register(obj, obj.__wbg_ptr, obj);
+    Matrix4Finalization.register(obj, obj.__wbg_ptr, obj);
     return obj;
   }
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    CircleArcFinalization.unregister(this);
+    Matrix4Finalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_matrix4_free(ptr, 0);
+  }
+  /**
+   * @returns {Float64Array}
+   */
+  get elements() {
+    const ret = wasm.matrix4_elements(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   *
+   *  * Create a new Matrix4 with identity elements.
+   *
+   */
+  constructor() {
+    const ret = wasm.matrix4_new();
+    this.__wbg_ptr = ret >>> 0;
+    Matrix4Finalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {number} m0
+   * @param {number} m1
+   * @param {number} m2
+   * @param {number} m3
+   * @param {number} m4
+   * @param {number} m5
+   * @param {number} m6
+   * @param {number} m7
+   * @param {number} m8
+   * @param {number} m9
+   * @param {number} m10
+   * @param {number} m11
+   * @param {number} m12
+   * @param {number} m13
+   * @param {number} m14
+   * @param {number} m15
+   * @returns {Matrix4}
+   */
+  static set(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15) {
+    const ret = wasm.matrix4_set(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15);
+    return Matrix4.__wrap(ret);
+  }
+  /**
+   *
+   *  * Clone the Matrix4 instance and return a new one.
+   *
+   * @returns {Matrix4}
+   */
+  clone() {
+    const ret = wasm.matrix4_clone(this.__wbg_ptr);
+    return Matrix4.__wrap(ret);
+  }
+  /**
+   *
+   *  * Sets the matrix element to create an identity matrix.
+   *
+   */
+  identity() {
+    wasm.matrix4_identity(this.__wbg_ptr);
+  }
+  /**
+   *
+   *  * Determinant for a 4x4 matrix.
+   *  * https://en.wikipedia.org/wiki/Determinant
+   *
+   * @returns {number}
+   */
+  determinant() {
+    const ret = wasm.matrix4_determinant(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @returns {Matrix4}
+   */
+  adjucate() {
+    const ret = wasm.matrix4_adjucate(this.__wbg_ptr);
+    return Matrix4.__wrap(ret);
+  }
+  /**
+   *
+   *  * Inverse of a matrix
+   *  * Returns a new Matrix4 instance.
+   *  * If the determinant is zero, it returns a zero matrix.
+   *  * It can be checked with is_zero() method.
+   *
+   * @returns {Matrix4}
+   */
+  inverse() {
+    const ret = wasm.matrix4_inverse(this.__wbg_ptr);
+    return Matrix4.__wrap(ret);
+  }
+  /**
+   *
+   *  * Multiply this matrix with another Matrix4
+   *  * Returns a new Matrix4 instance
+   *
+   * @param {Matrix4} other
+   * @returns {Matrix4}
+   */
+  multiply(other) {
+    _assertClass(other, Matrix4);
+    const ret = wasm.matrix4_multiply(this.__wbg_ptr, other.__wbg_ptr);
+    return Matrix4.__wrap(ret);
+  }
+  /**
+   *
+   *  * Add another Matrix4 to this one.
+   *  * Returns a new Matrix4 instance with the result.
+   *
+   * @param {Matrix4} incoming
+   * @returns {Matrix4}
+   */
+  add(incoming) {
+    _assertClass(incoming, Matrix4);
+    const ret = wasm.matrix4_add(this.__wbg_ptr, incoming.__wbg_ptr);
+    return Matrix4.__wrap(ret);
+  }
+  /**
+   *
+   *  * Subtract another Matrix4 from this one.
+   *  * Returns a new Matrix4 instance with the result.
+   *
+   * @param {Matrix4} incoming
+   * @returns {Matrix4}
+   */
+  subtract(incoming) {
+    _assertClass(incoming, Matrix4);
+    const ret = wasm.matrix4_subtract(this.__wbg_ptr, incoming.__wbg_ptr);
+    return Matrix4.__wrap(ret);
+  }
+  /**
+   *
+   *  * Flatten the matrix into a vector of f64.
+   *
+   * @returns {Float64Array}
+   */
+  flatten() {
+    const ret = wasm.matrix4_flatten(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   *
+   *  * Get the element at a specific index in the flattened matrix.
+   *
+   * @param {number} index
+   * @returns {number | undefined}
+   */
+  get_element_at(index) {
+    const ret = wasm.matrix4_get_element_at(this.__wbg_ptr, index);
+    return ret[0] === 0 ? undefined : ret[1];
+  }
+  /**
+   *
+   *  * Check if the matrix is a zero matrix.
+   *
+   * @returns {boolean}
+   */
+  is_zero() {
+    const ret = wasm.matrix4_is_zero(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   *
+   *  * Check if the matrix is an identity matrix.
+   *
+   * @returns {boolean}
+   */
+  is_identity() {
+    const ret = wasm.matrix4_is_identity(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   *
+   *  * Create a Transpose of the matrix.
+   *  * Returns a new Matrix4 instance.
+   *
+   * @returns {Matrix4}
+   */
+  transpose() {
+    const ret = wasm.matrix4_transpose(this.__wbg_ptr);
+    return Matrix4.__wrap(ret);
+  }
+};
+const OGArcFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogarc_free(ptr >>> 0, 1));
+class OGArc {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OGArcFinalization.unregister(this);
     return ptr;
   }
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_circlearc_free(ptr, 0);
+    wasm.__wbg_ogarc_free(ptr, 0);
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   set id(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    wasm.circlearc_set_id(this.__wbg_ptr, ptr0, len0);
+    wasm.ogarc_set_id(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.circlearc_id(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogarc_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   constructor(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.circlearc_new(ptr0, len0);
+    const ret = wasm.ogarc_new(ptr0, len0);
     this.__wbg_ptr = ret >>> 0;
-    CircleArcFinalization.register(this, this.__wbg_ptr, this);
+    OGArcFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
   /**
-  * @returns {CircleArc}
-  */
-  clone() {
-    const ret = wasm.circlearc_clone(this.__wbg_ptr);
-    return CircleArc.__wrap(ret);
-  }
-  /**
-  * @param {Vector3D} center
-  * @param {number} radius
-  * @param {number} start_angle
-  * @param {number} end_angle
-  * @param {number} segments
-  */
+   * @param {Vector3} center
+   * @param {number} radius
+   * @param {number} start_angle
+   * @param {number} end_angle
+   * @param {number} segments
+   */
   set_config(center, radius, start_angle, end_angle, segments) {
-    _assertClass(center, Vector3D);
+    _assertClass(center, Vector3$1);
     var ptr0 = center.__destroy_into_raw();
-    wasm.circlearc_set_config(this.__wbg_ptr, ptr0, radius, start_angle, end_angle, segments);
-  }
-  /**
-  */
-  generate_points() {
-    wasm.circlearc_generate_points(this.__wbg_ptr);
+    wasm.ogarc_set_config(this.__wbg_ptr, ptr0, radius, start_angle, end_angle, segments);
   }
-  /**
-  * @param {number} radius
-  */
-  update_radius(radius) {
-    wasm.circlearc_update_radius(this.__wbg_ptr, radius);
-  }
-  /**
-  * @param {Vector3D} center
-  */
-  update_center(center) {
-    _assertClass(center, Vector3D);
-    var ptr0 = center.__destroy_into_raw();
-    wasm.circlearc_update_center(this.__wbg_ptr, ptr0);
+  generate_geometry() {
+    wasm.ogarc_generate_geometry(this.__wbg_ptr);
   }
-  /**
-  */
   dispose_points() {
-    wasm.circlearc_destroy(this.__wbg_ptr);
+    wasm.ogarc_dispose_points(this.__wbg_ptr);
   }
-  /**
-  */
   destroy() {
-    wasm.circlearc_destroy(this.__wbg_ptr);
+    wasm.ogarc_destroy(this.__wbg_ptr);
   }
   /**
-  * @returns {string}
-  */
-  get_points() {
+   * @returns {string}
+   */
+  get_brep_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.circlearc_get_points(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogarc_get_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {(Vector3D)[]}
-  */
-  get_raw_points() {
+   * @returns {string}
+   */
+  get_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.circlearc_get_raw_points(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 4, 4);
-      return v1;
+      const ret = wasm.ogarc_get_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
 }
-typeof FinalizationRegistry === 'undefined' ? {
-  } : new FinalizationRegistry(ptr => wasm.__wbg_color_free(ptr >>> 0, 1));
-typeof FinalizationRegistry === 'undefined' ? {
-  } : new FinalizationRegistry(ptr => wasm.__wbg_colorrgb_free(ptr >>> 0, 1));
-typeof FinalizationRegistry === 'undefined' ? {
-  } : new FinalizationRegistry(ptr => wasm.__wbg_matrix3d_free(ptr >>> 0, 1));
-const OGCylinderFinalization = typeof FinalizationRegistry === 'undefined' ? {
+const OGCubeFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
-} : new FinalizationRegistry(ptr => wasm.__wbg_ogcylinder_free(ptr >>> 0, 1));
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogcube_free(ptr >>> 0, 1));
 /**
-*/
-class OGCylinder {
+ *
+ * * Copyright (c) 2025, OpenGeometry. All rights reserved.
+ * * Box primitive for OpenGeometry.
+ * *
+ * * Base created by default on XZ plane and extruded along Y axis.
+ * *
+ * * There are two ways to create a box:
+ * * 1. By creating a box with a rectangle face, create a Rectangle Poly Face and then extrude by a given height
+ * * 2. By creating a box primitive with given width, height, and depth
+ * *
+ * * This class is used to create a box primitive(2) using width, height, and depth.
+ *
+ */
+class OGCube {
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    OGCylinderFinalization.unregister(this);
+    OGCubeFinalization.unregister(this);
     return ptr;
   }
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_ogcylinder_free(ptr, 0);
+    wasm.__wbg_ogcube_free(ptr, 0);
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   set id(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    wasm.ogcylinder_set_id(this.__wbg_ptr, ptr0, len0);
+    wasm.ogcube_set_id(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogcylinder_id(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogcube_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   constructor(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ogcylinder_new(ptr0, len0);
+    const ret = wasm.ogcube_new(ptr0, len0);
     this.__wbg_ptr = ret >>> 0;
-    OGCylinderFinalization.register(this, this.__wbg_ptr, this);
+    OGCubeFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
+  clean_geometry() {
+    wasm.ogcube_clean_geometry(this.__wbg_ptr);
+  }
   /**
-  * @param {Vector3D} center
-  * @param {number} radius
-  * @param {number} height
-  * @param {number} angle
-  * @param {number} segments
-  */
-  set_config(center, radius, height, angle, segments) {
-    _assertClass(center, Vector3D);
+   * @param {Vector3} center
+   * @param {number} width
+   * @param {number} height
+   * @param {number} depth
+   */
+  set_config(center, width, height, depth) {
+    _assertClass(center, Vector3$1);
     var ptr0 = center.__destroy_into_raw();
-    wasm.ogcylinder_set_config(this.__wbg_ptr, ptr0, radius, height, angle, segments);
+    wasm.ogcube_set_config(this.__wbg_ptr, ptr0, width, height, depth);
   }
-  /**
-  */
   generate_geometry() {
-    wasm.ogcylinder_generate_geometry(this.__wbg_ptr);
+    wasm.ogcube_generate_geometry(this.__wbg_ptr);
   }
   /**
-  * @returns {string}
-  */
-  get_geometry() {
+   * @returns {string}
+   */
+  get_brep_dump() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogcylinder_get_geometry(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogcube_get_brep_dump(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  */
-  discard_geometry() {
-    wasm.ogcylinder_discard_geometry(this.__wbg_ptr);
-  }
-  /**
-  * @returns {string}
-  */
-  outline_edges() {
+   * @returns {string}
+   */
+  get_geometry_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogcylinder_outline_edges(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogcube_get_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {string}
-  */
-  get_brep_dump() {
+   * @returns {string}
+   */
+  get_outline_geometry_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogcylinder_get_brep_dump(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogcube_get_outline_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
 }
-const OGPolyLineFinalization = typeof FinalizationRegistry === 'undefined' ? {
+const OGCylinderFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
-} : new FinalizationRegistry(ptr => wasm.__wbg_ogpolyline_free(ptr >>> 0, 1));
-/**
-*/
-class OGPolyLine {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(OGPolyLine.prototype);
-    obj.__wbg_ptr = ptr;
-    OGPolyLineFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogcylinder_free(ptr >>> 0, 1));
+class OGCylinder {
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    OGPolyLineFinalization.unregister(this);
+    OGCylinderFinalization.unregister(this);
     return ptr;
   }
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_ogpolyline_free(ptr, 0);
+    wasm.__wbg_ogcylinder_free(ptr, 0);
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   set id(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    wasm.ogpolyline_set_id(this.__wbg_ptr, ptr0, len0);
+    wasm.ogcylinder_set_id(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolyline_id(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogcylinder_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   constructor(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ogpolyline_new(ptr0, len0);
+    const ret = wasm.ogcylinder_new(ptr0, len0);
     this.__wbg_ptr = ret >>> 0;
-    OGPolyLineFinalization.register(this, this.__wbg_ptr, this);
+    OGCylinderFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
   /**
-  * @returns {OGPolyLine}
-  */
-  clone() {
-    const ret = wasm.ogpolyline_clone(this.__wbg_ptr);
-    return OGPolyLine.__wrap(ret);
-  }
-  /**
-  * @param {(Vector3D)[]} points
-  */
-  set_config(points) {
-    const ptr0 = passArrayJsValueToWasm0(points, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.ogpolyline_set_config(this.__wbg_ptr, ptr0, len0);
-  }
-  /**
-  * @param {Vector3D} point
-  */
-  add_point(point) {
-    _assertClass(point, Vector3D);
-    var ptr0 = point.__destroy_into_raw();
-    wasm.ogpolyline_add_point(this.__wbg_ptr, ptr0);
-  }
-  /**
-  */
-  dispose_points() {
-    wasm.ogpolyline_destroy(this.__wbg_ptr);
+   * @param {Vector3} center
+   * @param {number} radius
+   * @param {number} height
+   * @param {number} angle
+   * @param {number} segments
+   */
+  set_config(center, radius, height, angle, segments) {
+    _assertClass(center, Vector3$1);
+    var ptr0 = center.__destroy_into_raw();
+    wasm.ogcylinder_set_config(this.__wbg_ptr, ptr0, radius, height, angle, segments);
   }
-  /**
-  */
-  destroy() {
-    wasm.ogpolyline_destroy(this.__wbg_ptr);
+  generate_geometry() {
+    wasm.ogcylinder_generate_geometry(this.__wbg_ptr);
   }
   /**
-  * @returns {string}
-  */
-  get_points() {
+   * @returns {string}
+   */
+  get_brep_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolyline_get_points(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogcylinder_get_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {(Vector3D)[]}
-  */
-  get_raw_points() {
+   * @returns {string}
+   */
+  get_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolyline_get_raw_points(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 4, 4);
-      return v1;
+      const ret = wasm.ogcylinder_get_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {boolean}
-  */
-  is_closed() {
-    const ret = wasm.ogpolyline_is_closed(this.__wbg_ptr);
-    return ret !== 0;
-  }
-  /**
-  */
-  check_closed_test() {
-    wasm.ogpolyline_check_closed_test(this.__wbg_ptr);
+   * @returns {string}
+   */
+  get_outline_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogcylinder_get_outline_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);
+    }
   }
 }
-const OGPolygonFinalization = typeof FinalizationRegistry === 'undefined' ? {
+const OGCylinderOldFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
-} : new FinalizationRegistry(ptr => wasm.__wbg_ogpolygon_free(ptr >>> 0, 1));
-/**
-*/
-class OGPolygon {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(OGPolygon.prototype);
-    obj.__wbg_ptr = ptr;
-    OGPolygonFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogcylinderold_free(ptr >>> 0, 1));
+class OGCylinderOld {
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    OGPolygonFinalization.unregister(this);
+    OGCylinderOldFinalization.unregister(this);
     return ptr;
   }
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_ogpolygon_free(ptr, 0);
-  }
-  /**
-  * @returns {boolean}
-  */
-  get extruded() {
-    const ret = wasm.__wbg_get_ogpolygon_extruded(this.__wbg_ptr);
-    return ret !== 0;
-  }
-  /**
-  * @param {boolean} arg0
-  */
-  set extruded(arg0) {
-    wasm.__wbg_set_ogpolygon_extruded(this.__wbg_ptr, arg0);
-  }
-  /**
-  * @returns {number}
-  */
-  get extruded_height() {
-    const ret = wasm.__wbg_get_ogpolygon_extruded_height(this.__wbg_ptr);
-    return ret;
-  }
-  /**
-  * @param {number} arg0
-  */
-  set extruded_height(arg0) {
-    wasm.__wbg_set_ogpolygon_extruded_height(this.__wbg_ptr, arg0);
-  }
-  /**
-  * @returns {boolean}
-  */
-  get is_polygon() {
-    const ret = wasm.__wbg_get_ogpolygon_is_polygon(this.__wbg_ptr);
-    return ret !== 0;
-  }
-  /**
-  * @param {boolean} arg0
-  */
-  set is_polygon(arg0) {
-    wasm.__wbg_set_ogpolygon_is_polygon(this.__wbg_ptr, arg0);
-  }
-  /**
-  * @returns {Vector3D}
-  */
-  get position() {
-    const ret = wasm.__wbg_get_ogpolygon_position(this.__wbg_ptr);
-    return Vector3D.__wrap(ret);
-  }
-  /**
-  * @param {Vector3D} arg0
-  */
-  set position(arg0) {
-    _assertClass(arg0, Vector3D);
-    var ptr0 = arg0.__destroy_into_raw();
-    wasm.__wbg_set_ogpolygon_position(this.__wbg_ptr, ptr0);
-  }
-  /**
-  * @returns {Vector3D}
-  */
-  get rotation() {
-    const ret = wasm.__wbg_get_ogpolygon_rotation(this.__wbg_ptr);
-    return Vector3D.__wrap(ret);
-  }
-  /**
-  * @param {Vector3D} arg0
-  */
-  set rotation(arg0) {
-    _assertClass(arg0, Vector3D);
-    var ptr0 = arg0.__destroy_into_raw();
-    wasm.__wbg_set_ogpolygon_rotation(this.__wbg_ptr, ptr0);
-  }
-  /**
-  * @returns {Vector3D}
-  */
-  get scale() {
-    const ret = wasm.__wbg_get_ogpolygon_scale(this.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+    wasm.__wbg_ogcylinderold_free(ptr, 0);
   }
   /**
-  * @param {Vector3D} arg0
-  */
-  set scale(arg0) {
-    _assertClass(arg0, Vector3D);
-    var ptr0 = arg0.__destroy_into_raw();
-    wasm.__wbg_set_ogpolygon_scale(this.__wbg_ptr, ptr0);
-  }
-  /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   set id(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    wasm.ogpolygon_set_id(this.__wbg_ptr, ptr0, len0);
+    wasm.ogcylinderold_set_id(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_id(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogcylinderold_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   constructor(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ogpolygon_new(ptr0, len0);
+    const ret = wasm.ogcylinderold_new(ptr0, len0);
     this.__wbg_ptr = ret >>> 0;
-    OGPolygonFinalization.register(this, this.__wbg_ptr, this);
+    OGCylinderOldFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
   /**
-  * @param {CircleArc} circle_arc
-  * @returns {OGPolygon}
-  */
-  static new_with_circle(circle_arc) {
-    _assertClass(circle_arc, CircleArc);
-    var ptr0 = circle_arc.__destroy_into_raw();
-    const ret = wasm.ogpolygon_new_with_circle(ptr0);
-    return OGPolygon.__wrap(ret);
+   * @param {Vector3} center
+   * @param {number} radius
+   * @param {number} height
+   * @param {number} angle
+   * @param {number} segments
+   */
+  set_config(center, radius, height, angle, segments) {
+    _assertClass(center, Vector3$1);
+    var ptr0 = center.__destroy_into_raw();
+    wasm.ogcylinderold_set_config(this.__wbg_ptr, ptr0, radius, height, angle, segments);
   }
-  /**
-  * @param {OGRectangle} rectangle
-  * @returns {OGPolygon}
-  */
-  static new_with_rectangle(rectangle) {
-    _assertClass(rectangle, OGRectangle);
-    var ptr0 = rectangle.__destroy_into_raw();
-    const ret = wasm.ogpolygon_new_with_rectangle(ptr0);
-    return OGPolygon.__wrap(ret);
+  generate_geometry() {
+    wasm.ogcylinderold_generate_geometry(this.__wbg_ptr);
   }
   /**
-  * @param {(Vector3D)[]} vertices
-  */
-  add_vertices(vertices) {
-    const ptr0 = passArrayJsValueToWasm0(vertices, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.ogpolygon_add_vertices(this.__wbg_ptr, ptr0, len0);
+   * @returns {string}
+   */
+  get_geometry() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogcylinderold_get_geometry(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);
+    }
+  }
+  discard_geometry() {
+    wasm.ogcylinderold_discard_geometry(this.__wbg_ptr);
   }
   /**
-  * @param {Vector3D} vertex
-  */
-  add_vertex(vertex) {
-    _assertClass(vertex, Vector3D);
-    var ptr0 = vertex.__destroy_into_raw();
-    wasm.ogpolygon_add_vertex(this.__wbg_ptr, ptr0);
-  }
-  /**
-  * @param {(Vector3D)[]} holes
-  */
-  add_holes(holes) {
-    const ptr0 = passArrayJsValueToWasm0(holes, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.ogpolygon_add_holes(this.__wbg_ptr, ptr0, len0);
-  }
-  /**
-  * @returns {string}
-  */
-  triangulate() {
+   * @returns {string}
+   */
+  outline_edges() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_triangulate(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogcylinderold_outline_edges(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {boolean} is_ccw
-  * @returns {string}
-  */
-  triangulate_with_holes_variable_geometry(is_ccw) {
+   * @returns {string}
+   */
+  get_brep_dump() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_triangulate_with_holes_variable_geometry(retptr, this.__wbg_ptr, is_ccw);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogcylinderold_get_brep_dump(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
+}
+const OGLineFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogline_free(ptr >>> 0, 1));
+class OGLine {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OGLineFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_ogline_free(ptr, 0);
+  }
   /**
-  * @returns {string}
-  */
-  triangulate_with_holes() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_triangulate_with_holes(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
+   * @param {string} id
+   */
+  set id(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.ogline_set_id(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
-  get_buffer_flush() {
+   * @returns {string}
+   */
+  get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_get_buffer_flush(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogline_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  */
-  clear_vertices() {
-    wasm.ogpolygon_clear_vertices(this.__wbg_ptr);
+   * @param {string} id
+   */
+  constructor(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ogline_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    OGLineFinalization.register(this, this.__wbg_ptr, this);
+    return this;
   }
   /**
-  */
-  reset_polygon() {
-    wasm.ogpolygon_reset_polygon(this.__wbg_ptr);
+   * @param {Vector3} start
+   * @param {Vector3} end
+   */
+  set_config(start, end) {
+    _assertClass(start, Vector3$1);
+    var ptr0 = start.__destroy_into_raw();
+    _assertClass(end, Vector3$1);
+    var ptr1 = end.__destroy_into_raw();
+    wasm.ogline_set_config(this.__wbg_ptr, ptr0, ptr1);
+  }
+  generate_geometry() {
+    wasm.ogline_generate_geometry(this.__wbg_ptr);
+  }
+  dispose_points() {
+    wasm.ogline_dispose_points(this.__wbg_ptr);
+  }
+  destroy() {
+    wasm.ogline_destroy(this.__wbg_ptr);
   }
   /**
-  * @param {number} height
-  * @returns {string}
-  */
-  extrude_by_height_with_holes(height) {
+   * @returns {string}
+   */
+  get_brep_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_extrude_by_height_with_holes(retptr, this.__wbg_ptr, height);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogline_get_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {number} height
-  * @returns {string}
-  */
-  extrude_by_height(height) {
+   * @returns {string}
+   */
+  get_geometry_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_extrude_by_height(retptr, this.__wbg_ptr, height);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogline_get_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
+}
+const OGPolygonFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogpolygon_free(ptr >>> 0, 1));
+class OGPolygon {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OGPolygonFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_ogpolygon_free(ptr, 0);
+  }
   /**
-  * @returns {string}
-  */
-  get_outlines() {
+   * @param {string} id
+   */
+  set id(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.ogpolygon_set_id(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @returns {string}
+   */
+  get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_get_outlines(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogpolygon_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {string}
-  */
-  get_geometry() {
+   * @param {string} id
+   */
+  constructor(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ogpolygon_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    OGPolygonFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {Vector3[]} points
+   */
+  set_config(points) {
+    const ptr0 = passArrayJsValueToWasm0(points, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.ogpolygon_set_config(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @param {Float64Array} transformation
+   */
+  set_transformation(transformation) {
+    const ptr0 = passArrayF64ToWasm0(transformation, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.ogpolygon_set_transformation(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @param {Vector3[]} vertices
+   */
+  add_vertices(vertices) {
+    const ptr0 = passArrayJsValueToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.ogpolygon_add_vertices(this.__wbg_ptr, ptr0, len0);
+  }
+  clean_geometry() {
+    wasm.ogpolygon_clean_geometry(this.__wbg_ptr);
+  }
+  generate_geometry() {
+    wasm.ogpolygon_generate_geometry(this.__wbg_ptr);
+  }
+  /**
+   * @returns {string}
+   */
+  get_brep_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_get_geometry(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogpolygon_get_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {string}
-  */
-  get_brep_data() {
+   * @returns {string}
+   */
+  get_geometry_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_get_brep_data(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogpolygon_get_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {string}
-  */
-  outline_edges() {
+   * @returns {string}
+   */
+  get_outline_geometry_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolygon_outline_edges(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogpolygon_get_outline_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
 }
-const OGRectangleFinalization = typeof FinalizationRegistry === 'undefined' ? {
+const OGPolylineFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
-} : new FinalizationRegistry(ptr => wasm.__wbg_ogrectangle_free(ptr >>> 0, 1));
-/**
-*/
-class OGRectangle {
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogpolyline_free(ptr >>> 0, 1));
+class OGPolyline {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
-    const obj = Object.create(OGRectangle.prototype);
+    const obj = Object.create(OGPolyline.prototype);
     obj.__wbg_ptr = ptr;
-    OGRectangleFinalization.register(obj, obj.__wbg_ptr, obj);
+    OGPolylineFinalization.register(obj, obj.__wbg_ptr, obj);
     return obj;
   }
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    OGRectangleFinalization.unregister(this);
+    OGPolylineFinalization.unregister(this);
     return ptr;
   }
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_ogrectangle_free(ptr, 0);
+    wasm.__wbg_ogpolyline_free(ptr, 0);
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   set id(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    wasm.ogrectangle_set_id(this.__wbg_ptr, ptr0, len0);
+    wasm.ogpolyline_set_id(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogrectangle_id(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogpolyline_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   constructor(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ogrectangle_new(ptr0, len0);
+    const ret = wasm.ogpolyline_new(ptr0, len0);
     this.__wbg_ptr = ret >>> 0;
-    OGRectangleFinalization.register(this, this.__wbg_ptr, this);
+    OGPolylineFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
   /**
-  * @returns {OGRectangle}
-  */
+   * @returns {OGPolyline}
+   */
   clone() {
-    const ret = wasm.ogrectangle_clone(this.__wbg_ptr);
-    return OGRectangle.__wrap(ret);
+    const ret = wasm.ogpolyline_clone(this.__wbg_ptr);
+    return OGPolyline.__wrap(ret);
   }
   /**
-  * @param {Vector3D} center
-  * @param {number} width
-  * @param {number} breadth
-  */
-  set_config(center, width, breadth) {
-    _assertClass(center, Vector3D);
-    var ptr0 = center.__destroy_into_raw();
-    wasm.ogrectangle_set_config(this.__wbg_ptr, ptr0, width, breadth);
+   * @param {Vector3[]} points
+   */
+  set_config(points) {
+    const ptr0 = passArrayJsValueToWasm0(points, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.ogpolyline_set_config(this.__wbg_ptr, ptr0, len0);
   }
-  /**
-  */
-  generate_points() {
-    wasm.ogrectangle_generate_points(this.__wbg_ptr);
+  generate_geometry() {
+    wasm.ogpolyline_generate_geometry(this.__wbg_ptr);
   }
   /**
-  * @param {number} width
-  */
-  update_width(width) {
-    wasm.ogrectangle_update_width(this.__wbg_ptr, width);
+   * @param {Vector3[]} points
+   */
+  add_multiple_points(points) {
+    const ptr0 = passArrayJsValueToWasm0(points, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.ogpolyline_add_multiple_points(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @param {number} breadth
-  */
-  update_breadth(breadth) {
-    wasm.ogrectangle_update_breadth(this.__wbg_ptr, breadth);
+   * @param {Vector3} point
+   */
+  add_point(point) {
+    _assertClass(point, Vector3$1);
+    var ptr0 = point.__destroy_into_raw();
+    wasm.ogpolyline_add_point(this.__wbg_ptr, ptr0);
   }
   /**
-  * @param {Vector3D} center
-  */
-  update_center(center) {
-    _assertClass(center, Vector3D);
-    var ptr0 = center.__destroy_into_raw();
-    wasm.ogrectangle_update_center(this.__wbg_ptr, ptr0);
+   * @returns {string}
+   */
+  get_points() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogpolyline_get_points(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);
+    }
   }
   /**
-  */
-  dispose_points() {
-    wasm.ogrectangle_destroy(this.__wbg_ptr);
+   * @returns {Vector3[]}
+   */
+  get_raw_points() {
+    const ret = wasm.ogpolyline_get_raw_points(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
   }
   /**
-  */
-  destroy() {
-    wasm.ogrectangle_destroy(this.__wbg_ptr);
+   * @returns {boolean}
+   */
+  is_closed() {
+    const ret = wasm.ogpolyline_is_closed(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  check_closed_test() {
+    wasm.ogpolyline_check_closed_test(this.__wbg_ptr);
   }
   /**
-  * @returns {string}
-  */
-  get_points() {
+   * @returns {string}
+   */
+  get_brep_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogrectangle_get_points(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogpolyline_get_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {(Vector3D)[]}
-  */
-  get_raw_points() {
+   * @returns {string}
+   */
+  get_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogrectangle_get_raw_points(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 4, 4);
-      return v1;
+      const ret = wasm.ogpolyline_get_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
 }
-const OGSimpleLineFinalization = typeof FinalizationRegistry === 'undefined' ? {
+const OGRectangleFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
-} : new FinalizationRegistry(ptr => wasm.__wbg_ogsimpleline_free(ptr >>> 0, 1));
-/**
-*/
-class OGSimpleLine {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(OGSimpleLine.prototype);
-    obj.__wbg_ptr = ptr;
-    OGSimpleLineFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogrectangle_free(ptr >>> 0, 1));
+class OGRectangle {
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    OGSimpleLineFinalization.unregister(this);
+    OGRectangleFinalization.unregister(this);
     return ptr;
   }
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_ogsimpleline_free(ptr, 0);
+    wasm.__wbg_ogrectangle_free(ptr, 0);
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   set id(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    wasm.ogsimpleline_set_id(this.__wbg_ptr, ptr0, len0);
+    wasm.ogrectangle_set_id(this.__wbg_ptr, ptr0, len0);
   }
   /**
-  * @returns {string}
-  */
+   * @returns {string}
+   */
   get id() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogsimpleline_id(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogrectangle_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @param {string} id
-  */
+   * @param {string} id
+   */
   constructor(id) {
     const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ogsimpleline_new(ptr0, len0);
+    const ret = wasm.ogrectangle_new(ptr0, len0);
     this.__wbg_ptr = ret >>> 0;
-    OGSimpleLineFinalization.register(this, this.__wbg_ptr, this);
+    OGRectangleFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
   /**
-  * @returns {OGSimpleLine}
-  */
-  clone() {
-    const ret = wasm.ogsimpleline_clone(this.__wbg_ptr);
-    return OGSimpleLine.__wrap(ret);
-  }
-  /**
-  * @param {Vector3D} start
-  * @param {Vector3D} end
-  */
-  set_config(start, end) {
-    _assertClass(start, Vector3D);
-    var ptr0 = start.__destroy_into_raw();
-    _assertClass(end, Vector3D);
-    var ptr1 = end.__destroy_into_raw();
-    wasm.ogsimpleline_set_config(this.__wbg_ptr, ptr0, ptr1);
-  }
-  /**
-  */
-  dispose_points() {
-    wasm.ogsimpleline_destroy(this.__wbg_ptr);
+   * @param {Vector3} center
+   * @param {number} width
+   * @param {number} breadth
+   */
+  set_config(center, width, breadth) {
+    _assertClass(center, Vector3$1);
+    var ptr0 = center.__destroy_into_raw();
+    wasm.ogrectangle_set_config(this.__wbg_ptr, ptr0, width, breadth);
   }
-  /**
-  */
-  destroy() {
-    wasm.ogsimpleline_destroy(this.__wbg_ptr);
+  generate_geometry() {
+    wasm.ogrectangle_generate_geometry(this.__wbg_ptr);
   }
   /**
-  * @returns {string}
-  */
-  get_points() {
+   * @returns {string}
+   */
+  get_brep_serialized() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogsimpleline_get_points(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
+      const ret = wasm.ogrectangle_get_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
   /**
-  * @returns {(Vector3D)[]}
-  */
-  get_raw_points() {
+   * @returns {string}
+   */
+  get_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
     try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogsimpleline_get_raw_points(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 4, 4);
-      return v1;
+      const ret = wasm.ogrectangle_get_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
 }
-const Vector3DFinalization = typeof FinalizationRegistry === 'undefined' ? {
+const Vector3Finalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
-} : new FinalizationRegistry(ptr => wasm.__wbg_vector3d_free(ptr >>> 0, 1));
-/**
-*/
-class Vector3D {
+} : new FinalizationRegistry(ptr => wasm.__wbg_vector3_free(ptr >>> 0, 1));
+let Vector3$1 = class Vector3 {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
-    const obj = Object.create(Vector3D.prototype);
+    const obj = Object.create(Vector3.prototype);
     obj.__wbg_ptr = ptr;
-    Vector3DFinalization.register(obj, obj.__wbg_ptr, obj);
+    Vector3Finalization.register(obj, obj.__wbg_ptr, obj);
     return obj;
   }
   static __unwrap(jsValue) {
-    if (!(jsValue instanceof Vector3D)) {
+    if (!(jsValue instanceof Vector3)) {
       return 0;
     }
     return jsValue.__destroy_into_raw();
@@ -1793,142 +1769,274 @@ class Vector3D {
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    Vector3DFinalization.unregister(this);
+    Vector3Finalization.unregister(this);
     return ptr;
   }
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_vector3d_free(ptr, 0);
+    wasm.__wbg_vector3_free(ptr, 0);
   }
   /**
-  * @returns {number}
-  */
+   * @returns {number}
+   */
   get x() {
-    const ret = wasm.__wbg_get_matrix3d_m11(this.__wbg_ptr);
+    const ret = wasm.__wbg_get_vector3_x(this.__wbg_ptr);
     return ret;
   }
   /**
-  * @param {number} arg0
-  */
+   * @param {number} arg0
+   */
   set x(arg0) {
-    wasm.__wbg_set_matrix3d_m11(this.__wbg_ptr, arg0);
+    wasm.__wbg_set_vector3_x(this.__wbg_ptr, arg0);
   }
   /**
-  * @returns {number}
-  */
+   * @returns {number}
+   */
   get y() {
-    const ret = wasm.__wbg_get_matrix3d_m12(this.__wbg_ptr);
+    const ret = wasm.__wbg_get_vector3_y(this.__wbg_ptr);
     return ret;
   }
   /**
-  * @param {number} arg0
-  */
+   * @param {number} arg0
+   */
   set y(arg0) {
-    wasm.__wbg_set_matrix3d_m12(this.__wbg_ptr, arg0);
+    wasm.__wbg_set_vector3_y(this.__wbg_ptr, arg0);
   }
   /**
-  * @returns {number}
-  */
+   * @returns {number}
+   */
   get z() {
-    const ret = wasm.__wbg_get_matrix3d_m13(this.__wbg_ptr);
+    const ret = wasm.__wbg_get_vector3_z(this.__wbg_ptr);
     return ret;
   }
   /**
-  * @param {number} arg0
-  */
+   * @param {number} arg0
+   */
   set z(arg0) {
-    wasm.__wbg_set_matrix3d_m13(this.__wbg_ptr, arg0);
+    wasm.__wbg_set_vector3_z(this.__wbg_ptr, arg0);
   }
   /**
-  * @param {number} x
-  * @param {number} y
-  * @param {number} z
-  */
+   * @param {number} x
+   * @param {number} y
+   * @param {number} z
+   */
   constructor(x, y, z) {
-    const ret = wasm.vector3d_create(x, y, z);
+    const ret = wasm.vector3_new(x, y, z);
     this.__wbg_ptr = ret >>> 0;
-    Vector3DFinalization.register(this, this.__wbg_ptr, this);
+    Vector3Finalization.register(this, this.__wbg_ptr, this);
     return this;
   }
   /**
-  * @param {number} x
-  * @param {number} y
-  * @param {number} z
-  */
-  update(x, y, z) {
-    wasm.vector3d_update(this.__wbg_ptr, x, y, z);
+   *
+   *  * Add the elements of another vector to this one.
+   *
+   * @param {Vector3} other
+   * @returns {Vector3}
+   */
+  add(other) {
+    _assertClass(other, Vector3);
+    const ret = wasm.vector3_add(this.__wbg_ptr, other.__wbg_ptr);
+    return Vector3.__wrap(ret);
   }
   /**
-  * @param {Vector3D} other
-  * @returns {Vector3D}
-  */
-  add(other) {
-    _assertClass(other, Vector3D);
-    const ret = wasm.vector3d_add(this.__wbg_ptr, other.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+   *
+   *  * Add a scalar value to each element of the vector.
+   *
+   * @param {number} scalar
+   * @returns {Vector3}
+   */
+  add_scalar(scalar) {
+    const ret = wasm.vector3_add_scalar(this.__wbg_ptr, scalar);
+    return Vector3.__wrap(ret);
   }
   /**
-  * @param {Vector3D} other
-  * @returns {Vector3D}
-  */
+   *
+   *  * Subtract the elements of another vector from this one.
+   *
+   * @param {Vector3} other
+   * @returns {Vector3}
+   */
   subtract(other) {
-    _assertClass(other, Vector3D);
-    const ret = wasm.vector3d_subtract(this.__wbg_ptr, other.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+    _assertClass(other, Vector3);
+    const ret = wasm.vector3_subtract(this.__wbg_ptr, other.__wbg_ptr);
+    return Vector3.__wrap(ret);
   }
   /**
-  * @param {number} scalar
-  * @returns {Vector3D}
-  */
-  add_scalar(scalar) {
-    const ret = wasm.vector3d_add_scalar(this.__wbg_ptr, scalar);
-    return Vector3D.__wrap(ret);
+   *
+   *  * Subtract a scalar value from each element of the vector.
+   *
+   * @param {number} scalar
+   * @returns {Vector3}
+   */
+  subtract_scalar(scalar) {
+    const ret = wasm.vector3_subtract_scalar(this.__wbg_ptr, scalar);
+    return Vector3.__wrap(ret);
   }
   /**
-  * @param {number} scalar
-  * @returns {Vector3D}
-  */
-  subtract_scalar(scalar) {
-    const ret = wasm.vector3d_subtract_scalar(this.__wbg_ptr, scalar);
-    return Vector3D.__wrap(ret);
+   *
+   *  * Clone the Vector3 instance and return a new one.
+   *
+   * @returns {Vector3}
+   */
+  clone() {
+    const ret = wasm.vector3_clone(this.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   *
+   *  * Set the current vector elements to zero.
+   *
+   */
+  zero() {
+    wasm.vector3_zero(this.__wbg_ptr);
+  }
+  /**
+   *
+   *  * Copy the elements from another Vector3 instance.
+   *
+   * @param {Vector3} other
+   */
+  copy(other) {
+    _assertClass(other, Vector3);
+    wasm.vector3_copy(this.__wbg_ptr, other.__wbg_ptr);
+  }
+  /**
+   *
+   *  * Multiply the vector by a scalar value.
+   *
+   * @param {number} scalar
+   * @returns {Vector3}
+   */
+  multiply_scalar(scalar) {
+    const ret = wasm.vector3_multiply_scalar(this.__wbg_ptr, scalar);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   *
+   *  * Multiply the vector by another Vector3 instance element-wise.
+   *
+   * @param {Vector3} other
+   * @returns {Vector3}
+   */
+  multiply(other) {
+    _assertClass(other, Vector3);
+    const ret = wasm.vector3_multiply(this.__wbg_ptr, other.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   *
+   *  * Divide the vector by another Vector3 instance element-wise.
+   *
+   * @param {Vector3} other
+   * @returns {Vector3}
+   */
+  divide(other) {
+    _assertClass(other, Vector3);
+    const ret = wasm.vector3_divide(this.__wbg_ptr, other.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   *
+   *  * Divide the vector by a scalar value.
+   *
+   * @param {number} scalar
+   * @returns {Vector3}
+   */
+  divide_scalar(scalar) {
+    const ret = wasm.vector3_divide_scalar(this.__wbg_ptr, scalar);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   *
+   *  * Invert the vector by negating the vector elements.
+   *
+   * @returns {Vector3}
+   */
+  negate() {
+    const ret = wasm.vector3_negate(this.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   *
+   *  * Calculate the dot product of this vector with another Vector3 instance.
+   *
+   * @param {Vector3} other
+   * @returns {number}
+   */
+  dot(other) {
+    _assertClass(other, Vector3);
+    const ret = wasm.vector3_dot(this.__wbg_ptr, other.__wbg_ptr);
+    return ret;
   }
   /**
-  * @param {number} height
-  * @param {Vector3D} up_vector
-  * @returns {Vector3D}
-  */
-  add_extrude_in_up(height, up_vector) {
-    _assertClass(up_vector, Vector3D);
-    var ptr0 = up_vector.__destroy_into_raw();
-    const ret = wasm.vector3d_add_extrude_in_up(this.__wbg_ptr, height, ptr0);
-    return Vector3D.__wrap(ret);
+   *
+   *  * Calculate the magnitude (length) of the vector.
+   *
+   * @returns {number}
+   */
+  magnitude() {
+    const ret = wasm.vector3_magnitude(this.__wbg_ptr);
+    return ret;
   }
   /**
-  * @param {Vector3D} other
-  * @returns {Vector3D}
-  */
-  cross(other) {
-    _assertClass(other, Vector3D);
-    const ret = wasm.vector3d_cross(this.__wbg_ptr, other.__wbg_ptr);
-    return Vector3D.__wrap(ret);
+   *
+   *  * Calculate the length of the vector.
+   *  * Since length is equivalent to magnitude, this method is an alias.
+   *
+   * @returns {number}
+   */
+  length() {
+    const ret = wasm.vector3_length(this.__wbg_ptr);
+    return ret;
   }
   /**
-  * @param {Vector3D} other
-  * @returns {number}
-  */
-  dot(other) {
-    _assertClass(other, Vector3D);
-    const ret = wasm.vector3d_dot(this.__wbg_ptr, other.__wbg_ptr);
+   *
+   *  * Normalize the vector
+   *
+   * @returns {Vector3}
+   */
+  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;
   }
   /**
-  * @returns {Vector3D}
-  */
-  clone() {
-    const ret = wasm.vector3d_clone(this.__wbg_ptr);
-    return Vector3D.__wrap(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$1);
+    var ptr0 = matrix.__destroy_into_raw();
+    wasm.vector3_apply_matrix4(this.__wbg_ptr, ptr0);
   }
-}
+};
 async function __wbg_load(module, imports) {
   if (typeof Response === 'function' && module instanceof Response) {
     if (typeof WebAssembly.instantiateStreaming === 'function') {
@@ -1936,7 +2044,7 @@ async function __wbg_load(module, imports) {
         return await WebAssembly.instantiateStreaming(module, imports);
       } catch (e) {
         if (module.headers.get('Content-Type') != 'application/wasm') {
-          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
         } else {
           throw e;
         }
@@ -1959,17 +2067,34 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
   const imports = {};
   imports.wbg = {};
-  imports.wbg.__wbg_vector3d_new = function (arg0) {
-    const ret = Vector3D.__wrap(arg0);
-    return addHeapObject(ret);
+  imports.wbg.__wbg_getRandomValues_38097e921c2494c3 = function () {
+    return handleError(function (arg0, arg1) {
+      globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+    }, arguments);
+  };
+  imports.wbg.__wbg_log_0c7c294ecbc8af77 = function (arg0) {
+    console.log(arg0);
   };
-  imports.wbg.__wbg_vector3d_unwrap = function (arg0) {
-    const ret = Vector3D.__unwrap(takeObject(arg0));
+  imports.wbg.__wbg_vector3_new = function (arg0) {
+    const ret = Vector3$1.__wrap(arg0);
     return ret;
   };
+  imports.wbg.__wbg_vector3_unwrap = function (arg0) {
+    const ret = Vector3$1.__unwrap(arg0);
+    return ret;
+  };
+  imports.wbg.__wbindgen_init_externref_table = function () {
+    const table = wasm.__wbindgen_export_2;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+  };
   imports.wbg.__wbindgen_string_new = function (arg0, arg1) {
     const ret = getStringFromWasm0(arg0, arg1);
-    return addHeapObject(ret);
+    return ret;
   };
   imports.wbg.__wbindgen_throw = function (arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
@@ -1980,14 +2105,22 @@ function __wbg_finalize_init(instance, module) {
   wasm = instance.exports;
   __wbg_init.__wbindgen_wasm_module = module;
   cachedDataViewMemory0 = null;
+  cachedFloat64ArrayMemory0 = null;
   cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
   return wasm;
 }
 async function __wbg_init(module_or_path) {
   if (wasm !== undefined) return wasm;
-  if (typeof module_or_path !== 'undefined' && Object.getPrototypeOf(module_or_path) === Object.prototype) ({
-    module_or_path
-  } = module_or_path);else console.warn('using deprecated parameters for the initialization function; pass a single object instead');
+  if (typeof module_or_path !== 'undefined') {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({
+        module_or_path
+      } = module_or_path);
+    } else {
+      console.warn('using deprecated parameters for the initialization function; pass a single object instead');
+    }
+  }
   if (typeof module_or_path === 'undefined') {
     module_or_path = new URL('opengeometry_bg.wasm', import.meta.url);
   }
@@ -12374,7 +12507,7 @@ const _sphere$1 = /*@__PURE__*/ new Sphere();
 const _intersectPointOnRay = /*@__PURE__*/ new Vector3();
 const _intersectPointOnSegment = /*@__PURE__*/ new Vector3();
 
-class Line extends Object3D {
+let Line$1 = class Line extends Object3D {
 
 	constructor( geometry = new BufferGeometry(), material = new LineBasicMaterial() ) {
 
@@ -12565,7 +12698,7 @@ class Line extends Object3D {
 
 	}
 
-}
+};
 
 function checkIntersection( object, raycaster, ray, thresholdSq, a, b ) {
 
@@ -12602,7 +12735,7 @@ function checkIntersection( object, raycaster, ray, thresholdSq, a, b ) {
 const _start = /*@__PURE__*/ new Vector3();
 const _end = /*@__PURE__*/ new Vector3();
 
-class LineSegments extends Line {
+class LineSegments extends Line$1 {
 
 	constructor( geometry, material ) {
 
@@ -13359,6 +13492,7 @@ class Pencil {
         this.onCursorMove = new Event();
         this.onElementHover = new Event();
         this.onElementSelected = new Event();
+        this.onElementUnselected = new Event();
         this.pencilMode = "cursor";
         this.container = container;
         this.scene = scene;
@@ -13382,12 +13516,14 @@ class Pencil {
         // Raycaster
         this.raycaster.params.Line.threshold = 0.1;
         // A Dummy Ground Plane
-        const geometry = new PlaneGeometry(100, 100);
+        const geometry = new PlaneGeometry(1000, 1000);
+        // const material = new THREE.MeshBasicMaterial({ color: 0xffff00, side: THREE.DoubleSide, wireframe: true });
         const material = new MeshBasicMaterial({ color: 0xffff00, side: DoubleSide, transparent: true, opacity: 0 });
         const plane = new Mesh(geometry, material);
         plane.name = "pencil-ground";
         plane.rotation.x = Math.PI / 2;
         this.scene.add(plane);
+        // plane.visible = true;
         plane.visible = false;
         this.dummyPlane = plane;
     }
@@ -13439,7 +13575,10 @@ class Pencil {
                     return;
                 }
                 const intersect = intersects[0];
-                this.onElementHover.trigger(intersect.object);
+                this.onElementHover.trigger({
+                    mesh: intersect.object,
+                    point: intersect.point
+                });
             }
         });
         this.container.addEventListener("mousedown", (event) => {
@@ -13456,10 +13595,51 @@ class Pencil {
             else if (this.pencilMode === "select") {
                 const intersects = this.raycaster.intersectObjects(this.pencilMeshes);
                 const intersect = intersects[0];
-                this.onElementSelected.trigger(intersect.object);
+                this.onElementSelected.trigger({
+                    mesh: intersect.object,
+                    point: intersect.point
+                });
+            }
+        });
+        this.container.addEventListener("mouseup", (event) => {
+            if (this.pencilMode === "select") {
+                const rect = this.container.getBoundingClientRect();
+                const x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+                const y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+                this.raycaster.setFromCamera(new Vector2(x, y), this.camera);
+                const intersects = this.raycaster.intersectObjects(this.pencilMeshes);
+                if (intersects.length > 0) {
+                    const intersect = intersects[0];
+                    this.onElementUnselected.trigger({
+                        mesh: intersect.object,
+                        point: intersect.point
+                    });
+                }
             }
         });
     }
+    fireCursor(mouse) {
+        const rect = this.container.getBoundingClientRect();
+        const x = ((mouse.clientX - rect.left) / rect.width) * 2 - 1;
+        const y = -((mouse.clientY - rect.top) / rect.height) * 2 + 1;
+        this.raycaster.setFromCamera(new Vector2(x, y), this.camera);
+        const intersects = this.raycaster.intersectObjects([this.dummyPlane]);
+        if (intersects.length > 0) {
+            const point = intersects[0].point;
+            this.onCursorDown.trigger(point);
+        }
+    }
+    fireCursorMove(mouse) {
+        const rect = this.container.getBoundingClientRect();
+        const x = ((mouse.clientX - rect.left) / rect.width) * 2 - 1;
+        const y = -((mouse.clientY - rect.top) / rect.height) * 2 + 1;
+        this.raycaster.setFromCamera(new Vector2(x, y), this.camera);
+        const intersects = this.raycaster.intersectObjects([this.dummyPlane]);
+        if (intersects.length > 0) {
+            const point = intersects[0].point;
+            this.onCursorMove.trigger(point);
+        }
+    }
 }
 
 function spotLabelElement() {
@@ -13485,88 +13665,126 @@ const OPEN_GEOMETRY_THREE_VERSION = '0.0.1';
 /**
  * Simple Line defined by Two Points
  */
-class SimpleLine extends Line {
+class Line extends Line$1 {
     set color(color) {
         if (this.material instanceof LineBasicMaterial) {
             this.material.color.set(color);
         }
     }
-    constructor(start = new Vector3D(1, 0, 0), end = new Vector3D(-1, 0, 0)) {
+    constructor(options) {
         super();
-        this.points = [];
         this.ogid = getUUID();
-        this.points.push(start);
-        this.points.push(end);
+        this.options = options;
+        this.line = new OGLine(this.ogid);
+        this.setConfig();
         this.generateGeometry();
     }
-    addPoint(point) {
-        this.points.push(point);
-        if (this.points.length > 2) {
-            throw new Error("Simple Line can only have two points, clear points or use PolyLine");
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for Line");
         }
-        if (this.points.length < 2)
-            return;
-        this.generateGeometry();
+    }
+    setConfig() {
+        this.validateOptions();
+        const { start, end } = this.options;
+        this.line.set_config(start.clone(), end.clone());
     }
     generateGeometry() {
-        const ogLine = new OGSimpleLine(this.ogid);
-        ogLine.set_config(this.points[0], this.points[1]);
-        const buf = ogLine.get_points();
-        const bufFlush = JSON.parse(buf);
-        const line = new BufferGeometry().setFromPoints(bufFlush);
-        const material = new LineBasicMaterial({ color: 0xff0000 });
-        this.geometry = line;
-        this.material = material;
+        this.line.generate_geometry();
+        const geometryData = this.line.get_geometry_serialized();
+        const bufferData = JSON.parse(geometryData);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new Float32BufferAttribute(bufferData, 3));
+        this.geometry = geometry;
+        this.material = new LineBasicMaterial({ color: 0x00ff00 });
     }
 }
 
-/**
- * PolyLine defined by multiple points
- */
-class PolyLine extends Line {
+var _Polyline_color;
+class Polyline extends Line$1 {
     set color(color) {
+        __classPrivateFieldSet(this, _Polyline_color, color, "f");
         if (this.material instanceof LineBasicMaterial) {
             this.material.color.set(color);
         }
     }
-    constructor(points = []) {
+    constructor(options) {
         super();
-        this.points = [];
+        this.options = { points: [] };
         this.isClosed = false;
+        this.transformationMatrix = new Matrix4();
+        // Properties that can be set externally but are not part of the constructor
+        // TODO: Consider making these properties part of the constructor options
+        _Polyline_color.set(this, 0x00ff00);
         this.ogid = getUUID();
-        this.points = points;
-        this.polyline = new OGPolyLine(this.ogid);
-        this.setConfig(points);
-        this.generateGeometry();
+        this.polyline = new OGPolyline(this.ogid);
+        if (options) {
+            this.options = options;
+            this.setConfig();
+            this.generateGeometry();
+        }
     }
-    setConfig(points) {
-        if (this.points.length < 2)
-            return;
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for Polyline");
+        }
+    }
+    setConfig() {
+        this.validateOptions();
+        const { points } = this.options;
         this.polyline.set_config(points);
     }
+    // addMultiplePoints(points: Vector3[]) {
+    //   this.points = points;
+    //   if (!this.polyline) return;
+    //   this.polyline.add_multiple_points(points);
+    //   this.generateGeometry();
+    // }
+    // // TODO: This needs to be improved 
+    // translate(translation: Vector3) {
+    //   if (!this.polyline) return;
+    //   this.polyline.translate(translation);
+    //   this.generateGeometry();
+    // }
+    // set_position(position: Vector3) {
+    //   if (!this.polyline) return;
+    //   this.polyline.set_position(position);
+    // }
     addPoint(point) {
-        this.points.push(point);
-        this.polyline.add_point(point);
-        if (this.points.length < 2)
+        if (!this.polyline)
             return;
+        this.polyline.add_point(point);
+        // if (this.points.length < 2) return;
+        this.clearGeometry();
         this.generateGeometry();
     }
+    /**
+     * Every time there are property changes, geometry needs to be discarded and regenerated.
+     * This is to ensure that the geometry is always up-to-date with the current state.
+     */
     clearGeometry() {
         this.geometry.dispose();
     }
+    saveTransformationToBREP() {
+        if (!this.polyline)
+            return;
+        // this.polyline.set_transformation_matrix(this.transformationMatrix.toArray());
+    }
     generateGeometry() {
-        this.clearGeometry();
-        const buf = this.polyline.get_points();
-        const bufFlush = JSON.parse(buf);
-        const line = new BufferGeometry().setFromPoints(bufFlush);
-        const material = new LineBasicMaterial({ color: 0xff0000 });
-        this.geometry = line;
-        this.material = material;
+        this.polyline.generate_geometry();
+        const geometryData = this.polyline.get_geometry_serialized();
+        const bufferData = JSON.parse(geometryData);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new Float32BufferAttribute(bufferData, 3));
+        this.geometry = geometry;
+        this.material = new LineBasicMaterial({ color: __classPrivateFieldGet(this, _Polyline_color, "f") });
         this.isClosed = this.polyline.is_closed();
     }
 }
+_Polyline_color = new WeakMap();
 
-class BaseCircle extends Line {
+var _Arc_color;
+class Arc extends Line$1 {
     set color(color) {
         if (this.material instanceof LineBasicMaterial) {
             this.material.color.set(color);
@@ -13574,103 +13792,136 @@ class BaseCircle extends Line {
     }
     constructor(options) {
         super();
-        // nodeChild: CirclePoly | null = null;
-        this.nodeOperation = "none";
+        // TODO: Create local properties for all Primitive classes
+        _Arc_color.set(this, 0x00ff00);
         this.ogid = getUUID();
         this.options = options;
-        this.circleArc = new CircleArc(this.ogid);
+        this.arc = new OGArc(this.ogid);
         this.setConfig();
         this.generateGeometry();
     }
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for Circle Arc");
+        }
+    }
     setConfig() {
-        const { radius, segments, position, startAngle, endAngle } = this.options;
-        this.circleArc.set_config(position, radius, startAngle, endAngle, segments);
+        this.validateOptions();
+        const { center, radius, segments, startAngle, endAngle } = this.options;
+        this.arc.set_config(center.clone(), radius, startAngle, endAngle, segments);
     }
     generateGeometry() {
-        this.circleArc.generate_points();
-        const bufRaw = this.circleArc.get_points();
-        const bufFlush = JSON.parse(bufRaw);
-        console.log(bufFlush);
-        const line = new BufferGeometry().setFromPoints(bufFlush);
-        const material = new LineBasicMaterial({ color: 0x000000 });
-        this.geometry = line;
-        this.material = material;
+        this.arc.generate_geometry();
+        const geometryData = this.arc.get_geometry_serialized();
+        const bufferData = JSON.parse(geometryData);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new Float32BufferAttribute(bufferData, 3));
+        this.geometry = geometry;
+        this.material = new LineBasicMaterial({ color: __classPrivateFieldGet(this, _Arc_color, "f") });
     }
     discardGeoemtry() {
         this.geometry.dispose();
     }
-    set radius(radius) {
-        this.options.radius = radius;
-        this.circleArc.update_radius(radius);
-        this.generateGeometry();
-        // if (this.nodeChild) {
-        //   this.nodeChild.update();
-        // }
-    }
 }
+_Arc_color = new WeakMap();
 
-var _Rectangle_color;
 /**
- * Rectangle
+ * Base class for all line-based primitives in OpenGeometry.
  */
-class Rectangle extends Line {
-    set width(width) {
-        this.options.width = width;
-        this.polyLineRectangle.update_width(width);
-        this.generateGeometry();
-    }
-    set breadth(breadth) {
-        this.options.breadth = breadth;
-        this.polyLineRectangle.update_breadth(breadth);
-        this.generateGeometry();
-    }
+class BaseLinePrimitive extends Line$1 {
+}
+
+class Rectangle extends BaseLinePrimitive {
+    // set width(width: number) {
+    //   this.options.width = width;
+    //   this.polyLineRectangle.update_width(width);
+    //   this.generateGeometry();
+    // }
+    // set breadth(breadth: number) {
+    //   this.options.breadth = breadth;
+    //   this.polyLineRectangle.update_breadth(breadth);
+    //   this.generateGeometry();
+    // }
+    // set center(center: Vector3) {
+    //   this.options.center = center;
+    //   this.polyLineRectangle.update_center(center);
+    //   this.generateGeometry();
+    // }
     set color(color) {
+        this.options.color = color;
         if (this.material instanceof LineBasicMaterial) {
             this.material.color.set(color);
-            __classPrivateFieldSet(this, _Rectangle_color, color, "f");
         }
     }
+    // FINAL: This flow should be used for other primitives
     constructor(options) {
+        var _a;
         super();
-        // nodeChild: RectanglePoly | null = null;
-        this.nodeOperation = "none";
-        _Rectangle_color.set(this, 0x000000);
-        this.ogid = getUUID();
-        this.options = options;
-        this.polyLineRectangle = new OGRectangle(this.ogid);
+        this.options = {
+            width: 1,
+            breadth: 1,
+            center: new Vector3$1(0, 0, 0),
+            color: 0x00ff00,
+        };
+        const ogid = (_a = options === null || options === void 0 ? void 0 : options.ogid) !== null && _a !== void 0 ? _a : getUUID();
+        this.polyLineRectangle = new OGRectangle(ogid);
+        // const mergedOptions = { ...this.options, ...options, ogid };
+        if (options) {
+            this.options = Object.assign(Object.assign({}, this.options), options);
+            this.ogid = options.ogid || getUUID();
+        }
+        else {
+            this.ogid = getUUID();
+        }
         this.setConfig();
         this.generateGeometry();
     }
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for Rectangle");
+        }
+    }
     setConfig() {
-        const { breadth, width, center } = this.options;
-        this.polyLineRectangle.set_config(center, width, breadth);
+        this.validateOptions();
+        const { width, breadth, center, color } = this.options;
+        this.polyLineRectangle.set_config(center.clone() || new Vector3$1(0, 0, 0), width, breadth);
+    }
+    getConfig() {
+        return this.options;
     }
     generateGeometry() {
-        this.polyLineRectangle.generate_points();
-        const bufRaw = this.polyLineRectangle.get_points();
-        const bufFlush = JSON.parse(bufRaw);
-        const line = new BufferGeometry().setFromPoints(bufFlush);
-        const material = new LineBasicMaterial({ color: __classPrivateFieldGet(this, _Rectangle_color, "f") });
-        this.geometry = line;
-        this.material = material;
+        this.polyLineRectangle.generate_geometry();
+        const geometryData = this.polyLineRectangle.get_geometry_serialized();
+        const bufferData = JSON.parse(geometryData);
+        console.log(bufferData);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new Float32BufferAttribute(bufferData, 3));
+        this.geometry = geometry;
+        this.material = new LineBasicMaterial({ color: 0x00ff00 });
+    }
+    getBrep() {
+        const brepData = this.polyLineRectangle.get_brep_serialized();
+        if (!brepData) {
+            throw new Error("Brep data is not available for Rectangle");
+        }
+        return JSON.parse(brepData);
     }
     discardGeometry() {
         this.geometry.dispose();
     }
 }
-_Rectangle_color = new WeakMap();
 
-var _Cylinder_outlineMesh;
-class Cylinder extends Mesh {
+var _CylinderOld_outlineMesh;
+class CylinderOld extends Mesh {
     constructor(options) {
         super();
-        _Cylinder_outlineMesh.set(this, null);
+        _CylinderOld_outlineMesh.set(this, null);
         // Store local center offset to align outlines
         // TODO: Can this be moved to Engine? It can increase performance | Needs to be used in other shapes too
         this._geometryCenterOffset = new Vector3();
         this.ogid = getUUID();
         this.options = options;
-        this.cylinder = new OGCylinder(this.ogid);
+        this.cylinder = new OGCylinderOld(this.ogid);
         this.setConfig();
         this.generateGeometry();
     }
@@ -13682,7 +13933,7 @@ class Cylinder extends Mesh {
     setConfig() {
         this.validateOptions();
         const { radius, height, segments, angle, center } = this.options;
-        this.cylinder.set_config((center === null || center === void 0 ? void 0 : center.clone()) || new Vector3D(0, 0, 0), radius, height, angle, segments);
+        this.cylinder.set_config((center === null || center === void 0 ? void 0 : center.clone()) || new Vector3$1(0, 0, 0), radius, height, angle, segments);
     }
     generateGeometry() {
         var _a, _b, _c;
@@ -13709,20 +13960,20 @@ class Cylinder extends Mesh {
         this.position.set(((_a = this.options.center) === null || _a === void 0 ? void 0 : _a.x) || 0, ((_b = this.options.center) === null || _b === void 0 ? void 0 : _b.y) || 0, ((_c = this.options.center) === null || _c === void 0 ? void 0 : _c.z) || 0);
     }
     set outline(enable) {
-        if (enable && !__classPrivateFieldGet(this, _Cylinder_outlineMesh, "f")) {
+        if (enable && !__classPrivateFieldGet(this, _CylinderOld_outlineMesh, "f")) {
             const outline_buff = this.cylinder.outline_edges();
             const outline_buf = JSON.parse(outline_buff);
             const outlineGeometry = new BufferGeometry();
             outlineGeometry.setAttribute("position", new Float32BufferAttribute(outline_buf, 3));
             outlineGeometry.translate(-this._geometryCenterOffset.x, -this._geometryCenterOffset.y, -this._geometryCenterOffset.z);
             const outlineMaterial = new LineBasicMaterial({ color: 0x000000 });
-            __classPrivateFieldSet(this, _Cylinder_outlineMesh, new LineSegments(outlineGeometry, outlineMaterial), "f");
-            this.add(__classPrivateFieldGet(this, _Cylinder_outlineMesh, "f"));
+            __classPrivateFieldSet(this, _CylinderOld_outlineMesh, new LineSegments(outlineGeometry, outlineMaterial), "f");
+            this.add(__classPrivateFieldGet(this, _CylinderOld_outlineMesh, "f"));
         }
-        if (!enable && __classPrivateFieldGet(this, _Cylinder_outlineMesh, "f")) {
-            this.remove(__classPrivateFieldGet(this, _Cylinder_outlineMesh, "f"));
-            __classPrivateFieldGet(this, _Cylinder_outlineMesh, "f").geometry.dispose();
-            __classPrivateFieldSet(this, _Cylinder_outlineMesh, null, "f");
+        if (!enable && __classPrivateFieldGet(this, _CylinderOld_outlineMesh, "f")) {
+            this.remove(__classPrivateFieldGet(this, _CylinderOld_outlineMesh, "f"));
+            __classPrivateFieldGet(this, _CylinderOld_outlineMesh, "f").geometry.dispose();
+            __classPrivateFieldSet(this, _CylinderOld_outlineMesh, null, "f");
         }
     }
     getBrepData() {
@@ -13731,32 +13982,37 @@ class Cylinder extends Mesh {
         console.log(brepDataParsed);
     }
 }
-_Cylinder_outlineMesh = new WeakMap();
+_CylinderOld_outlineMesh = new WeakMap();
 
-var _Polygon_outlineMesh;
+var _Polygon_outlineMesh, _Polygon_color;
 class Polygon extends Mesh {
-    constructor(vertices) {
-        var _a, _b;
+    set color(color) {
+        __classPrivateFieldSet(this, _Polygon_color, color, "f");
+        if (this.material instanceof MeshStandardMaterial) {
+            this.material.color.set(color);
+        }
+    }
+    // TODO: Make Options Optional
+    // constructor(vertices?: Vector3[]) // If no vertices are provided, it will be an empty polygon
+    constructor(options) {
         super();
-        this.layerVertices = [];
-        this.layerBackVertices = [];
-        this.polygon = null;
-        this.isTriangulated = false;
+        this.options = { vertices: [] };
         _Polygon_outlineMesh.set(this, null);
+        _Polygon_color.set(this, 0x00ff00);
+        this.transformationMatrix = new Matrix4();
+        // private _placement: THREE.Vector3 = new THREE.Vector3(0, 0, 0);
+        // private _yaw: number = 0;
+        // Store local center offset to align outlines
+        // TODO: Can this be moved to Engine? It can increase performance | Needs to be used in other shapes too
         this._geometryCenterOffset = new Vector3();
         this.ogid = getUUID();
-        this.polygon = new OGPolygon(this.ogid);
-        if (vertices) {
-            this.polygon.add_vertices(vertices);
-            // Triangulate the polygon - WORKS
-            (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.triangulate();
-            const bufFlush = (_b = this.polygon) === null || _b === void 0 ? void 0 : _b.get_buffer_flush();
-            this.addFlushBufferToScene(bufFlush);
-            // Testing New Triangulation - FAILING
-            // const triResult = JSON.parse(this.polygon.new_triangulate());
-            // console.log(triResult);
+        if (options) {
+            this.options = options;
         }
-        // THIS MIGHT HELP WITH SHARING THE POSITION with KERNEL when something is changed
+        this.polygon = new OGPolygon(this.ogid);
+        this.setConfig();
+        this.generateGeometry();
+        // TODO: THIS MIGHT HELP WITH SHARING THE POSITION with KERNEL when something is changed
         // const originalSet = this.position.set.bind(this.position);
         // this.position.set = (x: number, y: number, z: number) => {
         //   console.log(`Position set to (${x}, ${y}, ${z})`);
@@ -13770,152 +14026,468 @@ class Polygon extends Mesh {
         //   return originalCopy(v);
         // };
     }
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for Polygon");
+        }
+    }
+    setConfig() {
+        this.validateOptions();
+        const { vertices } = this.options;
+        this.polygon.set_config(vertices);
+    }
+    // /**
+    //  * Sets the placement of the polygon in 3D space.
+    //  * @param x X-coordinate
+    //  * @param y Y-coordinate
+    //  * @param z Z-coordinate
+    //  */
+    // placement(x: number, y: number, z: number) {
+    //   this._placement.set(x, y, z);
+    //   // Do the recalculation of position based on the placement
+    //   const clonedObject = this.clone();
+    //   clonedObject.rotation.set(0, 0, 0);
+    //   clonedObject.geometry.computeBoundingBox();
+    //   if (!clonedObject.geometry.boundingBox) return;
+    //   const center = new THREE.Vector3();
+    //   clonedObject.geometry.boundingBox.getCenter(center);
+    //   const min = clonedObject.geometry.boundingBox.min;
+    //   this.position.set(
+    //     center.x + this._placement.x - min.x,
+    //     // this._placement.y,
+    //     0.01, // Set Y to a small value to avoid z-fighting
+    //     center.z + this._placement.z - min.z
+    //   );
+    // }
+    // positionToPlacement() {
+    //   const clonedObject = this.clone();
+    //   clonedObject.rotation.set(0, 0, 0);
+    //   clonedObject.geometry.computeBoundingBox();
+    //   if (!clonedObject.geometry.boundingBox) return;
+    //   const min = clonedObject.geometry.boundingBox.min;
+    //   this._placement.set(
+    //     this.position.x + min.x,
+    //     this.position.y + min.y,
+    //     this.position.z + min.z
+    //   );
+    //   // console.log("Placement set to:", this._placement.x, this._placement.y, this._placement.z);
+    // }
+    // /**
+    //  * Rotates the polygon around the Y-axis.
+    //  * @param angle Rotation angle in Degrees
+    //  */
+    // set yaw(angle: number) {
+    //   this._yaw = angle;
+    //   this.rotation.set(0, 0, 0);
+    //   this.rotation.y = THREE.MathUtils.degToRad(this._yaw);
+    // }
+    // get yaw() {
+    //   return this._yaw;
+    // }
+    generateGeometry() {
+        // this.updateMatrix();
+        // this.transformationMatrix.copy(this.matrix);
+        // console.log("Transformation matrix set for polygon:", this.transformationMatrix.elements);
+        this.polygon.generate_geometry();
+        const geometryData = this.polygon.get_geometry_serialized();
+        const bufferData = JSON.parse(geometryData);
+        // TODO: If The Geometry is empty, no need to adjust position
+        if (bufferData.length === 0) {
+            console.warn("Geometry has no position attribute, skipping position adjustment.");
+            return;
+        }
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new Float32BufferAttribute(bufferData, 3));
+        const material = new MeshStandardMaterial({
+            color: __classPrivateFieldGet(this, _Polygon_color, "f"),
+            transparent: true,
+            opacity: 0.6,
+        });
+        geometry.computeVertexNormals();
+        geometry.computeBoundingBox();
+        this.geometry = geometry;
+        this.material = material;
+        // this.geometry.computeBoundingBox();
+        // const originalCenter = new THREE.Vector3();
+        // this.geometry.boundingBox?.getCenter(originalCenter);
+        // console.log("Original Center:", originalCenter.x, originalCenter.y, originalCenter.z);
+        // this.geometry.center();
+        // this.geometry.computeBoundingBox();
+        // const newCenter = new THREE.Vector3();
+        // this.geometry.boundingBox?.getCenter(newCenter);
+        // console.log("New Center after centering:", newCenter.x, newCenter.y, newCenter.z);
+        // if (!this.geometry.boundingBox) return;
+        // const min = this.geometry.boundingBox.min;
+        // // console.log("Position before centering:", this.position.x, this.position.y, this.position.z);
+        // console.log("Bounding Box Min:", min.x, min.y, min.z);
+        // this.position.set(-min.x, 0, -min.z);
+        // if (this._placement) {
+        //   this.placement(this._placement.x, this._placement.y, this._placement.z);
+        // }
+        // console.log("New Position after centering:", this.position.x, this.position.y, this.position.z);
+    }
     addVertices(vertices) {
-        var _a, _b;
         if (!this.polygon)
             return;
+        this.disposeGeometryMaterial();
         this.polygon.add_vertices(vertices);
-        (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.triangulate();
-        const bufFlush = (_b = this.polygon) === null || _b === void 0 ? void 0 : _b.get_buffer_flush();
-        this.addFlushBufferToScene(bufFlush);
+        this.generateGeometry();
     }
-    resetVertices() {
-        var _a;
+    saveTransformationToBREP() {
         if (!this.polygon)
             return;
-        this.layerVertices = [];
-        this.geometry.dispose();
-        (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.reset_polygon();
-        this.isTriangulated = false;
     }
-    addVertex(threeVertex) {
-        var _a, _b, _c;
-        if (this.isTriangulated) {
-            this.layerVertices = [];
+    // /**
+    //  * Rotates the object around the Y-axis.
+    //  * @param angle Rotation angle in Degrees
+    //  * @returns 
+    //  * @summary If rotation methods from threejs is used, it will rotate around the first vertex which might not be desired.
+    //  */
+    // rotateOnYAxis(angle: number) {
+    //   if (!this.polygon) return;
+    // }
+    // resetVertices() {
+    //   if (!this.polygon) return;
+    //   this.layerVertices = [];
+    //   this.geometry.dispose();
+    //   this.polygon?.clear_vertices();
+    //   this.isTriangulated = false;
+    // }
+    // addVertex(threeVertex: Vector3) {
+    //   if (this.isTriangulated) {
+    //     this.layerVertices = [];
+    //     this.geometry.dispose();
+    //     this.polygon?.clear_vertices();
+    //     this.isTriangulated = false;
+    //     for (const vertex of this.layerBackVertices) {
+    //       this.layerVertices.push(vertex.clone());
+    //     }
+    //   };
+    //   const backupVertex = new Vector3(
+    //     parseFloat(threeVertex.x.toFixed(2)),
+    //     0,
+    //     parseFloat(threeVertex.z.toFixed(2))
+    //   );
+    //   this.layerBackVertices.push(backupVertex);
+    //   const vertex = new Vector3(
+    //     parseFloat(threeVertex.x.toFixed(2)),
+    //     // when doing the parse operation getting -0 instead of 0
+    //     0,
+    //     parseFloat(threeVertex.z.toFixed(2))
+    //   );
+    //   this.layerVertices.push(vertex);
+    //   if (this.layerVertices.length > 3) {
+    //     this.polygon?.add_vertices(this.layerVertices);
+    //     const bufFlush = this.polygon?.triangulate();
+    //     if (!bufFlush) {
+    //       return;
+    //     }
+    //     this.addFlushBufferToScene(bufFlush);
+    //     this.isTriangulated = true;
+    //   }
+    // }
+    // addHole(holeVertices: Vector3[]) {
+    //   if (!this.polygon) return;
+    //   this.polygon.add_holes(holeVertices);
+    //   const triResult = JSON.parse(this.polygon.triangulate_with_holes());
+    //   console.log(triResult);
+    //   const newBufferFlush = triResult.new_buffer;
+    //   const geometry = new THREE.BufferGeometry();
+    //   geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(newBufferFlush), 3));
+    //   this.geometry = geometry;
+    //   // const bufFlush = this.polygon.get_buffer_flush();
+    //   // this.addFlushBufferToScene(bufFlush);
+    // }
+    // extrude(height: number) {
+    //   if (!this.polygon) return;
+    //   const extruded_buff = this.polygon.extrude_by_height(height);
+    //   console.log(extruded_buff);
+    //   this.generateExtrudedGeometry(extruded_buff);
+    // }
+    // generateExtrudedGeometry(extruded_buff: string) {
+    //   // THIS WORKS
+    //   const flushBuffer = JSON.parse(extruded_buff);
+    //   console.log(flushBuffer);
+    //   const geometry = new THREE.BufferGeometry();
+    //   geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(flushBuffer), 3));
+    //   geometry.computeVertexNormals();
+    //   this.geometry = geometry;
+    //   const material = new THREE.MeshStandardMaterial({
+    //     color: 0x00ff00, 
+    //     side: THREE.FrontSide, 
+    //     transparent: true, 
+    //     opacity: 0.5, 
+    //     // wireframe: true
+    //   });
+    //   this.material = material;
+    // }
+    getBrepData() {
+        if (!this.polygon)
+            return null;
+        const brepData = this.polygon.get_brep_serialized();
+        return brepData;
+    }
+    set outlineColor(color) {
+        if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f") && __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material instanceof LineBasicMaterial) {
+            __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material.color.set(color);
+        }
+    }
+    get outlineColor() {
+        if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f") && __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material instanceof LineBasicMaterial) {
+            return __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material.color.getHex();
+        }
+        return 0x000000; // Default color if outline mesh is not present
+    }
+    set outline(enable) {
+        if (enable && !__classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
+            const outline_buff = this.polygon.get_outline_geometry_serialized();
+            const outline_buf = JSON.parse(outline_buff);
+            const outlineGeometry = new BufferGeometry();
+            outlineGeometry.setAttribute("position", new Float32BufferAttribute(outline_buf, 3));
+            const outlineMaterial = new LineBasicMaterial({ color: 0x000000 });
+            __classPrivateFieldSet(this, _Polygon_outlineMesh, new LineSegments(outlineGeometry, outlineMaterial), "f");
+            // this.#outlineMesh.geometry.center();
+            // this.#outlineMesh.applyMatrix4(this.transformationMatrix);
+            this.add(__classPrivateFieldGet(this, _Polygon_outlineMesh, "f"));
+        }
+        if (!enable && __classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
+            this.remove(__classPrivateFieldGet(this, _Polygon_outlineMesh, "f"));
+            __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").geometry.dispose();
+            __classPrivateFieldSet(this, _Polygon_outlineMesh, null, "f");
+        }
+    }
+    get outline() {
+        if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
+            return true;
+        }
+        return false;
+    }
+    // bTree() {
+    //   if (!this.polygon) return;
+    //   const bTree = this.polygon.binary_tree();
+    //   const parsedData = JSON.parse(bTree);
+    //   console.log(parsedData);
+    // }
+    disposeGeometryMaterial() {
+        if (this.geometry) {
             this.geometry.dispose();
-            (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.reset_polygon();
-            this.isTriangulated = false;
-            for (const vertex of this.layerBackVertices) {
-                this.layerVertices.push(vertex.clone());
-            }
         }
-        const backupVertex = new Vector3D(parseFloat(threeVertex.x.toFixed(2)), 0, parseFloat(threeVertex.z.toFixed(2)));
-        this.layerBackVertices.push(backupVertex);
-        const vertex = new Vector3D(parseFloat(threeVertex.x.toFixed(2)), 
-        // when doing the parse operation getting -0 instead of 0
-        0, parseFloat(threeVertex.z.toFixed(2)));
-        this.layerVertices.push(vertex);
-        if (this.layerVertices.length > 3) {
-            (_b = this.polygon) === null || _b === void 0 ? void 0 : _b.add_vertices(this.layerVertices);
-            const bufFlush = (_c = this.polygon) === null || _c === void 0 ? void 0 : _c.triangulate();
-            if (!bufFlush) {
-                return;
+        if (this.material instanceof Material) {
+            this.material.dispose();
+        }
+        if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
+            __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").geometry.dispose();
+            if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material instanceof Material) {
+                __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material.dispose();
             }
-            this.addFlushBufferToScene(bufFlush);
-            this.isTriangulated = true;
         }
     }
-    addHole(holeVertices) {
-        if (!this.polygon)
-            return;
-        this.polygon.add_holes(holeVertices);
-        const triResult = JSON.parse(this.polygon.triangulate_with_holes());
-        console.log(triResult);
-        const newBufferFlush = triResult.new_buffer;
+    dispose() {
+        // // console.log("Disposing OG - Polygon");
+        // this.geometry.dispose();
+        // if (this.material instanceof THREE.Material) {
+        //   this.material.dispose();
+        // }
+        // if (this.#outlineMesh) {
+        //   this.#outlineMesh.geometry.dispose();
+        //   if (this.#outlineMesh.material instanceof THREE.Material) {
+        //     this.#outlineMesh.material.dispose();
+        //   }
+        // }
+        // this.polygon = null;
+        // this.layerVertices = [];
+        // this.layerBackVertices = [];
+    }
+}
+_Polygon_outlineMesh = new WeakMap(), _Polygon_color = new WeakMap();
+
+var _Cylinder_outlineMesh;
+class Cylinder extends Mesh {
+    constructor(options) {
+        super();
+        _Cylinder_outlineMesh.set(this, null);
+        this.ogid = getUUID();
+        this.options = options;
+        this.cylinder = new OGCylinder(this.ogid);
+        this.setConfig();
+        this.generateGeometry();
+    }
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for Cylinder");
+        }
+    }
+    setConfig() {
+        this.validateOptions();
+        const { radius, height, segments, angle, center } = this.options;
+        this.cylinder.set_config((center === null || center === void 0 ? void 0 : center.clone()) || new Vector3$1(0, 0, 0), radius, height, angle, segments);
+    }
+    generateGeometry() {
+        this.cylinder.generate_geometry();
+        const geometryData = this.cylinder.get_geometry_serialized();
+        const bufferData = JSON.parse(geometryData);
         const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new BufferAttribute(new Float32Array(newBufferFlush), 3));
+        geometry.setAttribute("position", new Float32BufferAttribute(bufferData, 3));
+        const material = new MeshStandardMaterial({
+            color: 0x00ff00,
+            transparent: true,
+            opacity: 0.6,
+        });
+        geometry.computeVertexNormals();
+        geometry.computeBoundingBox();
         this.geometry = geometry;
-        // const bufFlush = this.polygon.get_buffer_flush();
-        // this.addFlushBufferToScene(bufFlush);
+        this.material = material;
     }
-    addFlushBufferToScene(flush) {
-        const flushBuffer = JSON.parse(flush);
+    set outline(enable) {
+        if (enable && !__classPrivateFieldGet(this, _Cylinder_outlineMesh, "f")) {
+            const outline_buff = this.cylinder.get_outline_geometry_serialized();
+            const outline_buf = JSON.parse(outline_buff);
+            const outlineGeometry = new BufferGeometry();
+            outlineGeometry.setAttribute("position", new Float32BufferAttribute(outline_buf, 3));
+            const outlineMaterial = new LineBasicMaterial({ color: 0x000000 });
+            __classPrivateFieldSet(this, _Cylinder_outlineMesh, new LineSegments(outlineGeometry, outlineMaterial), "f");
+            this.add(__classPrivateFieldGet(this, _Cylinder_outlineMesh, "f"));
+        }
+        if (!enable && __classPrivateFieldGet(this, _Cylinder_outlineMesh, "f")) {
+            this.remove(__classPrivateFieldGet(this, _Cylinder_outlineMesh, "f"));
+            __classPrivateFieldGet(this, _Cylinder_outlineMesh, "f").geometry.dispose();
+            __classPrivateFieldSet(this, _Cylinder_outlineMesh, null, "f");
+        }
+    }
+    getBrep() {
+        const brepData = this.cylinder.get_brep_serialized();
+        if (!brepData) {
+            throw new Error("Brep data is not available for this cylinder.");
+        }
+        return JSON.parse(brepData);
+    }
+}
+_Cylinder_outlineMesh = new WeakMap();
+
+var _Cube_outlineMesh;
+class Cube extends Mesh {
+    constructor(options) {
+        super();
+        _Cube_outlineMesh.set(this, null);
+        // Store local center offset to align outlines
+        // TODO: Can this be moved to Engine? It can increase performance | Needs to be used in other shapes too
+        this._geometryCenterOffset = new Vector3();
+        this.ogid = getUUID();
+        this.options = options;
+        this.cube = new OGCube(this.ogid);
+        this.setConfig();
+        this.generateGeometry();
+    }
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for Cylinder");
+        }
+    }
+    setConfig() {
+        this.validateOptions();
+        const { width, height, depth, center } = this.options;
+        this.cube.set_config((center === null || center === void 0 ? void 0 : center.clone()) || new Vector3$1(0, 0, 0), width, height, depth);
+    }
+    generateGeometry() {
+        this.cube.generate_geometry();
+        const geometryData = this.cube.get_geometry_serialized();
+        const bufferData = JSON.parse(geometryData);
+        console.log(bufferData);
         const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
-        geometry.computeVertexNormals();
+        geometry.setAttribute("position", new Float32BufferAttribute(bufferData, 3));
         const material = new MeshStandardMaterial({
             color: 0x00ff00,
-            // side: THREE.DoubleSide, 
             transparent: true,
-            opacity: 0.5,
-            // wireframe: true
+            opacity: 0.6,
         });
-        this.geometry = geometry;
-        this.material = material;
-    }
-    extrude(height) {
-        if (!this.polygon)
-            return;
-        const extruded_buff = this.polygon.extrude_by_height(height);
-        console.log(extruded_buff);
-        this.generateExtrudedGeometry(extruded_buff);
-    }
-    generateExtrudedGeometry(extruded_buff) {
-        // THIS WORKS
-        const flushBuffer = JSON.parse(extruded_buff);
-        console.log(flushBuffer);
-        const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
         geometry.computeVertexNormals();
+        geometry.computeBoundingBox();
         this.geometry = geometry;
-        // const material = new THREE.MeshStandardMaterial({
-        //   color: 0x3a86ff,
-        // });
-        // // material.side = THREE.DoubleSide;
-        // this.material = material;
-    }
-    getBrepData() {
-        if (!this.polygon)
-            return;
-        const brepData = this.polygon.get_brep_data();
-        const parsedData = JSON.parse(brepData);
-        console.log(parsedData);
+        this.material = material;
     }
     set outline(enable) {
-        if (enable && !__classPrivateFieldGet(this, _Polygon_outlineMesh, "f") && this.polygon) {
-            const outline_buff = this.polygon.outline_edges();
+        if (enable && !__classPrivateFieldGet(this, _Cube_outlineMesh, "f")) {
+            const outline_buff = this.cube.get_outline_geometry_serialized();
             const outline_buf = JSON.parse(outline_buff);
             const outlineGeometry = new BufferGeometry();
             outlineGeometry.setAttribute("position", new Float32BufferAttribute(outline_buf, 3));
-            // TODO: Fix the outline position
-            // outlineGeometry.translate(
-            //   -this._geometryCenterOffset.x,
-            //   -this._geometryCenterOffset.y,
-            //   -this._geometryCenterOffset.z
-            // );
             const outlineMaterial = new LineBasicMaterial({ color: 0x000000 });
-            __classPrivateFieldSet(this, _Polygon_outlineMesh, new LineSegments(outlineGeometry, outlineMaterial), "f");
-            this.add(__classPrivateFieldGet(this, _Polygon_outlineMesh, "f"));
+            __classPrivateFieldSet(this, _Cube_outlineMesh, new LineSegments(outlineGeometry, outlineMaterial), "f");
+            this.add(__classPrivateFieldGet(this, _Cube_outlineMesh, "f"));
         }
-        if (!enable && __classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
-            this.remove(__classPrivateFieldGet(this, _Polygon_outlineMesh, "f"));
-            __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").geometry.dispose();
-            __classPrivateFieldSet(this, _Polygon_outlineMesh, null, "f");
+        if (!enable && __classPrivateFieldGet(this, _Cube_outlineMesh, "f")) {
+            this.remove(__classPrivateFieldGet(this, _Cube_outlineMesh, "f"));
+            __classPrivateFieldGet(this, _Cube_outlineMesh, "f").geometry.dispose();
+            __classPrivateFieldSet(this, _Cube_outlineMesh, null, "f");
         }
     }
-    get outline() {
-        if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
-            return true;
-        }
-        return false;
+    get outlineMesh() {
+        return __classPrivateFieldGet(this, _Cube_outlineMesh, "f");
     }
 }
-_Polygon_outlineMesh = new WeakMap();
+_Cube_outlineMesh = new WeakMap();
 
 class OpenGeometry {
+    set enablePencil(value) {
+        if (value && !this._pencil) {
+            if (!this.container || !this.scene) {
+                throw new Error("Container or Scene is not defined");
+            }
+            this._pencil = new Pencil(this.container, this.scene, this.camera);
+        }
+        else if (!value && this._pencil) ;
+    }
+    get pencil() {
+        return this._pencil;
+    }
+    get labelRenderer() {
+        return this._labelRenderer;
+    }
+    get enableDebug() {
+        return this._enableDebug;
+    }
+    /**
+     * Enables or disables debug mode for OpenGeometry.
+     * When enabled, it logs debug information to the console.
+     * Addtionally,
+     * 1. The geometry will be rendered with a semi-transparent material.
+     * 2. The faces will be rendered with a random color.
+     * 3. The normals will be rendered for better visualization.
+     * @param value - A boolean indicating whether to enable or disable debug mode.
+     */
+    set enableDebug(value) {
+        this._enableDebug = value;
+        if (this._enableDebug) {
+            console.log("OpenGeometry Debug Mode Enabled");
+        }
+    }
     constructor(container, threeScene, camera) {
         this.camera = camera;
+        this._enableDebug = false;
         this.scene = threeScene;
         this.container = container;
     }
-    // Why Generic Types are used sometimes
-    // verifyOptions(options: OpenGeometryOptions) {
-    //   for (const key in options) {
-    //     if (options[key as keyof OpenGeometryOptions] === undefined) {
-    //       throw new Error(`Missing required option: ${key}`);
-    //     }
-    //   }
-    // }
+    /**
+     * Asynchronously creates and initializes an instance of OpenGeometry.
+     *
+     * This factory method sets up the OpenGeometry engine by linking it with the
+     * rendering context and the WebAssembly module. It ensures all required
+     * options are provided and prepares the instance for 3D geometry operations.
+     *
+     * @param options - Configuration object for initializing OpenGeometry.
+     * @returns A promise that resolves to a fully initialized OpenGeometry instance.
+     * @throws If any of the required options (`container`, `scene`, or `camera`) are missing.
+     *
+     * @example
+     * ```ts
+     * const openGeometry = await OpenGeometry.create({
+     *   container: document.getElementById('myContainer')!,
+     *   scene: threeScene,
+     *   camera: threeCamera,
+     *   wasmURL: '/assets/opengeometry.wasm'
+     * });
+     * ```
+     */
     static create(options) {
         return __awaiter(this, void 0, void 0, function* () {
             const { container, scene, camera } = options;
@@ -13931,18 +14503,9 @@ class OpenGeometry {
         return __awaiter(this, void 0, void 0, function* () {
             yield __wbg_init(wasmURL);
             this.setuplabelRenderer();
-            if (!this.container || !this.scene)
-                return;
-            this._pencil = new Pencil(this.container, this.scene, this.camera);
             this.setupEvent();
         });
     }
-    get pencil() {
-        return this._pencil;
-    }
-    get labelRenderer() {
-        return this._labelRenderer;
-    }
     setuplabelRenderer() {
         if (!this.container || !this.scene) {
             throw new Error("Container or Scene is not defined");
@@ -13955,6 +14518,8 @@ class OpenGeometry {
         this._labelRenderer = labelRenderer;
     }
     setupEvent() {
+        // NOTE: The responsibility to resize normal rendererer lies with the user
+        // but the label renderer should be resized automatically
         window.addEventListener("resize", () => {
             var _a, _b, _c;
             if (!this.container)
@@ -13962,6 +14527,13 @@ class OpenGeometry {
             (_a = this._labelRenderer) === null || _a === void 0 ? void 0 : _a.setSize((_b = this.container) === null || _b === void 0 ? void 0 : _b.clientWidth, (_c = this.container) === null || _c === void 0 ? void 0 : _c.clientHeight);
         });
     }
+    // TODO: Can this be handled inside the OpenGeometry class itself?
+    /**
+     * Updates the label renderer to render the scene with the given camera.
+     * This method should be called in the animation loop or render loop of your application.
+     * @param scene - The Three.js scene containing the objects to be rendered.
+     * @param camera - The Three.js camera used for rendering the scene.
+     */
     update(scene, camera) {
         var _a;
         (_a = this._labelRenderer) === null || _a === void 0 ? void 0 : _a.render(scene, camera);
@@ -14015,9 +14587,9 @@ class BasePoly extends Mesh {
                 this.layerVertices.push(vertex.clone());
             }
         }
-        const backupVertex = new Vector3D(parseFloat(threeVertex.x.toFixed(2)), 0, parseFloat(threeVertex.z.toFixed(2)));
+        const backupVertex = new Vector3$1(parseFloat(threeVertex.x.toFixed(2)), 0, parseFloat(threeVertex.z.toFixed(2)));
         this.layerBackVertices.push(backupVertex);
-        const vertex = new Vector3D(parseFloat(threeVertex.x.toFixed(2)), 
+        const vertex = new Vector3$1(parseFloat(threeVertex.x.toFixed(2)), 
         // when doing the parse operation getting -0 instead of 0
         0, parseFloat(threeVertex.z.toFixed(2)));
         this.layerVertices.push(vertex);
@@ -14079,230 +14651,237 @@ class BasePoly extends Mesh {
         // this.material = material;
     }
 }
-class CirclePoly extends Mesh {
-    constructor(baseCircle) {
-        super();
-        this.polygon = null;
-        this.isExtruded = false;
-        this.ogid = getUUID();
-        if (!baseCircle.circleArc) {
-            throw new Error("CircleArc is not defined");
-        }
-        // baseCircle.nodeChild = this;
-        baseCircle.nodeOperation = "polygon";
-        this.baseCircle = baseCircle;
-        this.generateGeometry();
-        this.addFlushBufferToScene();
-    }
-    update() {
-        var _a, _b;
-        this.geometry.dispose();
-        (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.clear_vertices();
-        (_b = this.polygon) === null || _b === void 0 ? void 0 : _b.add_vertices(this.baseCircle.circleArc.get_raw_points());
-        this.generateGeometry();
-        this.addFlushBufferToScene();
-    }
-    generateGeometry() {
-        if (!this.baseCircle.circleArc)
-            return;
-        this.polygon = OGPolygon.new_with_circle(this.baseCircle.circleArc.clone());
-    }
-    addFlushBufferToScene() {
-        if (!this.polygon)
-            return;
-        const bufFlush = this.polygon.get_buffer_flush();
-        const flushBuffer = JSON.parse(bufFlush);
-        const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
-        // TODO: Do this using a set method, poly.visualizeTriangles = true
-        // different colors for each triangle in the polygon dont interolate
-        // const colors = new Float32Array(flushBuffer.length);
-        // for (let i = 0; i < colors.length; i += 9) {
-        //   const r = Math.random();
-        //   const g = Math.random();
-        //   const b = Math.random();
-        //   colors[i] = r;
-        //   colors[i + 1] = g;
-        //   colors[i + 2] = b;
-        //   colors[i + 3] = r;
-        //   colors[i + 4] = g;
-        //   colors[i + 5] = b;
-        //   colors[i + 6] = r;
-        //   colors[i + 7] = g;
-        //   colors[i + 8] = b;
-        // }
-        // geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
-        const material = new MeshStandardMaterial({
-            color: 0x00ff00,
-            // side: THREE.DoubleSide, 
-            transparent: true,
-            opacity: 0.5,
-            // wireframe: true
-        });
-        this.geometry = geometry;
-        this.material = material;
-    }
-    clearGeometry() {
-        this.geometry.dispose();
-    }
-    extrude(height) {
-        if (!this.polygon)
-            return;
-        const extruded_buff = this.polygon.extrude_by_height(height);
-        console.log(JSON.parse(extruded_buff));
-        this.isExtruded = true;
-        this.generateExtrudedGeometry(extruded_buff);
-    }
-    getBrepData() {
-        if (!this.polygon)
-            return;
-        const brepData = this.polygon.get_brep_data();
-        const parsedData = JSON.parse(brepData);
-        console.log(parsedData);
-    }
-    getOutline(type) {
-        if (!this.polygon)
-            return;
-        const outlines = this.polygon.get_outlines();
-        const outlineBuffer = JSON.parse(outlines);
-        // TODO: move this logic to Kernel
-        const faces = [];
-        for (const data of outlineBuffer) {
-            const vertices = [];
-            for (const vertex of data) {
-                const x_float = type === "side" ? 0 : parseFloat(vertex.x.toFixed(5));
-                const y_float = type === "top" ? 0 : parseFloat(vertex.y.toFixed(5));
-                const z_float = type === "front" ? 0 : parseFloat(vertex.z.toFixed(5));
-                vertices.push(new Vector3(x_float, y_float, z_float));
-            }
-            faces.push(vertices);
-        }
-        const clonedFaces = faces.map((face) => {
-            return face.map((vertex) => {
-                return new Vector3(vertex.x, vertex.y, vertex.z);
-            });
-        });
-        // remove duplicates inside the faces
-        const uniqueFaces = clonedFaces.map((face) => {
-            return face.filter((vertex, index, self) => index === self.findIndex((v) => (v.x === vertex.x && v.y === vertex.y && v.z === vertex.z)));
-        });
-        // Picking unique vertices from all faces
-        const uniqueVertices = [];
-        const vertexSet = new Set();
-        for (const face of uniqueFaces) {
-            for (const vertex of face) {
-                const key = `${vertex.x},${vertex.y},${vertex.z}`;
-                if (!vertexSet.has(key)) {
-                    vertexSet.add(key);
-                    uniqueVertices.push(vertex);
-                }
-            }
-        }
-        // arrange the vertices in a clockwise manner
-        const center = new Vector3();
-        for (const vertex of uniqueVertices) {
-            center.add(vertex);
-        }
-        center.divideScalar(uniqueVertices.length);
-        uniqueVertices.sort((a, b) => {
-            if (type === "side") {
-                const angleA = Math.atan2(a.y - center.y, a.z - center.z);
-                const angleB = Math.atan2(b.y - center.y, b.z - center.z);
-                return angleA - angleB;
-            }
-            else if (type === "top") {
-                const angleA = Math.atan2(a.x - center.x, a.z - center.z);
-                const angleB = Math.atan2(b.x - center.x, b.z - center.z);
-                return angleA - angleB;
-            }
-            const angleA = Math.atan2(a.x - center.x, a.y - center.y);
-            const angleB = Math.atan2(b.x - center.x, b.y - center.y);
-            return angleA - angleB;
-        });
-        // merge collinear vertices
-        const mergedVertices = [];
-        for (let i = 0; i < uniqueVertices.length; i++) {
-            const current = uniqueVertices[i];
-            const next = uniqueVertices[(i + 1) % uniqueVertices.length];
-            const prev = uniqueVertices[(i - 1 + uniqueVertices.length) % uniqueVertices.length];
-            const v1 = new Vector3().subVectors(current, prev);
-            const v2 = new Vector3().subVectors(next, current);
-            if (v1.angleTo(v2) > 0.01) {
-                mergedVertices.push(current);
-            }
-        }
-        mergedVertices.push(mergedVertices[0]);
-        // TODO: move logic until here to Kernel
-        // Create a new geometry with the merged vertices
-        const mergedGeometry = new BufferGeometry().setFromPoints(mergedVertices);
-        const mergedMaterial = new MeshBasicMaterial({ color: 0x000000, side: DoubleSide });
-        const mergedMesh = new Line(mergedGeometry, mergedMaterial);
-        return mergedMesh;
-    }
-    generateExtrudedGeometry(extruded_buff) {
-        // THIS WORKS
-        const flushBuffer = JSON.parse(extruded_buff);
-        const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
-        // To Test If Triangulation is working
-        // const colors = new Float32Array(flushBuffer.length);
-        // for (let i = 0; i < colors.length; i += 9) {
-        //   const r = Math.random();
-        //   const g = Math.random();
-        //   const b = Math.random();
-        //   colors[i] = r;
-        //   colors[i + 1] = g;
-        //   colors[i + 2] = b;
-        //   colors[i + 3] = r;
-        //   colors[i + 4] = g;
-        //   colors[i + 5] = b;
-        //   colors[i + 6] = r;
-        //   colors[i + 7] = g;
-        //   colors[i + 8] = b;
-        // }
-        // geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
-        // const material = new THREE.MeshPhongMaterial( {
-        //     color: 0xffffff,
-        //     flatShading: true,
-        //     vertexColors: true,
-        //     shininess: 0,
-        //     side: THREE.DoubleSide
-        // });
-        // const material = new THREE.MeshPhongMaterial({
-        //   color: 0x3a86ff,
-        // });
-        // material.side = THREE.DoubleSide;
-        this.geometry = geometry;
-        // this.material = material;
-    }
-}
+// export class CirclePoly extends THREE.Mesh {
+//   ogid: string;
+//   polygon: OGPolygon | null = null;
+//   baseCircle: Arc;
+//   isExtruded: boolean = false;
+//   constructor(baseCircle: Arc) {
+//     super();
+//     this.ogid = getUUID();
+//     if (!baseCircle.circleArc) {
+//       throw new Error("CircleArc is not defined");
+//     }
+//     // baseCircle.nodeChild = this;
+//     baseCircle.nodeOperation = "polygon";
+//     this.baseCircle = baseCircle;
+//     this.generateGeometry();
+//     this.addFlushBufferToScene();
+//   }
+//   update() {
+//     this.geometry.dispose();
+//     this.polygon?.clear_vertices();
+//     this.polygon?.add_vertices(this.baseCircle.circleArc.get_raw_points());
+//     this.generateGeometry();
+//     this.addFlushBufferToScene();
+//   }
+//   generateGeometry() {
+//     if (!this.baseCircle.circleArc) return;
+//     this.polygon = OGPolygon.new_with_circle(this.baseCircle.circleArc.clone());
+//   }
+//   addFlushBufferToScene() {
+//     if (!this.polygon) return;
+//     const bufFlush = this.polygon.get_buffer_flush();
+//     const flushBuffer = JSON.parse(bufFlush);
+//     const geometry = new THREE.BufferGeometry();
+//     geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(flushBuffer), 3));
+//     // TODO: Do this using a set method, poly.visualizeTriangles = true
+//     // different colors for each triangle in the polygon dont interolate
+//     // const colors = new Float32Array(flushBuffer.length);
+//     // for (let i = 0; i < colors.length; i += 9) {
+//     //   const r = Math.random();
+//     //   const g = Math.random();
+//     //   const b = Math.random();
+//     //   colors[i] = r;
+//     //   colors[i + 1] = g;
+//     //   colors[i + 2] = b;
+//     //   colors[i + 3] = r;
+//     //   colors[i + 4] = g;
+//     //   colors[i + 5] = b;
+//     //   colors[i + 6] = r;
+//     //   colors[i + 7] = g;
+//     //   colors[i + 8] = b;
+//     // }
+//     // geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
+//     const material = new THREE.MeshStandardMaterial({
+//       color: 0x00ff00, 
+//       // side: THREE.DoubleSide, 
+//       transparent: true, 
+//       opacity: 0.5, 
+//       // wireframe: true
+//     });
+//     this.geometry = geometry;
+//     this.material = material;
+//   }
+//   clearGeometry() {
+//     this.geometry.dispose();
+//   }
+//   extrude(height: number) {
+//     if (!this.polygon) return;
+//     const extruded_buff = this.polygon.extrude_by_height(height);
+//     console.log(JSON.parse(extruded_buff));
+//     this.isExtruded = true;
+//     this.generateExtrudedGeometry(extruded_buff);
+//   }
+//   getBrepData() {
+//     if (!this.polygon) return;
+//     const brepData = this.polygon.get_brep_data();
+//     const parsedData = JSON.parse(brepData);
+//     console.log(parsedData);
+//   }
+//   getOutline(type: OUTLINE_TYPE) {
+//     if (!this.polygon) return;
+//     const outlines = this.polygon.get_outlines();
+//     const outlineBuffer = JSON.parse(outlines);
+//     // TODO: move this logic to Kernel
+//     const faces = [];
+//     for (const data of outlineBuffer) {
+//       const vertices = [];
+//       for (const vertex of data) {
+//         const x_float = type === "side" ? 0 : parseFloat(vertex.x.toFixed(5));
+//         const y_float = type === "top" ? 0 : parseFloat(vertex.y.toFixed(5));
+//         const z_float = type === "front" ? 0 : parseFloat(vertex.z.toFixed(5));
+//         vertices.push(new THREE.Vector3(x_float, y_float, z_float));
+//       }
+//       faces.push(vertices);
+//     }
+//     const clonedFaces = faces.map((face) => {
+//       return face.map((vertex) => {
+//         return new THREE.Vector3(vertex.x, vertex.y, vertex.z);
+//       });
+//     }
+//     );
+//     // remove duplicates inside the faces
+//     const uniqueFaces = clonedFaces.map((face) => {
+//       return face.filter((vertex, index, self) =>
+//         index === self.findIndex((v) => (
+//           v.x === vertex.x && v.y === vertex.y && v.z === vertex.z
+//         ))
+//       );
+//     });
+//     // Picking unique vertices from all faces
+//     const uniqueVertices = [];
+//     const vertexSet = new Set();
+//     for (const face of uniqueFaces) {
+//       for (const vertex of face) {
+//         const key = `${vertex.x},${vertex.y},${vertex.z}`;
+//         if (!vertexSet.has(key)) {
+//           vertexSet.add(key);
+//           uniqueVertices.push(vertex);
+//         }
+//       }
+//     }
+//     // arrange the vertices in a clockwise manner
+//     const center = new THREE.Vector3();
+//     for (const vertex of uniqueVertices) {
+//       center.add(vertex);
+//     }
+//     center.divideScalar(uniqueVertices.length);
+//     uniqueVertices.sort((a, b) => {
+//       if (type === "side") {
+//         const angleA = Math.atan2(a.y - center.y, a.z - center.z);
+//         const angleB = Math.atan2(b.y - center.y, b.z - center.z);
+//         return angleA - angleB;
+//       } else if (type === "top") {
+//         const angleA = Math.atan2(a.x - center.x, a.z - center.z);
+//         const angleB = Math.atan2(b.x - center.x, b.z - center.z);
+//         return angleA - angleB;
+//       }
+//       const angleA = Math.atan2(a.x - center.x, a.y - center.y);
+//       const angleB = Math.atan2(b.x - center.x, b.y - center.y);
+//       return angleA - angleB;
+//     }
+//     );
+//     // merge collinear vertices
+//     const mergedVertices = [];
+//     for (let i = 0; i < uniqueVertices.length; i++) {
+//       const current = uniqueVertices[i];
+//       const next = uniqueVertices[(i + 1) % uniqueVertices.length];
+//       const prev = uniqueVertices[(i - 1 + uniqueVertices.length) % uniqueVertices.length];
+//       const v1 = new THREE.Vector3().subVectors(current, prev);
+//       const v2 = new THREE.Vector3().subVectors(next, current);
+//       if (v1.angleTo(v2) > 0.01) {
+//         mergedVertices.push(current);
+//       }
+//     }
+//     mergedVertices.push(mergedVertices[0]);
+//     // TODO: move logic until here to Kernel
+//     // Create a new geometry with the merged vertices
+//     const mergedGeometry = new THREE.BufferGeometry().setFromPoints(mergedVertices);
+//     const mergedMaterial = new THREE.MeshBasicMaterial({ color: 0x000000, side: THREE.DoubleSide });
+//     const mergedMesh = new THREE.Line(mergedGeometry, mergedMaterial);
+//     return mergedMesh;
+//   }
+//   generateExtrudedGeometry(extruded_buff: string) {
+//     // THIS WORKS
+//     const flushBuffer = JSON.parse(extruded_buff);
+//     const geometry = new THREE.BufferGeometry();
+//     geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(flushBuffer), 3));
+//     // To Test If Triangulation is working
+//     // const colors = new Float32Array(flushBuffer.length);
+//     // for (let i = 0; i < colors.length; i += 9) {
+//     //   const r = Math.random();
+//     //   const g = Math.random();
+//     //   const b = Math.random();
+//     //   colors[i] = r;
+//     //   colors[i + 1] = g;
+//     //   colors[i + 2] = b;
+//     //   colors[i + 3] = r;
+//     //   colors[i + 4] = g;
+//     //   colors[i + 5] = b;
+//     //   colors[i + 6] = r;
+//     //   colors[i + 7] = g;
+//     //   colors[i + 8] = b;
+//     // }
+//     // geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
+//     // const material = new THREE.MeshPhongMaterial( {
+//     //     color: 0xffffff,
+//     //     flatShading: true,
+//     //     vertexColors: true,
+//     //     shininess: 0,
+//     //     side: THREE.DoubleSide
+//     // });
+//     // const material = new THREE.MeshPhongMaterial({
+//     //   color: 0x3a86ff,
+//     // });
+//     // material.side = THREE.DoubleSide;
+//     this.geometry = geometry;
+//     // this.material = material;
+//   }
+//   dispose() {
+//     if (!this.polygon) return;
+//     this.geometry.dispose();
+//     this.polygon?.clear_vertices();
+//     this.polygon = null;
+//     this.isExtruded = false;
+//   }
+// }
 class RectanglePoly extends Mesh {
     constructor(baseRectangle) {
         super();
         this.polygon = null;
         this.isExtruded = false;
         this.ogid = getUUID();
-        if (!baseRectangle.polyLineRectangle) {
-            throw new Error("BaseRectangle is not defined");
-        }
-        // baseRectangle.nodeChild = this;
-        baseRectangle.nodeOperation = "polygon";
+        // if (!baseRectangle.polyLineRectangle) {
+        //   throw new Error("BaseRectangle is not defined");
+        // }
+        // // baseRectangle.nodeChild = this;
+        // baseRectangle.nodeOperation = "polygon";
         this.baseRectangle = baseRectangle;
         this.generateGeometry();
         this.addFlushBufferToScene();
     }
     update() {
-        var _a, _b;
+        var _a;
         this.geometry.dispose();
         (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.clear_vertices();
-        (_b = this.polygon) === null || _b === void 0 ? void 0 : _b.add_vertices(this.baseRectangle.polyLineRectangle.get_raw_points());
+        // this.polygon?.add_vertices(this.baseRectangle.polyLineRectangle.get_raw_points());
         this.generateGeometry();
         this.addFlushBufferToScene();
     }
     generateGeometry() {
-        if (!this.baseRectangle.polyLineRectangle)
-            return;
-        this.polygon = BasePolygon.new_with_rectangle(this.baseRectangle.polyLineRectangle.clone());
+        // if (!this.baseRectangle.polyLineRectangle) return;
+        // this.polygon = BasePolygon.new_with_rectangle(this.baseRectangle.polyLineRectangle.clone());
     }
     addFlushBufferToScene() {
         if (!this.polygon)
@@ -14437,7 +15016,7 @@ class RectanglePoly extends Mesh {
         // Create a new geometry with the merged vertices
         const mergedGeometry = new BufferGeometry().setFromPoints(mergedVertices);
         const mergedMaterial = new MeshBasicMaterial({ color: 0x000000, side: DoubleSide });
-        const mergedMesh = new Line(mergedGeometry, mergedMaterial);
+        const mergedMesh = new Line$1(mergedGeometry, mergedMaterial);
         return mergedMesh;
     }
 }
@@ -14459,5 +15038,5 @@ class FlatMesh extends Mesh {
     }
 }
 
-export { BaseCircle, BasePoly, CirclePoly, Cylinder, FlatMesh, OpenGeometry, PolyLine, Polygon, Rectangle, RectanglePoly, SimpleLine, SpotLabel, Vector3D };
+export { Arc, BasePoly, Cube, Cylinder, CylinderOld, FlatMesh, Line, OpenGeometry, Polygon, Polyline, Rectangle, RectanglePoly, SpotLabel, Vector3$1 as Vector3 };
 //# sourceMappingURL=index.js.map