matterviz 0.4.0 → 0.4.1

package/dist/fermi-surface/FermiSurfaceScene.svelte

@@ -1,17 +1,25 @@
 <script lang="ts">
   import type { BrillouinZoneData } from '../brillouin'
-  import { AXIS_COLORS, NEG_AXIS_COLORS } from '../colors'
-  import type { Matrix4Tuple, Vec3 } from '../math'
+  import {
+    cartesian_to_fractional,
+    default_camera_position,
+    k_lattice_inverse,
+    k_space_size,
+    polyhedron_centroid,
+    polyhedron_geometry,
+    ReciprocalVectors,
+  } from '../brillouin'
+  import type { D3InterpolateName } from '../colors'
+  import { get_d3_interpolator } from '../colors'
+  import type { Matrix4Tuple, Vec2, Vec3 } from '../math'
   import * as math from '../math'
-  import type { CameraProjection } from '../settings'
+  import { bind_renderer, build_orbit_props, SceneCamera } from '../scene'
+  import type { SceneControlProps, ThreltePointerEvent } from '../scene'
   import { DEFAULTS } from '../settings'
-  import { Arrow, Cylinder } from '../structure'
-  import { T, useThrelte } from '@threlte/core'
+  import { Cylinder } from '../structure'
+  import { T } from '@threlte/core'
   import * as extras from '@threlte/extras'
-  import * as d3_sc from 'd3-scale-chromatic'
-  import type { ComponentProps } from 'svelte'
   import { SvelteMap } from 'svelte/reactivity'
-  import type { Camera, Scene } from 'three'
   import {
     BackSide,
     BufferAttribute,
@@ -33,9 +41,6 @@
     RepresentationMode,
   } from './types'
 
-  // Threlte pointer event type for mesh interactions
-  type ThreltePointerEvent = { point: Vector3; nativeEvent: PointerEvent }
-
   let {
     fermi_data = $bindable(),
     bz_data = $bindable(),
@@ -75,15 +80,13 @@
     directional_light = DEFAULTS.structure.directional_light,
     gizmo = DEFAULTS.structure.show_gizmo,
     auto_rotate = DEFAULTS.structure.auto_rotate,
-    camera_is_moving = $bindable(false),
     scene = $bindable(),
     camera = $bindable(),
     hover_data = $bindable<FermiHoverData | null>(null),
-  }: {
+  }: SceneControlProps & {
     fermi_data?: FermiSurfaceData
     bz_data?: BrillouinZoneData
     camera_position?: Vec3 | undefined
-    camera_projection?: CameraProjection
     color_property?: ColorProperty
     color_scale?: string
     representation?: RepresentationMode
@@ -101,33 +104,20 @@
     clip_position?: number
     clip_flip?: boolean
     vector_scale?: number
-    rotation_damping?: number
-    max_zoom?: number
-    min_zoom?: number
-    rotate_speed?: number
-    zoom_speed?: number
-    pan_speed?: number
-    zoom_to_cursor?: boolean
-    fov?: number
-    initial_zoom?: number
-    ambient_light?: number
-    directional_light?: number
-    gizmo?: boolean | ComponentProps<typeof extras.Gizmo>
-    auto_rotate?: number
-    camera_is_moving?: boolean
-    scene?: Scene
-    camera?: Camera
     hover_data?: FermiHoverData | null
   } = $props()
 
-  const threlte = useThrelte()
+  const threlte = bind_renderer(
+    (threlte_scene, threlte_camera) => {
+      scene = threlte_scene
+      camera = threlte_camera
+    },
+    // Enable object sorting for proper depth ordering of transparent surfaces
+    (renderer) => (renderer.sortObjects = true),
+  )
 
-  // Compute scene size for clipping (also used for camera positioning later)
-  function get_scene_size(): number {
-    if (!fermi_data?.k_lattice) return 10
-    const mags = fermi_data.k_lattice.map((vec) => Math.hypot(...vec))
-    return mags.reduce((sum, mag) => sum + mag, 0) / 3
-  }
+  // Characteristic scene size, used for clipping and camera positioning
+  const scene_size = $derived(k_space_size(fermi_data?.k_lattice))
 
   // Compute clipping plane based on axis and position
   // Plane equation: dot(normal, point) + constant >= 0 means point is visible
@@ -138,7 +128,7 @@
     const normal_arr: Vec3 = [0, 0, 0]
     normal_arr[axis_idx] = clip_flip ? -1 : 1
 
