opengeometry 2.0.13 → 2.0.14

package/opengeometry/pkg/opengeometry.js

@@ -29,69 +29,13 @@ function handleError(f, args) {
     }
 }
 
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches && builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
 let WASM_VECTOR_LEN = 0;
@@ -150,94 +94,23 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
-
-if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
 function takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_export_2.get(idx);
     wasm.__externref_table_dealloc(idx);
     return value;
 }
-
-let cachedFloat64ArrayMemory0 = null;
-
-function getFloat64ArrayMemory0() {
-    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
-        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
-    }
-    return cachedFloat64ArrayMemory0;
-}
-
-function getArrayF64FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
-}
-
-function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4, 4) >>> 0;
-    for (let i = 0; i < array.length; i++) {
-        const add = addToExternrefTable0(array[i]);
-        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
-    }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
-}
-
-function passArrayF64ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 8, 8) >>> 0;
-    getFloat64ArrayMemory0().set(arg, ptr / 8);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
 /**
- * Wasm entry point: analyze a flat `[x0,y0,z0,…]` loop, returning the report as
- * JSON (the corrected points are not returned here; use the kernel API).
- * @param {Float64Array} flat_points
+ * @param {string} local_brep_serialized
+ * @param {number} height
  * @returns {string}
  */
-export function analyzeProfile(flat_points) {
+export function extrudeBrepFace(local_brep_serialized, height) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passArrayF64ToWasm0(flat_points, wasm.__wbindgen_malloc);
+        const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.analyzeProfile(ptr0, len0);
+        const ret = wasm.extrudeBrepFace(ptr0, len0, height);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -252,47 +125,71 @@ export function analyzeProfile(flat_points) {
     }
 }
 
+let cachedFloat64ArrayMemory0 = null;
+
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
- * Wasm entry point: check a serialized B-rep's geometric validity, returning
- * the [`ValidityReport`] as JSON.
- * @param {string} brep_json
+ * Wasm entry point for general extrude. `direction` is `[x,y,z]`; `extent_kind`
+ * is `"one_sided" | "symmetric" | "two_sided"`; `d_plus`/`d_minus` are the
+ * extent distances (`d_minus` ignored unless two-sided, `d_plus` is the
+ * distance for one-sided/symmetric).
+ * @param {string} local_brep_serialized
+ * @param {Float64Array} direction
+ * @param {string} extent_kind
+ * @param {number} d_plus
+ * @param {number} d_minus
  * @returns {string}
  */
