react-cheminfo 0.14.0 → 0.16.0

package/lib/parallel/core/parallelBrush.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The brush, as arithmetic rather than as a library.
+ *
+ * Everything a vertical brush does — create by dragging on a bare axis, move
+ * the band, drag either edge, clear by pressing outside it — is four answers
+ * to one question: which part of the axis the press landed on. Written this
+ * way it is a pure function of a press and a pointer, so the whole gesture is
+ * covered by tests in a runtime with no DOM at all, which is the one thing a
+ * DOM-mutating brush could never be.
+ */
+import type { ParallelAxisLayout } from './parallelAxes.ts';
+import type { ParallelRange } from './parallelTypes.ts';
+/** A band kept on one axis, in pixels from the top of the drawing area. */
+export interface ParallelBand {
+    /** The upper edge, which is the higher value. */
+    top: number;
+    /** The lower edge, which is the lower value. */
+    bottom: number;
+}
+/** Which part of an axis a press landed on. */
+export type ParallelBrushGrip = 'create' | 'move' | 'top' | 'bottom';
+/** A drag in progress on one axis. */
+export interface ParallelBrushDrag {
+    /** The axis being brushed, by its id. */
+    axis: string;
+    /** What the press took hold of. */
+    grip: ParallelBrushGrip;
+    /** Where the press landed, in pixels from the top of the drawing area. */
+    originY: number;
+    /** The band as it stood when the press landed. */
+    origin: ParallelBand;
+}
+/** How close to an edge a press has to land to take hold of it, in pixels. */
+export declare const PARALLEL_BRUSH_HANDLE_REACH = 4;
+/** How tall a released band has to be to count as a band rather than a click. */
+export declare const PARALLEL_BRUSH_SMALLEST = 1;
+/** How far either side of an axis a press still reaches it, in pixels. */
+export declare const PARALLEL_BRUSH_HALF_WIDTH = 9;
+/**
+ * What a press at that height takes hold of.
+ * @param y - Where the press landed, in pixels from the top of the drawing area.
+ * @param band - The band already on that axis, or `null` when it carries none.
+ * @returns The grip. A press within {@link PARALLEL_BRUSH_HANDLE_REACH} of an
+ * edge takes that edge, a press inside the band moves it, and anything else —
+ * including a press on a bare axis — starts a new one.
+ */
+export declare function parallelBrushGrip(y: number, band: ParallelBand | null): ParallelBrushGrip;
+/**
+ * The band a drag stands at, now that the pointer is there.
+ * @param drag - The drag, as it began.
+ * @param y - Where the pointer is, in pixels from the top of the drawing area.
+ * @param height - Height of the drawing area, in pixels.
+ * @returns The band, held inside the drawing area at both ends. Dragging one
+ * edge past the other swaps them rather than inverting the band, and a band
+ * being moved keeps its height rather than being squashed against an end.
+ */
+export declare function parallelBandAt(drag: ParallelBrushDrag, y: number, height: number): ParallelBand;
+/**
+ * Whether a released band keeps anything, or was a click that clears the axis.
+ * @param band - The band, as the pointer left it.
+ * @returns Whether it is tall enough to be an interval.
+ */
+export declare function parallelIsBand(band: ParallelBand): boolean;
+/**
+ * Where an interval sits on its axis, in pixels.
+ * @param range - The interval, low value first.
+ * @param axis - The axis it belongs to.
+ * @returns The band.
+ */
+export declare function parallelBandOf(range: ParallelRange, axis: ParallelAxisLayout): ParallelBand;
+/**
+ * What interval a band keeps, in the axis's own units.
+ * @param band - The band, in pixels from the top of the drawing area.
+ * @param axis - The axis it belongs to.
+ * @returns The interval, low value first — which is the order every filter in
+ * the family reads, and getting it backwards keeps nothing at all.
+ */
+export declare function parallelRangeOf(band: ParallelBand, axis: ParallelAxisLayout): ParallelRange;
+//# sourceMappingURL=parallelBrush.d.ts.map

