react-cheminfo 0.69.0 → 0.71.0

package/src/mass/core/massCommands.ts

@@ -0,0 +1,156 @@
+/**
+ * Everything the viewer offers, what each is called, and the key it answers to.
+ *
+ * One table, read by three things that must agree: the toolbar draws it, the
+ * tooltip explains it, and the key handler fires it. Written apart from all
+ * three so a command cannot be added to the toolbar without a name, or bound to
+ * a key nothing tells the reader about.
+ *
+ * The keys are the infrared viewer's wherever the two viewers share a command,
+ * so a chemist who has learned one has learned the other.
+ */
+
+/** The key a command answers to. */
+export interface MassShortcut {
+  /** The `event.key` values it fires on, the first being the one shown. */
+  keys: readonly string[];
+  /**
+   * How to write the key in a tooltip, where the raw value would read badly.
+   * @default the first of `keys`
+   */
+  label?: readonly string[];
+}
+
+/** A gesture that does the same thing, listed under the tooltip's title. */
+export interface MassGesture {
+  /** Where the gesture is made, or what it is made with. */
+  title: string;
+  /** The buttons, keys or wheel that make it. */
+  shortcuts: readonly string[];
+}
+
+/** One thing the viewer can be asked to do. */
+export interface MassCommand {
+  /** What it is called, which is what the tooltip is titled. */
+  title: string;
+  /**
+   * The key it answers to, absent for a command with none.
+   * @default undefined
+   */
+  shortcut?: MassShortcut;
+  /**
+   * What it does, in a sentence, under the title in the tooltip.
+   * @default undefined
+   */
+  description?: string;
+  /**
+   * The gestures that do the same thing, for the ones a key cannot describe.
+   * @default undefined
+   */
+  gestures?: readonly MassGesture[];
+}
+
+/** Where the chart is, for a gesture made anywhere on it. */
+const OVER_THE_CHART = 'Over the chart';
+
+/** Everything the viewer offers, in the order it is reached for. */
+export const massCommands = {
+  about: {
+    title: 'About the mass spectrum viewer',
+    description: 'What it reads, what it is built on, and what it credits.',
+  },
+  documentation: {
+    title: 'Documentation',
+    shortcut: { keys: ['h'] },
+    description:
+      'How to open a spectrum, what the panels hold, and every gesture.',
+  },
+  fullScreen: {
+    title: 'Full screen',
+    description:
+      'The viewer takes the whole screen rather than its corner of the page. Esc gives it back.',
+  },
+  openFiles: {
+    title: 'Open spectra…',
+    shortcut: { keys: ['o'] },
+    description:
+      'Reads JCAMP-DX files and two-column text files of m/z and intensity, and adds what they hold to the chart.',
+    gestures: [{ title: OVER_THE_CHART, shortcuts: ['Drop files'] }],
+  },
+  readTool: {
+    title: 'Read',
+    shortcut: { keys: ['r'] },
+    description:
+      'A drag narrows the m/z axis, which is the question a spectrum is nearly always asked. Released below the baseline, it takes the intensity axis with it.',
+    gestures: [{ title: OVER_THE_CHART, shortcuts: ['Drag'] }],
+  },
+  boxTool: {
+    title: 'Square zoom',
+    shortcut: { keys: ['b'] },
+    description:
+      'A drag zooms to exactly the rectangle it sweeps out, both axes at once — for looking into the baseline under a cluster rather than across the spectrum.',
+    gestures: [{ title: OVER_THE_CHART, shortcuts: ['Drag a rectangle'] }],
+  },
+  zoomIn: {
+    title: 'Zoom in',
+    shortcut: { keys: ['+', '='] },
+    description: 'Brings the small peaks up, scaling the intensity about zero.',
+    gestures: [{ title: OVER_THE_CHART, shortcuts: ['Scroll wheel'] }],
+  },
+  zoomOut: {
+    title: 'Zoom out',
+    shortcut: { keys: ['-'] },
+    description: 'Puts the intensity axis back out again.',
+    gestures: [{ title: OVER_THE_CHART, shortcuts: ['Scroll wheel'] }],
+  },
+  resetZoom: {
+    title: 'Zoom to fit',
+    shortcut: { keys: ['f'] },
+    description: 'Shows every spectrum that is drawn, whole.',
+    gestures: [{ title: OVER_THE_CHART, shortcuts: ['Double click'] }],
+  },
+  toggleLabels: {
+    title: 'Label the peaks',
+    shortcut: { keys: ['l'] },
+    description:
+      'Writes the m/z and the intensity over the tallest peaks of the selected spectrum. Which peaks follows the zoom: zoom onto a cluster and every line of it is labelled.',
+  },
+  toggleCharges: {
+    title: 'Write the charges',
+    shortcut: { keys: ['z'] },
+    description:
+      'Adds the charge to the label of every peak whose isotopologue spacing, or charge ladder, established one.',
+  },
+  exportImage: {
+    title: 'Save figure…',
+    shortcut: { keys: ['x'] },
+    description:
+      'The chart as it stands, saved as a PNG or an SVG at a chosen resolution, or copied as a PNG.',
+  },
+  clear: {
+    title: 'Close every spectrum',
+    description: 'Empties the chart and starts again.',
+  },
+} as const satisfies Record<string, MassCommand>;
+
+/** Identity of one of the commands the viewer offers. */
+export type MassCommandId = keyof typeof massCommands;
+
+/** What to do when each command is run, as the shell wires them. */
+export type MassCommandHandlers = Partial<
+  Record<MassCommandId, (() => void) | undefined>
+>;
+
+/** How a component runs a command. */
+export type RunMassCommand = (id: MassCommandId) => void;
+
+/**
+ * What a command is called, with its key, for a label and an `aria-label`.
+ * @param id - Which command.
+ * @returns The title, and the key in parentheses when it has one.
+ */
+export function massCommandLabel(id: MassCommandId): string {
+  const entry: MassCommand = massCommands[id];
+  const key = entry.shortcut?.label?.[0] ?? entry.shortcut?.keys[0];
+  return key === undefined ? entry.title : `${entry.title} (${key})`;
+}

