matterviz 0.4.2 → 0.4.3

package/dist/layout/json-tree/utils.js

@@ -1,5 +1,5 @@
-// Pre-compiled regex for valid JS identifiers (used in path formatting)
-const VALID_IDENTIFIER_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+// JSON Tree utility functions
+import { build_path, format_path, parse_path } from '../../json-path';
 // Circular-safe JSON.stringify helper (hoisted for reuse)
 function safe_stringify(val) {
     const seen = new WeakSet();
@@ -26,34 +26,22 @@ export function get_value_type(value) {
     if (value === undefined)
         return `undefined`;
     const type = typeof value;
-    if (type === `string`)
-        return `string`;
-    if (type === `number`)
-        return `number`;
-    if (type === `boolean`)
-        return `boolean`;
-    if (type === `symbol`)
-        return `symbol`;
-    if (type === `bigint`)
-        return `bigint`;
-    if (type === `function`)
-        return `function`;
-    if (type === `object`) {
-        if (Array.isArray(value))
-            return `array`;
-        if (value instanceof Date)
-            return `date`;
-        if (value instanceof RegExp)
-            return `regexp`;
-        if (value instanceof Map)
-            return `map`;
-        if (value instanceof Set)
-            return `set`;
-        if (value instanceof Error)
-            return `error`;
-        return `object`;
-    }
-    return `object`; // fallback
+    // string/number/boolean/symbol/bigint/function map directly to JsonValueType
+    if (type !== `object`)
+        return type;
+    if (Array.isArray(value))
+        return `array`;
+    if (value instanceof Date)
+        return `date`;
+    if (value instanceof RegExp)
+        return `regexp`;
+    if (value instanceof Map)
+        return `map`;
+    if (value instanceof Set)
+        return `set`;
+    if (value instanceof Error)
+        return `error`;
+    return `object`;
 }
 // Check if a value type is expandable (has children)
 export const is_expandable_type = (value_type) => value_type === `object` ||
@@ -82,40 +70,6 @@ export function get_child_count(value) {
         return value.size;
     return 0;
 }
-// Format a path segment for display
-// Handles both string keys and numeric indices
-// is_first: true for the first segment (no leading dot for valid identifiers)
-function format_path_segment(segment, is_first = false) {
-    if (typeof segment === `number`) {
-        return `[${segment}]`;
-    }
-    // Check if the key is a valid identifier (can use dot notation)
-    if (VALID_IDENTIFIER_RE.test(segment)) {
-        return is_first ? segment : `.${segment}`;
-    }
-    // Use bracket notation for keys with special characters
-    return `["${segment.replaceAll('"', `\\"`)}"]`;
-}
-// Format a full path from segments
-// e.g., ["users", 0, "name"] -> "users[0].name"
-// e.g., [0, "name"] -> "[0].name" (root numeric index)
-// e.g., ["key.with.dot"] -> '["key.with.dot"]' (root special key)
-export function format_path(segments) {
-    if (segments.length === 0)
-        return ``;
-    let result = format_path_segment(segments[0], true);
-    for (let idx = 1; idx < segments.length; idx++) {
-        result += format_path_segment(segments[idx]);
-    }
-    return result;
-}
-// Build a path string from parent path and key
-export function build_path(parent_path, key) {
-    if (!parent_path) {
-        return format_path_segment(key, true);
-    }
-    return parent_path + format_path_segment(key);
-}
 // Format a primitive/special value to string (shared by serialize and preview)
 function format_special_value(value, type) {
     if (type === `undefined`)
@@ -190,18 +144,13 @@ export function matches_search(path, key, value, query) {
     if (!query)
         return false;
     const lower_query = query.toLowerCase();
-    // Check path
     if (path.toLowerCase().includes(lower_query))
         return true;
-    // Check key
     if (key !== null && String(key).toLowerCase().includes(lower_query))
         return true;
-    // Check value (for primitives)
-    const type = get_value_type(value);
-    if (is_primitive_type(type)) {
-        return String(value).toLowerCase().includes(lower_query);
-    }
-    return false;
+    // Check value (only primitives are searchable as strings)
+    return (is_primitive_type(get_value_type(value)) &&
+        String(value).toLowerCase().includes(lower_query));
 }
 // Iterate over children of an expandable value, calling visitor for each
 function for_each_child(value, type, visitor) {
@@ -291,89 +240,31 @@ export function get_ancestor_paths(path) {
     }
     return ancestors;
 }
-// Parse a path string into segments
-// e.g., "users[0].name" -> ["users", 0, "name"]
-export function parse_path(path) {
-    if (!path)
-        return [];
-    const segments = [];
-    let current = ``;
-    let in_bracket = false;
-    // Bracket tokens are numeric indices or quoted keys (quotes stripped, \" unescaped)
-    const push_bracket_token = (token) => {
-        const num = Number(token);
-        if (Number.isNaN(num)) {
-            segments.push(token.replaceAll(/^"|"$/g, ``).replaceAll(String.raw `\"`, `"`));
-        }
-        else
-            segments.push(num);
-    };
-    for (const char of path) {
-        if (char === `.` && !in_bracket) {
-            if (current)
-                segments.push(current);
-            current = ``;
-        }
-        else if (char === `[`) {
-            if (current)
-                segments.push(current);
-            current = ``;
-            in_bracket = true;
-        }
-        else if (char === `]`) {
-            if (current)
-                push_bracket_token(current);
-            current = ``;
-            in_bracket = false;
-        }
-        else
-            current += char;
-    }
-    // Handle trailing content (e.g., unclosed bracket like "a[0")
-    if (current) {
-        if (in_bracket)
-            push_bracket_token(current);
-        else
-            segments.push(current);
-    }
-    return segments;
-}
 // Check if two values are deeply equal (for change detection)
 export function values_equal(val_a, val_b) {
     if (val_a === val_b)
         return true;
-    // Handle NaN (NaN !== NaN in JS, but we want NaN === NaN for change detection)
-    if (typeof val_a === `number` &&
-        typeof val_b === `number` &&
-        Number.isNaN(val_a) &&
-        Number.isNaN(val_b))
-        return true;
-    if (val_a === null || val_b === null)
-        return false;
-    if (typeof val_a !== typeof val_b)
+    // NaN !== NaN in JS, but we want NaN === NaN for change detection
+    if (typeof val_a === `number` && typeof val_b === `number`) {
+        return Number.isNaN(val_a) && Number.isNaN(val_b);
+    }
+    if (val_a === null || val_b === null || typeof val_a !== typeof val_b)
         return false;
     const type = get_value_type(val_a);
-    // For primitives, strict equality is sufficient
-    if (is_primitive_type(type) || type === `symbol`) {
-        return val_a === val_b;
-    }
-    // For dates, compare timestamps
-    if (type === `date`) {
+    if (type !== get_value_type(val_b))
+        return false;
+    if (is_primitive_type(type) || type === `symbol`)
+        return false; // strict equality failed above
+    if (type === `date`)
         return val_a.getTime() === val_b.getTime();
-    }
-    // For regex, compare string representation
-    if (type === `regexp`) {
+    if (type === `regexp`)
         return val_a.toString() === val_b.toString();
-    }
-    // For objects and arrays, do shallow comparison (for performance)
-    // Deep changes will be detected at the child level
-    if (type === `array`) {
+    // Objects and arrays use shallow size comparison for performance —
+    // deep changes are detected at the child level
+    if (type === `array`)
         return val_a.length === val_b.length;
-    }
     if (type === `object`) {
-        const keys_a = Object.keys(val_a);
-        const keys_b = Object.keys(val_b);
-        return keys_a.length === keys_b.length;
+        return Object.keys(val_a).length === Object.keys(val_b).length;
     }
     return false;
 }
@@ -513,42 +404,27 @@ export function format_byte_size(bytes) {
 export function compute_diff(old_val, new_val, current_path = ``, result = new Map(), seen = new WeakSet()) {
     const old_type = get_value_type(old_val);
     const new_type = get_value_type(new_val);
+    const mark_changed = () => result.set(current_path, {
+        status: `changed`,
+        path: current_path,
+        old_value: old_val,
+        new_value: new_val,
+    });
     // Different types = changed
     if (old_type !== new_type) {
-        result.set(current_path, {
-            status: `changed`,
-            path: current_path,
-            old_value: old_val,
-            new_value: new_val,
-        });
+        mark_changed();
         return result;
     }
-    // Both primitive: compare values (with NaN === NaN special case)
+    // Both primitive: compare values (values_equal treats NaN === NaN)
     if (is_primitive_type(old_type)) {
-        const both_nan = typeof old_val === `number` &&
-            typeof new_val === `number` &&
-            Number.isNaN(old_val) &&
-            Number.isNaN(new_val);
-        if (!both_nan && old_val !== new_val) {
-            result.set(current_path, {
-                status: `changed`,
-                path: current_path,
-                old_value: old_val,
-                new_value: new_val,
-            });
-        }
+        if (!values_equal(old_val, new_val))
+            mark_changed();
         return result;
     }
     // Non-expandable special types (date, regexp, etc): compare string forms
     if (!is_expandable_type(old_type)) {
-        if (String(old_val) !== String(new_val)) {
-            result.set(current_path, {
-                status: `changed`,
-                path: current_path,
-                old_value: old_val,
-                new_value: new_val,
-            });
-        }
+        if (String(old_val) !== String(new_val))
+            mark_changed();
         return result;
     }
     // Prevent circular references
@@ -616,13 +492,8 @@ export function compute_diff(old_val, new_val, current_path = ``, result = new M
     }
     // Maps: wrap entries as { key, value } to match JsonNode.get_children() rendering
     if (old_type === `map`) {
-        diff_indexed(Array.from(old_val.entries()).map(([key, val]) => ({
-            key,
-            value: val,
-        })), Array.from(new_val.entries()).map(([key, val]) => ({
-            key,
-            value: val,
-        })));
+        const wrap_entries = (map) => Array.from(map, ([key, value]) => ({ key, value }));
+        diff_indexed(wrap_entries(old_val), wrap_entries(new_val));
         return result;
     }
     if (old_type === `set`) {

package/dist/marching-cubes.d.ts

@@ -1,14 +1,21 @@
-import type { Matrix3x3, Vec3 } from './math';
+import { type Matrix3x3, type Vec3 } from './math';
 export interface MarchingCubesResult {
     vertices: Vec3[];
     faces: number[][];
     normals: Vec3[];
 }
+export interface MarchingCubesBuffers {
+    positions: Float32Array;
+    indices: Uint32Array;
+    normals: Float32Array;
+}
 export interface MarchingCubesOptions {
     periodic?: boolean;
     interpolate?: boolean;
     centered?: boolean;
     normals?: boolean;
+    position_offset?: Vec3;
 }
+export declare function marching_cubes_buffers(grid: number[][][], iso_value: number, k_lattice: Matrix3x3, options?: MarchingCubesOptions): MarchingCubesBuffers;
 export declare function marching_cubes(grid: number[][][], iso_value: number, k_lattice: Matrix3x3, options?: MarchingCubesOptions): MarchingCubesResult;
 export declare function compute_vertex_normals(vertices: Vec3[], faces: number[][]): Vec3[];

package/dist/marching-cubes.js

@@ -1,3 +1,6 @@
+// Marching Cubes algorithm for isosurface extraction
+// Based on the classic algorithm by Lorensen & Cline (1987)
+import { mat3x3_vec3_multiply, matrix_inverse_3x3 } from './math';
 const wrap_grid_idx = (val, dim) => ((val % dim) + dim) % dim;
 const clamp_grid_idx = (val, max) => Math.max(0, Math.min(val, max));
 // Edge table: for each cube configuration (256 cases), which edges are intersected
@@ -311,18 +314,18 @@ function compute_gradient(grid, ix, iy, iz, nx, ny, nz, periodic) {
     const [iz_m, iz_p] = periodic
         ? [wrap_grid_idx(iz - 1, nz), wrap_grid_idx(iz + 1, nz)]
         : [Math.max(0, iz - 1), Math.min(nz - 1, iz + 1)];
-    const dx = (grid[ix_p][iy_w][iz_w] - grid[ix_m][iy_w][iz_w]) * 0.5;
-    const dy = (grid[ix_w][iy_p][iz_w] - grid[ix_w][iy_m][iz_w]) * 0.5;
-    const dz = (grid[ix_w][iy_w][iz_p] - grid[ix_w][iy_w][iz_m]) * 0.5;
-    const len_sq = dx * dx + dy * dy + dz * dz;
-    if (len_sq < 1e-20)
-        return [0, 0, 1];
-    const inv_len = 1 / Math.sqrt(len_sq);
-    return [-dx * inv_len, -dy * inv_len, -dz * inv_len];
+    const x_lo = grid[ix_m][iy_w][iz_w];
+    const x_hi = grid[ix_p][iy_w][iz_w];
+    const y_lo = grid[ix_w][iy_m][iz_w];
+    const y_hi = grid[ix_w][iy_p][iz_w];
+    const z_row = grid[ix_w][iy_w];
+    const scale = (lo, hi) => 1 / Math.max(1, periodic ? 2 : hi - lo);
+    const gz = -(z_row[iz_p] - z_row[iz_m]) * scale(iz_m, iz_p);
+    return [-(x_hi - x_lo) * scale(ix_m, ix_p), -(y_hi - y_lo) * scale(iy_m, iy_p), gz];
 }
 // Main marching cubes algorithm (optimized version)
-export function marching_cubes(grid, iso_value, k_lattice, options = {}) {
-    const { periodic = true, interpolate = true, centered = true, normals: compute_norms = true, } = options;
+function marching_cubes_raw(grid, iso_value, k_lattice, options = {}) {
+    const { periodic = true, interpolate = true, centered = true, normals: compute_norms = true, position_offset, } = options;
     // When centered=true, shift fractional coordinates by -0.5 so the grid is
     // centered at the origin (Γ point). This is needed for proper BZ visualization.
     const center_offset = centered ? 0.5 : 0;
@@ -330,24 +333,30 @@ export function marching_cubes(grid, iso_value, k_lattice, options = {}) {
     const ny = grid[0]?.length || 0;
     const nz = grid[0]?.[0]?.length || 0;
     if (nx < 2 || ny < 2 || nz < 2) {
-        return { vertices: [], faces: [], normals: [] };
+        return { positions: [], indices: [], normals: [] };
     }
-    const vertices = [];
-    const faces = [];
+    const positions = [];
+    const indices = [];
     const normals = [];
-    // Cache keys use UNWRAPPED grid coords (reach n in periodic mode, hence radix n+1):
-    // wrapping would merge vertices on opposite cell faces into cell-spanning triangles.
-    const key_nz = nz + 1;
-    const key_ny_nz = (ny + 1) * key_nz;
-    const max_flat = (nx + 1) * key_ny_nz; // for computing cache keys
-    // Use numeric cache key - safe for grids up to ~300³ (2^53 / 2 / max_flat)
-    // For much larger grids (>30M cells), consider switching to Map<string, number>
-    // with keys like `${flat1},${flat2}` or Map<bigint, number> to avoid
-    // Number.MAX_SAFE_INTEGER limits. The current approach is faster for typical grids.
-    if (max_flat > 30_000_000) {
-        console.warn(`Grid size ${nx}×${ny}×${nz} may cause cache key overflow`);
-    }
-    const vertex_cache = new Map();
+    // Iterate over all cubes in the grid
+    const max_x = periodic ? nx : nx - 1;
+    const max_y = periodic ? ny : ny - 1;
+    const max_z = periodic ? nz : nz - 1;
+    // Rolling typed edge caches retain only the current x slab. Coordinates stay
+    // UNWRAPPED (reach n in periodic mode), so opposite cell faces remain distinct
+    // and never create cell-spanning triangles.
+    const edge_stride = max_z + 1;
+    const edge_plane_size = (max_y + 1) * edge_stride;
+    const x_edge_cache = new Int32Array(edge_plane_size);
+    let y_edge_current = new Int32Array(edge_plane_size);
+    let y_edge_next = new Int32Array(edge_plane_size);
+    let z_edge_current = new Int32Array(edge_plane_size);
+    let z_edge_next = new Int32Array(edge_plane_size);
+    x_edge_cache.fill(-1);
+    y_edge_current.fill(-1);
+    y_edge_next.fill(-1);
+    z_edge_current.fill(-1);
+    z_edge_next.fill(-1);
     // Precompute k_lattice values for faster coordinate transform
     const [kx0, kx1, kx2] = k_lattice[0];
     const [ky0, ky1, ky2] = k_lattice[1];
@@ -358,6 +367,16 @@ export function marching_cubes(grid, iso_value, k_lattice, options = {}) {
     const inv_nx = 1 / (periodic ? nx : nx - 1);
     const inv_ny = 1 / (periodic ? ny : ny - 1);
     const inv_nz = 1 / (periodic ? nz : nz - 1);
+    // Singular lattices cannot map covectors; fall back to index-space unit gradients.
+    let normal_transform = null;
+    if (compute_norms) {
+        try {
+            normal_transform = matrix_inverse_3x3(k_lattice);
+        }
+        catch {
+            /* keep null */
+        }
+    }
     // Get or create vertex on an edge (fully optimized with flat array lookups)
     const get_vertex_on_edge = (ix, iy, iz, edge_idx, cube_values) => {
         // Use flat arrays instead of destructuring
@@ -369,13 +388,24 @@ export function marching_cubes(grid, iso_value, k_lattice, options = {}) {
         const ox2 = CUBE_VERTS_X[v2_idx];
         const oy2 = CUBE_VERTS_Y[v2_idx];
         const oz2 = CUBE_VERTS_Z[v2_idx];
-        // Sorted numeric key from UNWRAPPED coords (value/gradient lookups wrap internally).
-        // Safe for grids up to ~300³ before exceeding Number.MAX_SAFE_INTEGER
-        const flat1 = (ix + ox1) * key_ny_nz + (iy + oy1) * key_nz + (iz + oz1);
-        const flat2 = (ix + ox2) * key_ny_nz + (iy + oy2) * key_nz + (iz + oz2);
-        const cache_key = flat1 < flat2 ? flat1 * max_flat + flat2 : flat2 * max_flat + flat1;
-        const cached = vertex_cache.get(cache_key);
-        if (cached !== undefined)
+        // Key the edge's lower endpoint. For x-edges, x is the rolling slab and
+        // y/z are equal; y- and z-edges normalize their sole varying key coordinate.
+        let cache;
+        let cache_idx;
+        if (ox1 !== ox2) {
+            cache = x_edge_cache;
+            cache_idx = (iy + oy1) * edge_stride + iz + oz1;
+        }
+        else if (oy1 !== oy2) {
+            cache = ox1 === 0 ? y_edge_current : y_edge_next;
+            cache_idx = (iy + Math.min(oy1, oy2)) * edge_stride + iz + oz1;
+        }
+        else {
+            cache = ox1 === 0 ? z_edge_current : z_edge_next;
+            cache_idx = (iy + oy1) * edge_stride + iz + Math.min(oz1, oz2);
+        }
+        const cached = cache[cache_idx];
+        if (cached >= 0)
             return cached;
         // Compute vertex position
         const v1 = cube_values[v1_idx];
@@ -407,26 +437,37 @@ export function marching_cubes(grid, iso_value, k_lattice, options = {}) {
             fz = (iz + (oz1 + oz2) * 0.5) * inv_nz - center_offset;
         }
         // Transform to Cartesian (inlined)
-        const vert_idx = vertices.length;
-        vertices.push([
-            fx * kx0 + fy * ky0 + fz * kz0,
-            fx * kx1 + fy * ky1 + fz * kz1,
-            fx * kx2 + fy * ky2 + fz * kz2,
-        ]);
-        // Compute normal from grid gradient (skip if caller will compute from geometry)
+        const vert_idx = positions.length / 3;
+        const cart_x = fx * kx0 + fy * ky0 + fz * kz0;
+        const cart_y = fx * kx1 + fy * ky1 + fz * kz1;
+        const cart_z = fx * kx2 + fy * ky2 + fz * kz2;
+        if (position_offset) {
+            positions.push(cart_x + position_offset[0], cart_y + position_offset[1], cart_z + position_offset[2]);
+        }
+        else
+            positions.push(cart_x, cart_y, cart_z);
         if (compute_norms) {
-            normals.push(compute_gradient(grid, ix + ox1, iy + oy1, iz + oz1, nx, ny, nz, periodic));
+            const [gx, gy, gz] = compute_gradient(grid, ix + ox1, iy + oy1, iz + oz1, nx, ny, nz, periodic);
+            // Scale by grid spacing without a lattice inverse (singular / anisotropic grids)
+            const index_grad = [gx / inv_nx, gy / inv_ny, gz / inv_nz];
+            const [cx, cy, cz] = normal_transform
+                ? mat3x3_vec3_multiply(normal_transform, index_grad)
+                : index_grad;
+            const length = Math.hypot(cx, cy, cz);
+            if (length > 1e-10)
+                normals.push(cx / length, cy / length, cz / length);
+            else
+                normals.push(0, 0, 1);
         }
-        vertex_cache.set(cache_key, vert_idx);
+        cache[cache_idx] = vert_idx;
         return vert_idx;
     };
-    // Iterate over all cubes in the grid
-    const max_x = periodic ? nx : nx - 1;
-    const max_y = periodic ? ny : ny - 1;
-    const max_z = periodic ? nz : nz - 1;
     // Preallocate cube_values array (reuse across iterations)
     const cube_values = Array(8);
     for (let ix = 0; ix < max_x; ix++) {
+        x_edge_cache.fill(-1);
+        y_edge_next.fill(-1);
+        z_edge_next.fill(-1);
         const ix_row = grid[ix];
         const ix1_row = grid[(ix + 1) % nx];
         for (let iy = 0; iy < max_y; iy++) {
@@ -476,13 +517,39 @@ export function marching_cubes(grid, iso_value, k_lattice, options = {}) {
                     const v2 = get_vertex_on_edge(ix, iy, iz, tri_list[tri_idx + 2], cube_values);
                     // Skip degenerate triangles
                     if (v0 !== v1 && v1 !== v2 && v0 !== v2) {
-                        faces.push([v0, v1, v2]);
+                        indices.push(v0, v1, v2);
                     }
                 }
             }
         }
+        ;
+        [y_edge_current, y_edge_next] = [y_edge_next, y_edge_current];
+        [z_edge_current, z_edge_next] = [z_edge_next, z_edge_current];
     }
-    return { vertices, faces, normals };
+    return { positions, indices, normals };
+}
+// Buffer-oriented result for renderers that otherwise immediately flatten the
+// compatibility arrays. This avoids one Vec3 and one triangle-array allocation
+// per emitted vertex/face while preserving the public marching_cubes() API.
+export function marching_cubes_buffers(grid, iso_value, k_lattice, options = {}) {
+    const raw = marching_cubes_raw(grid, iso_value, k_lattice, options);
+    return {
+        positions: Float32Array.from(raw.positions),
+        indices: Uint32Array.from(raw.indices),
+        normals: Float32Array.from(raw.normals),
+    };
+}
+const packed_to_vec3 = (values) => Array.from({ length: values.length / 3 }, (_, idx) => {
+    const offset = idx * 3;
+    return [values[offset], values[offset + 1], values[offset + 2]];
+});
+export function marching_cubes(grid, iso_value, k_lattice, options = {}) {
+    const raw = marching_cubes_raw(grid, iso_value, k_lattice, options);
+    return {
+        vertices: packed_to_vec3(raw.positions),
+        faces: packed_to_vec3(raw.indices),
+        normals: packed_to_vec3(raw.normals),
+    };
 }
 // Compute per-vertex normals from faces using area-weighted averaging
 // Uses fan triangulation for N-gon faces (quads, etc.)

package/dist/math.d.ts

@@ -63,6 +63,7 @@ export declare function vec9_to_mat3x3(flat_array: number[]): Matrix3x3;
 export declare function tensor_to_flat_array(tensor: number[][]): number[];
 export declare const transpose_3x3_matrix: (matrix: Matrix3x3) => Matrix3x3;
 export declare function scale_lattice_matrix(orig_matrix: Matrix3x3, scaling_factors: Vec3): Matrix3x3;
+export declare const create_cart_to_frac_matrix: (lattice: Matrix3x3) => Matrix3x3;
 export declare const create_frac_to_cart: (lattice: Matrix3x3) => (frac: Vec3) => Vec3;
 export declare const create_cart_to_frac: (lattice: Matrix3x3) => (cart: Vec3) => Vec3;
 export type LatticeConverters = {
@@ -106,6 +107,6 @@ export declare function polygon_centroid(vertices: Vec2[]): Vec2;
 export declare function solve_linear_system(A: number[][], // NxN coefficient matrix
 b: number[]): number[] | null;
 export declare const cross_2d: (origin: Vec2, point_a: Vec2, point_b: Vec2) => number;
-export declare const monotone_chain: (sorted: Vec2[]) => Vec2[];
-export declare function convex_hull_2d(points: Vec2[]): Vec2[];
+export declare const monotone_chain: (sorted: Vec2[], tolerance?: number) => Vec2[];
+export declare function convex_hull_2d(points: Vec2[], tolerance?: number): Vec2[];
 export {};