package/lib/parallel/core/parallelBrush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelBrush.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelBrush.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,2EAA2E;AAC3E,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,+CAA+C;AAC/C,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;AAErE,sCAAsC;AACtC,MAAM,WAAW,iBAAiB;IAChC,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,IAAI,EAAE,iBAAiB,CAAC;IACxB,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,8EAA8E;AAC9E,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,0EAA0E;AAC1E,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,YAAY,GAAG,IAAI,GACxB,iBAAiB,CAMnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,iBAAiB,EACvB,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,GACb,YAAY,CAcd;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,kBAAkB,GACvB,YAAY,CAKd;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,kBAAkB,GACvB,aAAa,CAIf"}

package/lib/parallel/core/parallelBrush.js

@@ -0,0 +1,99 @@
+/**
+ * The brush, as arithmetic rather than as a library.
+ *
+ * Everything a vertical brush does — create by dragging on a bare axis, move
+ * the band, drag either edge, clear by pressing outside it — is four answers
+ * to one question: which part of the axis the press landed on. Written this
+ * way it is a pure function of a press and a pointer, so the whole gesture is
+ * covered by tests in a runtime with no DOM at all, which is the one thing a
+ * DOM-mutating brush could never be.
+ */
+import { parallelValueToY, parallelYToValue } from "./parallelAxes.js";
+/** How close to an edge a press has to land to take hold of it, in pixels. */
+export const PARALLEL_BRUSH_HANDLE_REACH = 4;
+/** How tall a released band has to be to count as a band rather than a click. */
+export const PARALLEL_BRUSH_SMALLEST = 1;
+/** How far either side of an axis a press still reaches it, in pixels. */
+export const PARALLEL_BRUSH_HALF_WIDTH = 9;
+/**
+ * What a press at that height takes hold of.
+ * @param y - Where the press landed, in pixels from the top of the drawing area.
+ * @param band - The band already on that axis, or `null` when it carries none.
+ * @returns The grip. A press within {@link PARALLEL_BRUSH_HANDLE_REACH} of an
+ * edge takes that edge, a press inside the band moves it, and anything else —
+ * including a press on a bare axis — starts a new one.
+ */
+export function parallelBrushGrip(y, band) {
+    if (band === null)
+        return 'create';
+    if (Math.abs(y - band.top) <= PARALLEL_BRUSH_HANDLE_REACH)
+        return 'top';
+    if (Math.abs(y - band.bottom) <= PARALLEL_BRUSH_HANDLE_REACH)
+        return 'bottom';
+    if (y > band.top && y < band.bottom)
+        return 'move';
+    return 'create';
+}
+/**
+ * The band a drag stands at, now that the pointer is there.
+ * @param drag - The drag, as it began.
+ * @param y - Where the pointer is, in pixels from the top of the drawing area.
+ * @param height - Height of the drawing area, in pixels.
+ * @returns The band, held inside the drawing area at both ends. Dragging one
+ * edge past the other swaps them rather than inverting the band, and a band
+ * being moved keeps its height rather than being squashed against an end.
+ */
+export function parallelBandAt(drag, y, height) {
+    const to = clamp(y, 0, height);
+    if (drag.grip === 'create')
+        return order(drag.originY, to);
+    if (drag.grip === 'top')
+        return order(to, drag.origin.bottom);
+    if (drag.grip === 'bottom')
+        return order(drag.origin.top, to);
+    const shift = clamp(to - drag.originY, -drag.origin.top, height - drag.origin.bottom);
+    return {
+        top: drag.origin.top + shift,
+        bottom: drag.origin.bottom + shift,
+    };
+}
+/**
+ * Whether a released band keeps anything, or was a click that clears the axis.
+ * @param band - The band, as the pointer left it.
+ * @returns Whether it is tall enough to be an interval.
+ */
+export function parallelIsBand(band) {
+    return band.bottom - band.top >= PARALLEL_BRUSH_SMALLEST;
+}
+/**
+ * Where an interval sits on its axis, in pixels.
+ * @param range - The interval, low value first.
+ * @param axis - The axis it belongs to.
+ * @returns The band.
+ */
+export function parallelBandOf(range, axis) {
+    return order(parallelValueToY(range[1], axis), parallelValueToY(range[0], axis));
+}
+/**
+ * What interval a band keeps, in the axis's own units.
+ * @param band - The band, in pixels from the top of the drawing area.
+ * @param axis - The axis it belongs to.
+ * @returns The interval, low value first — which is the order every filter in
+ * the family reads, and getting it backwards keeps nothing at all.
+ */
+export function parallelRangeOf(band, axis) {
+    const low = parallelYToValue(band.bottom, axis);
+    const high = parallelYToValue(band.top, axis);
+    return low <= high ? [low, high] : [high, low];
+}
+function order(a, b) {
+    return a <= b ? { top: a, bottom: b } : { top: b, bottom: a };
+}
+function clamp(value, low, high) {
+    if (value < low)
+        return low;
+    if (value > high)
+        return high;
+    return value;
+}
+//# sourceMappingURL=parallelBrush.js.map

