okgeometry-api 0.2.3 → 0.2.5

package/wasm/okgeometrycore_bg.js

@@ -0,0 +1,941 @@
+/**
+ * Get the length of an arc.
+ * @param {number} radius
+ * @param {number} start_angle
+ * @param {number} end_angle
+ * @returns {number}
+ */
+export function arc_length(radius, start_angle, end_angle) {
+    const ret = wasm.arc_length(radius, start_angle, end_angle);
+    return ret;
+}
+
+/**
+ * Evaluate a point on an arc at parameter t ∈ [0,1].
+ * Returns [x, y, z].
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} start_angle
+ * @param {number} end_angle
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function arc_point_at(cx, cy, cz, nx, ny, nz, radius, start_angle, end_angle, t) {
+    const ret = wasm.arc_point_at(cx, cy, cz, nx, ny, nz, radius, start_angle, end_angle, t);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Get the circumference of a circle.
+ * @param {number} radius
+ * @returns {number}
+ */
+export function circle_length(radius) {
+    const ret = wasm.circle_length(radius);
+    return ret;
+}
+
+/**
+ * Evaluate a point on a circle at parameter t ∈ [0,1].
+ * Returns [x, y, z].
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function circle_point_at(cx, cy, cz, nx, ny, nz, radius, t) {
+    const ret = wasm.circle_point_at(cx, cy, cz, nx, ny, nz, radius, t);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Create an arc and return sampled points
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} start_angle
+ * @param {number} end_angle
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function create_arc(cx, cy, cz, nx, ny, nz, radius, start_angle, end_angle, samples) {
+    const ret = wasm.create_arc(cx, cy, cz, nx, ny, nz, radius, start_angle, end_angle, samples);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Create a circle and return sampled points
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function create_circle(cx, cy, cz, nx, ny, nz, radius, samples) {
+    const ret = wasm.create_circle(cx, cy, cz, nx, ny, nz, radius, samples);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Create a line segment and return sampled points
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function create_line(x1, y1, z1, x2, y2, z2, samples) {
+    const ret = wasm.create_line(x1, y1, z1, x2, y2, z2, samples);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Create a polyline and return the points
+ * @param {Float64Array} coords
+ * @param {number} samples_per_segment
+ * @returns {Float64Array}
+ */
+export function create_polyline(coords, samples_per_segment) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_polyline(ptr0, len0, samples_per_segment);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Serialize a curve to a list of points for Three.js rendering
+ * Returns a flat array of coordinates: [x1, y1, z1, x2, y2, z2, ...]
+ * @param {string} curve_type
+ * @param {Float64Array} params
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function curve_to_points(curve_type, params, samples) {
+    const ptr0 = passStringToWasm0(curve_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.curve_to_points(ptr0, len0, ptr1, len1, samples);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Extrude a circle and return mesh buffers
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} segments
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function extrude_circle(cx, cy, cz, nx, ny, nz, radius, dx, dy, dz, segments, with_caps) {
+    const ret = wasm.extrude_circle(cx, cy, cz, nx, ny, nz, radius, dx, dy, dz, segments, with_caps);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Extrude a line segment and return mesh buffers
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} segments
+ * @returns {Float64Array}
+ */
+export function extrude_line(x1, y1, z1, x2, y2, z2, dx, dy, dz, segments) {
+    const ret = wasm.extrude_line(x1, y1, z1, x2, y2, z2, dx, dy, dz, segments);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Extrude a polyline and return mesh buffers
+ * @param {Float64Array} coords
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} segments
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function extrude_polyline(coords, dx, dy, dz, segments, with_caps) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.extrude_polyline(ptr0, len0, dx, dy, dz, segments, with_caps);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Get the length of a line segment.
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @returns {number}
+ */
+export function line_length(x1, y1, z1, x2, y2, z2) {
+    const ret = wasm.line_length(x1, y1, z1, x2, y2, z2);
+    return ret;
+}
+
+/**
+ * Evaluate a point on a line segment at parameter t ∈ [0,1].
+ * Returns [x, y, z].
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function line_point_at(x1, y1, z1, x2, y2, z2, t) {
+    const ret = wasm.line_point_at(x1, y1, z1, x2, y2, z2, t);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Get the tangent direction of a line segment. Returns [x, y, z].
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @returns {Float64Array}
+ */
+export function line_tangent(x1, y1, z1, x2, y2, z2) {
+    const ret = wasm.line_tangent(x1, y1, z1, x2, y2, z2);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Loft between multiple circles
+ *
+ * # Parameters
+ * * `circle_data` - Flat array of circle definitions [cx, cy, cz, nx, ny, nz, radius, ...]
+ * * `segments` - Number of segments to sample along each curve
+ * * `with_caps` - Whether to create end caps
+ *
+ * # Returns
+ * Mesh buffers for the lofted surface
+ * @param {Float64Array} circle_data
+ * @param {number} segments
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function loft_circles(circle_data, segments, with_caps) {
+    const ptr0 = passArrayF64ToWasm0(circle_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.loft_circles(ptr0, len0, segments, with_caps);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Loft between multiple polylines
+ *
+ * # Parameters
+ * * `polyline_data` - Flat array where each polyline is prefixed by its point count:
+ *   [count1, x1, y1, z1, x2, y2, z2, ..., count2, x1, y1, z1, ...]
+ * * `segments` - Number of segments to sample along each curve
+ * * `with_caps` - Whether to create end caps
+ *
+ * # Returns
+ * Mesh buffers for the lofted surface
+ * @param {Float64Array} polyline_data
+ * @param {number} segments
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function loft_polylines(polyline_data, segments, with_caps) {
+    const ptr0 = passArrayF64ToWasm0(polyline_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.loft_polylines(ptr0, len0, segments, with_caps);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Perform boolean intersection on two meshes
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_intersection(vertex_count_a, buffer_a, vertex_count_b, buffer_b) {
+    const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_boolean_intersection(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Perform boolean operation on two meshes
+ *
+ * # Parameters
+ * * `vertex_count_a` - Number of vertices in mesh A
+ * * `buffer_a` - Buffer for mesh A [vertices..., indices...]
+ * * `vertex_count_b` - Number of vertices in mesh B
+ * * `buffer_b` - Buffer for mesh B [vertices..., indices...]
+ * * `operation` - Operation type: "union", "intersection", or "subtraction"
+ *
+ * # Returns
+ * Result mesh buffer [vertices..., indices...]
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_operation(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
+    const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_boolean_operation(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2);
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
+/**
+ * Perform boolean subtraction on two meshes (A - B)
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_subtraction(vertex_count_a, buffer_a, vertex_count_b, buffer_b) {
+    const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_boolean_subtraction(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Perform boolean union on two meshes
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_union(vertex_count_a, buffer_a, vertex_count_b, buffer_b) {
+    const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_boolean_union(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Chamfer all edges of a primitive mesh (flat bevel)
+ *
+ * # Arguments
+ * * `mesh_type` - "box", "cylinder", or "prism"
+ * * `params` - Parameters: [width,height,depth] for box, [radius,height,segments] for cylinder/prism
+ * * `offset` - Chamfer offset distance
+ *
+ * # Returns
+ * Result mesh buffer [vertexCount, vertices..., indices...]
+ * @param {string} mesh_type
+ * @param {Float64Array} params
+ * @param {number} offset
+ * @returns {Float64Array}
+ */
+export function mesh_chamfer_all_edges(mesh_type, params, offset) {
+    const ptr0 = passStringToWasm0(mesh_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_chamfer_all_edges(ptr0, len0, ptr1, len1, offset);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Create a box mesh and return buffers
+ * Returns [vertices..., indices...]
+ * @param {number} width
+ * @param {number} height
+ * @param {number} depth
+ * @returns {Float64Array}
+ */
+export function mesh_create_box(width, height, depth) {
+    const ret = wasm.mesh_create_box(width, height, depth);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Create a cone mesh and return buffers
+ * @param {number} radius
+ * @param {number} height
+ * @param {number} segments
+ * @returns {Float64Array}
+ */
+export function mesh_create_cone(radius, height, segments) {
+    const ret = wasm.mesh_create_cone(radius, height, segments);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Create a cylinder mesh and return buffers
+ * @param {number} radius
+ * @param {number} height
+ * @param {number} segments
+ * @returns {Float64Array}
+ */
+export function mesh_create_cylinder(radius, height, segments) {
+    const ret = wasm.mesh_create_cylinder(radius, height, segments);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Create a prism mesh and return buffers
+ * @param {number} radius
+ * @param {number} height
+ * @param {number} sides
+ * @returns {Float64Array}
+ */
+export function mesh_create_prism(radius, height, sides) {
+    const ret = wasm.mesh_create_prism(radius, height, sides);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Create a sphere mesh and return buffers
+ * @param {number} radius
+ * @param {number} segments
+ * @param {number} rings
+ * @returns {Float64Array}
+ */
+export function mesh_create_sphere(radius, segments, rings) {
+    const ret = wasm.mesh_create_sphere(radius, segments, rings);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Export a mesh to OBJ format
+ * Takes mesh buffers as input (same format as mesh_to_buffers output)
+ * Returns OBJ string
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {string}
+ */
+export function mesh_export_obj(vertex_count, buffer) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mesh_export_obj(vertex_count, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Get mesh statistics
+ * Returns [vertex_count, face_count, edge_count]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_get_stats(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_stats(vertex_count, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Import OBJ data and return mesh buffers
+ * @param {string} obj_data
+ * @returns {Float64Array}
+ */
+export function mesh_import_obj(obj_data) {
+    const ptr0 = passStringToWasm0(obj_data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_import_obj(ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Intersect two meshes, returning intersection polyline points.
+ * Returns: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
+ * @param {number} va_count
+ * @param {Float64Array} buffer_a
+ * @param {number} vb_count
+ * @param {Float64Array} buffer_b
+ * @returns {Float64Array}
+ */
+export function mesh_mesh_intersect(va_count, buffer_a, vb_count, buffer_b) {
+    const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_mesh_intersect(va_count, ptr0, len0, vb_count, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Intersect a mesh with a plane, returning polyline points.
+ * Input: vertex_count, mesh_buffer..., nx, ny, nz, d
+ * Returns: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} d
+ * @returns {Float64Array}
+ */
+export function mesh_plane_intersect(vertex_count, buffer, nx, ny, nz, d) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_plane_intersect(vertex_count, ptr0, len0, nx, ny, nz, d);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Rotate a mesh around an arbitrary axis and return new buffers
+ * Axis is defined by (ax, ay, az), angle in radians
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} angle
+ * @returns {Float64Array}
+ */
+export function mesh_rotate(vertex_count, buffer, ax, ay, az, angle) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_rotate(vertex_count, ptr0, len0, ax, ay, az, angle);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Scale a mesh non-uniformly and return new buffers
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} sx
+ * @param {number} sy
+ * @param {number} sz
+ * @returns {Float64Array}
+ */
+export function mesh_scale(vertex_count, buffer, sx, sy, sz) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_scale(vertex_count, ptr0, len0, sx, sy, sz);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Translate a mesh by an offset vector and return new buffers
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @returns {Float64Array}
+ */
+export function mesh_translate(vertex_count, buffer, dx, dy, dz) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_translate(vertex_count, ptr0, len0, dx, dy, dz);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Intersect two NURBS curves.
+ * Returns: [num_points, x,y,z, ...]
+ * @param {Float64Array} data_a
+ * @param {Float64Array} data_b
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_curve_intersect(data_a, data_b) {
+    const ptr0 = passArrayF64ToWasm0(data_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(data_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_curve_curve_intersect(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Intersect a NURBS curve with a plane.
+ * Input: same curve format as sample_nurbs_curve + plane normal (nx,ny,nz) and d.
+ * Returns: [num_points, x,y,z, x,y,z, ...]
+ * @param {Float64Array} data
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} d
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_plane_intersect(data, nx, ny, nz, d) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_curve_plane_intersect(ptr0, len0, nx, ny, nz, d);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Intersect a NURBS surface with a plane.
+ * Input: same surface format as tessellate_nurbs_surface, then plane (nx,ny,nz,d) appended.
+ * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
+ * @param {Float64Array} surface_data
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} d
+ * @param {number} tess
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_plane_intersect(surface_data, nx, ny, nz, d, tess) {
+    const ptr0 = passArrayF64ToWasm0(surface_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_plane_intersect(ptr0, len0, nx, ny, nz, d, tess);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Intersect two NURBS surfaces.
+ * Returns polyline buffer.
+ * @param {Float64Array} data_a
+ * @param {Float64Array} data_b
+ * @param {number} tess
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_surface_intersect(data_a, data_b, tess) {
+    const ptr0 = passArrayF64ToWasm0(data_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(data_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_surface_intersect(ptr0, len0, ptr1, len1, tess);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Get the total length of a polyline.
+ * Input: flat coords [x1,y1,z1, x2,y2,z2, ...]
+ * @param {Float64Array} coords
+ * @returns {number}
+ */
+export function polyline_length(coords) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.polyline_length(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Evaluate a point on a polyline at parameter t ∈ [0,1].
+ * Input: flat coords [x1,y1,z1, x2,y2,z2, ...]
+ * Returns [x, y, z].
+ * @param {Float64Array} coords
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function polyline_point_at(coords, t) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.polyline_point_at(ptr0, len0, t);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Sample a NURBS curve.
+ * Input: degree, then flat control points [x,y,z,...], then flat weights, then flat knots
+ * Format: [degree, num_pts, x0,y0,z0, ..., w0,w1,..., k0,k1,...]
+ * @param {Float64Array} data
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function sample_nurbs_curve(data, samples) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sample_nurbs_curve(ptr0, len0, samples);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Tessellate a NURBS surface to a mesh buffer.
+ * Input format: [degree_u, degree_v, num_u, num_v, ...control_points(flat)..., ...weights(flat)..., ...knots_u..., ...knots_v..., u_segs, v_segs]
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function tessellate_nurbs_surface(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.tessellate_nurbs_surface(ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Simple test function to verify WASM is working
+ * @returns {string}
+ */
+export function test_wasm() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.test_wasm();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Get version info
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    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);
+}
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+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 passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}