package/src/mass/core/massDomain.ts

@@ -0,0 +1,229 @@
+/**
+ * The window a chart opens on, worked out from the spectra it was handed.
+ *
+ * This is what "zoom to fit" and the first render both call, so it has to be
+ * right for a peak table of four rows and for a profile scan of half a million
+ * points alike, and it has to answer something usable when it is handed nothing
+ * at all — a chart with no data is still mounted, still measured, and still
+ * builds its scales.
+ */
+
+import { xMaxValue } from 'ml-spectra-processing';
+
+import type { MassDomain, MassSpectrum, MassTrace } from './massSpectrum.ts';
+
+/**
+ * How much air is left either side of the outermost peak, as a fraction.
+ *
+ * A stick drawn exactly on the axis reads as a spectrum that was cut off there;
+ * two percent is enough to show that it was not.
+ */
+export const X_DOMAIN_PADDING = 0.02;
+
+/**
+ * How far above the tallest peak the intensity axis runs.
+ *
+ * The base peak carries the label nobody wants to lose — its m/z and its
+ * intensity, on two lines — and it is drawn above the stick. Twenty percent is
+ * the room those lines take at the top of a chart of any usual height.
+ */
+export const Y_DOMAIN_HEADROOM = 1.2;
+
+/**
+ * The window that shows everything currently drawn.
+ *
+ * A spectrum marked `excludeFromDomain` is left out of the extents, because it
+ * is a preview rather than data: a predicted pattern that appears and
+ * disappears with the pointer would throw away the zoom the user set every
+ * time it moved the axes. The exclusion is dropped when it would leave nothing
+ * at all — previewing into an empty chart has to show the preview, not an empty
+ * axis from 0 to 1.
+ *
+ * In mirror mode the negative half is the reflection of the positive one rather
+ * than its own extent. Two spectra compared head-to-head are only comparable if
+ * a peak of the same height means the same intensity in both halves; giving each
+ * half its own scale makes the weaker spectrum look as intense as the stronger,
+ * which is precisely the comparison the view exists to make.
+ * @param spectra - What the chart draws.
+ * @param mirror - Whether the chart reflects its spectra about zero. Defaults
+ * to `false`.
+ * @returns The window, in m/z and in intensity.
+ */
+export function fullDomain(
+  spectra: readonly MassSpectrum[],
+  mirror = false,
+): MassDomain {
+  const extent = traceExtent(spectra, false) ?? traceExtent(spectra, true);
+  if (extent === null) return { x: [0, 1], y: [0, 1] };
+
+  const { xMinimum, xMaximum, yMaximum } = extent;
+  const padding = (xMaximum - xMinimum) * X_DOMAIN_PADDING;
+  // A single peak, or several at one m/z, has no width to take a fraction of.
+  const x: [number, number] =
+    padding > 0
+      ? [xMinimum - padding, xMaximum + padding]
+      : [xMinimum - 1, xMaximum + 1];
+  const top = yMaximum > 0 ? yMaximum * Y_DOMAIN_HEADROOM : 1;
+  return { x, y: mirror ? [-top, top] : [0, top] };
+}
+
+/**
+ * What a fitted window was fitted *to*, as one string two renders can compare.
+ *
+ * The chart puts its window back to `fullDomain` when it is handed different
+ * data, and must not when the same data is merely drawn differently — so
+ * something has to tell the two apart. It is the identities that are compared
+ * and never the extents: a spectrum switched from its profile to its sticks
+ * moves the fitted window by a hair, and refitting on a hair throws away the
+ * zoom somebody set, which is the whole reason this exists. Loading a spectrum,
+ * closing one and reflecting the chart about zero are the changes that have to
+ * be shown, and every one of them shows up here.
+ *
+ * A spectrum kept out of the automatic domain is kept out of this too, for the
+ * reason it is kept out of the extents: a predicted pattern previewed under the
+ * pointer comes and goes with the pointer, and refitting on it would throw the
+ * zoom away every time a search result is read. The identities are joined by a
+ * character no identity holds, so `a b` and `a` then `b` are two fits.
+ * @param spectra - What the chart draws.
+ * @param mirror - Whether the chart reflects its spectra about zero. Defaults
+ * to `false`.
+ * @returns A string equal to itself exactly when a fit would be made to the
+ * same thing.
+ */
+export function fittedTo(
+  spectra: readonly MassSpectrum[],
+  mirror = false,
+): string {
+  let key = mirror ? 'mirror' : 'upward';
+  for (const spectrum of spectra) {
+    if (spectrum.excludeFromDomain) continue;
+    key += `\u0000${spectrum.id}`;
+  }
+  return key;
+}
+
+/**
+ * The tallest intensity among the traces a set of spectra currently draws.
+ *
+ * What "how tall is this chart" comes to, in the units the spectra are in, with
+ * the headroom `fullDomain` adds left off — so it answers a question about the
+ * measurement rather than about the plot. A preview kept out of the extents is
+ * kept out of this too, and a chart holding nothing but a preview is measured
+ * by it rather than answering zero.
+ * @param spectra - The spectra to measure, drawn or not.
+ * @returns The tallest intensity drawn, or `0` when nothing is.
+ */
+export function basePeakOf(spectra: readonly MassSpectrum[]): number {
+  const extent = traceExtent(spectra, false) ?? traceExtent(spectra, true);
+  return extent === null ? 0 : extent.yMaximum;
+}
+
+/**
+ * How much of the axis framing a peak shows, either side of its mass.
+ *
+ * Wide enough to hold the isotopologue cluster of a singly charged ion, because
+ * a peak is read in its cluster and not alone: the M+1 says how much carbon it
+ * holds and the spacing says what charge it carries.
+ */
+export const MZ_FRAME_HALF_WIDTH = 2.5;
+
+/** How a mass is framed. */
+export interface MzFrameOptions {
+  /**
+   * How much of the axis to show either side of the mass.
+   * @default MZ_FRAME_HALF_WIDTH
+   */
+  halfWidth?: number;
+  /**
+   * Whether the chart reflects its spectra about zero, which decides the height
+   * it opens on when it has no window of its own.
+   * @default false
+   */
+  mirror?: boolean;
+}
+
+/**
+ * The window that frames one mass, keeping the intensity axis where it was.
+ *
+ * The vertical extent is deliberately not recomputed from what falls inside the
+ * new window: a click is a request to look somewhere else along the m/z axis,
+ * and rescaling the height at the same time makes whatever was just clicked fill
+ * the plot, so every peak looks like the base peak and the one number the eye
+ * reads off a spectrum stops meaning anything. It is only worked out from the
+ * spectra when the chart has no window of its own to keep.
+ * @param mz - The mass to frame.
+ * @param spectra - What the chart is drawing, for the height it opens on.
+ * @param domain - The window the chart is showing, `null` when it is fitting.
+ * @param options - How wide a window, and whether the chart is mirrored.
+ * @returns The window to show.
+ */
+export function mzFrame(
+  mz: number,
+  spectra: readonly MassSpectrum[],
+  domain: MassDomain | null,
+  options: MzFrameOptions = {},
+): MassDomain {
+  const { halfWidth = MZ_FRAME_HALF_WIDTH, mirror = false } = options;
+  const y = domain?.y ?? fullDomain(spectra, mirror).y;
+  return { x: [mz - halfWidth, mz + halfWidth], y };
+}
+
+/** The extremes of a set of traces, before any padding is added. */
+interface TraceExtent {
+  /** The lowest m/z drawn. */
+  xMinimum: number;
+  /** The highest m/z drawn. */
+  xMaximum: number;
+  /** The tallest intensity drawn. */
+  yMaximum: number;
+}
+
+/**
+ * The extremes over every trace that is currently drawn.
+ * @param spectra - What the chart draws.
+ * @param includeExcluded - Whether to count the spectra kept out of the domain.
+ * @returns The extremes, or `null` when nothing is drawn.
+ */
+function traceExtent(
+  spectra: readonly MassSpectrum[],
+  includeExcluded: boolean,
+): TraceExtent | null {
+  let extent: TraceExtent | null = null;
+  for (const spectrum of spectra) {
+    if (!includeExcluded && spectrum.excludeFromDomain) continue;
+    if (spectrum.showProfile && spectrum.profile !== null) {
+      extent = widen(extent, spectrum.profile);
+    }
+    if (spectrum.showCentroid) extent = widen(extent, spectrum.centroid);
+  }
+  return extent;
+}
+
+/**
+ * Grow an extent to cover one more trace.
+ *
+ * The m/z ends are read off the first and last sample rather than searched for:
+ * `MassTrace.x` is increasing by construction, so a scan would walk several
+ * hundred thousand points of a profile to learn what index zero already says.
+ * @param extent - What has been covered so far, `null` for nothing.
+ * @param trace - The trace to cover as well.
+ * @returns The grown extent, unchanged when the trace holds no point.
+ */
+function widen(
+  extent: TraceExtent | null,
+  trace: MassTrace,
+): TraceExtent | null {
+  const { x, y } = trace;
+  if (x.length === 0 || y.length === 0) return extent;
+  const first = x[0] as number;
+  const last = x.at(-1) as number;
+  const tallest = xMaxValue(y);
+  if (extent === null) {
+    return { xMinimum: first, xMaximum: last, yMaximum: tallest };
+  }
+  return {
+    xMinimum: Math.min(extent.xMinimum, first),
+    xMaximum: Math.max(extent.xMaximum, last),
+    yMaximum: Math.max(extent.yMaximum, tallest),
+  };
+}