package/lib/parallel/core/parallelBrush.js.map

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

package/lib/parallel/core/parallelExtent.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The two ends of one axis, read off its own column.
+ *
+ * Deliberately not `chartPadExtent`: a parallel-coordinates axis ends exactly
+ * on the data, because the reader compares rows against each other rather than
+ * against a round number, and the best row has to touch the top of its axis.
+ * The only opening is for a column with no spread at all, which would
+ * otherwise draw no axis and place every row on one pixel.
+ */
+/** How far a column with no spread at all is opened, on each side. */
+export declare const PARALLEL_DEGENERATE_PADDING = 0.5;
+/** The two ends of an axis, low first. */
+export interface ParallelExtent {
+    /** The value at the bottom of the axis. */
+    min: number;
+    /** The value at its top. */
+    max: number;
+}
+/**
+ * The smallest and the largest finite value of one column.
+ * @param values - The column, read in place.
+ * @param count - How many rows to read, from the start.
+ * @returns The extent. A column holding no finite value at all comes back as
+ * half a unit either side of zero, and a constant one as half a unit either
+ * side of its value, so that both still draw an axis.
+ */
+export declare function parallelExtent(values: ArrayLike<number>, count: number): ParallelExtent;
+//# sourceMappingURL=parallelExtent.d.ts.map

package/lib/parallel/core/parallelExtent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelExtent.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelExtent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,sEAAsE;AACtE,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAE/C,0CAA0C;AAC1C,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,4BAA4B;IAC5B,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,EACzB,KAAK,EAAE,MAAM,GACZ,cAAc,CAuBhB"}

package/lib/parallel/core/parallelExtent.js

@@ -0,0 +1,47 @@
+/**
+ * The two ends of one axis, read off its own column.
+ *
+ * Deliberately not `chartPadExtent`: a parallel-coordinates axis ends exactly
+ * on the data, because the reader compares rows against each other rather than
+ * against a round number, and the best row has to touch the top of its axis.
+ * The only opening is for a column with no spread at all, which would
+ * otherwise draw no axis and place every row on one pixel.
+ */
+/** How far a column with no spread at all is opened, on each side. */
+export const PARALLEL_DEGENERATE_PADDING = 0.5;
+/**
+ * The smallest and the largest finite value of one column.
+ * @param values - The column, read in place.
+ * @param count - How many rows to read, from the start.
+ * @returns The extent. A column holding no finite value at all comes back as
+ * half a unit either side of zero, and a constant one as half a unit either
+ * side of its value, so that both still draw an axis.
+ */
+export function parallelExtent(values, count) {
+    const rows = Math.min(count, values.length);
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (let row = 0; row < rows; row++) {
+        const value = values[row];
+        if (!Number.isFinite(value))
+            continue;
+        if (value < min)
+            min = value;
+        if (value > max)
+            max = value;
+    }
+    if (min > max) {
+        return {
+            min: -PARALLEL_DEGENERATE_PADDING,
+            max: PARALLEL_DEGENERATE_PADDING,
+        };
+    }
+    if (min === max) {
+        return {
+            min: min - PARALLEL_DEGENERATE_PADDING,
+            max: max + PARALLEL_DEGENERATE_PADDING,
+        };
+    }
+    return { min, max };
+}
+//# sourceMappingURL=parallelExtent.js.map