-export function checkBrepValidity(brep_json) {
-    let deferred3_0;
-    let deferred3_1;
+export function extrudeBrepFaceDirectional(local_brep_serialized, direction, extent_kind, d_plus, d_minus) {
+    let deferred5_0;
+    let deferred5_1;
     try {
-        const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.checkBrepValidity(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
+        const ptr1 = passArrayF64ToWasm0(direction, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(extent_kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.extrudeBrepFaceDirectional(ptr0, len0, ptr1, len1, ptr2, len2, d_plus, d_minus);
+        var ptr4 = ret[0];
+        var len4 = ret[1];
         if (ret[3]) {
-            ptr2 = 0; len2 = 0;
+            ptr4 = 0; len4 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
     }
 }
 
 /**
- * Wasm entry point: heal a serialized B-rep, returning JSON
- * `{ "brep": <healed brep>, "report": <heal report> }`.
- * @param {string} brep_json
- * @param {number} tolerance
+ * Wasm entry point: analyze a flat `[x0,y0,z0,…]` loop, returning the report as
+ * JSON (the corrected points are not returned here; use the kernel API).
+ * @param {Float64Array} flat_points
  * @returns {string}
  */
-export function healBrep(brep_json, tolerance) {
+export function analyzeProfile(flat_points) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passArrayF64ToWasm0(flat_points, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.healBrep(ptr0, len0, tolerance);
+        const ret = wasm.analyzeProfile(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -307,6 +204,39 @@ export function healBrep(brep_json, tolerance) {
     }
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
 /**
  * Wasm entry point: offset a centreline by `width` into stroked regions via the
  * deterministic analytic offset. `centreline_flat` is `[x0,y0,z0, …]`. Returns
@@ -378,17 +308,16 @@ export function offsetRingVariable(ring_flat, distances, holes_json) {
 }
 
 /**
- * @param {string} local_brep_serialized
- * @param {number} height
+ * @param {string} serialized
  * @returns {string}
  */
-export function extrudeBrepFace(local_brep_serialized, height) {
+export function validateAnalyticBrep(serialized) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.extrudeBrepFace(ptr0, len0, height);
+        const ret = wasm.validateAnalyticBrep(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -404,143 +333,114 @@ export function extrudeBrepFace(local_brep_serialized, height) {
 }
 
 /**
- * Wasm entry point for general extrude. `direction` is `[x,y,z]`; `extent_kind`
- * is `"one_sided" | "symmetric" | "two_sided"`; `d_plus`/`d_minus` are the
- * extent distances (`d_minus` ignored unless two-sided, `d_plus` is the
- * distance for one-sided/symmetric).
- * @param {string} local_brep_serialized
- * @param {Float64Array} direction
- * @param {string} extent_kind
- * @param {number} d_plus
- * @param {number} d_minus
- * @returns {string}
- */
-export function extrudeBrepFaceDirectional(local_brep_serialized, direction, extent_kind, d_plus, d_minus) {
-    let deferred5_0;
-    let deferred5_1;
-    try {
-        const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(direction, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(extent_kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.extrudeBrepFaceDirectional(ptr0, len0, ptr1, len1, ptr2, len2, d_plus, d_minus);
-        var ptr4 = ret[0];
-        var len4 = ret[1];
-        if (ret[3]) {
-            ptr4 = 0; len4 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred5_0 = ptr4;
-        deferred5_1 = len4;
-        return getStringFromWasm0(ptr4, len4);
-    } finally {
-        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
-    }
-}
-
-/**
- * Wasm entry point for union.
- * @param {string} lhs_brep_serialized
- * @param {string} rhs_brep_serialized
+ * @param {string} serialized
+ * @param {number} deflection
  * @param {string | null} [options_json]
- * @returns {OGBooleanResult}
+ * @returns {OGAnalyticTessellation}
  */
-export function booleanUnion(lhs_brep_serialized, rhs_brep_serialized, options_json) {
-    const ptr0 = passStringToWasm0(lhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function tessellate_brep(serialized, deflection, options_json) {
+    const ptr0 = passStringToWasm0(serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(rhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.booleanUnion(ptr0, len0, ptr1, len1, ptr2, len2);
+    var ptr1 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.tessellate_brep(ptr0, len0, deflection, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return OGBooleanResult.__wrap(ret[0]);
+    return OGAnalyticTessellation.__wrap(ret[0]);
 }
 
-/**
- * Wasm entry point for intersection.
- * @param {string} lhs_brep_serialized
- * @param {string} rhs_brep_serialized
- * @param {string | null} [options_json]
- * @returns {OGBooleanResult}
- */
-export function booleanIntersection(lhs_brep_serialized, rhs_brep_serialized, options_json) {
-    const ptr0 = passStringToWasm0(lhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(rhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.booleanIntersection(ptr0, len0, ptr1, len1, ptr2, len2);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+let cachedFloat32ArrayMemory0 = null;
+
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
     }
-    return OGBooleanResult.__wrap(ret[0]);
+    return cachedFloat32ArrayMemory0;
 }
 
-/**
- * Wasm entry point for subtraction.
- * @param {string} lhs_brep_serialized
- * @param {string} rhs_brep_serialized
- * @param {string | null} [options_json]
- * @returns {OGBooleanResult}
- */
-export function booleanSubtraction(lhs_brep_serialized, rhs_brep_serialized, options_json) {
-    const ptr0 = passStringToWasm0(lhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(rhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.booleanSubtraction(ptr0, len0, ptr1, len1, ptr2, len2);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
     }
-    return OGBooleanResult.__wrap(ret[0]);
+    return cachedUint32ArrayMemory0;
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
 /**
- * Wasm entry point for array-backed repeated subtraction.
- * @param {string} lhs_brep_serialized
- * @param {string} cutters_brep_serialized
- * @param {string | null} [options_json]
- * @returns {OGBooleanResult}
+ * Wasm entry point: check a serialized B-rep's geometric validity, returning
+ * the [`ValidityReport`] as JSON.
+ * @param {string} brep_json
+ * @returns {string}
  */
-export function booleanSubtractionMany(lhs_brep_serialized, cutters_brep_serialized, options_json) {
-    const ptr0 = passStringToWasm0(lhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(cutters_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.booleanSubtractionMany(ptr0, len0, ptr1, len1, ptr2, len2);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+export function checkBrepValidity(brep_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.checkBrepValidity(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
-    return OGBooleanResult.__wrap(ret[0]);
 }
 
 /**
- * Wasm entry point for array-backed batched union. Accepts a JSON array of
- * serialized BReps and folds them with `batch_union` in one boundary crossing.
- * @param {string} operands_brep_serialized
- * @param {string | null} [options_json]
- * @returns {OGBooleanResult}
+ * Wasm entry point: heal a serialized B-rep, returning JSON
+ * `{ "brep": <healed brep>, "report": <heal report> }`.
+ * @param {string} brep_json
+ * @param {number} tolerance
+ * @returns {string}
  */
-export function batchUnion(operands_brep_serialized, options_json) {
-    const ptr0 = passStringToWasm0(operands_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.batchUnion(ptr0, len0, ptr1, len1);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+export function healBrep(brep_json, tolerance) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.healBrep(ptr0, len0, tolerance);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
-    return OGBooleanResult.__wrap(ret[0]);
 }
 
 const Matrix3Finalization = (typeof FinalizationRegistry === 'undefined')
@@ -661,207 +561,617 @@ export class Matrix4 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Matrix4.prototype);
+        const obj = Object.create(Matrix4.prototype);
+        obj.__wbg_ptr = ptr;
+        Matrix4Finalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        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 OGAnalyticBrepFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_oganalyticbrep_free(ptr >>> 0, 1));
+
+export class OGAnalyticBrep {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OGAnalyticBrep.prototype);
+        obj.__wbg_ptr = ptr;
+        OGAnalyticBrepFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OGAnalyticBrepFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_oganalyticbrep_free(ptr, 0);
+    }
+    /**
+     * @param {string} serialized
+     */
+    constructor(serialized) {
+        const ptr0 = passStringToWasm0(serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        OGAnalyticBrepFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} config_json
+     * @returns {OGAnalyticBrep}
+     */
+    static from_primitive(config_json) {
+        const ptr0 = passStringToWasm0(config_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_from_primitive(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticBrep.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get_brep_serialized() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.oganalyticbrep_get_brep_serialized(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} length_unit
+     * @returns {string}
+     */
+    export_step(length_unit) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(length_unit, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.oganalyticbrep_export_step(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} frame_json
+     * @param {number} scale
+     * @returns {OGAnalyticBrep}
+     */
+    placed(frame_json, scale) {
+        const ptr0 = passStringToWasm0(frame_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_placed(this.__wbg_ptr, ptr0, len0, scale);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticBrep.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    prepare_ifc_exchange() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.oganalyticbrep_prepare_ifc_exchange(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {number} face_id
+     * @param {Float64Array} point
+     * @returns {Float64Array}
+     */
+    face_normal_at(face_id, point) {
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_face_normal_at(this.__wbg_ptr, face_id, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * @param {Float64Array} point
+     * @returns {string}
+     */
+    classify_point(point) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.oganalyticbrep_classify_point(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} camera_json
+     * @param {string} hlr_json
+     * @param {number} deflection
+     * @returns {string}
+     */
+    project_to_2d_lines(camera_json, hlr_json, deflection) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(camera_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(hlr_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.oganalyticbrep_project_to_2d_lines(this.__wbg_ptr, ptr0, len0, ptr1, len1, deflection);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {OGAnalyticBrep} other
+     * @param {string} operation
+     * @param {string} id
+     * @returns {OGAnalyticBrep}
+     */
+    boolean_brep(other, operation, id) {
+        _assertClass(other, OGAnalyticBrep);
+        const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_boolean_brep(this.__wbg_ptr, other.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticBrep.__wrap(ret[0]);
+    }
+    /**
+     * @param {number} thickness
+     * @param {string} id
+     * @returns {OGAnalyticBrep}
+     */
+    shell(thickness, id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_shell(this.__wbg_ptr, thickness, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticBrep.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get_boolean_report_serialized() {
+        const ret = wasm.oganalyticbrep_get_boolean_report_serialized(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {number} deflection
+     * @returns {OGAnalyticTessellation}
+     */
+    tessellate(deflection) {
+        const ret = wasm.oganalyticbrep_tessellate(this.__wbg_ptr, deflection);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticTessellation.__wrap(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get_face_count() {
+        const ret = wasm.oganalyticbrep_get_face_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get_edge_count() {
+        const ret = wasm.oganalyticbrep_get_edge_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    get_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.oganalyticbrep_get_id(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get_bounds() {
+        const ret = wasm.oganalyticbrep_get_bounds(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get_vertex_count() {
+        const ret = wasm.oganalyticbrep_get_vertex_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get_revision() {
+        const ret = wasm.oganalyticbrep_get_revision(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+}
+
+const OGAnalyticTessellationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_oganalytictessellation_free(ptr >>> 0, 1));
+
+export class OGAnalyticTessellation {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OGAnalyticTessellation.prototype);
         obj.__wbg_ptr = ptr;
-        Matrix4Finalization.register(obj, obj.__wbg_ptr, obj);
+        OGAnalyticTessellationFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        Matrix4Finalization.unregister(this);
+        OGAnalyticTessellationFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_matrix4_free(ptr, 0);
+        wasm.__wbg_oganalytictessellation_free(ptr, 0);
     }
     /**
      * @returns {Float64Array}
      */
-    get elements() {
-        const ret = wasm.matrix4_elements(this.__wbg_ptr);
+    positions() {
+        const ret = wasm.oganalytictessellation_positions(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}
+     * @returns {Float32Array}
      */
-    multiply(other) {
-        _assertClass(other, Matrix4);
-        const ret = wasm.matrix4_multiply(this.__wbg_ptr, other.__wbg_ptr);
-        return Matrix4.__wrap(ret);
+    normals() {
+        const ret = wasm.oganalytictessellation_normals(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     *
-     *  * Add another Matrix4 to this one.
-     *  * Returns a new Matrix4 instance with the result.
-     *
-     * @param {Matrix4} incoming
-     * @returns {Matrix4}
+     * @returns {Uint32Array}
      */
-    add(incoming) {
-        _assertClass(incoming, Matrix4);
-        const ret = wasm.matrix4_add(this.__wbg_ptr, incoming.__wbg_ptr);
-        return Matrix4.__wrap(ret);
+    indices() {
+        const ret = wasm.oganalytictessellation_indices(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     *
-     *  * Subtract another Matrix4 from this one.
-     *  * Returns a new Matrix4 instance with the result.
-     *
-     * @param {Matrix4} incoming
-     * @returns {Matrix4}
+     * @returns {Uint32Array}
      */
-    subtract(incoming) {
-        _assertClass(incoming, Matrix4);
-        const ret = wasm.matrix4_subtract(this.__wbg_ptr, incoming.__wbg_ptr);
-        return Matrix4.__wrap(ret);
+    triangle_face_ids() {
+        const ret = wasm.oganalytictessellation_triangle_face_ids(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     *
-     *  * Flatten the matrix into a vector of f64.
-     *
      * @returns {Float64Array}
      */
-    flatten() {
-        const ret = wasm.matrix4_flatten(this.__wbg_ptr);
+    outline_positions() {
+        const ret = wasm.oganalytictessellation_outline_positions(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}
+     * @returns {Uint32Array}
      */
-    is_zero() {
-        const ret = wasm.matrix4_is_zero(this.__wbg_ptr);
-        return ret !== 0;
+    outline_edge_ids() {
+        const ret = wasm.oganalytictessellation_outline_edge_ids(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     *
-     *  * Check if the matrix is an identity matrix.
-     *
-     * @returns {boolean}
+     * @returns {bigint}
      */
-    is_identity() {
-        const ret = wasm.matrix4_is_identity(this.__wbg_ptr);
-        return ret !== 0;
+    revision() {
+        const ret = wasm.oganalytictessellation_revision(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-     *
-     *  * Create a Transpose of the matrix.
-     *  * Returns a new Matrix4 instance.
-     *
-     * @returns {Matrix4}
+     * @returns {number}
      */
-    transpose() {
-        const ret = wasm.matrix4_transpose(this.__wbg_ptr);
-        return Matrix4.__wrap(ret);
+    achieved_deflection() {
+        const ret = wasm.oganalytictessellation_achieved_deflection(this.__wbg_ptr);
+        return ret;
     }
 }
 
@@ -1082,95 +1392,6 @@ export class OGArc {
     }
 }
 
-const OGBooleanResultFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ogbooleanresult_free(ptr >>> 0, 1));
-/**
- * Result payload returned across the wasm boundary.
- */
-export class OGBooleanResult {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(OGBooleanResult.prototype);
-        obj.__wbg_ptr = ptr;
-        OGBooleanResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        OGBooleanResultFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ogbooleanresult_free(ptr, 0);
-    }
-    /**
-     * @returns {string}
-     */
-    get brepSerialized() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ogbooleanresult_brepSerialized(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * @returns {string}
-     */
-    get geometrySerialized() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ogbooleanresult_geometrySerialized(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * @returns {string}
-     */
-    get outlineGeometrySerialized() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ogbooleanresult_outlineGeometrySerialized(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * @returns {string}
-     */
-    get reportJson() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ogbooleanresult_reportJson(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 OGCuboidFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ogcuboid_free(ptr >>> 0, 1));
@@ -5243,7 +5464,7 @@ export class OGSphere {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogsphere_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
 }
@@ -5636,7 +5857,7 @@ export class OGSweep {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogellipticalarc_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
     /**
@@ -5920,7 +6141,7 @@ export class OGWedge {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogwedge_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogellipticalarc_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
 }
@@ -6305,7 +6526,7 @@ export class WorkPlane {
      * @returns {Vector3}
      */
     get origin() {
-        const ret = wasm.workplane_origin(this.__wbg_ptr);
+        const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
     /**
@@ -6362,13 +6583,6 @@ function __wbg_get_imports() {
         const ret = Vector3.__unwrap(arg0);
         return ret;
     };
-    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
-        const ret = debugString(arg1);
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
     imports.wbg.__wbindgen_init_externref_table = function() {
         const table = wasm.__wbindgen_export_2;
         const offset = table.grow(4);
@@ -6398,7 +6612,9 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
     cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;