react-cheminfo 0.69.0 → 0.71.0

package/lib/mass/core/peakTable.js

@@ -0,0 +1,53 @@
+/**
+ * The rows the peak table lists, and the text they are copied out as.
+ *
+ * The rows are the centroid's own peaks, read through `selectCentroidPeaks` —
+ * the same windowing the chart is read through — so the table and the chart
+ * can never disagree about which peaks exist.
+ */
+import { selectCentroidPeaks } from "./centroidPeaks.js";
+import { formatIntensity, formatMz } from "./massFormat.js";
+/**
+ * How many rows the table lists at most, the most intense kept.
+ *
+ * Far more than anybody reads, and few enough that a centroid of fifty
+ * thousand peaks does not lay out fifty thousand rows under a pointer move.
+ */
+export const PEAK_TABLE_LIMIT = 1000;
+/**
+ * The floor the table starts at, as a fraction of the base peak: where a
+ * chemist's own peak list starts, and where everything under it is the
+ * baseline the compound sits on.
+ */
+export const PEAK_TABLE_THRESHOLD = 0.01;
+/**
+ * The peaks the table lists for one spectrum, in increasing m/z.
+ * @param spectrum - The spectrum the table is about.
+ * @param options - The window, and the floor.
+ * @returns The peaks, shared with the centroid's cache — read, never written.
+ */
+export function peakTableRows(spectrum, options = {}) {
+    const { domain = null, threshold = PEAK_TABLE_THRESHOLD } = options;
+    return selectCentroidPeaks(spectrum.centroid, {
+        ...(domain === null ? {} : { from: domain.x[0], to: domain.x[1] }),
+        threshold,
+        limit: PEAK_TABLE_LIMIT,
+    });
+}
+/**
+ * The rows as tab-separated text, the way a spreadsheet takes a paste.
+ *
+ * Written to the decimals the table shows rather than as the doubles are held,
+ * so what is pasted is what was read on screen.
+ * @param peaks - The rows, in the order they are listed.
+ * @param mzDecimals - How many decimals the masses are written with.
+ * @returns A header line and one line per peak.
+ */
+export function peakTableToTsv(peaks, mzDecimals) {
+    const lines = ['m/z\tintensity\tcharge'];
+    for (const peak of peaks) {
+        lines.push(`${formatMz(peak.x, mzDecimals)}\t${formatIntensity(peak.y, mzDecimals)}\t${peak.charge === 0 ? '' : peak.charge}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+//# sourceMappingURL=peakTable.js.map

package/lib/mass/core/peakTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"peakTable.js","sourceRoot":"","sources":["../../../src/mass/core/peakTable.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAG5D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,CAAC;AAErC;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CAAC;AAiBzC;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAC3B,QAAsB,EACtB,UAA4B,EAAE;IAE9B,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,SAAS,GAAG,oBAAoB,EAAE,GAAG,OAAO,CAAC;IACpE,OAAO,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE;QAC5C,GAAG,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAClE,SAAS;QACT,KAAK,EAAE,gBAAgB;KACxB,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,KAAgC,EAChC,UAAkB;IAElB,MAAM,KAAK,GAAG,CAAC,wBAAwB,CAAC,CAAC;IACzC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CACR,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,KAAK,eAAe,CAAC,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,KAAK,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CACnH,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;AACjC,CAAC"}

package/lib/mass/core/resolutionOf.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The resolution of a spectrum as everything downstream asks for it, and the
+ * decimals every number on screen is written with.
+ */
+import type { MassResolution } from './massResolution.ts';
+import type { MassMeta, MassSpectrum } from './massSpectrum.ts';
+/** The evidence a verdict is decided on. */
+export interface DecideResolutionOptions {
+    /** What the peak widths measured, `null` for a peak table. */
+    measured: MassResolution | null;
+    /** What the file said about the acquisition. */
+    meta: MassMeta | null;
+    /** The m/z of every picked peak. */
+    masses: Float64Array;
+}
+/**
+ * The strongest verdict there is evidence for.
+ *
+ * A measurement wins outright. Otherwise the instrument the file names decides
+ * the kind, but never the decimals beyond what the masses were written with:
+ * an ion trap exporting four decimals resolves one, and a table of whole
+ * numbers stays whole whatever instrument it came off — writing `330.0` claims
+ * a decimal nobody wrote.
+ * @param options - The measurement, the file's records and the masses.
+ * @returns The verdict.
+ */
+export declare function decideResolution(options: DecideResolutionOptions): MassResolution;
+/**
+ * The verdict on a spectrum: the one it was read with, or else the one its file
+ * and its masses imply.
+ *
+ * A spectrum a host built itself carries no verdict, and has no peak widths to
+ * measure one from either, so what the file named and what the masses were
+ * written with are all there is. Cached per centroid, since the verdict is
+ * asked of every drawn spectrum on every change of what is drawn, and a
+ * centroid is replaced rather than written into.
+ * @param spectrum - The spectrum.
+ * @returns How finely it resolves masses.
+ */
+export declare function resolutionOf(spectrum: MassSpectrum): MassResolution;
+/**
+ * How many decimals the masses of spectra drawn together are written with when
+ * nobody chose: high-resolution masses or nominal ones, nothing in between.
+ *
+ * A high-resolution spectrum is written to the decimals its verdict allows —
+ * four, or fewer where the file wrote fewer, since padding `330.12` out to
+ * `330.1200` claims digits nobody measured. Anything else is written as the
+ * nominal mass: a low-resolution instrument's decimals are where its noise
+ * lives, and a reader who wants them chooses a number of decimals instead.
+ *
+ * Asked of all of them at once rather than of each, so one table and one axis
+ * never disagree about how wide a number is — and the most precise spectrum
+ * wins: put a calculated isotopic pattern beside a nominal peak table and the
+ * masses go back to four decimals, because rounding the pattern to match would
+ * hide the very difference the comparison was made to show.
+ * @param spectra - The spectra being shown together.
+ * @returns The decimals; four when none of them holds a peak.
+ */
+export declare function mzDecimalsOf(spectra: readonly MassSpectrum[]): number;
+//# sourceMappingURL=resolutionOf.d.ts.map

package/lib/mass/core/resolutionOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolutionOf.d.ts","sourceRoot":"","sources":["../../../src/mass/core/resolutionOf.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGhE,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB;IACtC,8DAA8D;IAC9D,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAChC,gDAAgD;IAChD,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IACtB,oCAAoC;IACpC,MAAM,EAAE,YAAY,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,uBAAuB,GAC/B,cAAc,CAOhB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,cAAc,CAWnE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CAWrE"}

package/lib/mass/core/resolutionOf.js

@@ -0,0 +1,84 @@
+/**
+ * The resolution of a spectrum as everything downstream asks for it, and the
+ * decimals every number on screen is written with.
+ */
+import { MZ_DECIMALS, statedResolution } from "./massResolution.js";
+import { writtenResolution } from "./writtenResolution.js";
+/**
+ * The strongest verdict there is evidence for.
+ *
+ * A measurement wins outright. Otherwise the instrument the file names decides
+ * the kind, but never the decimals beyond what the masses were written with:
+ * an ion trap exporting four decimals resolves one, and a table of whole
+ * numbers stays whole whatever instrument it came off — writing `330.0` claims
+ * a decimal nobody wrote.
+ * @param options - The measurement, the file's records and the masses.
+ * @returns The verdict.
+ */
+export function decideResolution(options) {
+    const { measured, meta, masses } = options;
+    if (measured !== null)
+        return measured;
+    const written = writtenResolution(masses);
+    const stated = statedResolution(meta);
+    if (stated === null || written.kind === 'nominal')
+        return written;
+    return { ...stated, decimals: Math.min(stated.decimals, written.decimals) };
+}
+/**
+ * The verdict on a spectrum: the one it was read with, or else the one its file
+ * and its masses imply.
+ *
+ * A spectrum a host built itself carries no verdict, and has no peak widths to
+ * measure one from either, so what the file named and what the masses were
+ * written with are all there is. Cached per centroid, since the verdict is
+ * asked of every drawn spectrum on every change of what is drawn, and a
+ * centroid is replaced rather than written into.
+ * @param spectrum - The spectrum.
+ * @returns How finely it resolves masses.
+ */
+export function resolutionOf(spectrum) {
+    if (spectrum.resolution !== undefined)
+        return spectrum.resolution;
+    const cached = decidedCache.get(spectrum.centroid.x);
+    if (cached !== undefined)
+        return cached;
+    const resolution = decideResolution({
+        measured: null,
+        meta: spectrum.meta,
+        masses: spectrum.centroid.x,
+    });
+    decidedCache.set(spectrum.centroid.x, resolution);
+    return resolution;
+}
+/**
+ * How many decimals the masses of spectra drawn together are written with when
+ * nobody chose: high-resolution masses or nominal ones, nothing in between.
+ *
+ * A high-resolution spectrum is written to the decimals its verdict allows —
+ * four, or fewer where the file wrote fewer, since padding `330.12` out to
+ * `330.1200` claims digits nobody measured. Anything else is written as the
+ * nominal mass: a low-resolution instrument's decimals are where its noise
+ * lives, and a reader who wants them chooses a number of decimals instead.
+ *
+ * Asked of all of them at once rather than of each, so one table and one axis
+ * never disagree about how wide a number is — and the most precise spectrum
+ * wins: put a calculated isotopic pattern beside a nominal peak table and the
+ * masses go back to four decimals, because rounding the pattern to match would
+ * hide the very difference the comparison was made to show.
+ * @param spectra - The spectra being shown together.
+ * @returns The decimals; four when none of them holds a peak.
+ */
+export function mzDecimalsOf(spectra) {
+    let decimals = -1;
+    for (const spectrum of spectra) {
+        if (spectrum.centroid.x.length === 0)
+            continue;
+        const resolution = resolutionOf(spectrum);
+        decimals = Math.max(decimals, resolution.kind === 'high' ? resolution.decimals : MZ_DECIMALS.nominal);
+    }
+    return decimals === -1 ? MZ_DECIMALS.high : decimals;
+}
+/** The verdicts already decided, keyed by the masses they were decided on. */
+const decidedCache = new WeakMap();
+//# sourceMappingURL=resolutionOf.js.map

package/lib/mass/core/resolutionOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolutionOf.js","sourceRoot":"","sources":["../../../src/mass/core/resolutionOf.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAY3D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAgC;IAEhC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAC3C,IAAI,QAAQ,KAAK,IAAI;QAAE,OAAO,QAAQ,CAAC;IACvC,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,OAAO,CAAC;IAClE,OAAO,EAAE,GAAG,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;AAC9E,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAC,QAAsB;IACjD,IAAI,QAAQ,CAAC,UAAU,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC,UAAU,CAAC;IAClE,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACrD,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,MAAM,UAAU,GAAG,gBAAgB,CAAC;QAClC,QAAQ,EAAE,IAAI;QACd,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;KAC5B,CAAC,CAAC;IACH,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;IAClD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,YAAY,CAAC,OAAgC;IAC3D,IAAI,QAAQ,GAAG,CAAC,CAAC,CAAC;IAClB,KAAK,MAAM,QAAQ,IAAI,OAAO,EAAE,CAAC;QAC/B,IAAI,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QAC/C,MAAM,UAAU,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC1C,QAAQ,GAAG,IAAI,CAAC,GAAG,CACjB,QAAQ,EACR,UAAU,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CACvE,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC;AACvD,CAAC;AAED,8EAA8E;AAC9E,MAAM,YAAY,GAAG,IAAI,OAAO,EAAgC,CAAC"}

package/lib/mass/core/scanFilter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * What a Thermo scan filter states, mined for the fields the records left blank.
+ *
+ * The structured `##$` records are the polite answer and the scan filter is the
+ * honest one: a real Exploris export writes `##$IONISATION=` with nothing after
+ * the equals sign and then names `NSI` in the middle of the conditions block
+ * two lines later. So every field falls back to this, per field and never
+ * wholesale — an explicit record always wins, because the exporter that wrote
+ * it knew something the filter line does not say.
+ *
+ * A filter reads like
+ * `FTMS + p NSI Full ms2 194.5000@hcd50.00 [44.0860-220.4300]`, preceded by the
+ * raw file name and followed by `Scan #:` and `RT:` lines.
+ */
+/**
+ * Read every field a conditions block states.
+ *
+ * Keyed by the same labels the metadata table uses, so a caller only has to
+ * look up the label it failed to fill — nothing here has to know which fields
+ * exist or what order they are shown in.
+ * @param conditions - The instrument's own scan description, verbatim.
+ * @returns The fields it states, by label; empty when it states none.
+ */
+export declare function parseScanFilter(conditions: string): Record<string, string>;
+//# sourceMappingURL=scanFilter.d.ts.map

package/lib/mass/core/scanFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanFilter.d.ts","sourceRoot":"","sources":["../../../src/mass/core/scanFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqC1E"}

package/lib/mass/core/scanFilter.js

@@ -0,0 +1,107 @@
+/**
+ * What a Thermo scan filter states, mined for the fields the records left blank.
+ *
+ * The structured `##$` records are the polite answer and the scan filter is the
+ * honest one: a real Exploris export writes `##$IONISATION=` with nothing after
+ * the equals sign and then names `NSI` in the middle of the conditions block
+ * two lines later. So every field falls back to this, per field and never
+ * wholesale — an explicit record always wins, because the exporter that wrote
+ * it knew something the filter line does not say.
+ *
+ * A filter reads like
+ * `FTMS + p NSI Full ms2 194.5000@hcd50.00 [44.0860-220.4300]`, preceded by the
+ * raw file name and followed by `Scan #:` and `RT:` lines.
+ */
+/**
+ * Read every field a conditions block states.
+ *
+ * Keyed by the same labels the metadata table uses, so a caller only has to
+ * look up the label it failed to fill — nothing here has to know which fields
+ * exist or what order they are shown in.
+ * @param conditions - The instrument's own scan description, verbatim.
+ * @returns The fields it states, by label; empty when it states none.
+ */
+export function parseScanFilter(conditions) {
+    if (!conditions)
+        return {};
+    const derived = {};
+    const analyser = group(/^(?<value>FTMS|ITMS|TOFMS)\b/m, conditions);
+    if (analyser)
+        derived.Analyser = analyser;
+    const ionisation = group(/\b(?<value>ESI|NSI|APCI|MALDI)\b/, conditions);
+    if (ionisation)
+        derived.Ionization = ionisation;
+    // The sign is read between the analyser and the ion source rather than on its
+    // own, because a bare `-` also separates the two ends of the scan range.
+    if (/(?:FTMS|ITMS|TOFMS) \+ /.test(conditions)) {
+        derived.Polarity = 'positive';
+    }
+    else if (/(?:FTMS|ITMS|TOFMS) - /.test(conditions)) {
+        derived.Polarity = 'negative';
+    }
+    readFragmentation(conditions, derived);
+    const range = /\[(?<from>[\d.]+)-(?<to>[\d.]+)\]/.exec(conditions);
+    const from = range?.groups?.from;
+    const to = range?.groups?.to;
+    if (from !== undefined && to !== undefined) {
+        derived['Scan range'] = `${Number(from)}–${Number(to)} m/z`;
+    }
+    const retentionTime = group(/^RT:\s*(?<value>.+)$/m, conditions);
+    if (retentionTime)
+        derived['Retention time'] = `${retentionTime} min`;
+    const scans = group(/^Scan #:\s*(?<value>.+)$/m, conditions);
+    if (scans)
+        derived.Scans = scans;
+    const rawFile = group(/^(?<value>\S+\.raw)$/m, conditions);
+    if (rawFile)
+        derived['Raw file'] = rawFile;
+    return derived;
+}
+/**
+ * Read the level a scan was taken at, and what it isolated to get there.
+ *
+ * The level is read first and everything else only under it, because the
+ * isolation and the energy are the level's own clause: a survey scan that
+ * happens to be described one line below a product scan states no level of its
+ * own, and reading its `@hcd50.00` anyway would report a collision energy for a
+ * spectrum nothing was ever fragmented into.
+ *
+ * The level is not tied to the shape of that clause, though — `Full ms2
+ * 194.5000@etd` and `SIM ms [190.0000-200.0000]` are both real filters, and an
+ * MS2 that loses its level because the activation was spelled unusually loses
+ * the precursor the annotator would have searched for.
+ * @param conditions - The instrument's own scan description.
+ * @param derived - The fields read so far, added to in place.
+ */
+function readFragmentation(conditions, derived) {
+    const level = /\b(?:Full|SIM|SRM) ms(?<level>\d*)\b/.exec(conditions)?.groups
+        ?.level;
+    if (level === undefined)
+        return;
+    if (level === '') {
+        derived['MS level'] = 'MS1';
+        return;
+    }
+    derived['MS level'] = `MS${level}`;
+    // The isolation is anchored to the level the filter just stated, so an MS3
+    // reports the window it was isolated at rather than the one before it.
+    const isolation = group(new RegExp(String.raw ` ms${level} (?<value>\d+(?:\.\d+)?)`), conditions);
+    if (isolation)
+        derived['Isolation m/z'] = isolation;
+    const clause = /@(?<activation>[a-z]+)(?<energy>\d+(?:\.\d+)?)/.exec(conditions);
+    const activation = clause?.groups?.activation;
+    const energy = clause?.groups?.energy;
+    if (activation !== undefined && energy !== undefined) {
+        derived['Collision energy'] = `${activation.toUpperCase()} ${energy}`;
+    }
+}
+/**
+ * The `value` capture of a pattern, trimmed.
+ * @param pattern - A regular expression carrying a `value` named group.
+ * @param conditions - The text to read it out of.
+ * @returns The capture, or `''` when the pattern does not match.
+ */
+function group(pattern, conditions) {
+    return pattern.exec(conditions)?.groups?.value?.trim() ?? '';
+}
+//# sourceMappingURL=scanFilter.js.map

package/lib/mass/core/scanFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanFilter.js","sourceRoot":"","sources":["../../../src/mass/core/scanFilter.ts"],"names":[],"mappings":"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"}

package/lib/mass/core/spectrumJcamp.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Writing spectra back out as JCAMP-DX, so what was loaded can be taken away.
+ *
+ * JCAMP is the format to write rather than two columns of text because it
+ * carries the acquisition records beside the points, so a spectrum that came in
+ * knowing it was an MS2 scan at 3.2 minutes goes out still knowing it — and
+ * comes back into this viewer, or into any other reader of the format, with its
+ * acquisition table intact.
+ *
+ * The points are written as an `##PEAK TABLE=` of explicit `x y` pairs rather
+ * than as a compressed `##XYDATA=` record, and that is a correctness choice. An
+ * XYDATA record states a first x and an increment and lets the reader rebuild
+ * the axis, which is exact only for an evenly sampled trace; a TOF or an FT scan
+ * is not evenly sampled, and writing one that way moves every m/z. Explicit
+ * pairs round trip bit for bit, at about 16 bytes a point.
+ */
+import type { MassSpectrum } from './massSpectrum.ts';
+/** The extension a written spectrum is saved under. */
+export declare const JCAMP_EXTENSION = ".jdx";
+/** What a JCAMP-DX file is served as. */
+export declare const JCAMP_MIME_TYPE = "chemical/x-jcamp-dx";
+/**
+ * Write one spectrum as a JCAMP-DX block.
+ *
+ * The trace written is the one the spectrum is the record of: the continuous
+ * profile where the file held one, and the centroid otherwise. Both are never
+ * written, because a reader — this one included — picks the peaks of a profile
+ * as it loads it, so a file carrying the sticks as well would come back as two
+ * spectra of the same acquisition.
+ * @param spectrum - The spectrum.
+ * @returns The block, `##TITLE=` through `##END=`.
+ */
+export declare function massSpectrumToJcamp(spectrum: MassSpectrum): string;
+/**
+ * Write every spectrum of a list as one JCAMP-DX file.
+ *
+ * One file rather than one download per spectrum: a browser asked for eleven
+ * files in a row blocks all but the first. The blocks go inside a `LINK` block,
+ * which is what JCAMP has for a container, so dropping the file back on the
+ * chart brings the whole list back. A list of one is written as that block
+ * alone: wrapping a single spectrum in a container gains nothing.
+ * @param spectra - The spectra, in the order the list holds them.
+ * @param title - What to call the file's own outer block.
+ * @returns The file.
+ */
+export declare function massSpectraToJcamp(spectra: readonly MassSpectrum[], title?: string): string;
+//# sourceMappingURL=spectrumJcamp.d.ts.map

package/lib/mass/core/spectrumJcamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spectrumJcamp.d.ts","sourceRoot":"","sources":["../../../src/mass/core/spectrumJcamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,uDAAuD;AACvD,eAAO,MAAM,eAAe,SAAS,CAAC;AAEtC,yCAAyC;AACzC,eAAO,MAAM,eAAe,wBAAwB,CAAC;AAErD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAMlE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,KAAK,SAAmC,GACvC,MAAM,CAaR"}

package/lib/mass/core/spectrumJcamp.js

@@ -0,0 +1,167 @@
+/**
+ * Writing spectra back out as JCAMP-DX, so what was loaded can be taken away.
+ *
+ * JCAMP is the format to write rather than two columns of text because it
+ * carries the acquisition records beside the points, so a spectrum that came in
+ * knowing it was an MS2 scan at 3.2 minutes goes out still knowing it — and
+ * comes back into this viewer, or into any other reader of the format, with its
+ * acquisition table intact.
+ *
+ * The points are written as an `##PEAK TABLE=` of explicit `x y` pairs rather
+ * than as a compressed `##XYDATA=` record, and that is a correctness choice. An
+ * XYDATA record states a first x and an increment and lets the reader rebuild
+ * the axis, which is exact only for an evenly sampled trace; a TOF or an FT scan
+ * is not evenly sampled, and writing one that way moves every m/z. Explicit
+ * pairs round trip bit for bit, at about 16 bytes a point.
+ */
+import { fromJSON } from 'convert-to-jcamp';
+import { metaRecord } from "./massMeta.js";
+/** The extension a written spectrum is saved under. */
+export const JCAMP_EXTENSION = '.jdx';
+/** What a JCAMP-DX file is served as. */
+export const JCAMP_MIME_TYPE = 'chemical/x-jcamp-dx';
+/**
+ * Write one spectrum as a JCAMP-DX block.
+ *
+ * The trace written is the one the spectrum is the record of: the continuous
+ * profile where the file held one, and the centroid otherwise. Both are never
+ * written, because a reader — this one included — picks the peaks of a profile
+ * as it loads it, so a file carrying the sticks as well would come back as two
+ * spectra of the same acquisition.
+ * @param spectrum - The spectrum.
+ * @returns The block, `##TITLE=` through `##END=`.
+ */
+export function massSpectrumToJcamp(spectrum) {
+    const trace = spectrum.profile ?? spectrum.centroid;
+    return fromJSON({ x: trace.x, y: trace.y }, { info: infoRecords(spectrum), meta: metaRecords(spectrum) });
+}
+/**
+ * Write every spectrum of a list as one JCAMP-DX file.
+ *
+ * One file rather than one download per spectrum: a browser asked for eleven
+ * files in a row blocks all but the first. The blocks go inside a `LINK` block,
+ * which is what JCAMP has for a container, so dropping the file back on the
+ * chart brings the whole list back. A list of one is written as that block
+ * alone: wrapping a single spectrum in a container gains nothing.
+ * @param spectra - The spectra, in the order the list holds them.
+ * @param title - What to call the file's own outer block.
+ * @returns The file.
+ */
+export function massSpectraToJcamp(spectra, title = `${spectra.length} mass spectra`) {
+    const only = spectra.length === 1 ? spectra[0] : undefined;
+    if (only !== undefined)
+        return massSpectrumToJcamp(only);
+    const blocks = [];
+    for (const spectrum of spectra)
+        blocks.push(massSpectrumToJcamp(spectrum));
+    return `##TITLE=${recordValue(title)}
+##JCAMP-DX=4.24
+##DATA TYPE=LINK
+##BLOCKS=${blocks.length}
+${blocks.join('\n')}
+##END=
+`;
+}
+/**
+ * The standard records of a block: what it is called, and what its axes are.
+ * @param spectrum - The spectrum.
+ * @returns The records, as `convert-to-jcamp` takes them.
+ */
+function infoRecords(spectrum) {
+    const info = {
+        title: recordValue(spectrum.name),
+        dataType: 'MASS SPECTRUM',
+        xUnits: 'M/Z',
+        yUnits: 'RELATIVE ABUNDANCE',
+    };
+    const { meta } = spectrum;
+    if (meta === null)
+        return info;
+    for (const field of meta.fields) {
+        const record = metaRecord(field.label);
+        if (record?.info === true)
+            info[record.key] = recordValue(field.value);
+    }
+    if (meta.molecularFormula !== null) {
+        info.MOLFORM = recordValue(meta.molecularFormula);
+    }
+    // `origin` is the one standard record `fromJSON` writes from a lowercase key,
+    // and the reader shows it as the source, so it goes through that key or not at
+    // all: an `##ORIGIN=` written twice is a file two readers disagree about.
+    const source = info.ORIGIN;
+    if (source !== undefined) {
+        info.origin = source;
+        delete info.ORIGIN;
+    }
+    return info;
+}
+/**
+ * The `$`-prefixed records of a block: the acquisition, as far as it is known.
+ *
+ * Everything the acquisition table holds, plus whatever the origin knows that
+ * the table does not — an mzML or a netCDF states the MS level and the polarity
+ * in its own structures rather than in a record, and those facts would otherwise
+ * be the one thing a round trip through JCAMP lost.
+ *
+ * The formula is written here as well as into the standard `##MOLFORM=`, which
+ * looks like the same fact stated twice and is: a reader that keeps only the
+ * `$` records — `common-spectrum` is one — would otherwise lose it, and it
+ * drives which masses an annotator looks for.
+ * @param spectrum - The spectrum.
+ * @returns The records, keyed without their `##$`.
+ */
+function metaRecords(spectrum) {
+    const records = {};
+    const { meta, origin } = spectrum;
+    if (meta !== null) {
+        for (const field of meta.fields) {
+            const record = metaRecord(field.label);
+            if (record !== null && !record.info) {
+                records[record.key] = recordValue(field.value);
+            }
+        }
+        if (meta.conditions !== null) {
+            records.CONDITIONS = recordValue(meta.conditions);
+        }
+        if (meta.molecularFormula !== null) {
+            records.ACCURATE_MF = recordValue(meta.molecularFormula);
+        }
+    }
+    fill(records, 'MSLEVEL', origin.msLevel);
+    fill(records, 'MODE', origin.polarity);
+    fill(records, 'ISOLATION', origin.precursorMz);
+    if (origin.retentionTime !== undefined) {
+        fill(records, 'RETENTIONTIME', `${origin.retentionTime} min`);
+    }
+    return records;
+}
+/**
+ * Write a fact the origin knows, unless the table already stated it.
+ *
+ * The table wins because it is what the file itself said, whereas the origin is
+ * what was derived from it — and a value shown in the panel that changed on the
+ * way out is worse than a value written in a slightly different spelling.
+ * @param records - The records being built.
+ * @param key - The record to write.
+ * @param value - What it says, absent when nothing is known.
+ */
+function fill(records, key, value) {
+    if (value === undefined || records[key] !== undefined)
+        return;
+    records[key] = recordValue(String(value));
+}
+/**
+ * A value put where a JCAMP record's value goes.
+ *
+ * A record is one line and `$$` opens a comment that runs to the end of it, so
+ * an instrument's scan description — which arrives with newlines in it as often
+ * as not — would otherwise either break the file in two or lose its tail. Both
+ * failures are silent on the way back in, which is why this is done to every
+ * value rather than to the ones known to be long.
+ * @param value - The value as it is held.
+ * @returns The value as one line, with no comment marker in it.
+ */
+function recordValue(value) {
+    return value.replaceAll(/\s+/g, ' ').replaceAll('$$', '$').trim();
+}
+//# sourceMappingURL=spectrumJcamp.js.map

package/lib/mass/core/spectrumJcamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spectrumJcamp.js","sourceRoot":"","sources":["../../../src/mass/core/spectrumJcamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,uDAAuD;AACvD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC;AAEtC,yCAAyC;AACzC,MAAM,CAAC,MAAM,eAAe,GAAG,qBAAqB,CAAC;AAErD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAsB;IACxD,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,QAAQ,CAAC,QAAQ,CAAC;IACpD,OAAO,QAAQ,CACb,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,EAC1B,EAAE,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,CAC7D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAgC,EAChC,KAAK,GAAG,GAAG,OAAO,CAAC,MAAM,eAAe;IAExC,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3D,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAEzD,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,MAAM,QAAQ,IAAI,OAAO;QAAE,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC3E,OAAO,WAAW,WAAW,CAAC,KAAK,CAAC;;;WAG3B,MAAM,CAAC,MAAM;EACtB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;;CAElB,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,SAAS,WAAW,CAAC,QAAsB;IACzC,MAAM,IAAI,GAA2B;QACnC,KAAK,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC;QACjC,QAAQ,EAAE,eAAe;QACzB,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,oBAAoB;KAC7B,CAAC;IACF,MAAM,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC;IAC1B,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAE/B,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,MAAM,EAAE,IAAI,KAAK,IAAI;YAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACzE,CAAC;IACD,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE,CAAC;QACnC,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACpD,CAAC;IACD,8EAA8E;IAC9E,+EAA+E;IAC/E,0EAA0E;IAC1E,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC3B,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,WAAW,CAAC,QAAsB;IACzC,MAAM,OAAO,GAA2B,EAAE,CAAC;IAC3C,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,QAAQ,CAAC;IAElC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAClB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACvC,IAAI,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACpC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;QACD,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YAC7B,OAAO,CAAC,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE,CAAC;YACnC,OAAO,CAAC,WAAW,GAAG,WAAW,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC3D,CAAC;IACH,CAAC;IAED,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACzC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvC,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;IAC/C,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;QACvC,IAAI,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAAC,aAAa,MAAM,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,IAAI,CACX,OAA+B,EAC/B,GAAW,EACX,KAAkC;IAElC,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS;QAAE,OAAO;IAC9D,OAAO,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,WAAW,CAAC,KAAa;IAChC,OAAO,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;AACpE,CAAC"}

package/lib/mass/core/toMassSpectrum.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Turning what a reader produced into what the viewer holds.
+ *
+ * A reader answers about a file and knows nothing about the session it is being
+ * read into — which spectra are already open, what colours they took, what this
+ * one should be called. That is the gap this closes: the peaks are picked here,
+ * the resolution decided, and it is the only place an identity or a colour is
+ * invented.
+ */
+import type { AnalyseSpectrumOptions } from './analyseSpectrum.ts';
+import type { LoadedMassSpectrum } from './loadedMassSpectrum.ts';
+import type { MassSpectrum } from './massSpectrum.ts';
+/** What has to be decided for a loaded spectrum to become a held one. */
+export interface ToMassSpectrumOptions {
+    /**
+     * Identity, which every later edit and selection is keyed on.
+     * @default a fresh UUID
+     */
+    id?: string;
+    /**
+     * The colour to draw it in.
+     * @default the lowest hue not in `taken`
+     */
+    color?: string;
+    /**
+     * The colours the spectra already open have taken, so a new one is told apart
+     * from them. Ignored when `color` says outright.
+     * @default no colours taken
+     */
+    taken?: readonly string[];
+    /**
+     * What to call it, overriding the file's own title.
+     * @default the file's title, then its name, then `Spectrum`
+     */
+    name?: string;
+    /**
+     * How the peaks are picked, beyond what the file itself said.
+     * @default the analysis's own defaults
+     */
+    analysis?: Omit<AnalyseSpectrumOptions, 'continuous'>;
+}
+/**
+ * Make a held spectrum out of a read one.
+ *
+ * The resolution is the strongest verdict there is evidence for, as
+ * `decideResolution` weighs it: measured on the peak widths when the trace is a
+ * profile, otherwise what the file says the instrument was, and only failing
+ * both what the decimals of the masses imply.
+ * @param loaded - What the reader produced.
+ * @param options - The identity, colour and name to give it.
+ * @returns The spectrum as the viewer holds it, its peaks picked.
+ * @throws {Error} Whatever the peak picking refuses the trace with.
+ */
+export declare function toMassSpectrum(loaded: LoadedMassSpectrum, options?: ToMassSpectrumOptions): MassSpectrum;
+/**
+ * Make held spectra out of everything one file held.
+ *
+ * The colours are handed out one at a time against a growing list, so a file
+ * carrying three scans gives three spectra of three colours rather than three
+ * of the same — `nextSpectrumColor` can only answer that if it is told what the
+ * previous call took.
+ * @param loaded - What the reader produced, in file order.
+ * @param options - The colours already taken, and how the peaks are picked.
+ * @returns The spectra, in the same order.
+ */
+export declare function toMassSpectra(loaded: readonly LoadedMassSpectrum[], options?: Pick<ToMassSpectrumOptions, 'taken' | 'analysis'>): MassSpectrum[];
+//# sourceMappingURL=toMassSpectrum.d.ts.map

package/lib/mass/core/toMassSpectrum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toMassSpectrum.d.ts","sourceRoot":"","sources":["../../../src/mass/core/toMassSpectrum.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGtD,yEAAyE;AACzE,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,YAAY,CAAC,CAAC;CACvD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,GAAE,qBAA0B,GAClC,YAAY,CAiCd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,kBAAkB,EAAE,EACrC,OAAO,GAAE,IAAI,CAAC,qBAAqB,EAAE,OAAO,GAAG,UAAU,CAAM,GAC9D,YAAY,EAAE,CAahB"}