package/lib/parallel/core/parallelExtent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelExtent.js","sourceRoot":"","sources":["../../../src/parallel/core/parallelExtent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,sEAAsE;AACtE,MAAM,CAAC,MAAM,2BAA2B,GAAG,GAAG,CAAC;AAU/C;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAyB,EACzB,KAAa;IAEb,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC;IACnC,IAAI,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC;IACnC,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;QACpC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAW,CAAC;QACpC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,SAAS;QACtC,IAAI,KAAK,GAAG,GAAG;YAAE,GAAG,GAAG,KAAK,CAAC;QAC7B,IAAI,KAAK,GAAG,GAAG;YAAE,GAAG,GAAG,KAAK,CAAC;IAC/B,CAAC;IACD,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;QACd,OAAO;YACL,GAAG,EAAE,CAAC,2BAA2B;YACjC,GAAG,EAAE,2BAA2B;SACjC,CAAC;IACJ,CAAC;IACD,IAAI,GAAG,KAAK,GAAG,EAAE,CAAC;QAChB,OAAO;YACL,GAAG,EAAE,GAAG,GAAG,2BAA2B;YACtC,GAAG,EAAE,GAAG,GAAG,2BAA2B;SACvC,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AACtB,CAAC"}

package/lib/parallel/core/parallelFilter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Which rows the brushes keep.
+ *
+ * Exported rather than kept inside the figure, because a table beside the
+ * figure has to filter on the same answer. Two definitions of "kept" is the
+ * fault this file exists to prevent: a table showing fourteen rows under a
+ * plot drawing one is not a rounding error, it is two different programs.
+ */
+import type { ParallelAxis, ParallelRange, ParallelRanges } from './parallelTypes.ts';
+/**
+ * Whether one value falls inside an interval.
+ * @param range - The interval, low value first.
+ * @param value - The value to test.
+ * @returns Whether it is kept. Both ends are inclusive, and a value that is
+ * not a number is kept by no interval at all — a row whose property has not
+ * been worked out yet cannot be said to be in range.
+ */
+export declare function parallelRangeKeeps(range: ParallelRange, value: number): boolean;
+/**
+ * Which rows every brush keeps at once.
+ * @param axes - The axes, whose ids the intervals are keyed by.
+ * @param ranges - The interval each axis keeps, or `null` for none.
+ * @param count - How many rows there are.
+ * @returns One byte per row, `1` for kept. An interval keyed on an axis that
+ * is not drawn is ignored rather than emptying the figure, so a range left
+ * over from a column the reader has since hidden does not silently filter
+ * everything away.
+ */
+export declare function parallelIncludedMask(axes: readonly ParallelAxis[], ranges: ParallelRanges, count: number): Uint8Array;
+/**
+ * How many rows a mask keeps.
+ * @param included - One byte per row, `1` for kept.
+ * @returns The count.
+ */
+export declare function parallelKeptCount(included: Uint8Array): number;
+//# sourceMappingURL=parallelFilter.d.ts.map

package/lib/parallel/core/parallelFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelFilter.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,cAAc,EACf,MAAM,oBAAoB,CAAC;AAY5B;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,MAAM,GACZ,OAAO,CAET;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,MAAM,GACZ,UAAU,CA0BZ;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAM9D"}

package/lib/parallel/core/parallelFilter.js