package/src/mass/core/massEditorApi.ts

@@ -0,0 +1,68 @@
+/**
+ * The handle a host drives the viewer through.
+ *
+ * A handle rather than props, for the reason NMRium uses one: "frame this peak"
+ * and "take these spectra" are *gestures*, and a gesture expressed as a prop has
+ * to change to be obeyed — so asking for the same window twice does nothing the
+ * second time, and a host ends up inventing a nonce to make it work.
+ */
+
+import type { MassDomain, MassSpectrum } from './massSpectrum.ts';
+
+/** How much room to leave either side of a mass a host asks to be framed. */
+export interface ZoomToMzOptions {
+  /**
+   * How much of the m/z axis to show either side of the mass.
+   * @default MZ_FRAME_HALF_WIDTH
+   */
+  halfWidth?: number;
+}
+
+/** What a host can ask of the viewer. */
+export interface MassEditorHandle {
+  /** The spectra that are open, in the order they were loaded. */
+  getSpectra: () => MassSpectrum[];
+  /** Draw these instead of what is open, and refit to them. */
+  setSpectra: (spectra: MassSpectrum[]) => void;
+  /** Draw these as well as what is open. */
+  addSpectra: (spectra: MassSpectrum[]) => void;
+  /**
+   * Read files the way a drop on the chart reads them, and add what they hold.
+   * Resolves once every file has been read; what could not be read is said in
+   * the status bar.
+   */
+  openFiles: (files: readonly File[]) => Promise<void>;
+  /** Close every spectrum. */
+  clear: () => void;
+  /** Show this window. */
+  setDomain: (domain: MassDomain) => void;
+  /** Show what fits. */
+  resetDomain: () => void;
+  /**
+   * Frame a mass, keeping the intensity axis as it is.
+   *
+   * The commonest thing a host wants: a peak named in a table beside the viewer
+   * is clicked, and the chart should go there.
+   */
+  zoomToMz: (mz: number, options?: ZoomToMzOptions) => void;
+  /** Point the panels at one spectrum, or at none. */
+  selectSpectrum: (id: string | null) => void;
+}
+
+/**
+ * A click on the plot, as the viewer tells its host about it.
+ *
+ * A click is a press let go over the plot without travelling: the end of a zoom
+ * drag is never one, and a click on the axis labels is not reported.
+ */
+export interface MassPlotClick {
+  /** Where it landed on the m/z axis. */
+  mz: number;
+  /**
+   * The m/z of the picked peak within reach of the click, `null` when it landed
+   * on none — an empty stretch of the plot is not a peak of zero.
+   */
+  peakMz: number | null;
+  /** Identity of the spectrum selected when it was made, `null` for none. */
+  spectrumId: string | null;
+}