-    const scaled_position = clip_position * get_scene_size()
+    const scaled_position = clip_position * scene_size
     // constant = -position for normal case (keep points >= position)
     // constant = +position for flipped case (keep points <= position)
     const constant = clip_flip ? scaled_position : -scaled_position
@@ -159,24 +149,8 @@
     }
   })
 
-  $effect(() => {
-    scene = threlte.scene
-    camera = threlte.camera.current
-    if (threlte.renderer) {
-      // Enable object sorting for proper depth ordering of transparent surfaces
-      threlte.renderer.sortObjects = true
-      Object.assign(threlte.renderer.domElement, { __renderer: threlte.renderer })
-    }
-  })
-
   extras.interactivity()
 
-  // Get color interpolator from d3
-  const get_interpolator = (name: string): (t: number) => string => {
-    const fn = d3_sc[name as keyof typeof d3_sc]
-    return typeof fn === `function` ? fn : d3_sc.interpolateViridis
-  }
-
   // Filter surfaces based on selected bands
   let visible_surfaces = $derived(
     fermi_data?.isosurfaces.filter((surface) =>
@@ -216,7 +190,7 @@
   })
 
   // Compute property range for color scaling
-  let property_range = $derived.by((): [number, number] => {
+  let property_range = $derived.by((): Vec2 => {
     if (color_property !== `velocity` && color_property !== `custom`) {
       return [0, 1]
     }
@@ -247,7 +221,7 @@
       const normalized = max_val > min_val
         ? (prop - min_val) / (max_val - min_val)
         : 0.5
-      return get_interpolator(color_scale)(normalized)
+      return get_d3_interpolator(color_scale as D3InterpolateName)(normalized)
     }
     // Spin coloring
     if (color_property === `spin` && surface.spin) {
@@ -377,108 +351,30 @@
     }
   })
 
-  // Compute rotation target from surfaces or BZ
-  const rotation_target = $derived.by((): Vec3 => {
-    if (bz_data?.vertices && bz_data.vertices.length > 0) {
-      const sum = bz_data.vertices.reduce(
-        (acc, vert) => math.add(acc, vert),
-        [0, 0, 0] as Vec3,
-      )
-      return math.scale(sum, 1 / bz_data.vertices.length)
-    }
-    return [0, 0, 0]
-  })
-
-  // Scene size for camera positioning (uses helper function defined earlier)
-  const scene_size = $derived(get_scene_size())
+  // BZ centroid as rotation center
+  const rotation_target = $derived(polyhedron_centroid(bz_data?.vertices))
 
-  const computed_camera_position = $derived.by(
-    () =>
-      camera_position || ([10, 3, 8].map((coord) =>
-        coord * Math.max(1, scene_size)
-      ) as Vec3),
+  const computed_camera_position = $derived(
+    camera_position || default_camera_position(scene_size),
   )
 
-  const gizmo_props = $derived({
-    background: { enabled: false },
-    className: `responsive-gizmo`,
-    ...Object.fromEntries(
-      [...AXIS_COLORS, ...NEG_AXIS_COLORS].map(([axis, color, hover]) => [
-        axis,
-        {
-          color,
-          labelColor: `#111`,
-          opacity: axis.startsWith(`n`) ? 0.9 : 0.8,
-          hover: {
-            color: hover,
-            labelColor: `#222`,
-            opacity: axis.startsWith(`n`) ? 1 : 0.9,
-          },
-        },
-      ]),
-    ),
-    ...(typeof gizmo === `object` ? gizmo : {}),
-    offset: { left: 5, bottom: 5 },
-  })
-
-  const is_ortho = $derived(camera_projection === `orthographic`)
-  const orbit_controls_props = $derived({
-    position: [0, 0, 0],
+  const orbit_controls_props = $derived(build_orbit_props({
+    camera_projection,
     target: rotation_target,
-    enableRotate: rotate_speed > 0,
-    rotateSpeed: rotate_speed,
-    enableZoom: zoom_speed > 0,
-    zoomSpeed: is_ortho ? zoom_speed * 2 : zoom_speed,
-    zoomToCursor: zoom_to_cursor,
-    enablePan: pan_speed > 0,
-    panSpeed: pan_speed,
-    maxZoom: max_zoom,
-    minZoom: min_zoom,
-    autoRotate: Boolean(auto_rotate),
-    autoRotateSpeed: auto_rotate,
-    enableDamping: Boolean(rotation_damping),
-    dampingFactor: rotation_damping,
-    onstart: () => (camera_is_moving = true),
-    onend: () => (camera_is_moving = false),
-  })
-
-  const vector_colors = [`red`, `green`, `blue`]
-  const vector_labels = [`b₁`, `b₂`, `b₃`]
+    rotate_speed,
+    zoom_speed,
+    zoom_to_cursor,
+    pan_speed,
+    max_zoom,
+    min_zoom,
+    auto_rotate,
+    rotation_damping,
+  }))
 
   // Create BZ geometry
-  const bz_geometry = $derived.by(() => {
-    if (!bz_data || bz_data.faces.length === 0) return null
-
-    const positions: number[] = []
-    const normals: number[] = []
-
-    for (const face of bz_data.faces) {
-      if (face.length < 3) continue
-
-      for (let face_idx = 1; face_idx < face.length - 1; face_idx++) {
-        const indices = [face[0], face[face_idx], face[face_idx + 1]]
-        if (indices.some((idx) => idx < 0 || idx >= bz_data.vertices.length)) continue
-        const [v0, v1, v2] = indices.map((idx) => bz_data.vertices[idx])
-        positions.push(...v0, ...v1, ...v2)
-
-        const e1: Vec3 = math.subtract(v1, v0)
-        const e2: Vec3 = math.subtract(v2, v0)
-        const normal_vec = math.cross_3d(e1, e2)
-        const len = Math.hypot(...normal_vec)
-        const norm = len > 1e-10 ? normal_vec.map((coord) => coord / len) : [0, 0, 0]
-        normals.push(...norm, ...norm, ...norm)
-      }
-    }
-
-    const geometry = new BufferGeometry()
-    geometry.setAttribute(
-      `position`,
-      new BufferAttribute(new Float32Array(positions), 3),
-    )
-    geometry.setAttribute(`normal`, new BufferAttribute(new Float32Array(normals), 3))
-    geometry.computeBoundingSphere()
-    return geometry
-  })
+  const bz_geometry = $derived(
+    bz_data ? polyhedron_geometry(bz_data.vertices, bz_data.faces) : null,
+  )
 
   $effect(() => {
     const prev_geometry = bz_geometry
@@ -516,26 +412,12 @@
     return { ...base, color: surface_color }
   }
 
-  // Compute inverse of k_lattice for Cartesian->fractional conversion (cached)
-  const k_lattice_inv = $derived.by(() => {
-    if (!fermi_data?.k_lattice) return null
-    try {
-      return math.matrix_inverse_3x3(fermi_data.k_lattice)
-    } catch {
-      return null
-    }
-  })
+  // Inverse of k_lattice for Cartesian->fractional conversion (cached)
+  const k_lattice_inv = $derived(k_lattice_inverse(fermi_data?.k_lattice))
 
   // Throttle state for pointer move events to avoid O(n) vertex lookups causing jank
   let last_hover_time = 0
 
-  // Convert Cartesian k-coordinates to fractional (reciprocal lattice units)
-  // Returns null if k_lattice is unavailable or inversion failed
-  function cartesian_to_fractional(cart: Vec3): Vec3 | null {
-    if (!k_lattice_inv) return null
-    return math.mat3x3_vec3_multiply(k_lattice_inv, cart)
-  }
-
   // Find index of nearest vertex to a point in a surface
   function find_nearest_vertex(surface: Isosurface, point: Vec3): number {
     let [min_dist, nearest_idx] = [Infinity, 0]
@@ -564,7 +446,7 @@
   ): FermiHoverData {
     // event.point is in world space (after sym_matrix transformation)
     const position_cartesian: Vec3 = [event.point.x, event.point.y, event.point.z]
-    const position_fractional = cartesian_to_fractional(position_cartesian)
+    const position_fractional = cartesian_to_fractional(k_lattice_inv, position_cartesian)
 
     // Transform world-space point to local space for nearest-vertex lookup
     // surface.vertices are in local space (raw geometry before sym_matrix)
@@ -610,26 +492,20 @@
     last_hover_time = now
     hover_data = create_hover_data(event, surface, surface_color, sym_idx, sym_matrix)
   }
+
+  const clear_hover = () => {
+    hover_data = null
+  }
 </script>
 
-{#if camera_projection === `perspective`}
-  <T.PerspectiveCamera makeDefault position={computed_camera_position} {fov}>
-    <extras.OrbitControls {...orbit_controls_props}>
-      {#if gizmo}<extras.Gizmo {...gizmo_props} />{/if}
-    </extras.OrbitControls>
-  </T.PerspectiveCamera>
-{:else}
-  <T.OrthographicCamera
-    makeDefault
-    position={computed_camera_position}
-    zoom={initial_zoom}
-    near={-100}
-  >
-    <extras.OrbitControls {...orbit_controls_props}>
-      {#if gizmo}<extras.Gizmo {...gizmo_props} />{/if}
-    </extras.OrbitControls>
-  </T.OrthographicCamera>
-{/if}
+<SceneCamera
+  {camera_projection}
+  position={computed_camera_position}
+  {fov}
+  zoom={initial_zoom}
+  orbit_props={orbit_controls_props}
+  {gizmo}
+/>
 
 <T.DirectionalLight position={[3, 10, 10]} intensity={directional_light} />
 <T.DirectionalLight position={[-3, -5, -10]} intensity={directional_light * 0.5} />
@@ -657,24 +533,11 @@
 
   <!-- Reciprocal lattice vectors -->
   {#if show_vectors && fermi_data?.k_lattice}
-    {#each fermi_data.k_lattice as vec, idx (idx)}
-      {@const scaled_vec = vec.map((coord) => coord * vector_scale) as Vec3}
-      {@const label_position = scaled_vec.map((coord) => coord * 1.15) as Vec3}
-      <Arrow
-        position={[0, 0, 0]}
-        vector={scaled_vec}
-        color={vector_colors[idx]}
-        scale={1}
-        shaft_radius={scene_size * 0.008}
-        arrow_head_radius={scene_size * 0.028}
-        arrow_head_length={-0.1}
-      />
-      <extras.HTML center position={label_position}>
-        <span style:color={vector_colors[idx]} style:font-size="1.2em">
-          {vector_labels[idx]}
-        </span>
-      </extras.HTML>
-    {/each}
+    <ReciprocalVectors
+      k_lattice={fermi_data.k_lattice}
+      {vector_scale}
+      size={scene_size}
+    />
   {/if}
 
   <!-- Fermi surfaces (with optional symmetry tiling) -->
@@ -700,9 +563,7 @@
             {renderOrder}
             onpointermove={(event: ThreltePointerEvent) =>
             handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={() => {
-              hover_data = null
-            }}
+            onpointerleave={clear_hover}
           >
             <T.MeshBasicMaterial
               color={surface_color}
@@ -723,9 +584,7 @@
             renderOrder={renderOrder * 2}
             onpointermove={(event: ThreltePointerEvent) =>
             handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={() => {
-              hover_data = null
-            }}
+            onpointerleave={clear_hover}
           >
             <T.MeshStandardMaterial
               {...get_material_props(surface_color, use_vertex_colors, surface_idx, `back`)}
@@ -742,9 +601,7 @@
             renderOrder={renderOrder * 2 + 1}
             onpointermove={(event: ThreltePointerEvent) =>
             handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={() => {
-              hover_data = null
-            }}
+            onpointerleave={clear_hover}
           >
             <T.MeshStandardMaterial
               {...get_material_props(
@@ -767,9 +624,7 @@
             {renderOrder}
             onpointermove={(event: ThreltePointerEvent) =>
             handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={() => {
-              hover_data = null
-            }}
+            onpointerleave={clear_hover}
           >
             <T.MeshStandardMaterial
               {...get_material_props(
@@ -788,10 +643,3 @@
     {/if}
   {/each}
 </T.Group>
-
-<style>
-  :global(.fermi-surface .responsive-gizmo) {
-    width: clamp(70px, 18cqmin, 100px) !important;
-    height: clamp(70px, 18cqmin, 100px) !important;
-  }
-</style>

package/dist/fermi-surface/FermiSurfaceScene.svelte.d.ts

@@ -1,15 +1,11 @@
 import type { BrillouinZoneData } from '../brillouin';
 import type { Vec3 } from '../math';
-import type { CameraProjection } from '../settings';
-import * as extras from '@threlte/extras';
-import type { ComponentProps } from 'svelte';
-import type { Camera, Scene } from 'three';
+import type { SceneControlProps } from '../scene';
 import type { ColorProperty, FermiHoverData, FermiSurfaceData, RepresentationMode } from './types';
-type $$ComponentProps = {
+type $$ComponentProps = SceneControlProps & {
     fermi_data?: FermiSurfaceData;
     bz_data?: BrillouinZoneData;
     camera_position?: Vec3 | undefined;
-    camera_projection?: CameraProjection;
     color_property?: ColorProperty;
     color_scale?: string;
     representation?: RepresentationMode;
@@ -27,24 +23,8 @@ type $$ComponentProps = {
     clip_position?: number;
     clip_flip?: boolean;
     vector_scale?: number;
-    rotation_damping?: number;
-    max_zoom?: number;
-    min_zoom?: number;
-    rotate_speed?: number;
-    zoom_speed?: number;
-    pan_speed?: number;
-    zoom_to_cursor?: boolean;
-    fov?: number;
-    initial_zoom?: number;
-    ambient_light?: number;
-    directional_light?: number;
-    gizmo?: boolean | ComponentProps<typeof extras.Gizmo>;
-    auto_rotate?: number;
-    camera_is_moving?: boolean;
-    scene?: Scene;
-    camera?: Camera;
     hover_data?: FermiHoverData | null;
 };
-declare const FermiSurfaceScene: import("svelte").Component<$$ComponentProps, {}, "camera_position" | "camera_projection" | "camera" | "scene" | "camera_is_moving" | "surface_opacity" | "bz_data" | "hover_data" | "fermi_data">;
+declare const FermiSurfaceScene: import("svelte").Component<$$ComponentProps, {}, "scene" | "camera" | "camera_projection" | "camera_position" | "surface_opacity" | "bz_data" | "hover_data" | "fermi_data">;
 type FermiSurfaceScene = ReturnType<typeof FermiSurfaceScene>;
 export default FermiSurfaceScene;

package/dist/fermi-surface/compute.js

@@ -2,7 +2,7 @@
 import * as math from '../math';
 import { EPS } from '../math';
 import { CLOSED_CONTOUR_TOLERANCE, IRREDUCIBLE_BZ_MIN_VERTICES, IRREDUCIBLE_BZ_TOLERANCE, SPANNING_THRESHOLD, } from './constants';
-import { marching_cubes } from './marching-cubes';
+import { marching_cubes } from '../marching-cubes';
 const safe_mod = (val, dim) => ((val % dim) + dim) % dim;
 // Precompute Catmull-Rom coefficients for a given t value
 // Returns [c0, c1, c2, c3] where result = c0*p0 + c1*p1 + c2*p2 + c3*p3
@@ -29,7 +29,7 @@ function tricubic_interpolate(grid, fx, fy, fz, px, py, pz) {
     const [cz0, cz1, cz2, cz3] = catmull_rom_coeffs(fz - iz);
     // Wrapped stencil indices (modulo hoisted out of the inner loop); a zero period
     // (single-point axis) has no neighbours, so collapse the stencil onto index 0
-    const stencil = (idx, period) => [idx - 1, idx, idx + 1, idx + 2].map((v) => period > 0 ? ((v % period) + period) % period : 0);
+    const stencil = (idx, period) => [idx - 1, idx, idx + 1, idx + 2].map((stencil_idx) => period > 0 ? ((stencil_idx % period) + period) % period : 0);
     const [wx, wy, wz] = [stencil(ix, px), stencil(iy, py), stencil(iz, pz)];
     // Interpolate along z, then y, then x (fully inlined)
     let result = 0;
@@ -60,8 +60,8 @@ function upsample_grid(grid, factor, periodic = false) {
     // period (count of unique points) doubles as the resampling span numerator
     const endpoint = periodic ? 0 : 1;
     const dims = [grid.length, grid[0]?.length || 0, grid[0]?.[0]?.length || 0];
-    const [px, py, pz] = dims.map((n) => n - endpoint);
-    const [new_nx, new_ny, new_nz] = [px, py, pz].map((p) => Math.round(p * factor) + endpoint);
+    const [px, py, pz] = dims.map((dim) => dim - endpoint);
+    const [new_nx, new_ny, new_nz] = [px, py, pz].map((period) => Math.round(period * factor) + endpoint);
     // Map new index → source coordinate; a single-point axis (span 0) pins its lone
     // output to source 0 to avoid 0/0 = NaN
     const src_coords = (new_n, period) => {
@@ -142,7 +142,8 @@ export function extract_fermi_surface(band_data, options = {}) {
             if (compute_velocities && band_data.velocities) {
                 isosurface.properties = compute_fermi_velocities(isosurface, band_data.velocities[spin_idx][band_idx], band_data.k_lattice, band_data.k_grid, periodic);
                 isosurface.avg_velocity =
-                    isosurface.properties.reduce((s, v) => s + v, 0) / isosurface.properties.length;
+                    isosurface.properties.reduce((sum, velocity) => sum + velocity, 0) /
+                        isosurface.properties.length;
             }
             // Compute dimensionality if requested
             if (compute_dimensionality) {
@@ -348,19 +349,19 @@ function compute_edge_intersection(surface, vertex_distances, v0_idx, v1_idx) {
     // Edge must cross the plane (opposite signs)
     if (d0 * d1 >= 0)
         return null;
-    const t = d0 / (d0 - d1);
+    const frac = d0 / (d0 - d1);
     const v0 = surface.vertices[v0_idx];
     const v1 = surface.vertices[v1_idx];
     const point = [
-        v0[0] + t * (v1[0] - v0[0]),
-        v0[1] + t * (v1[1] - v0[1]),
-        v0[2] + t * (v1[2] - v0[2]),
+        v0[0] + frac * (v1[0] - v0[0]),
+        v0[1] + frac * (v1[1] - v0[1]),
+        v0[2] + frac * (v1[2] - v0[2]),
     ];
     let property;
     if (surface.properties) {
         property =
             surface.properties[v0_idx] +
-                t * (surface.properties[v1_idx] - surface.properties[v0_idx]);
+                frac * (surface.properties[v1_idx] - surface.properties[v0_idx]);
     }
     return { point, property };
 }

package/dist/fermi-surface/export.js

@@ -1,16 +1,5 @@
+import { download } from '../io/fetch';
 import { to_error } from '../utils';
-// Helper to trigger file download
-function download_file(content, filename, mime_type) {
-    const blob = new Blob([content], { type: mime_type });
-    const url = URL.createObjectURL(blob);
-    const link = document.createElement(`a`);
-    link.href = url;
-    link.download = filename;
-    document.body.append(link);
-    link.click();
-    document.body.removeChild(link);
-    URL.revokeObjectURL(url);
-}
 // Export scene to STL format (good for 3D printing)
 export async function export_to_stl(scene, filename) {
     const { STLExporter } = await import(`three/addons/exporters/STLExporter.js`);
@@ -18,14 +7,14 @@ export async function export_to_stl(scene, filename) {
     const result = exporter.parse(scene, { binary: true });
     // Binary STL returns DataView, convert to ArrayBuffer for Blob
     const buffer = result instanceof DataView ? result.buffer : result;
-    download_file(buffer, `${filename}.stl`, `application/octet-stream`);
+    download(buffer, `${filename}.stl`, `application/octet-stream`);
 }
 // Export scene to OBJ format (widely compatible)
 export async function export_to_obj(scene, filename) {
     const { OBJExporter } = await import(`three/addons/exporters/OBJExporter.js`);
     const exporter = new OBJExporter();
     const result = exporter.parse(scene);
-    download_file(result, `${filename}.obj`, `text/plain`);
+    download(result, `${filename}.obj`, `text/plain`);
 }
 // Export scene to GLTF format (modern web/AR standard)
 export async function export_to_gltf(scene, filename) {
@@ -34,7 +23,7 @@ export async function export_to_gltf(scene, filename) {
     return new Promise((resolve, reject) => {
         exporter.parse(scene, (gltf) => {
             const output = JSON.stringify(gltf, null, 2);
-            download_file(output, `${filename}.gltf`, `application/json`);
+            download(output, `${filename}.gltf`, `application/json`);
             resolve();
         }, (error) => reject(to_error(error)), { binary: false });
     });

package/dist/fermi-surface/index.d.ts

@@ -6,7 +6,6 @@ export { default as FermiSurfaceTooltip } from './FermiSurfaceTooltip.svelte';
 export * from './compute';
 export * from './constants';
 export * from './export';
-export * from './marching-cubes';
 export * from './parse';
 export * from './symmetry';
 export * from './types';

package/dist/fermi-surface/index.js

@@ -7,7 +7,6 @@ export { default as FermiSurfaceTooltip } from './FermiSurfaceTooltip.svelte';
 export * from './compute';
 export * from './constants';
 export * from './export';
-export * from './marching-cubes';
 export * from './parse';
 export * from './symmetry';
 export * from './types';

package/dist/fermi-surface/parse.d.ts

@@ -1,2 +1,2 @@
 import type { BandGridData, FermiSurfaceData } from './types';
-export declare function parse_fermi_file(content: string, filename?: string): BandGridData | FermiSurfaceData | null;
+export declare function parse_fermi_file(content: string, filename?: string): BandGridData | FermiSurfaceData;