@@ -0,0 +1,74 @@
+/**
+ * Which rows the brushes keep.
+ *
+ * Exported rather than kept inside the figure, because a table beside the
+ * figure has to filter on the same answer. Two definitions of "kept" is the
+ * fault this file exists to prevent: a table showing fourteen rows under a
+ * plot drawing one is not a rounding error, it is two different programs.
+ */
+/**
+ * Whether one value falls inside an interval.
+ * @param range - The interval, low value first.
+ * @param value - The value to test.
+ * @returns Whether it is kept. Both ends are inclusive, and a value that is
+ * not a number is kept by no interval at all — a row whose property has not
+ * been worked out yet cannot be said to be in range.
+ */
+export function parallelRangeKeeps(range, value) {
+    return value >= range[0] && value <= range[1];
+}
+/**
+ * Which rows every brush keeps at once.
+ * @param axes - The axes, whose ids the intervals are keyed by.
+ * @param ranges - The interval each axis keeps, or `null` for none.
+ * @param count - How many rows there are.
+ * @returns One byte per row, `1` for kept. An interval keyed on an axis that
+ * is not drawn is ignored rather than emptying the figure, so a range left
+ * over from a column the reader has since hidden does not silently filter
+ * everything away.
+ */
+export function parallelIncludedMask(axes, ranges, count) {
+    const included = new Uint8Array(count).fill(1);
+    const active = [];
+    for (const axis of axes) {
+        const range = ranges[axis.id];
+        if (range === null || range === undefined)
+            continue;
+        active.push({
+            values: axis.values,
+            minimum: Math.min(range[0], range[1]),
+            maximum: Math.max(range[0], range[1]),
+        });
+    }
+    if (active.length === 0)
+        return included;
+    for (const range of active) {
+        const rows = Math.min(count, range.values.length);
+        for (let row = 0; row < rows; row++) {
+            if (included[row] === 0)
+                continue;
+            const value = range.values[row];
+            if (value >= range.minimum && value <= range.maximum)
+                continue;
+            included[row] = 0;
+        }
+        // A row the figure has no value for on a brushed axis is not in range.
+        for (let row = rows; row < count; row++)
+            included[row] = 0;
+    }
+    return included;
+}
+/**
+ * How many rows a mask keeps.
+ * @param included - One byte per row, `1` for kept.
+ * @returns The count.
+ */
+export function parallelKeptCount(included) {
+    let kept = 0;
+    for (const row of included) {
+        if (row !== 0)
+            kept++;
+    }
+    return kept;
+}
+//# sourceMappingURL=parallelFilter.js.map

