matterviz 0.3.2 → 0.3.4

package/dist/plot/Surface3D.svelte

@@ -1,137 +1,188 @@
-<script lang="ts">import { T } from '@threlte/core';
-import * as THREE from 'three';
-let { config, x_range = [0, 1], y_range = [0, 1], z_range = [0, 1], scene_x = 10, scene_y = 10, scene_z = 5, } = $props();
-// Normalize value to scene coordinates (centered around 0)
-function normalize(value, [min_val, max_val], scene_size) {
-    return ((value - min_val) / (max_val - min_val || 1) - 0.5) * scene_size;
-}
-// Parse color to THREE.Color with fallback
-function parse_color(color) {
+<script lang="ts">
+  import type { Surface3DConfig } from './types'
+  import { T } from '@threlte/core'
+  import * as THREE from 'three'
+
+  let {
+    config,
+    x_range = [0, 1],
+    y_range = [0, 1],
+    z_range = [0, 1],
+    scene_x = 10,
+    scene_y = 10,
+    scene_z = 5,
+  }: {
+    config: Surface3DConfig
+    x_range?: [number, number]
+    y_range?: [number, number]
+    z_range?: [number, number]
+    scene_x?: number
+    scene_y?: number
+    scene_z?: number
+  } = $props()
+
+  // Normalize value to scene coordinates (centered around 0)
+  function normalize(
+    value: number,
+    [min_val, max_val]: [number, number],
+    scene_size: number,
+  ): number {
+    return ((value - min_val) / (max_val - min_val || 1) - 0.5) * scene_size
+  }
+
+  // Parse color to THREE.Color with fallback
+  function parse_color(color: string): THREE.Color {
     try {
-        return new THREE.Color(color);
+      return new THREE.Color(color)
+    } catch {
+      return new THREE.Color(0x4488ff)
     }
-    catch {
-        return new THREE.Color(0x4488ff);
-    }
-}
-// Calculate vertex color based on config
-function get_vertex_color(x_val, y_val, z_val) {
-    if (config.color_fn)
-        return parse_color(config.color_fn(x_val, y_val, z_val));
-    if (config.color)
-        return parse_color(config.color);
+  }
+
+  // Calculate vertex color based on config
+  function get_vertex_color(
+    x_val: number,
+    y_val: number,
+    z_val: number,
+  ): THREE.Color {
+    if (config.color_fn) return parse_color(config.color_fn(x_val, y_val, z_val))
+    if (config.color) return parse_color(config.color)
     // Default: color by z value (blue to red gradient)
-    const z_norm = (z_val - z_range[0]) / (z_range[1] - z_range[0] || 1);
-    return new THREE.Color().setHSL(0.66 - z_norm * 0.66, 0.8, 0.5);
-}
-// Add vertex position (with Y/Z swap for Three.js) and color to arrays
-function add_vertex(positions, colors, x_val, y_val, z_val) {
-    positions.push(normalize(x_val, x_range, scene_x), normalize(z_val, z_range, scene_z), // user Z → Three.js Y (vertical)
-    normalize(y_val, y_range, scene_y));
-    const color = get_vertex_color(x_val, y_val, z_val);
-    colors.push(color.r, color.g, color.b);
-}
-// Build geometry from positions/colors arrays with optional grid indices
-function build_geometry(positions, colors, res_a, res_b, triangles) {
-    const geom = new THREE.BufferGeometry();
-    geom.setAttribute(`position`, new THREE.Float32BufferAttribute(positions, 3));
-    geom.setAttribute(`color`, new THREE.Float32BufferAttribute(colors, 3));
+    const z_norm = (z_val - z_range[0]) / (z_range[1] - z_range[0] || 1)
+    return new THREE.Color().setHSL(0.66 - z_norm * 0.66, 0.8, 0.5)
+  }
+
+  // Add vertex position (with Y/Z swap for Three.js) and color to arrays
+  function add_vertex(
+    positions: number[],
+    colors: number[],
+    x_val: number,
+    y_val: number,
+    z_val: number,
+  ): void {
+    positions.push(
+      normalize(x_val, x_range, scene_x),
+      normalize(z_val, z_range, scene_z), // user Z → Three.js Y (vertical)
+      normalize(y_val, y_range, scene_y), // user Y → Three.js Z (depth)
+    )
+    const color = get_vertex_color(x_val, y_val, z_val)
+    colors.push(color.r, color.g, color.b)
+  }
+
+  // Build geometry from positions/colors arrays with optional grid indices
+  function build_geometry(
+    positions: number[],
+    colors: number[],
+    res_a?: number,
+    res_b?: number,
+    triangles?: number[][],
+  ): THREE.BufferGeometry {
+    const geom = new THREE.BufferGeometry()
+    geom.setAttribute(`position`, new THREE.Float32BufferAttribute(positions, 3))
+    geom.setAttribute(`color`, new THREE.Float32BufferAttribute(colors, 3))
     // Set indices: either from explicit triangles or generate grid
     if (triangles?.length) {
-        geom.setIndex(triangles.flat());
-    }
-    else if (res_a && res_b && res_a >= 2 && res_b >= 2) {
-        const indices = [];
-        for (let ib = 0; ib < res_b - 1; ib++) {
-            for (let ia = 0; ia < res_a - 1; ia++) {
-                const tl = ib * res_a + ia;
-                indices.push(tl, tl + res_a, tl + 1, tl + 1, tl + res_a, tl + res_a + 1);
-            }
+      geom.setIndex(triangles.flat())
+    } else if (res_a && res_b && res_a >= 2 && res_b >= 2) {
+      const indices: number[] = []
+      for (let ib = 0; ib < res_b - 1; ib++) {
+        for (let ia = 0; ia < res_a - 1; ia++) {
+          const tl = ib * res_a + ia
+          indices.push(tl, tl + res_a, tl + 1, tl + 1, tl + res_a, tl + res_a + 1)
         }
-        geom.setIndex(indices);
+      }
+      geom.setIndex(indices)
     }
-    geom.computeVertexNormals();
-    return geom;
-}
-// Parse resolution config into [res_a, res_b]
-function get_resolution() {
+    geom.computeVertexNormals()
+    return geom
+  }
+
+  // Parse resolution config into [res_a, res_b]
+  function get_resolution(): [number, number] {
     return Array.isArray(config.resolution)
-        ? config.resolution
-        : [config.resolution ?? 20, config.resolution ?? 20];
-}
-function create_geometry() {
-    const [res_a, res_b] = get_resolution();
-    const positions = [];
-    const colors = [];
+      ? config.resolution
+      : [config.resolution ?? 20, config.resolution ?? 20]
+  }
+
+  function create_geometry(): THREE.BufferGeometry | null {
+    const [res_a, res_b] = get_resolution()
+    const positions: number[] = []
+    const colors: number[] = []
+
     if (config.type === `grid` && config.z_fn) {
-        if (res_a < 2 || res_b < 2)
-            return new THREE.BufferGeometry();
-        const [x0, x1] = config.x_range ?? x_range;
-        const [y0, y1] = config.y_range ?? y_range;
-        const x_step = (x1 - x0) / (res_a - 1);
-        const y_step = (y1 - y0) / (res_b - 1);
-        for (let ib = 0; ib < res_b; ib++) {
-            for (let ia = 0; ia < res_a; ia++) {
-                const x_val = x0 + ia * x_step;
-                const y_val = y0 + ib * y_step;
-                add_vertex(positions, colors, x_val, y_val, config.z_fn(x_val, y_val));
-            }
+      if (res_a < 2 || res_b < 2) return new THREE.BufferGeometry()
+      const [x0, x1] = config.x_range ?? x_range
+      const [y0, y1] = config.y_range ?? y_range
+      const x_step = (x1 - x0) / (res_a - 1)
+      const y_step = (y1 - y0) / (res_b - 1)
+      for (let ib = 0; ib < res_b; ib++) {
+        for (let ia = 0; ia < res_a; ia++) {
+          const x_val = x0 + ia * x_step
+          const y_val = y0 + ib * y_step
+          add_vertex(positions, colors, x_val, y_val, config.z_fn(x_val, y_val))
         }
-        return build_geometry(positions, colors, res_a, res_b);
+      }
+      return build_geometry(positions, colors, res_a, res_b)
     }
+
     if (config.type === `parametric` && config.parametric_fn) {
-        if (res_a < 2 || res_b < 2)
-            return new THREE.BufferGeometry();
-        const [u0, u1] = config.u_range ?? [0, 1];
-        const [v0, v1] = config.v_range ?? [0, 1];
-        const u_step = (u1 - u0) / (res_a - 1);
-        const v_step = (v1 - v0) / (res_b - 1);
-        for (let ib = 0; ib < res_b; ib++) {
-            for (let ia = 0; ia < res_a; ia++) {
-                const pt = config.parametric_fn(u0 + ia * u_step, v0 + ib * v_step);
-                add_vertex(positions, colors, pt.x, pt.y, pt.z);
-            }
+      if (res_a < 2 || res_b < 2) return new THREE.BufferGeometry()
+      const [u0, u1] = config.u_range ?? [0, 1]
+      const [v0, v1] = config.v_range ?? [0, 1]
+      const u_step = (u1 - u0) / (res_a - 1)
+      const v_step = (v1 - v0) / (res_b - 1)
+      for (let ib = 0; ib < res_b; ib++) {
+        for (let ia = 0; ia < res_a; ia++) {
+          const pt = config.parametric_fn(u0 + ia * u_step, v0 + ib * v_step)
+          add_vertex(positions, colors, pt.x, pt.y, pt.z)
         }
-        return build_geometry(positions, colors, res_a, res_b);
+      }
+      return build_geometry(positions, colors, res_a, res_b)
     }
+
     if (config.type === `triangulated` && config.points?.length) {
-        for (const pt of config.points) {
-            add_vertex(positions, colors, pt.x, pt.y, pt.z);
-        }
-        return build_geometry(positions, colors, undefined, undefined, config.triangles);
+      for (const pt of config.points) {
+        add_vertex(positions, colors, pt.x, pt.y, pt.z)
+      }
+      return build_geometry(positions, colors, undefined, undefined, config.triangles)
     }
-    return null;
-}
-// Geometry with proper disposal on change/unmount
-let geometry = $state(null);
-let wireframe_geometry = $state(null);
-$effect(() => {
-    const new_geom = create_geometry();
-    const new_wireframe = new_geom ? new THREE.WireframeGeometry(new_geom) : null;
-    geometry = new_geom;
-    wireframe_geometry = new_wireframe;
+
+    return null
+  }
+
+  // Geometry with proper disposal on change/unmount
+  let geometry: THREE.BufferGeometry | null = $state(null)
+  let wireframe_geometry: THREE.WireframeGeometry | null = $state(null)
+
+  $effect(() => {
+    const new_geom = create_geometry()
+    const new_wireframe = new_geom ? new THREE.WireframeGeometry(new_geom) : null
+    geometry = new_geom
+    wireframe_geometry = new_wireframe
     return () => {
-        new_geom?.dispose();
-        new_wireframe?.dispose();
-    };
-});
-// Material properties
-let is_transparent = $derived((config.opacity ?? 1) < 1);
-let material_props = $derived({
+      new_geom?.dispose()
+      new_wireframe?.dispose()
+    }
+  })
+
+  // Material properties
+  let is_transparent = $derived((config.opacity ?? 1) < 1)
+  let material_props = $derived({
     transparent: is_transparent,
     opacity: config.opacity ?? 1,
     side: (config.double_sided ?? is_transparent)
-        ? THREE.DoubleSide
-        : THREE.FrontSide,
+      ? THREE.DoubleSide
+      : THREE.FrontSide,
     vertexColors: true,
     depthWrite: true,
-});
-let wireframe_props = $derived({
+  })
+
+  let wireframe_props = $derived({
     color: config.wireframe_color ?? `#333`,
     linewidth: config.wireframe_width ?? 1,
     transparent: true,
     opacity: 0.5,
-});
+  })
 </script>
 
 {#if geometry}

package/dist/plot/ZeroLines.svelte

@@ -1,6 +1,58 @@
-<script lang="ts">import { get_scale_type_name } from './';
-let { display, x_scale_fn, x2_scale_fn, y_scale_fn, y2_scale_fn, x_range, x2_range, y_range, y2_range, x_scale_type, x2_scale_type, y_scale_type, y2_scale_type, x_is_time = false, x2_is_time = false, has_x2 = false, has_y2 = false, width, height, pad, } = $props();
-const spans_zero = (range) => Math.min(range[0], range[1]) <= 0 && Math.max(range[0], range[1]) >= 0;
+<script lang="ts">
+  import type { Vec2 } from '../math'
+  import { get_scale_type_name, type ScaleType, type Sides } from './'
+
+  let {
+    display,
+    x_scale_fn,
+    x2_scale_fn,
+    y_scale_fn,
+    y2_scale_fn,
+    x_range,
+    x2_range,
+    y_range,
+    y2_range,
+    x_scale_type,
+    x2_scale_type,
+    y_scale_type,
+    y2_scale_type,
+    x_is_time = false,
+    x2_is_time = false,
+    has_x2 = false,
+    has_y2 = false,
+    width,
+    height,
+    pad,
+  }: {
+    display: {
+      x_zero_line?: boolean
+      x2_zero_line?: boolean
+      y_zero_line?: boolean
+      y2_zero_line?: boolean
+    }
+    x_scale_fn: (val: number) => number
+    x2_scale_fn?: (val: number) => number
+    y_scale_fn: (val: number) => number
+    y2_scale_fn?: (val: number) => number
+    x_range: Vec2
+    x2_range?: Vec2
+    y_range: Vec2
+    y2_range?: Vec2
+    x_scale_type?: ScaleType
+    x2_scale_type?: ScaleType
+    y_scale_type?: ScaleType
+    y2_scale_type?: ScaleType
+    x_is_time?: boolean
+    x2_is_time?: boolean
+    has_x2?: boolean
+    has_y2?: boolean
+    width: number
+    height: number
+    pad: Required<Sides>
+  } = $props()
+
+  const spans_zero = (range: Vec2): boolean =>
+    Math.min(range[0], range[1]) <= 0 && Math.max(range[0], range[1]) >= 0
 </script>
 
 {#if display.x_zero_line && get_scale_type_name(x_scale_type) !== `log` &&

package/dist/plot/ZoomRect.svelte

@@ -1,5 +1,7 @@
-<script lang="ts">let { start, current } = $props();
-export {};
+<script lang="ts">
+  import type { XyObj } from './'
+
+  let { start, current }: { start: XyObj | null; current: XyObj | null } = $props()
 </script>
 
 {#if start && current && isFinite(start.x) && isFinite(start.y) &&

package/dist/plot/axis-utils.js

@@ -10,9 +10,7 @@ export function merge_series_state(old_series, new_series) {
     }
     return new_series.map((new_srs, idx) => {
         // Match by id if available (string or number), otherwise fall back to index
-        const old_srs = (new_srs.id !== undefined && new_srs.id !== ``
-            ? by_id.get(new_srs.id)
-            : undefined) ??
+        const old_srs = (new_srs.id !== undefined && new_srs.id !== `` ? by_id.get(new_srs.id) : undefined) ??
             old_series[idx];
         if (!old_srs) {
             return new_srs;

package/dist/plot/data-cleaning.js

@@ -21,9 +21,7 @@ export function compute_local_variance(values, window_size) {
         const start = Math.max(0, idx - half_window);
         const end = Math.min(len, idx + half_window + 1);
         // Welford's online variance calculation
-        let mean = 0;
-        let m2 = 0;
-        let count = 0;
+        let [mean, m2, count] = [0, 0, 0];
         for (let jdx = start; jdx < end; jdx++) {
             const val = values[jdx];
             if (!Number.isFinite(val))
@@ -170,13 +168,9 @@ export function detect_instability(x_values, y_values, config = {}) {
         }
     }
     if (valid_y.length < window_size * 2) {
-        return {
-            detected: false,
-            onset_index: -1,
-            onset_x: NaN,
-            combined_score: 0,
-            method_scores: { derivative_variance: 0, amplitude_growth: 0, sign_changes: 0 },
-        };
+        const method_scores = { derivative_variance: 0, amplitude_growth: 0, sign_changes: 0 };
+        const detected = false;
+        return { detected, onset_index: -1, onset_x: NaN, combined_score: 0, method_scores };
     }
     // Run all three detection methods
     const deriv_result = detect_derivative_variance(valid_y, window_size, threshold);
@@ -188,12 +182,12 @@ export function detect_instability(x_values, y_values, config = {}) {
         sign_changes: sign_result.score,
     };
     // Compute weighted combined score
-    const total_weight = weights.derivative_variance + weights.amplitude_growth +
-        weights.sign_changes;
+    const total_weight = weights.derivative_variance + weights.amplitude_growth + weights.sign_changes;
     const combined_score = total_weight > 0
         ? (weights.derivative_variance * deriv_result.score +
             weights.amplitude_growth * amp_result.score +
-            weights.sign_changes * sign_result.score) / total_weight
+            weights.sign_changes * sign_result.score) /
+            total_weight
         : 0;
     // Find earliest onset across all methods that exceeded threshold
     const onset_candidates = [
@@ -214,16 +208,8 @@ export function detect_instability(x_values, y_values, config = {}) {
         }
     }
     const detected = combined_score >= threshold || onset_index >= 0;
-    const onset_x = onset_index >= 0 && onset_index < x_values.length
-        ? x_values[onset_index]
-        : NaN;
-    return {
-        detected,
-        onset_index,
-        onset_x,
-        combined_score,
-        method_scores,
-    };
+    const onset_x = onset_index >= 0 && onset_index < x_values.length ? x_values[onset_index] : NaN;
+    return { detected, onset_index, onset_x, combined_score, method_scores };
 }
 // --- Smoothing Functions ---
 // Moving average - O(n)
@@ -235,8 +221,7 @@ export function smooth_moving_average(values, window) {
     for (let idx = 0; idx < values.length; idx++) {
         const start = Math.max(0, idx - half_window);
         const end = Math.min(values.length, idx + half_window + 1);
-        let sum = 0;
-        let count = 0;
+        let [sum, count] = [0, 0];
         for (let jdx = start; jdx < end; jdx++) {
             if (Number.isFinite(values[jdx])) {
                 sum += values[jdx];
@@ -291,8 +276,7 @@ export function smooth_savitzky_golay(values, window, polynomial_order = DEFAULT
     // Cache coefficient sum to avoid O(n × window) redundant reductions in loop
     const coeffs_sum = coeffs.reduce((a, b) => a + b, 0);
     for (let idx = 0; idx < values.length; idx++) {
-        let sum = 0;
-        let weight_sum = 0;
+        let [sum, weight_sum] = [0, 0];
         for (let jdx = 0; jdx < actual_window; jdx++) {
             const data_idx = idx - half + jdx;
             if (data_idx >= 0 && data_idx < values.length && Number.isFinite(values[data_idx])) {
@@ -300,7 +284,7 @@ export function smooth_savitzky_golay(values, window, polynomial_order = DEFAULT
                 weight_sum += coeffs[jdx];
             }
         }
-        result[idx] = weight_sum !== 0 ? sum / weight_sum * coeffs_sum : values[idx];
+        result[idx] = weight_sum !== 0 ? (sum / weight_sum) * coeffs_sum : values[idx];
     }
     return result;
 }

package/dist/plot/data-transform.js

@@ -17,6 +17,7 @@ export const prepare_legend_data = (series) => series.map((series_data, series_i
     label: series_data.label ?? `Series ${series_idx + 1}`,
     visible: series_data.visible ?? true,
     display_style: {
+        // Prefer the series’ symbol when present, falling back to settings
         symbol_type: !Array.isArray(series_data.point_style)
             ? (series_data.point_style?.symbol_type ?? DEFAULTS.scatter.symbol_type)
             : DEFAULTS.scatter.symbol_type,
@@ -38,7 +39,7 @@ export const create_data_points = (series, filter_fn) => series
 // If prop is a scalar, returns the scalar (applied to all indices).
 // Returns undefined if prop is null/undefined.
 export function process_prop(prop, idx) {
-    if (prop === null || prop === undefined)
+    if (prop == null)
         return undefined;
     return Array.isArray(prop) ? prop[idx] : prop;
 }

package/dist/plot/fill-utils.js

@@ -113,6 +113,8 @@ export function resolve_boundary(boundary, series, x_values, domains) {
         case `function`:
             return x_values.map((curr_x) => boundary.fn(curr_x));
         case `data`:
+            if (boundary.values.length === 0)
+                return Array(x_values.length).fill(NaN);
             // If lengths match, use directly; otherwise interpolate
             if (boundary.values.length === x_values.length) {
                 return [...boundary.values];

package/dist/plot/layout.d.ts

@@ -1,6 +1,6 @@
 import type { AxisConfig, Sides } from './';
 export declare const LABEL_GAP_DEFAULT = 30;
-export declare const filter_padding: <T extends Partial<Sides>>(padding: T | undefined | null, defaults: Required<Sides>) => Required<Sides>;
+export declare const filter_padding: (padding: Partial<Sides> | undefined | null, defaults: Required<Sides>) => Required<Sides>;
 export declare function measure_text_width(text: string, font?: string): number;
 export interface AutoPaddingConfig {
     padding: Partial<Sides>;
@@ -34,6 +34,9 @@ export interface Rect {
     width: number;
     height: number;
 }
+export declare const pad_rect: (rect: Rect, padding: number) => Rect;
+export declare const centered_rect: (center_x: number, top_y: number, width: number, height: number) => Rect;
+export declare const rect_within_rect: (rect: Rect, bounds: Rect) => boolean;
 export interface ElementPlacementConfig {
     plot_bounds: Rect;
     element_size: {

package/dist/plot/layout.js

@@ -23,10 +23,12 @@ export function measure_text_width(text, font = `12px sans-serif`) {
     return ctx.measureText(text).width;
 }
 // Measure the widest formatted tick label. Used for auto-padding and label placement.
-export const measure_max_tick_width = (ticks, format = ``) => ticks.length === 0 ? 0 : Math.max(...ticks.map((tick) => {
-    const label = typeof tick === `string` ? tick : format_value(tick, format);
-    return measure_text_width(label, `12px sans-serif`);
-}));
+export const measure_max_tick_width = (ticks, format = ``) => ticks.length === 0
+    ? 0
+    : Math.max(...ticks.map((tick) => {
+        const label = typeof tick === `string` ? tick : format_value(tick, format);
+        return measure_text_width(label, `12px sans-serif`);
+    }));
 // Estimated height of a single tick label line (font-size 0.8em ≈ 12px + leading)
 export const TICK_LABEL_HEIGHT = 16;
 // Estimated height of an axis label (font-size ~14px + margin)
@@ -68,18 +70,22 @@ export function constrain_tooltip_position(cursor_x, cursor_y, tooltip_width, to
     const abs_offset_y = Math.abs(offset_y);
     // Determine X position based on preferred side and flip state
     let raw_x;
-    if (offset_x >= 0) { // Prefer right side: flip to left if overflows
+    if (offset_x >= 0) {
+        // Prefer right side: flip to left if overflows
         raw_x = flip_x ? cursor_x - abs_offset_x - tooltip_width : cursor_x + abs_offset_x;
     }
-    else { // Prefer left side: flip to right if overflows
+    else {
+        // Prefer left side: flip to right if overflows
         raw_x = flip_x ? cursor_x + abs_offset_x : cursor_x - abs_offset_x - tooltip_width;
     }
     // Determine Y position based on preferred side and flip state
     let raw_y;
-    if (offset_y >= 0) { // Prefer bottom: flip to top if overflows
+    if (offset_y >= 0) {
+        // Prefer bottom: flip to top if overflows
         raw_y = flip_y ? cursor_y - abs_offset_y - tooltip_height : cursor_y + abs_offset_y;
     }
-    else { // Prefer top: flip to bottom if overflows
+    else {
+        // Prefer top: flip to bottom if overflows
         raw_y = flip_y ? cursor_y + abs_offset_y : cursor_y - abs_offset_y - tooltip_height;
     }
     // Clamp to viewport bounds
@@ -87,6 +93,22 @@ export function constrain_tooltip_position(cursor_x, cursor_y, tooltip_width, to
     const y_pos = Math.max(0, Math.min(raw_y, viewport_height - tooltip_height));
     return { x: x_pos, y: y_pos };
 }
+export const pad_rect = (rect, padding) => ({
+    x: rect.x - padding,
+    y: rect.y - padding,
+    width: rect.width + 2 * padding,
+    height: rect.height + 2 * padding,
+});
+export const centered_rect = (center_x, top_y, width, height) => ({
+    x: center_x - width / 2,
+    y: top_y,
+    width,
+    height,
+});
+export const rect_within_rect = (rect, bounds) => rect.x >= bounds.x &&
+    rect.x + rect.width <= bounds.x + bounds.width &&
+    rect.y >= bounds.y &&
+    rect.y + rect.height <= bounds.y + bounds.height;
 // Scoring constants
 const EXCLUSION_PENALTY = 1000;
 const DISTANCE_WEIGHT = 0.001;
@@ -129,7 +151,7 @@ export function compute_element_placement(config) {
     const effective_y_max = Math.max(valid_y_min, valid_y_max);
     // Subsample points for performance
     const sampled_points = points.length > MAX_SAMPLE_POINTS
-        ? Array.from({ length: MAX_SAMPLE_POINTS }, (_, idx) => points[Math.floor(idx * points.length / MAX_SAMPLE_POINTS)])
+        ? Array.from({ length: MAX_SAMPLE_POINTS }, (_, idx) => points[Math.floor((idx * points.length) / MAX_SAMPLE_POINTS)])
         : points;
     let best_result = {
         x: effective_x_min,
@@ -197,11 +219,8 @@ export function compute_element_placement(config) {
             euclidean_dist([cand_x, elem_bottom], [plot_left, plot_bottom]), // bottom-left
             euclidean_dist([elem_right, elem_bottom], [plot_right, plot_bottom]));
             // Higher bonus for positions closer to corners (0 = at corner, 1 = far from all)
-            const corner_bonus = max_corner_dist > 0
-                ? (1 - min_corner_dist / max_corner_dist) * CORNER_WEIGHT
-                : 0;
-            const score = -overlap_count + min_distance * DISTANCE_WEIGHT + corner_bonus -
-                exclusion_penalty;
+            const corner_bonus = max_corner_dist > 0 ? (1 - min_corner_dist / max_corner_dist) * CORNER_WEIGHT : 0;
+            const score = -overlap_count + min_distance * DISTANCE_WEIGHT + corner_bonus - exclusion_penalty;
             if (score > best_result.score) {
                 best_result = { x: cand_x, y: cand_y, score };
             }

package/dist/plot/reference-line.d.ts

@@ -12,12 +12,12 @@ export interface RefLinesByZIndex {
 export declare function group_ref_lines_by_z(lines: IndexedRefLine[]): RefLinesByZIndex;
 export declare function normalize_value(value: RefLineValue): number;
 export declare const normalize_point: (point: [RefLineValue, RefLineValue]) => [number, number];
-export declare function resolve_line_endpoints(ref_line: RefLine, { x_min, x_max, y_min, y_max }: {
+export declare function resolve_line_endpoints(ref_line: RefLine, { x_min, x_max, y_min, y_max, }: {
     x_min: number;
     x_max: number;
     y_min: number;
     y_max: number;
-}, { x_scale, x2_scale, y_scale, y2_scale }: {
+}, { x_scale, x2_scale, y_scale, y2_scale, }: {
     x_scale: (val: number) => number;
     x2_scale?: (val: number) => number;
     y_scale: (val: number) => number;