okgeometry-api 1.1.6 → 1.1.7

package/wasm/okgeometrycore_bg.js

@@ -1,1686 +0,0 @@
-/**
- * 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;
-}
-
-/**
- * Chamfer corners of a polyline by cutting each corner with a straight segment.
- * Input: flat coords [x1,y1,z1, ...], distance from corner to cut.
- * Output: encoded polycurve segments [segment_count, type, ...data, ...]
- *   type 0 = Line: [sx,sy,sz, ex,ey,ez]
- * @param {Float64Array} coords
- * @param {number} distance
- * @returns {Float64Array}
- */
-export function chamfer_polycurve(coords, distance) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.chamfer_polycurve(ptr0, len0, distance);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * 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;
-}
-
-/**
- * Evaluate a NURBS curve at normalized parameter t in [0,1].
- * Returns [x, y, z].
- * @param {Float64Array} data
- * @param {number} t
- * @returns {Float64Array}
- */
-export function evaluate_nurbs_curve_at(data, t) {
-    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.evaluate_nurbs_curve_at(ptr0, len0, t);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * 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.
- * Uses the polyline's actual vertices (no resampling) to preserve sharp corners.
- * @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;
-}
-
-/**
- * Fillet corners of a polyline with arcs of a given radius.
- * Input: flat coords [x1,y1,z1, ...], radius, plane normal (nx,ny,nz; 0,0,0 for auto).
- * Output: encoded polycurve segments [segment_count, type, ...data, type, ...data, ...]
- *   type 0 = Line: [sx,sy,sz, ex,ey,ez]
- *   type 1 = Arc: [cx,cy,cz, nx,ny,nz, radius, start_angle, end_angle]
- * @param {Float64Array} coords
- * @param {number} radius
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz
- * @returns {Float64Array}
- */
-export function fillet_polycurve(coords, radius, nx, ny, nz) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.fillet_polycurve(ptr0, len0, radius, nx, ny, nz);
-    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;
-}
-
-/**
- * Offset a line segment perpendicular to line direction relative to reference normal.
- * Returns [startX,startY,startZ,endX,endY,endZ]
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} x2
- * @param {number} y2
- * @param {number} z2
- * @param {number} distance
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz
- * @returns {Float64Array}
- */
-export function line_offset(x1, y1, z1, x2, y2, z2, distance, nx, ny, nz) {
-    const ret = wasm.line_offset(x1, y1, z1, x2, y2, z2, distance, nx, ny, nz);
-    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v1;
-}
-
-/**
- * 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 a NURBS surface through multiple NURBS curves.
- * Input: [num_curves, degree_v, curve1_data..., curve2_data..., ...]
- * Each curve_data: [degree, num_pts, x,y,z,..., w0,w1,..., k0,k1,...]
- * Returns the NurbsSurface data (same format as tessellate input, without u_segs/v_segs).
- * @param {Float64Array} data
- * @returns {Float64Array}
- */
-export function loft_nurbs_surface(data) {
-    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.loft_nurbs_surface(ptr0, len0);
-    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` - Ignored for polylines (kept for API compat). Points are used directly.
- * * `with_caps` - Whether to create end caps (fan triangulation from center)
- *
- * # 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;
-}
-
-/**
- * Make multiple NURBS curves compatible (same knot vectors, same CP count).
- * Input: [curve_count, curve1_data..., curve2_data..., ...]
- * Each curve: [degree, num_cp, cp_xyz..., weights..., knots...]
- * Output: same format with unified curves.
- * @param {Float64Array} curves_data
- * @returns {Float64Array}
- */
-export function make_nurbs_curves_compatible(curves_data) {
-    const ptr0 = passArrayF64ToWasm0(curves_data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.make_nurbs_curves_compatible(ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Apply a 4x4 transformation matrix to a mesh.
- * matrix: flat [m00,m01,m02,m03, m10,m11,..., m30,m31,m32,m33] (16 elements, row-major)
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {Float64Array} matrix
- * @returns {Float64Array}
- */
-export function mesh_apply_matrix(vertex_count, buffer, matrix) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArrayF64ToWasm0(matrix, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_apply_matrix(vertex_count, ptr0, len0, ptr1, len1);
-    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v3;
-}
-
-/**
- * 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;
-}
-
-/**
- * Extract boundary (perimeter) edges from a mesh as polylines.
- * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @returns {Float64Array}
- */
-export function mesh_boundary_polylines(vertex_count, buffer) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_boundary_polylines(vertex_count, ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Coplanar connected face groups.
- * Output format:
- * [groupCount, triCount, tri..., centroidX,centroidY,centroidZ, normalX,normalY,normalZ, ...]
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @returns {Float64Array}
- */
-export function mesh_build_coplanar_connected_face_groups(vertex_count, buffer) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_build_coplanar_connected_face_groups(vertex_count, ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * 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;
-}
-
-/**
- * Compute planar curve normal from ordered points.
- * @param {Float64Array} coords
- * @param {boolean} closed
- * @returns {Float64Array}
- */
-export function mesh_compute_planar_curve_normal(coords, closed) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_compute_planar_curve_normal(ptr0, len0, closed);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Odd/even mesh containment test.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {boolean}
- */
-export function mesh_contains_point(vertex_count, buffer, px, py, pz) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_contains_point(vertex_count, ptr0, len0, px, py, pz);
-    return ret !== 0;
-}
-
-/**
- * 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;
-}
-
-/**
- * Evaluate a point on a mesh surface at parametric coordinates (u, v).
- * Maps u ∈ [0,1] and v ∈ [0,1] to the mesh's AABB bounding box,
- * then casts a ray perpendicular to the best-fit projection plane.
- * Returns [x, y, z] of the intersection point, or [NaN, NaN, NaN] if no hit.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} u
- * @param {number} v
- * @returns {Float64Array}
- */
-export function mesh_evaluate(vertex_count, buffer, u, v) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_evaluate(vertex_count, ptr0, len0, u, v);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * 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);
-    }
-}
-
-/**
- * Push/pull a planar face set by moving its coplanar connected region.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @param {number} distance
- * @returns {Float64Array}
- */
-export function mesh_extrude_face(vertex_count, buffer, face_index, distance) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_extrude_face(vertex_count, ptr0, len0, face_index, distance);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Extrude planar curve profile by normal * height.
- * @param {Float64Array} coords
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz
- * @param {number} height
- * @param {boolean} closed
- * @returns {Float64Array}
- */
-export function mesh_extrude_planar_curve(coords, nx, ny, nz, height, closed) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_extrude_planar_curve(ptr0, len0, nx, ny, nz, height, closed);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Find the best matching coplanar connected face group by normal and optional near-point.
- * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz
- * @param {number} near_x
- * @param {number} near_y
- * @param {number} near_z
- * @param {boolean} use_near_point
- * @returns {Float64Array}
- */
-export function mesh_find_face_group_by_normal(vertex_count, buffer, nx, ny, nz, near_x, near_y, near_z, use_near_point) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_find_face_group_by_normal(vertex_count, ptr0, len0, nx, ny, nz, near_x, near_y, near_z, use_near_point);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Find the coplanar connected face group containing triangle_index.
- * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} triangle_index
- * @returns {Float64Array}
- */
-export function mesh_find_face_group_by_triangle_index(vertex_count, buffer, triangle_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_find_face_group_by_triangle_index(vertex_count, ptr0, len0, triangle_index);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Axis-aligned bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @returns {Float64Array}
- */
-export function mesh_get_bounds(vertex_count, buffer) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_bounds(vertex_count, ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Coplanar connected face-group centroid containing a given triangle face index.
- * Output format: [x, y, z] or [] when unavailable.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {Float64Array}
- */
-export function mesh_get_coplanar_face_group_centroid(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_coplanar_face_group_centroid(vertex_count, ptr0, len0, face_index);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Edge-connected coplanar triangle indices as [count, i0, i1, ...].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {Float64Array}
- */
-export function mesh_get_coplanar_face_indices(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_coplanar_face_indices(vertex_count, ptr0, len0, face_index);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Coplanar connected face region projected to a plane basis.
- * Output format:
- * [faceCount, faceIndex0, faceIndex1, ..., uMin, uMax, vMin, vMax]
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @param {number} ox
- * @param {number} oy
- * @param {number} oz
- * @param {number} ux
- * @param {number} uy
- * @param {number} uz
- * @param {number} vx
- * @param {number} vy
- * @param {number} vz
- * @param {number} margin_scale
- * @param {number} min_margin
- * @returns {Float64Array}
- */
-export function mesh_get_coplanar_face_region(vertex_count, buffer, face_index, ox, oy, oz, ux, uy, uz, vx, vy, vz, margin_scale, min_margin) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_coplanar_face_region(vertex_count, ptr0, len0, face_index, ox, oy, oz, ux, uy, uz, vx, vy, vz, margin_scale, min_margin);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Unique undirected triangle edges as [edgeCount, v0a, v0b, v1a, v1b, ...].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @returns {Float64Array}
- */
-export function mesh_get_edge_vertex_pairs(vertex_count, buffer) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_edge_vertex_pairs(vertex_count, ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Face area.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {number}
- */
-export function mesh_get_face_area(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_face_area(vertex_count, ptr0, len0, face_index);
-    return ret;
-}
-
-/**
- * Face centroid as [x, y, z].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {Float64Array}
- */
-export function mesh_get_face_centroid(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_face_centroid(vertex_count, ptr0, len0, face_index);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Face normal as [x, y, z].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {Float64Array}
- */
-export function mesh_get_face_normal(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_face_normal(vertex_count, ptr0, len0, face_index);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * 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;
-}
-
-/**
- * Check if triangulated mesh is a closed volume (no welded boundary edges).
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @returns {boolean}
- */
-export function mesh_is_closed_volume(vertex_count, buffer) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_is_closed_volume(vertex_count, ptr0, len0);
-    return ret !== 0;
-}
-
-/**
- * Merge multiple mesh buffers while preserving per-mesh vertex order and index remapping.
- * Input format: [mesh_count, len1, mesh1..., len2, mesh2..., ...]
- * @param {Float64Array} mesh_data
- * @returns {Float64Array}
- */
-export function mesh_merge(mesh_data) {
-    const ptr0 = passArrayF64ToWasm0(mesh_data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_merge(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;
-}
-
-/**
- * Create a planar patch mesh from boundary points using CDT.
- * Correctly handles concave polygons (unlike fan triangulation).
- * Input: flat coordinate array [x1,y1,z1, x2,y2,z2, ...]
- * Output: mesh buffer [vertexCount, x1,y1,z1,..., i0,i1,i2, ...]
- * @param {Float64Array} coords
- * @returns {Float64Array}
- */
-export function mesh_patch_from_points(coords) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_patch_from_points(ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * 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;
-}
-
-/**
- * Shift closed boolean cutter curve and adjust height.
- * Returns [height, epsilon, pointCount, x,y,z,...]
- * @param {Float64Array} coords
- * @param {boolean} closed
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz
- * @param {number} height
- * @returns {Float64Array}
- */
-export function mesh_prepare_boolean_cutter_curve(coords, closed, nx, ny, nz, height) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_prepare_boolean_cutter_curve(ptr0, len0, closed, nx, ny, nz, height);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Raycast against mesh and return closest hit.
- * Output: [] when no hit, otherwise [pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance]
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} ox
- * @param {number} oy
- * @param {number} oz
- * @param {number} dx
- * @param {number} dy
- * @param {number} dz
- * @param {number} max_distance
- * @returns {Float64Array}
- */
-export function mesh_raycast(vertex_count, buffer, ox, oy, oz, dx, dy, dz, max_distance) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_raycast(vertex_count, ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Raycast against mesh and return all hits sorted by distance.
- * Output: [hitCount, (point, normal, faceIndex, distance)*]
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} ox
- * @param {number} oy
- * @param {number} oz
- * @param {number} dx
- * @param {number} dy
- * @param {number} dz
- * @param {number} max_distance
- * @returns {Float64Array}
- */
-export function mesh_raycast_all(vertex_count, buffer, ox, oy, oz, dx, dy, dz, max_distance) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_raycast_all(vertex_count, ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Raycast against many meshes packed as:
- * [meshCount, meshLen0, meshRaw0..., meshLen1, meshRaw1..., ...]
- * Output: [hitCount, meshIndex, pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance, ...]
- * @param {Float64Array} mesh_data
- * @param {number} ox
- * @param {number} oy
- * @param {number} oz
- * @param {number} dx
- * @param {number} dy
- * @param {number} dz
- * @param {number} max_distance
- * @returns {Float64Array}
- */
-export function mesh_raycast_many(mesh_data, ox, oy, oz, dx, dy, dz, max_distance) {
-    const ptr0 = passArrayF64ToWasm0(mesh_data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_raycast_many(ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
-    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;
-}
-
-/**
- * Evaluate a NURBS surface at (u, v) parameters.
- * Input format: same as tessellate but last 2 values are u, v instead of u_segs, v_segs
- * Returns [x, y, z]
- * @param {Float64Array} data
- * @param {number} u
- * @param {number} v
- * @returns {Float64Array}
- */
-export function nurbs_surface_evaluate(data, u, v) {
-    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.nurbs_surface_evaluate(ptr0, len0, u, v);
-    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;
-}
-
-/**
- * Offset a polyline by a distance in a given plane.
- * If nx=ny=nz=0, the plane normal is auto-detected.
- * Returns flat [x1,y1,z1, x2,y2,z2, ...] of the offset polyline.
- * @param {Float64Array} coords
- * @param {number} distance
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz
- * @returns {Float64Array}
- */
-export function offset_polyline_curve(coords, distance, nx, ny, nz) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.offset_polyline_curve(ptr0, len0, distance, nx, ny, nz);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Convert a polycurve (Line/Arc segments) to an exact NURBS curve.
- * Input format: [segment_count, type1, ...data1..., type2, ...data2..., ...]
- * type 0 = Line (6 floats: start_xyz, end_xyz)
- * type 1 = Arc (9 floats: center_xyz, normal_xyz, radius, start_angle, end_angle)
- * Output format: [degree, num_cp, cp_x1,y1,z1,..., w1,w2,..., k1,k2,...]
- * @param {Float64Array} segment_data
- * @returns {Float64Array}
- */
-export function polycurve_to_nurbs(segment_data) {
-    const ptr0 = passArrayF64ToWasm0(segment_data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.polycurve_to_nurbs(ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * 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;
-}
-
-/**
- * Find the closest point on a ray to a given point.
- * Returns [x, y, z] of the closest point on the ray.
- * @param {number} ox
- * @param {number} oy
- * @param {number} oz
- * @param {number} dx
- * @param {number} dy
- * @param {number} dz
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {Float64Array}
- */
-export function ray_closest_point(ox, oy, oz, dx, dy, dz, px, py, pz) {
-    const ret = wasm.ray_closest_point(ox, oy, oz, dx, dy, dz, px, py, pz);
-    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v1;
-}
-
-/**
- * Find the parameter t for the closest point on a ray to a given point.
- * The closest point is at: origin + t * direction
- * Note: t can be negative if the closest point is "behind" the ray origin.
- * @param {number} ox
- * @param {number} oy
- * @param {number} oz
- * @param {number} dx
- * @param {number} dy
- * @param {number} dz
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number}
- */
-export function ray_closest_point_parameter(ox, oy, oz, dx, dy, dz, px, py, pz) {
-    const ret = wasm.ray_closest_point_parameter(ox, oy, oz, dx, dy, dz, px, py, pz);
-    return ret;
-}
-
-/**
- * Compute the distance from a ray to a point.
- * Ray is defined by origin (ox, oy, oz) and direction (dx, dy, dz).
- * Direction should be normalized for accurate distance.
- * Returns the perpendicular distance from the ray to the point.
- * @param {number} ox
- * @param {number} oy
- * @param {number} oz
- * @param {number} dx
- * @param {number} dy
- * @param {number} dz
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number}
- */
-export function ray_distance_to_point(ox, oy, oz, dx, dy, dz, px, py, pz) {
-    const ret = wasm.ray_distance_to_point(ox, oy, oz, dx, dy, dz, px, py, pz);
-    return ret;
-}
-
-/**
- * Get a point along the ray at parameter t.
- * Returns [x, y, z] = origin + t * direction
- * @param {number} ox
- * @param {number} oy
- * @param {number} oz
- * @param {number} dx
- * @param {number} dy
- * @param {number} dz
- * @param {number} t
- * @returns {Float64Array}
- */
-export function ray_point_at(ox, oy, oz, dx, dy, dz, t) {
-    const ret = wasm.ray_point_at(ox, oy, oz, dx, dy, dz, t);
-    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v1;
-}
-
-/**
- * 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;
-}
-
-/**
- * Sweep a profile curve along a path curve using exact curve evaluation.
- * profile_data/path_data: encoded curve (see decode_curve)
- * Returns mesh buffers.
- * @param {Float64Array} profile_data
- * @param {Float64Array} path_data
- * @param {number} profile_segments
- * @param {number} path_segments
- * @param {boolean} with_caps
- * @returns {Float64Array}
- */
-export function sweep_curves(profile_data, path_data, profile_segments, path_segments, with_caps) {
-    const ptr0 = passArrayF64ToWasm0(profile_data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArrayF64ToWasm0(path_data, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.sweep_curves(ptr0, len0, ptr1, len1, profile_segments, path_segments, with_caps);
-    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v3;
-}
-
-/**
- * Sweep a profile polyline along a path polyline.
- * profile_coords: flat [x,y,z,...] for profile curve
- * path_coords: flat [x,y,z,...] for path curve
- * with_caps: whether to close the ends
- * Returns mesh buffers.
- * @param {Float64Array} profile_coords
- * @param {Float64Array} path_coords
- * @param {boolean} with_caps
- * @returns {Float64Array}
- */
-export function sweep_polylines(profile_coords, path_coords, with_caps) {
-    const ptr0 = passArrayF64ToWasm0(profile_coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArrayF64ToWasm0(path_coords, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.sweep_polylines(ptr0, len0, ptr1, len1, with_caps);
-    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v3;
-}
-
-/**
- * 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;
-}