package/lib/parallel/core/parallelFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelFilter.js","sourceRoot":"","sources":["../../../src/parallel/core/parallelFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkBH;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAAoB,EACpB,KAAa;IAEb,OAAO,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAA6B,EAC7B,MAAsB,EACtB,KAAa;IAEb,MAAM,QAAQ,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAkB,EAAE,CAAC;IACjC,KAAK,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS;YAAE,SAAS;QACpD,MAAM,CAAC,IAAI,CAAC;YACV,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;YACrC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;SACtC,CAAC,CAAC;IACL,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,QAAQ,CAAC;IAEzC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAClD,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;YACpC,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC;gBAAE,SAAS;YAClC,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAW,CAAC;YAC1C,IAAI,KAAK,IAAI,KAAK,CAAC,OAAO,IAAI,KAAK,IAAI,KAAK,CAAC,OAAO;gBAAE,SAAS;YAC/D,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC;QACD,uEAAuE;QACvE,KAAK,IAAI,GAAG,GAAG,IAAI,EAAE,GAAG,GAAG,KAAK,EAAE,GAAG,EAAE;YAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7D,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAoB;IACpD,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;QAC3B,IAAI,GAAG,KAAK,CAAC;YAAE,IAAI,EAAE,CAAC;IACxB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/lib/parallel/core/parallelHit.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Which row the pointer is over.
+ *
+ * Only the segment between the two axes the pointer sits between is tested, so
+ * the cost is one distance per row whatever the number of axes. The vertical
+ * gap to the segment is projected onto its normal, so a steep line is no
+ * harder to pick than a flat one — without which the only rows a reader can
+ * ever point at are the uninteresting ones.
+ */
+import type { ParallelAxisLayout } from './parallelAxes.ts';
+/** How far the pointer may sit from a line and still pick it, in pixels. */
+export declare const PARALLEL_HOVER_TOLERANCE = 6;
+/** A pointer position, relative to the top left of the drawing area. */
+export interface ParallelPoint {
+    /** Pixels from the left of the drawing area. */
+    x: number;
+    /** Pixels from its top. */
+    y: number;
+}
+/** The pair of axes a pointer sits between, as indices into the layouts. */
+export interface ParallelSegment {
+    /** The axis to the left of the pointer. */
+    left: number;
+    /** The axis to its right. */
+    right: number;
+}
+/**
+ * The pair of axes a horizontal position sits between.
+ * @param x - Pixels from the left of the drawing area.
+ * @param axes - The axes, from left to right.
+ * @param tolerance - How far past the first and the last axis still counts. Defaults to {@link PARALLEL_HOVER_TOLERANCE}.
+ * @returns The pair, or `null` when there are fewer than two axes or the
+ * position is past either end of the figure.
+ */
+export declare function parallelSegmentAt(x: number, axes: readonly ParallelAxisLayout[], tolerance?: number): ParallelSegment | null;
+/**
+ * The row whose line runs closest to the pointer.
+ * @param point - Where the pointer is, relative to the drawing area.
+ * @param axes - The axes, from left to right.
+ * @param values - Each axis's column, in the same order.
+ * @param count - How many rows are drawn.
+ * @param included - Which rows a brush keeps, a zero meaning the row is not pickable. Defaults to every row.
+ * @param tolerance - How far the pointer may sit from a line. Defaults to {@link PARALLEL_HOVER_TOLERANCE}.
+ * @returns The row, or `-1` when the pointer is over no line.
+ */
+export declare function parallelNearestRow(point: ParallelPoint, axes: readonly ParallelAxisLayout[], values: ReadonlyArray<ArrayLike<number>>, count: number, included?: Uint8Array, tolerance?: number): number;
+//# sourceMappingURL=parallelHit.d.ts.map

package/lib/parallel/core/parallelHit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelHit.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelHit.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG5D,4EAA4E;AAC5E,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,wEAAwE;AACxE,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,CAAC,EAAE,MAAM,CAAC;CACX;AAED,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,SAAS,kBAAkB,EAAE,EACnC,SAAS,GAAE,MAAiC,GAC3C,eAAe,GAAG,IAAI,CAaxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,SAAS,kBAAkB,EAAE,EACnC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EACxC,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,UAAU,EACrB,SAAS,GAAE,MAAiC,GAC3C,MAAM,CA6BR"}

package/lib/parallel/core/parallelHit.js