package/src/mass/core/massFormat.ts

@@ -0,0 +1,187 @@
+/**
+ * How every number about a mass spectrum is written, wherever it is written.
+ *
+ * An m/z is written to the decimals the spectra on screen resolve — four for a
+ * high-resolution measurement, none for a nominal-mass table, as
+ * `mzDecimalsOf` settles it for all of them at once — and an intensity follows
+ * it. Settled once here, so a table, an axis label and a tooltip never disagree
+ * about how wide one number is.
+ */
+
+import {
+  SCIENTIFIC_ABOVE,
+  formatScientific,
+} from '../../chart/core/axisLabels.ts';
+import { formatInteger } from '../../format/core/numbers.ts';
+
+import type { MassResolution } from './massResolution.ts';
+import { MZ_DECIMALS } from './massResolution.ts';
+import type { MassFormat } from './massSpectrum.ts';
+
+/** Decimals an intensity is written with, on the 0–100 scale. */
+export const INTENSITY_DECIMALS = 2;
+
+/**
+ * An m/z as every table, axis label and tooltip writes it.
+ *
+ * Always a fixed number of decimals, never `toPrecision` and never the shortest
+ * form that round-trips: a column of masses is read by running an eye down it,
+ * and `163` above `162.9871` above `164.1` is unreadable in a way that
+ * `163.0000` above `162.9871` above `164.1000` is not.
+ * @param mz - The mass-to-charge ratio.
+ * @param decimals - How many decimals the spectra on screen resolve, as
+ * `mzDecimalsOf` decides. Defaults to the high-resolution four.
+ * @returns The number as it is written.
+ */
+export function formatMz(mz: number, decimals = MZ_DECIMALS.high): string {
+  return mz.toFixed(decimals);
+}
+
+/**
+ * An intensity as every table and tooltip writes it, on the 0–100 scale.
+ *
+ * It follows the m/z rather than being decided on its own: a nominal-mass peak
+ * table quotes relative intensities as whole percentages too, and one column of
+ * the same table rounded and the other not looks like a bug. Past the chart's
+ * own `SCIENTIFIC_ABOVE`, and under a hundredth — where two decimals would write
+ * a zero that is not one — the intensity is written as a power of ten, which is
+ * how the axis beside it spells such numbers too.
+ * @param intensity - The intensity, normalised to a base peak of 100, or the
+ * counts themselves for a spectrum that kept them.
+ * @param mzDecimals - How many decimals the masses beside it are written with.
+ * Defaults to the high-resolution four.
+ * @returns The number as it is written.
+ */
+export function formatIntensity(
+  intensity: number,
+  mzDecimals = MZ_DECIMALS.high,
+): string {
+  const decimals = mzDecimals === 0 ? 0 : INTENSITY_DECIMALS;
+  if (intensity === 0) return (0).toFixed(decimals);
+  const size = Math.abs(intensity);
+  if (size >= SCIENTIFIC_ABOVE || size < PLAIN_BELOW) {
+    return formatScientific(intensity, INTENSITY_DECIMALS);
+  }
+  return intensity.toFixed(decimals);
+}
+
+/**
+ * A range of masses, low end first, as the list and the table write it.
+ * @param masses - The m/z of every peak, ascending.
+ * @param decimals - How many decimals to write them with.
+ * @returns `43.8490 – 223.6762`, or `''` for a spectrum holding no peak.
+ */
+export function formatMzRange(masses: Float64Array, decimals: number): string {
+  if (masses.length === 0) return '';
+  const first = masses[0] as number;
+  const last = masses.at(-1) as number;
+  return `${formatMz(first, decimals)} – ${formatMz(last, decimals)}`;
+}
+
+/**
+ * A format as a chemist writes it rather than as the code spells it.
+ * @param format - The format the spectrum was read from.
+ * @returns Its name; a format this package does not read, as it was given.
+ */
+export function massFormatLabel(format: MassFormat): string {
+  return FORMAT_LABELS.get(format) ?? format;
+}
+
+/**
+ * What a resolution verdict is called, in the words a status line uses.
+ * @param resolution - The verdict.
+ * @returns `high resolution`, `low resolution` or `nominal mass`.
+ */
+export function resolutionLabel(resolution: MassResolution): string {
+  return RESOLUTION_LABELS[resolution.kind];
+}
+
+/**
+ * A resolving power as it is quoted: approximately, and to two figures.
+ *
+ * Two significant figures because that is all a median over a score of peaks
+ * can claim, and because `R ≈ 47,000` is how an instrument's resolution is
+ * quoted on its data sheet.
+ * @param resolvingPower - The resolving power `m / Δm`.
+ * @returns `R ≈ 47,000`.
+ */
+export function resolvingPowerLabel(resolvingPower: number): string {
+  return `R ≈ ${formatInteger(Number(resolvingPower.toPrecision(2)))}`;
+}
+
+/**
+ * How a verdict was reached, said as a reader would want it said.
+ * @param resolution - The verdict.
+ * @returns The sentence fragment, e.g. `measured on the peak widths`.
+ */
+export function resolutionBasisLabel(resolution: MassResolution): string {
+  return BASIS_LABELS[resolution.basis];
+}
+
+/**
+ * The intensity below which two decimals have nothing left to say it in.
+ *
+ * A hundredth, which is exactly where `INTENSITY_DECIMALS` runs out: `0.01` is
+ * the smallest number two decimals can write, and everything under it rounds to
+ * a zero that is not one.
+ */
+const PLAIN_BELOW = 1e-2;
+
+/**
+ * How each format is spelled where it is shown: `mzML` and `netCDF` are the
+ * names of the standards, capitals and all, and a table that showed `mzml`
+ * would read as a typo in a panel whose whole purpose is to quote the file
+ * faithfully. Every format a reader of the family hands spectra over in, the
+ * vendor ones included, since a host reading them hands the format over too.
+ */
+const FORMAT_LABELS = new Map<MassFormat, string>([
+  ['jcamp', 'JCAMP-DX'],
+  ['text', 'Text, two columns'],
+  ['calculated', 'Calculated'],
+  ['mzml', 'mzML'],
+  ['mzxml', 'mzXML'],
+  ['mzdata', 'mzData'],
+  ['imzml', 'imzML'],
+  ['mzmlb', 'mzMLb'],
+  ['netcdf', 'netCDF'],
+  ['mgf', 'MGF'],
+  ['msp', 'MSP library'],
+  ['msn', 'MS1/MS2 text'],
+  ['dta', 'Sequest DTA'],
+  ['pkl', 'Micromass peak list'],
+  ['asm', 'Allotrope ASM'],
+  ['thermo', 'Thermo RAW'],
+  ['uep', 'Waters UNIFI package'],
+  ['watersraw', 'Waters RAW'],
+  ['wiff', 'SCIEX WIFF'],
+  ['wiff2', 'SCIEX WIFF2'],
+  ['wiffscan', 'SCIEX WIFF scan file'],
+  ['shimadzu', 'Shimadzu'],
+  ['chemstationms', 'Agilent ChemStation MS'],
+  ['chemstationch', 'Agilent ChemStation trace'],
+  ['chemstationuv', 'Agilent ChemStation UV'],
+  ['agilentdad', 'Agilent MassHunter device'],
+  ['masshunter', 'Agilent MassHunter'],
+  ['brukerflex', 'Bruker flex'],
+  ['brukertsf', 'Bruker timsTOF (TSF)'],
+  ['brukertdf', 'Bruker timsTOF (TDF)'],
+  ['penx', 'PerkinElmer TotalChrom'],
+  ['varian', 'Varian Saturn'],
+  ['spc', 'Galactic SPC'],
+  ['wdf', 'Renishaw WDF'],
+  ['targetraster', 'AP-MALDI target raster'],
+]);
+
+/** How each kind of resolution is named. */
+const RESOLUTION_LABELS: Record<MassResolution['kind'], string> = {
+  high: 'high resolution',
+  low: 'low resolution',
+  nominal: 'nominal mass',
+};
+
+/** How each basis of a verdict is said. */
+const BASIS_LABELS: Record<MassResolution['basis'], string> = {
+  peakWidth: 'measured on the peak widths',
+  instrument: 'stated by the file',
+  decimals: 'read off the decimals written',
+};