matterviz 0.3.6 → 0.4.0

package/dist/src/lib/index.ts

@@ -1,61 +0,0 @@
-export * from './brillouin'
-export * from './chempot-diagram'
-export * from './colors'
-export * from './composition'
-export * from './constants'
-export * from './controls'
-export * from './convex-hull'
-export * from './coordination'
-export * from './element'
-export { default as EmptyState } from './EmptyState.svelte'
-export * from './feedback'
-export * from './fermi-surface'
-export { default as FilePicker } from './FilePicker.svelte'
-export * from './heatmap-matrix'
-export { default as Icon } from './Icon.svelte'
-export * from './icons'
-export * from './io'
-export { default as MillerIndexInput } from './MillerIndexInput.svelte'
-// Explicit exports to avoid name clash with fermi-surface's Isosurface type
-export {
-  auto_isosurface_settings,
-  DEFAULT_ISOSURFACE_SETTINGS,
-  generate_layers,
-  grid_data_range,
-  Isosurface as VolumetricIsosurface,
-  IsosurfaceControls,
-  LAYER_COLORS,
-  parse_chgcar,
-  parse_cube,
-  parse_volumetric_file,
-  sample_hkl_slice,
-  tile_volumetric_data,
-  trilinear_interpolate,
-} from './isosurface'
-export type {
-  DataRange,
-  IsosurfaceLayer,
-  IsosurfaceSettings,
-  SliceResult,
-  VolumetricData,
-  VolumetricFileData,
-} from './isosurface'
-export * from './labels'
-export * from './layout'
-export * from './math'
-export * from './overlays'
-export * from './periodic-table'
-export * from './phase-diagram'
-export * from './plot'
-export * from './rdf'
-export * from './sanitize'
-export * from './settings'
-export * from './spectral'
-export * from './structure'
-export * from './symmetry'
-export * from './table'
-export * from './theme'
-export * from './time'
-export { default as Trajectory } from './trajectory/Trajectory.svelte'
-export * from './utils'
-export * from './xrd'

package/dist/src/lib/io/decompress.ts

@@ -1,92 +0,0 @@
-import type { COMPRESSION_EXTENSIONS } from '$lib/constants'
-import { COMPRESSION_EXTENSIONS_REGEX, COMPRESSION_FORMATS } from '$lib/constants'
-
-export type CompressionFormat = keyof typeof COMPRESSION_FORMATS
-export type CompressionExtension = (typeof COMPRESSION_EXTENSIONS)[number]
-
-export function detect_compression_format(filename: string): CompressionFormat | null {
-  const lower = filename.toLowerCase()
-  for (const [format, extensions] of Object.entries(COMPRESSION_FORMATS)) {
-    if (extensions.some((ext) => lower.endsWith(ext))) return format as CompressionFormat
-  }
-  return null
-}
-
-// Decompress data and return as text string
-export async function decompress_data(
-  data: ArrayBuffer | ReadableStream<Uint8Array> | null,
-  format: CompressionFormat,
-): Promise<string> {
-  const buffer = await decompress_data_binary(data, format)
-  return new TextDecoder().decode(buffer)
-}
-
-// Decompress data and return as ArrayBuffer (for binary files like .brml.gz)
-export async function decompress_data_binary(
-  data: ArrayBuffer | ReadableStream<Uint8Array> | null,
-  format: CompressionFormat,
-): Promise<ArrayBuffer> {
-  try {
-    // Handle unsupported formats
-    if (format === `zip` || format === `xz` || format === `bz2`) {
-      throw new Error(
-        `${format.toUpperCase()} decompression is not supported in the browser. ` +
-          `Please extract the ${format.toUpperCase()} file first.`,
-      )
-    }
-
-    const stream =
-      data instanceof ArrayBuffer
-        ? new ReadableStream({
-            start(controller) {
-              controller.enqueue(new Uint8Array(data))
-              controller.close()
-            },
-          })
-        : data
-    if (!stream) throw new Error(`Invalid data stream`)
-    const unzip = new DecompressionStream(format)
-    return await new Response(stream.pipeThrough(unzip)).arrayBuffer()
-  } catch (error) {
-    throw new Error(`Failed to decompress ${format} file: ${error}`, { cause: error })
-  }
-}
-
-export function decompress_file(file: File): Promise<{ content: string; filename: string }> {
-  const format = detect_compression_format(file.name)
-  const is_supported = Boolean(format && ![`zip`, `xz`, `bz2`].includes(format))
-
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader()
-
-    reader.addEventListener(
-      `load`,
-      () => {
-        try {
-          const result = reader.result
-          if (!result) throw new Error(`Failed to read file`)
-
-          if (is_supported && format) {
-            if (!(result instanceof ArrayBuffer)) throw new Error(`Expected binary file data`)
-            decompress_data(result, format).then((content) => {
-              const filename = file.name.replace(COMPRESSION_EXTENSIONS_REGEX, ``)
-              resolve({ content, filename })
-            }, reject)
-          } else {
-            if (typeof result !== `string`) throw new Error(`Expected text file data`)
-            resolve({ content: result, filename: file.name })
-          }
-        } catch (error) {
-          reject(error)
-        }
-      },
-      { once: true },
-    )
-    reader.addEventListener(`error`, () =>
-      reject(new Error(`Failed to read file ${file.name}`)),
-    )
-
-    if (is_supported) reader.readAsArrayBuffer(file)
-    else reader.readAsText(file)
-  })
-}