@@ -0,0 +1,81 @@
+/**
+ * Which row the pointer is over.
+ *
+ * Only the segment between the two axes the pointer sits between is tested, so
+ * the cost is one distance per row whatever the number of axes. The vertical
+ * gap to the segment is projected onto its normal, so a steep line is no
+ * harder to pick than a flat one — without which the only rows a reader can
+ * ever point at are the uninteresting ones.
+ */
+import { parallelPixelAt } from "./parallelAxes.js";
+/** How far the pointer may sit from a line and still pick it, in pixels. */
+export const PARALLEL_HOVER_TOLERANCE = 6;
+/**
+ * The pair of axes a horizontal position sits between.
+ * @param x - Pixels from the left of the drawing area.
+ * @param axes - The axes, from left to right.
+ * @param tolerance - How far past the first and the last axis still counts. Defaults to {@link PARALLEL_HOVER_TOLERANCE}.
+ * @returns The pair, or `null` when there are fewer than two axes or the
+ * position is past either end of the figure.
+ */
+export function parallelSegmentAt(x, axes, tolerance = PARALLEL_HOVER_TOLERANCE) {
+    const first = axes[0];
+    const last = axes.at(-1);
+    if (first === undefined || last === undefined || axes.length < 2)
+        return null;
+    if (x < first.x - tolerance || x > last.x + tolerance)
+        return null;
+    for (let index = 1; index < axes.length; index++) {
+        const right = axes[index];
+        if (right === undefined)
+            continue;
+        if (x <= right.x || index === axes.length - 1) {
+            return { left: index - 1, right: index };
+        }
+    }
+    return null;
+}
+/**
+ * The row whose line runs closest to the pointer.
+ * @param point - Where the pointer is, relative to the drawing area.
+ * @param axes - The axes, from left to right.
+ * @param values - Each axis's column, in the same order.
+ * @param count - How many rows are drawn.
+ * @param included - Which rows a brush keeps, a zero meaning the row is not pickable. Defaults to every row.
+ * @param tolerance - How far the pointer may sit from a line. Defaults to {@link PARALLEL_HOVER_TOLERANCE}.
+ * @returns The row, or `-1` when the pointer is over no line.
+ */
+export function parallelNearestRow(point, axes, values, count, included, tolerance = PARALLEL_HOVER_TOLERANCE) {
+    const segment = parallelSegmentAt(point.x, axes, tolerance);
+    if (segment === null)
+        return -1;
+    const left = axes[segment.left];
+    const right = axes[segment.right];
+    const leftColumn = values[segment.left];
+    const rightColumn = values[segment.right];
+    if (left === undefined || right === undefined)
+        return -1;
+    if (leftColumn === undefined || rightColumn === undefined)
+        return -1;
+    const width = right.x - left.x;
+    if (width <= 0)
+        return -1;
+    const ratio = (point.x - left.x) / width;
+    const rows = Math.min(count, leftColumn.length, rightColumn.length);
+    let nearest = -1;
+    let nearestDistance = tolerance;
+    for (let row = 0; row < rows; row++) {
+        if (included?.[row] === 0)
+            continue;
+        const leftY = parallelPixelAt(left.pixels, leftColumn[row]);
+        const rightY = parallelPixelAt(right.pixels, rightColumn[row]);
+        const gap = Math.abs(leftY + (rightY - leftY) * ratio - point.y);
+        const distance = (gap * width) / Math.hypot(width, rightY - leftY);
+        if (distance < nearestDistance) {
+            nearestDistance = distance;
+            nearest = row;
+        }
+    }
+    return nearest;
+}
+//# sourceMappingURL=parallelHit.js.map

package/lib/parallel/core/parallelHit.js.map

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