package/dist/src/lib/io/export.ts

@@ -1,385 +0,0 @@
-import { download } from '$lib/io/fetch'
-import type { AnyStructure } from '$lib/structure'
-import { create_structure_filename } from '$lib/structure/export'
-import { type Camera, type Scene, Vector2, type WebGLRenderer } from 'three'
-
-function is_webgl_renderer_like(value: unknown): value is WebGLRenderer {
-  if (typeof value !== `object` || !value) return false
-  const renderer_obj = value as Record<string, unknown>
-  return (
-    typeof renderer_obj.render === `function` &&
-    typeof renderer_obj.getPixelRatio === `function` &&
-    typeof renderer_obj.setPixelRatio === `function` &&
-    typeof renderer_obj.getSize === `function` &&
-    typeof renderer_obj.setSize === `function`
-  )
-}
-
-function get_canvas_renderer(canvas: HTMLCanvasElement): WebGLRenderer | undefined {
-  const renderer_val = (canvas as unknown as Record<string, unknown>)[`__renderer`]
-  return is_webgl_renderer_like(renderer_val) ? renderer_val : undefined
-}
-
-// Capture a WebGL canvas as a PNG Blob at the given DPI.
-// Temporarily adjusts renderer pixel ratio for high-res capture, then restores.
-// Returns data directly (no browser download), suitable for programmatic capture
-// in test suites, server-side rendering, or Python widget integration via anywidget.
-// DPI is converted to a resolution multiplier relative to 72 DPI baseline, capped at 10x.
-export function canvas_to_png_blob(
-  canvas: HTMLCanvasElement,
-  png_dpi = 150,
-  scene: Scene | null = null,
-  camera: Camera | null = null,
-): Promise<Blob> {
-  const resolution_multiplier = Math.min(png_dpi / 72, 10)
-  const renderer = get_canvas_renderer(canvas)
-
-  if (resolution_multiplier <= 1.1 || !renderer) {
-    if (renderer && scene && camera) renderer.render(scene, camera)
-    return new Promise((resolve, reject) => {
-      try {
-        canvas.toBlob((blob) => {
-          if (blob) resolve(blob)
-          else reject(new Error(`Failed to generate PNG - canvas may be empty`))
-        }, `image/png`)
-      } catch (error) {
-        reject(error)
-      }
-    })
-  }
-
-  // Temporarily modify the renderer's pixel ratio for high-res capture
-  const orig_pixel_ratio = renderer.getPixelRatio()
-  const orig_size = renderer.getSize(new Vector2())
-  const restore = () => {
-    renderer.setPixelRatio(orig_pixel_ratio)
-    renderer.setSize(orig_size.width, orig_size.height, false)
-  }
-
-  renderer.setPixelRatio(resolution_multiplier)
-  renderer.setSize(orig_size.width, orig_size.height, false)
-  if (scene && camera) renderer.render(scene, camera)
-
-  return new Promise((resolve, reject) => {
-    try {
-      canvas.toBlob((blob) => {
-        restore()
-        if (blob) resolve(blob)
-        else reject(new Error(`Failed to generate high-resolution PNG`))
-      }, `image/png`)
-    } catch (error) {
-      restore()
-      reject(error)
-    }
-  })
-}
-
-// Export structure as PNG image from canvas (triggers browser download)
-export function export_canvas_as_png(
-  canvas: HTMLCanvasElement | null,
-  structure_or_filename: AnyStructure | string | undefined,
-  png_dpi = 150,
-  scene: Scene | null = null,
-  camera: Camera | null = null,
-): void {
-  if (!canvas) {
-    if (typeof window !== `undefined`) console.warn(`Canvas not found for PNG export`)
-    return
-  }
-
-  let filename =
-    typeof structure_or_filename === `string`
-      ? structure_or_filename
-      : create_structure_filename(structure_or_filename, `png`)
-
-  const suffix = `-${Math.round(png_dpi)}dpi`
-  if (filename.toLowerCase().endsWith(`.png`)) {
-    filename = filename.replace(/\.png$/i, `${suffix}.png`)
-  } else {
-    filename = `${filename}${suffix}.png`
-  }
-
-  canvas_to_png_blob(canvas, png_dpi, scene, camera)
-    .then((blob) => download(blob, filename, `image/png`))
-    .catch((error) => console.error(`Error exporting PNG:`, error))
-}
-
-// Helper to ensure font-family is set on SVG root
-function set_svg_font_family(svg: SVGElement) {
-  const style = svg.getAttribute(`style`) || ``
-  if (!style.includes(`font-family`)) {
-    svg.setAttribute(`style`, `${style}${style ? `;` : ``}font-family:sans-serif;`)
-  }
-  // Also set as attribute for extra robustness
-  svg.setAttribute(`font-family`, `sans-serif`)
-}
-
-// Serialize an SVG element to a standalone SVG string with proper XML headers.
-// Clones the element to avoid mutation, sets font-family/xmlns, and
-// prepends XML declaration + SVG DOCTYPE. Returns a complete SVG document string
-// suitable for saving to file or further processing.
-export function svg_to_svg_string(svg_element: SVGElement): string {
-  const cloned_svg = svg_element.cloneNode(true) as SVGElement
-
-  set_svg_font_family(cloned_svg)
-  if (!cloned_svg.hasAttribute(`xmlns`)) {
-    cloned_svg.setAttribute(`xmlns`, `http://www.w3.org/2000/svg`)
-  }
-
-  const svg_string = new XMLSerializer().serializeToString(cloned_svg)
-  return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n${svg_string}`
-}
-
-// Export SVG element as SVG file (triggers browser download)
-export function export_svg_as_svg(svg_element: SVGElement | null, filename: string): void {
-  if (!svg_element) {
-    console.warn(`SVG element not found for export`)
-    return
-  }
-  try {
-    const svg_content = svg_to_svg_string(svg_element)
-    download(svg_content, filename, `image/svg+xml;charset=utf-8`)
-  } catch (error) {
-    console.error(`Error exporting SVG:`, error)
-  }
-}
-
-// Rasterize an SVG element to a PNG Blob at the given DPI.
-// Creates an offscreen canvas at the scaled resolution, draws the SVG via an
-// Image element, and returns the resulting PNG Blob. Rejects if viewBox is
-// missing or dimensions are invalid (zero width/height).
-// DPI is converted to a resolution multiplier relative to 72 DPI baseline, capped at 10x.
-export function svg_to_png_blob(svg_element: SVGElement, png_dpi = 150): Promise<Blob> {
-  const viewBox = svg_element.getAttribute(`viewBox`)?.trim()
-  if (!viewBox) return Promise.reject(new Error(`SVG viewBox not found for PNG export`))
-
-  const parts = viewBox.split(/[\s,]+/).map(Number)
-  if (parts.length < 4 || !parts.every(Number.isFinite)) {
-    return Promise.reject(new Error(`Invalid SVG dimensions for PNG export`))
-  }
-  const [, , width, height] = parts
-  if (!(width > 0) || !(height > 0)) {
-    return Promise.reject(new Error(`Invalid SVG dimensions for PNG export`))
-  }
-  if (!Number.isFinite(png_dpi) || png_dpi <= 0) {
-    return Promise.reject(new Error(`Invalid PNG DPI for export`))
-  }
-
-  const resolution_multiplier = Math.min(png_dpi / 72, 10)
-  const pixel_width = Math.round(width * resolution_multiplier)
-  const pixel_height = Math.round(height * resolution_multiplier)
-
-  const canvas = document.createElement(`canvas`)
-  const ctx = canvas.getContext(`2d`)
-  if (!ctx) return Promise.reject(new Error(`Canvas 2D context not available`))
-
-  canvas.width = pixel_width
-  canvas.height = pixel_height
-
-  const cloned_svg = svg_element.cloneNode(true) as SVGElement
-  set_svg_font_family(cloned_svg)
-
-  const serialized = new XMLSerializer().serializeToString(cloned_svg)
-  const svg_blob = new Blob([serialized], { type: `image/svg+xml;charset=utf-8` })
-  const svg_data_url = URL.createObjectURL(svg_blob)
-
-  return new Promise((resolve, reject) => {
-    const img = new Image()
-    img.addEventListener(`load`, () => {
-      try {
-        ctx.clearRect(0, 0, pixel_width, pixel_height)
-        ctx.drawImage(img, 0, 0, pixel_width, pixel_height)
-        canvas.toBlob(
-          (blob) => {
-            if (blob) resolve(blob)
-            else reject(new Error(`Failed to generate PNG blob`))
-          },
-          `image/png`,
-          1,
-        )
-      } catch (error) {
-        reject(error)
-      } finally {
-        URL.revokeObjectURL(svg_data_url)
-      }
-    })
-    img.addEventListener(`error`, () => {
-      URL.revokeObjectURL(svg_data_url)
-      reject(new Error(`Failed to load SVG for PNG export`))
-    })
-    img.src = svg_data_url
-  })
-}
-
-// Export SVG element as PNG (triggers browser download)
-export function export_svg_as_png(
-  svg_element: SVGElement | null,
-  filename: string,
-  png_dpi = 150,
-): void {
-  if (!svg_element) {
-    console.warn(`SVG element not found for PNG export`)
-    return
-  }
-  svg_to_png_blob(svg_element, png_dpi)
-    .then((blob) => download(blob, filename, `image/png`))
-    .catch((error) => console.error(`Error exporting PNG:`, error))
-}
-
-// Generate FFmpeg command for WebM to MP4 conversion
-export function get_ffmpeg_conversion_command(input_filename: string): string {
-  const output = input_filename.replace(/\.webm$/i, `.mp4`)
-  return `ffmpeg -i "${input_filename}" -c:v libx264 -preset medium -crf 18 -pix_fmt yuv420p -movflags faststart "${output}"`
-}
-
-// Export trajectory video as WebM with frame-by-frame rendering to prevent dropped frames.
-// Note: Browsers only support WebM natively. Use FFmpeg for MP4 conversion (see get_ffmpeg_conversion_command).
-export async function export_trajectory_video(
-  canvas: HTMLCanvasElement | null,
-  filename: string,
-  options: {
-    fps?: number
-    total_frames?: number
-    on_progress?: (progress: number) => void
-    on_step?: (step_idx: number) => void | Promise<void>
-    resolution_multiplier?: number
-  } = {},
-): Promise<void> {
-  const {
-    fps = 30,
-    total_frames = 100,
-    on_progress,
-    on_step,
-    resolution_multiplier = 1,
-  } = options
-
-  if (
-    !canvas ||
-    typeof MediaRecorder === `undefined` ||
-    !MediaRecorder.isTypeSupported(`video/webm;codecs=vp9`)
-  )
-    throw new Error(`WebM video recording not supported in this browser`)
-
-  const renderer = get_canvas_renderer(canvas)
-
-  // Store original renderer settings if changing resolution
-  let orig_pixel_ratio: number | undefined
-  let orig_size: Vector2 | undefined
-
-  if (resolution_multiplier !== 1 && renderer) {
-    orig_pixel_ratio = renderer.getPixelRatio()
-    orig_size = renderer.getSize(new Vector2())
-    // Adjust pixel ratio for different resolution export
-    renderer.setPixelRatio(orig_pixel_ratio * resolution_multiplier)
-    renderer.setSize(orig_size.width, orig_size.height, false)
-  }
-
-  // Calculate bitrate based on actual video dimensions
-  // VP9 typically needs 0.08-0.12 bits per pixel per frame for good quality
-  // canvas dimensions include device pixel ratio and any resolution_multiplier
-  const pixels_per_frame = canvas.width * canvas.height
-  const bits_per_pixel_per_frame = 0.1 // Good quality for VP9
-  // Clamp bitrate to reasonable bounds (1 Mbps min, 200 Mbps max)
-  const calculated_bitrate = pixels_per_frame * fps * bits_per_pixel_per_frame
-  const bitrate = Math.max(1_000_000, Math.min(calculated_bitrate, 200_000_000))
-
-  const stream = canvas.captureStream(0)
-  const chunks: Blob[] = []
-  const recorder = new MediaRecorder(stream, {
-    mimeType: `video/webm;codecs=vp9`,
-    videoBitsPerSecond: bitrate,
-  })
-
-  recorder.addEventListener(`dataavailable`, (event) => {
-    if (event.data.size > 0) chunks.push(event.data)
-  })
-
-  const track = stream.getVideoTracks()[0] as MediaStreamTrack & {
-    requestFrame?: () => void
-  }
-
-  // Start recording
-  recorder.start()
-
-  const frame_duration = 1000 / fps
-
-  try {
-    // Render each frame sequentially with precise timing
-    for (let idx = 0; idx < total_frames; idx++) {
-      const frame_start = performance.now()
-
-      on_progress?.((idx / total_frames) * 100)
-
-      // Update trajectory step
-      if (on_step) await on_step(idx)
-
-      // Double RAF ensures Three.js completes rendering before capture
-      await new Promise((resolve) =>
-        requestAnimationFrame(() => requestAnimationFrame(resolve)),
-      )
-
-      // Capture frame
-      track.requestFrame?.()
-
-      // Wait for remaining frame time to maintain consistent FPS
-      const elapsed = performance.now() - frame_start
-      const remaining = Math.max(0, frame_duration - elapsed)
-      if (remaining > 0) {
-        await new Promise((resolve) => setTimeout(resolve, remaining))
-      }
-    }
-  } finally {
-    // Restore original renderer settings
-    if (orig_pixel_ratio !== undefined && orig_size && renderer) {
-      renderer.setPixelRatio(orig_pixel_ratio)
-      renderer.setSize(orig_size.width, orig_size.height, false)
-    }
-  }
-
-  // Finalize recording
-  return new Promise((resolve, reject) => {
-    let is_resolved = false
-
-    recorder.addEventListener(`stop`, () => {
-      if (is_resolved) return
-      is_resolved = true
-
-      try {
-        const blob = new Blob(chunks, { type: `video/webm` })
-        const webm_filename = filename.replace(/\.(mp4|webm)$/i, `.webm`)
-        download(blob, webm_filename, `video/webm`)
-        on_progress?.(100)
-        resolve()
-      } catch (error) {
-        reject(error)
-      }
-    })
-
-    recorder.addEventListener(`error`, (event) => {
-      if (is_resolved) return
-      is_resolved = true
-      const error_msg =
-        event instanceof ErrorEvent && event.error instanceof Error
-          ? event.error.message
-          : event.type
-      reject(new Error(`MediaRecorder error: ${error_msg}`))
-    })
-
-    // Stop recording with safety timeout
-    try {
-      recorder.stop()
-      // Fallback: force resolution if recorder doesn't stop within 5 seconds
-      setTimeout(() => {
-        if (!is_resolved) {
-          is_resolved = true
-          reject(new Error(`Recording timeout - recorder did not stop`))
-        }
-      }, 5000)
-    } catch (error) {
-      if (!is_resolved) {
-        is_resolved = true
-        reject(error)
-      }
-    }
-  })
-}

package/dist/src/lib/io/fetch.ts

@@ -1,46 +0,0 @@
-import { decompress_data } from '$lib/io/decompress'
-
-// Convert params object to URL query string, omitting empty/undefined values.
-// Example: {foo: "bar", baz: 42, empty: ""} → "foo=bar&baz=42"
-export const to_query = (params: Record<string, string | number | undefined>): string =>
-  new URLSearchParams(
-    Object.entries(params)
-      .filter(([, val]) => val !== `` && val !== undefined)
-      .map(([key, val]) => [key, String(val)]),
-  ).toString()
-
-export async function fetch_zipped<T>(url: string, { unzip = true } = {}): Promise<T | null> {
-  const response = await fetch(url)
-  if (!response.ok) {
-    console.error(`${response.status} ${response.statusText} for ${response.url}`)
-    return null
-  }
-  if (!unzip) return (await response.blob()) as T
-  return JSON.parse(await decompress_data(response.body, `gzip`))
-}
-
-// Original download implementation
-function default_download(data: string | Blob, filename: string, type: string) {
-  const file = new Blob([data], { type })
-  const link = document.createElement(`a`)
-  const url = URL.createObjectURL(file)
-  link.style.display = `none`
-  link.href = url
-  link.download = filename
-  document.body.appendChild(link)
-  link.click()
-  link.remove()
-  URL.revokeObjectURL(url)
-}
-
-// Function to download data to a file - checks for global override first
-export function download(data: string | Blob, filename: string, type: string): void {
-  // Check if there's a global download override (used by VSCode extension)
-  const global_download = (globalThis as Record<string, unknown>).download
-  if (typeof global_download === `function` && global_download !== download) {
-    return (global_download as typeof download)(data, filename, type)
-  }
-
-  // Use default browser download
-  return default_download(data, filename, type)
-}

package/dist/src/lib/io/file-drop.ts

@@ -1,51 +0,0 @@
-// Shared file-drop handler composable for drag-and-drop file loading.
-import { decompress_file } from './decompress'
-import { handle_url_drop } from './url-drop'
-
-export interface FileDropOptions {
-  allow: () => boolean
-  on_drop: (content: string | ArrayBuffer, filename: string) => void | Promise<void>
-  on_error?: (msg: string) => void
-  set_loading?: (loading: boolean) => void
-}
-
-// Handles URL drops (from FilePicker), direct file drops with decompression,
-// loading state, and error reporting.
-export function create_file_drop_handler(
-  opts: FileDropOptions,
-): (event: DragEvent) => Promise<void> {
-  return async (event: DragEvent) => {
-    event.preventDefault()
-    if (!opts.allow()) return
-
-    opts.set_loading?.(true)
-
-    let drop_filename = ``
-    try {
-      let url_error: string | undefined
-      const handled = await handle_url_drop(event, opts.on_drop).catch((exc) => {
-        url_error = exc instanceof Error ? exc.message : String(exc)
-        return false
-      })
-      if (handled) return
-
-      const file = event.dataTransfer?.files[0]
-      if (!file) {
-        if (url_error) opts.on_error?.(`Failed to load from URL: ${url_error}`)
-        return
-      }
-      drop_filename = file.name
-
-      const { content, filename } = await decompress_file(file)
-      if (content) await opts.on_drop(content, filename)
-    } catch (exc) {
-      const detail = exc instanceof Error ? exc.message : String(exc)
-      const msg = drop_filename
-        ? `Failed to load file ${drop_filename}: ${detail}`
-        : `Failed to load file: ${detail}`
-      opts.on_error?.(msg)
-    } finally {
-      opts.set_loading?.(false)
-    }
-  }
-}

package/dist/src/lib/io/index.ts

@@ -1,7 +0,0 @@
-export * from './decompress'
-export * from './export'
-export * from './fetch'
-export * from './file-drop'
-export * from './is-binary'
-export type * from './types'
-export * from './url-drop'

package/dist/src/lib/io/is-binary.ts

@@ -1,24 +0,0 @@
-// Simplified binary detection
-export const is_binary = (content: string): boolean => {
-  if (!content) return false
-  if (content.includes(`\0`)) return true
-
-  let binary_char_count = 0
-  let printable_ascii_count = 0
-
-  for (let char_idx = 0; char_idx < content.length; char_idx += 1) {
-    const char_code = content.charCodeAt(char_idx)
-    if (
-      char_code <= 8 ||
-      (char_code >= 14 && char_code <= 31) ||
-      (char_code >= 127 && char_code <= 255)
-    ) {
-      binary_char_count += 1
-    }
-    if (char_code >= 32 && char_code <= 126) printable_ascii_count += 1
-  }
-
-  return (
-    binary_char_count / content.length > 0.1 || printable_ascii_count / content.length < 0.7
-  )
-}

package/dist/src/lib/io/types.ts

@@ -1,8 +0,0 @@
-export interface FileInfo {
-  name: string
-  url: string
-  label?: string // human-readable display name (falls back to name)
-  type?: string
-  category?: string
-  category_icon?: string
-}