package/lib/parallel/core/parallelPaint.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The lines, painted into a canvas.
+ *
+ * The first canvas figure in the family, and for one reason: ten thousand
+ * polylines of a dozen points each is a hundred and twenty thousand SVG
+ * coordinates the browser would keep as elements. Everything a reader points
+ * at, brushes or reads is still SVG or HTML over the top, so only the mass of
+ * lines is pixels — which is also why saving the figure keeps the axes and
+ * loses the lines, and why a site that needs a downloadable figure should say
+ * so before choosing this one.
+ */
+import type { ParallelAxisLayout } from './parallelAxes.ts';
+/** How strongly one kept line is drawn, so that the mass reads as a density. */
+export declare const PARALLEL_INCLUDED_ALPHA = 0.35;
+/** What one pass of the line painter needs. */
+export interface ParallelPaint {
+    /** The axes, from left to right, already placed and measured. */
+    layouts: readonly ParallelAxisLayout[];
+    /** Each axis's column, in the same order. */
+    values: ReadonlyArray<ArrayLike<number>>;
+    /** How many rows to draw. */
+    count: number;
+    /**
+     * Which rows the brushes keep, a zero meaning the row is drawn underneath in
+     * the excluded ink.
+     * @default null — every row is kept and nothing is drawn underneath
+     */
+    included?: Uint8Array | null;
+    /**
+     * Which colour each row takes, as a step into `palette`.
+     * @default null — every line takes `line`
+     */
+    steps?: Uint8Array | null;
+    /**
+     * The colours a step indexes, from `parallelPalette`.
+     * @default [] — nothing to index
+     */
+    palette?: readonly string[];
+    /** The ink a line takes when no quantity is colouring the lines. */
+    line: string;
+    /** The ink the rows a brush left out are drawn in. */
+    excluded: string;
+    /**
+     * How strongly a kept line is drawn. Turn it down for a dense library.
+     * @default PARALLEL_INCLUDED_ALPHA
+     */
+    includedAlpha?: number;
+}
+/** One row drawn over the mass, and the ink it is drawn in. */
+export interface ParallelHighlight {
+    /** The row. */
+    row: number;
+    /** Its ink. */
+    color: string;
+}
+/** What the highlight pass needs. */
+export interface ParallelHighlightPaint {
+    /** The rows to draw, the last one on top. */
+    highlights: readonly ParallelHighlight[];
+    /** The axes, from left to right. */
+    layouts: readonly ParallelAxisLayout[];
+    /** Each axis's column, in the same order. */
+    values: ReadonlyArray<ArrayLike<number>>;
+    /** The ink the halo under each line is drawn in. */
+    halo: string;
+}
+/**
+ * Resize a canvas to the device pixel grid and move its origin to the drawing
+ * area, which also clears whatever it held.
+ * @param canvas - The canvas, or `null` before it is mounted.
+ * @param width - Width of the figure, in CSS pixels.
+ * @param height - Its height, in CSS pixels.
+ * @returns The context, or `null` when there is nothing to draw on.
+ */
+export declare function preparePlotCanvas(canvas: HTMLCanvasElement | null, width: number, height: number): CanvasRenderingContext2D | null;
+/**
+ * Draw one line per row: the ones a brush left out first, underneath, then the
+ * kept ones over them.
+ *
+ * The excluded rows are one single path stroked once, in a light grey rather
+ * than a translucent black: overlapping segments of one stroked path
+ * accumulate alpha, so a translucent black saturates to black wherever the
+ * library is dense, while a light grey is a colour the pile can only converge
+ * on.
+ * @param context - A context already scaled and moved to the drawing area by {@link preparePlotCanvas}.
+ * @param paint - See {@link ParallelPaint}.
+ */
+export declare function paintParallelLines(context: CanvasRenderingContext2D, paint: ParallelPaint): void;
+/**
+ * Draw a few singled-out rows over the mass, each over a halo and dotted at
+ * every axis crossing.
+ * @param context - A context already scaled and moved to the drawing area.
+ * @param paint - See {@link ParallelHighlightPaint}.
+ */
+export declare function paintParallelHighlights(context: CanvasRenderingContext2D, paint: ParallelHighlightPaint): void;
+/**
+ * Add one row's line to the path being built.
+ * @param context - A context already scaled and moved to the drawing area.
+ * @param row - The row to trace.
+ * @param layouts - The axes, from left to right.
+ * @param values - Each axis's column, in the same order.
+ */
+export declare function traceParallelRow(context: CanvasRenderingContext2D, row: number, layouts: readonly ParallelAxisLayout[], values: ReadonlyArray<ArrayLike<number>>): void;
+//# sourceMappingURL=parallelPaint.d.ts.map

package/lib/parallel/core/parallelPaint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelPaint.d.ts","sourceRoot":"","sources":["../../../src/parallel/core/parallelPaint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG5D,gFAAgF;AAChF,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAa5C,+CAA+C;AAC/C,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvC,6CAA6C;IAC7C,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;IACzC,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAC7B;;;OAGG;IACH,KAAK,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,eAAe;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,qCAAqC;AACrC,MAAM,WAAW,sBAAsB;IACrC,6CAA6C;IAC7C,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACzC,oCAAoC;IACpC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvC,6CAA6C;IAC7C,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;IACzC,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,GAAG,IAAI,EAChC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,wBAAwB,GAAG,IAAI,CAYjC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,wBAAwB,EACjC,KAAK,EAAE,aAAa,GACnB,IAAI,CAoCN;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,wBAAwB,EACjC,KAAK,EAAE,sBAAsB,GAC5B,IAAI,CA2BN;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,wBAAwB,EACjC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,SAAS,kBAAkB,EAAE,EACtC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GACvC,IAAI,CAiBN"}