@inflexa-ai/harness 0.42.1 → 0.43.0

package/dist/report-render/figures/dendrogram.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The dendrogram of one category axis of a heatmap: the check of its edge table, the leaf order that the axis
+ * takes, and the elbow of each edge.
+ *
+ * The tree table holds one row for each edge: the parent node, the child node, and the height of the parent.
+ * A leaf is a child that is never a parent, and the root is the one parent that is never a child. The leaf
+ * order is the depth-first order from the root, with the children of a node in the order of the table. Thus
+ * the scipy `leaves_list` order and the R `hclust` order both survive, because each writes the left child
+ * first.
+ *
+ * A leaf sits at height zero and at its place in the leaf order. An inner node sits at its height, midway
+ * between the places of its outer children, as the scipy and the R dendrograms place it.
+ */
+import { type Result } from "neverthrow";
+import type { Cell } from "../chart.js";
+import type { RenderProblem } from "../types.js";
+import type { FigureTree } from "./index.js";
+/** One checked tree: the axis categories in leaf order, and the elbow of each edge in table order. */
+export interface CheckedTree {
+    readonly order: readonly Cell[];
+    readonly height: number;
+    readonly elbows: readonly Elbow[];
+}
+/**
+ * The elbow of one edge, in tree coordinates: the place along the axis and the height of each of its three
+ * points. It rises from the child to the height of the parent, then it runs across to the place of the parent.
+ */
+export type Elbow = readonly [readonly [number, number], readonly [number, number], readonly [number, number]];
+/**
+ * Check the tree of one axis against the categories of that axis, and give the leaf order and the elbows.
+ *
+ * Each fault refuses, and the problem names the fault: an edge with an empty node, a height that is no
+ * number, a node with two heights or two parents, no root or two roots, a cycle, a child over its parent, a
+ * leaf that is no category, and a category that no leaf names.
+ */
+export declare function checkTree(blockId: string, axis: "x" | "y", tree: FigureTree, categories: readonly Cell[]): Result<CheckedTree, RenderProblem>;

package/dist/report-render/figures/dendrogram.js

@@ -0,0 +1,130 @@
+/**
+ * The dendrogram of one category axis of a heatmap: the check of its edge table, the leaf order that the axis
+ * takes, and the elbow of each edge.
+ *
+ * The tree table holds one row for each edge: the parent node, the child node, and the height of the parent.
+ * A leaf is a child that is never a parent, and the root is the one parent that is never a child. The leaf
+ * order is the depth-first order from the root, with the children of a node in the order of the table. Thus
+ * the scipy `leaves_list` order and the R `hclust` order both survive, because each writes the left child
+ * first.
+ *
+ * A leaf sits at height zero and at its place in the leaf order. An inner node sits at its height, midway
+ * between the places of its outer children, as the scipy and the R dendrograms place it.
+ */
+import { err, ok } from "neverthrow";
+import { chartProblem, toNumber } from "./common.js";
+/**
+ * Check the tree of one axis against the categories of that axis, and give the leaf order and the elbows.
+ *
+ * Each fault refuses, and the problem names the fault: an edge with an empty node, a height that is no
+ * number, a node with two heights or two parents, no root or two roots, a cycle, a child over its parent, a
+ * leaf that is no category, and a category that no leaf names.
+ */
+export function checkTree(blockId, axis, tree, categories) {
+    const fault = (detail) => err(chartProblem(blockId, `The tree of ${axis} ${detail}`));
+    if (tree.rows.length === 0)
+        return fault("holds no edge.");
+    const edges = [];
+    const heightOf = new Map();
+    const parentOf = new Map();
+    const childrenOf = new Map();
+    for (const [index, row] of tree.rows.entries()) {
+        const parent = nodeName(row[tree.parent]);
+        const child = nodeName(row[tree.child]);
+        if (parent === undefined || child === undefined) {
+            return fault(`holds an edge with no ${parent === undefined ? "parent" : "child"} at row ${index + 1}.`);
+        }
+        const height = toNumber(row[tree.height]);
+        if (height === null) {
+            return fault(`gives the node "${parent}" the height "${String(row[tree.height] ?? "")}", which is not a number.`);
+        }
+        const known = heightOf.get(parent);
+        if (known !== undefined && known !== height)
+            return fault(`gives the node "${parent}" two heights, ${known} and ${height}.`);
+        heightOf.set(parent, height);
+        const prior = parentOf.get(child);
+        if (prior === parent)
+            return fault(`holds the edge from "${parent}" to "${child}" two times.`);
+        if (prior !== undefined)
+            return fault(`gives the node "${child}" two parents, "${prior}" and "${parent}".`);
+        parentOf.set(child, parent);
+        const children = childrenOf.get(parent) ?? [];
+        children.push(child);
+        childrenOf.set(parent, children);
+        edges.push({ parent, child, height });
+    }
+    const roots = [...childrenOf.keys()].filter((node) => !parentOf.has(node));
+    if (roots.length === 0)
+        return fault(`holds a cycle through the node "${edges[0].parent}".`);
+    if (roots.length > 1)
+        return fault(`holds more than one root, for example "${roots[0]}" and "${roots[1]}". A tree holds one root.`);
+    // Each child has one parent and the root has none, thus a walk from the root meets each node one time. A
+    // node that the walk never meets sits on a cycle apart from the root.
+    const preorder = [];
+    const stack = [roots[0]];
+    for (let node = stack.pop(); node !== undefined; node = stack.pop()) {
+        preorder.push(node);
+        const children = childrenOf.get(node) ?? [];
+        for (let index = children.length - 1; index >= 0; index -= 1)
+            stack.push(children[index]);
+    }
+    const met = new Set(preorder);
+    const stray = edges.find((edge) => !met.has(edge.parent));
+    if (stray !== undefined)
+        return fault(`holds a cycle through the node "${stray.parent}".`);
+    for (const edge of edges) {
+        const own = heightOf.get(edge.child);
+        if (own !== undefined && own > edge.height) {
+            return fault(`puts the node "${edge.child}" at the height ${own}, over the height ${edge.height} of its parent "${edge.parent}".`);
+        }
+    }
+    const byName = new Map();
+    for (const category of categories)
+        byName.set(String(category), category);
+    const leaves = preorder.filter((node) => !childrenOf.has(node));
+    const order = [];
+    for (const leaf of leaves) {
+        const category = byName.get(leaf);
+        if (category === undefined)
+            return fault(`holds the leaf "${leaf}", which is no category of the ${axis} axis.`);
+        order.push(category);
+    }
+    const named = new Set(leaves);
+    const absent = categories.find((category) => !named.has(String(category)));
+    if (absent !== undefined)
+        return fault(`holds no leaf for the ${axis} category "${String(absent)}".`);
+    const place = new Map(leaves.map((leaf, index) => [leaf, index]));
+    // The reverse of the preorder meets each child before its parent, and the walk met each node, thus each
+    // lookup below finds a place.
+    const placeOf = (node) => place.get(node);
+    for (let index = preorder.length - 1; index >= 0; index -= 1) {
+        const node = preorder[index];
+        const children = childrenOf.get(node);
+        if (children === undefined)
+            continue;
+        let low = Infinity;
+        let high = -Infinity;
+        for (const child of children) {
+            low = Math.min(low, placeOf(child));
+            high = Math.max(high, placeOf(child));
+        }
+        place.set(node, (low + high) / 2);
+    }
+    const heightAt = (node) => heightOf.get(node) ?? 0;
+    const elbows = edges.map((edge) => {
+        const child = placeOf(edge.child);
+        return [
+            [child, heightAt(edge.child)],
+            [child, edge.height],
+            [placeOf(edge.parent), edge.height],
+        ];
+    });
+    return ok({ order, height: heightAt(roots[0]), elbows });
+}
+/** The name of one node cell, or `undefined` for an empty cell. */
+function nodeName(cell) {
+    if (cell === undefined)
+        return undefined;
+    const name = String(cell);
+    return name === "" ? undefined : name;
+}

package/dist/report-render/figures/dense.d.ts

@@ -0,0 +1,111 @@
+/**
+ * The shared parts of the dense scatter figures: the volcano, the MA plot, the Manhattan plot, and the QQ plot.
+ *
+ * Each of these figures draws one point for each row of a table of many thousand rows. Thus each one builds
+ * its points through the composition machinery of the context, and the points read the shared payload past
+ * the inline bound. The figure then styles the series of the composition output and sets its axes. It never
+ * puts a series before that output, because the page fills the leading series from their descriptors.
+ */
+import { type Result } from "neverthrow";
+import { type ChartChannel, type ChartEncoding, type ChartType } from "../../contracts/report-blocks.js";
+import type { ChartRow, EchartOption } from "../chart.js";
+import type { RenderProblem } from "../types.js";
+import { type LeaderName, type NamedPoint, type NameFrame } from "./label-room.js";
+/**
+ * The symbol sizes in pixels of a dense figure: a signal point, and a point that states no finding.
+ *
+ * A dense cloud reads by its shape, and a large symbol fills the plot with ink. The null points draw smaller,
+ * thus the signal points read first.
+ */
+export declare const DENSE_SIGNAL_SYMBOL_PX = 5;
+export declare const DENSE_NULL_SYMBOL_PX = 3;
+/** The opacity of a signal point and of a null point. A null cloud of thousands of points recedes. */
+export declare const DENSE_SIGNAL_OPACITY = 0.85;
+export declare const DENSE_NULL_OPACITY = 0.45;
+/**
+ * The drawing order of a null layer. The runtime draws a scatter at the order 2, thus a null layer at 1 draws
+ * under the signal points whatever its place in the series list.
+ */
+export declare const DENSE_NULL_Z = 1;
+/**
+ * The symbol and the size in pixels of a point whose stored p is 0.
+ *
+ * A stored zero states that the true p sits under the resolution of the test, and `neg_log10` gives it no value.
+ * The figure draws such a point at the top of the plotted range, and the upward triangle tells it apart from a
+ * point at its true height.
+ */
+export declare const BELOW_RESOLUTION_SYMBOL = "triangle";
+export declare const BELOW_RESOLUTION_SYMBOL_PX = 7;
+/** The name and the tooltip of a series of stored zeros, where the figure gives the series no name of its own. */
+export declare const BELOW_RESOLUTION_NAME = "p = 0";
+export declare const BELOW_RESOLUTION_TOOLTIP: EchartOption;
+/**
+ * The rows whose stored p is 0 and whose other coordinate draws. `others` gives the plotted value of the other
+ * axis for each row.
+ */
+export declare function belowResolutionRows(rows: readonly ChartRow[], pColumn: string, others: readonly (number | null)[]): number[];
+/**
+ * The drawn height of a stored zero: the largest finite transformed p of the table, where it passes the line
+ * of the figure, else one unit over the line. Thus a stored zero always reads as significant.
+ */
+export declare function belowResolutionHeight(peak: number | undefined, line: number): number;
+/** The name of the series that carries the point names of a dense figure. */
+export declare const POINT_NAMES = "Point names";
+/**
+ * The series of the point names of a dense figure: one point with no symbol at the anchor of each name, with the
+ * name as its label, and a leader line from each named point to its anchor. A name with no place draws nothing.
+ *
+ * The derivation places each name, because the chart runtime moves no label that sits on its point. The series
+ * follows the points in the series list and keeps its rows inline, thus the points still read the shared
+ * payload, and the names draw over them.
+ *
+ * The page frame reads a window 1280 pixels wide. On a narrower window the plot is smaller than its frame and the
+ * text keeps its size, thus the runtime also hides a name that overlaps another.
+ */
+export declare function pointNameSeries(names: readonly NamedPoint[], placed: readonly (LeaderName | undefined)[]): EchartOption[];
+/**
+ * The series of the text that a figure places itself, for the page and for each export.
+ *
+ * `build` places the text in one frame and gives the series that carry it. The page takes the series of the page
+ * frame, and each export takes the series of the frame of its size, under its width in the member that
+ * `exportOption` reads. `names` are the names of the series that `build` can give, thus an export drops each page
+ * series of those names, and a size where no text finds a place draws none.
+ */
+export declare function sizedSeries(names: readonly string[], build: (frame: NameFrame) => EchartOption[]): {
+    readonly page: EchartOption[];
+    readonly member: EchartOption;
+};
+/** The channel of the quick path that a dense figure demands. An absent channel refuses. */
+export declare function demandedChannel(blockId: string, chartType: ChartType, encoding: ChartEncoding, channel: "x" | "y" | "group"): Result<ChartChannel, RenderProblem>;
+/**
+ * The plotted value of one channel for each row: the transformed value where the channel declares a
+ * transform, else the number of the cell. The composition reads the same numbers, thus a rule of the figure
+ * and a point of the chart agree.
+ */
+export declare function plottedValues(rows: readonly ChartRow[], channel: ChartChannel): (number | null)[];
+/**
+ * The smallest round number at or above a positive value: one of the round coefficients times a power of ten.
+ * A value that is not positive gives one.
+ *
+ * A figure ends an axis here. The ladder is fine, thus the end leaves little empty room past the data.
+ */
+export declare function niceCeiling(value: number): number;
+/**
+ * The range fields of an axis symmetric around zero, with a tick at each end, at zero, and at each half.
+ *
+ * The runtime picks its own tick step, and a step that does not divide the end leaves the last tick short of
+ * it. The half of the end always divides it, thus the two ends and zero carry a tick.
+ */
+export declare function symmetricRange(end: number): EchartOption;
+/** The largest value of a list, or `undefined` for an empty list. The loop keeps a long list off the stack. */
+export declare function largest(values: readonly number[]): number | undefined;
+/** The smallest value of a list, or `undefined` for an empty list. */
+export declare function smallest(values: readonly number[]): number | undefined;
+/** The series of an option, as objects. */
+export declare function seriesOf(option: EchartOption): EchartOption[];
+/** The axis of an option as one object. A composition of one grid gives one object for each axis. */
+export declare function axisOf(option: EchartOption, key: "xAxis" | "yAxis"): EchartOption;
+/** The fields of one layer of points: the fill, the opacity, the symbol size, and the drawing order. */
+export declare function pointLayer(color: string, size: number, opacity: number, z?: number): EchartOption;
+/** The shown text of a count in a legend name: a whole number with a thousands separator. */
+export declare function countText(count: number): string;

package/dist/report-render/figures/dense.js

@@ -0,0 +1,204 @@
+/**
+ * The shared parts of the dense scatter figures: the volcano, the MA plot, the Manhattan plot, and the QQ plot.
+ *
+ * Each of these figures draws one point for each row of a table of many thousand rows. Thus each one builds
+ * its points through the composition machinery of the context, and the points read the shared payload past
+ * the inline bound. The figure then styles the series of the composition output and sets its axes. It never
+ * puts a series before that output, because the page fills the leading series from their descriptors.
+ */
+import { err, ok } from "neverthrow";
+import { channelColumn, channelTransform } from "../../contracts/report-blocks.js";
+import { SIZED_SERIES_MEMBER } from "../chart-renderers.js";
+import { CHART_EXPORT_SIZES, CHART_INK } from "../design.js";
+import { formatNumberCell } from "../number-format.js";
+import { chartProblem, toNumber, transformColumn } from "./common.js";
+import { EXPORT_PLOT_FRAMES, PAGE_PLOT_FRAME } from "./label-room.js";
+/**
+ * The symbol sizes in pixels of a dense figure: a signal point, and a point that states no finding.
+ *
+ * A dense cloud reads by its shape, and a large symbol fills the plot with ink. The null points draw smaller,
+ * thus the signal points read first.
+ */
+export const DENSE_SIGNAL_SYMBOL_PX = 5;
+export const DENSE_NULL_SYMBOL_PX = 3;
+/** The opacity of a signal point and of a null point. A null cloud of thousands of points recedes. */
+export const DENSE_SIGNAL_OPACITY = 0.85;
+export const DENSE_NULL_OPACITY = 0.45;
+/**
+ * The drawing order of a null layer. The runtime draws a scatter at the order 2, thus a null layer at 1 draws
+ * under the signal points whatever its place in the series list.
+ */
+export const DENSE_NULL_Z = 1;
+/**
+ * The symbol and the size in pixels of a point whose stored p is 0.
+ *
+ * A stored zero states that the true p sits under the resolution of the test, and `neg_log10` gives it no value.
+ * The figure draws such a point at the top of the plotted range, and the upward triangle tells it apart from a
+ * point at its true height.
+ */
+export const BELOW_RESOLUTION_SYMBOL = "triangle";
+export const BELOW_RESOLUTION_SYMBOL_PX = 7;
+/** The name and the tooltip of a series of stored zeros, where the figure gives the series no name of its own. */
+export const BELOW_RESOLUTION_NAME = "p = 0";
+export const BELOW_RESOLUTION_TOOLTIP = { formatter: "{b}<br/>{a}: p = 0" };
+/**
+ * The rows whose stored p is 0 and whose other coordinate draws. `others` gives the plotted value of the other
+ * axis for each row.
+ */
+export function belowResolutionRows(rows, pColumn, others) {
+    const found = [];
+    for (let index = 0; index < rows.length; index += 1) {
+        if (toNumber(rows[index][pColumn]) === 0 && others[index] !== null)
+            found.push(index);
+    }
+    return found;
+}
+/**
+ * The drawn height of a stored zero: the largest finite transformed p of the table, where it passes the line
+ * of the figure, else one unit over the line. Thus a stored zero always reads as significant.
+ */
+export function belowResolutionHeight(peak, line) {
+    return peak !== undefined && peak > line ? peak : line + 1;
+}
+/** The name of the series that carries the point names of a dense figure. */
+export const POINT_NAMES = "Point names";
+/** The stroke width in pixels of the leader line between a point and its name. */
+const LEADER_LINE_WIDTH_PX = 0.5;
+/**
+ * The series of the point names of a dense figure: one point with no symbol at the anchor of each name, with the
+ * name as its label, and a leader line from each named point to its anchor. A name with no place draws nothing.
+ *
+ * The derivation places each name, because the chart runtime moves no label that sits on its point. The series
+ * follows the points in the series list and keeps its rows inline, thus the points still read the shared
+ * payload, and the names draw over them.
+ *
+ * The page frame reads a window 1280 pixels wide. On a narrower window the plot is smaller than its frame and the
+ * text keeps its size, thus the runtime also hides a name that overlaps another.
+ */
+export function pointNameSeries(names, placed) {
+    const items = [];
+    const leaders = [];
+    for (const [index, name] of names.entries()) {
+        const anchor = placed[index];
+        if (anchor === undefined)
+            continue;
+        items.push({ name: name.text, value: [anchor.x, anchor.y], label: { position: anchor.side } });
+        leaders.push([{ coord: [name.x, name.y] }, { coord: [anchor.x, anchor.y] }]);
+    }
+    if (items.length === 0)
+        return [];
+    return [
+        {
+            type: "scatter",
+            name: POINT_NAMES,
+            silent: true,
+            symbolSize: 0,
+            tooltip: { show: false },
+            label: { show: true, distance: 0, color: CHART_INK, formatter: "{b}" },
+            labelLayout: { hideOverlap: true },
+            data: items,
+            markLine: {
+                silent: true,
+                symbol: "none",
+                label: { show: false },
+                lineStyle: { color: CHART_INK, width: LEADER_LINE_WIDTH_PX, type: "solid" },
+                data: leaders,
+            },
+        },
+    ];
+}
+/**
+ * The series of the text that a figure places itself, for the page and for each export.
+ *
+ * `build` places the text in one frame and gives the series that carry it. The page takes the series of the page
+ * frame, and each export takes the series of the frame of its size, under its width in the member that
+ * `exportOption` reads. `names` are the names of the series that `build` can give, thus an export drops each page
+ * series of those names, and a size where no text finds a place draws none.
+ */
+export function sizedSeries(names, build) {
+    const widths = {};
+    for (const [kind, size] of Object.entries(CHART_EXPORT_SIZES)) {
+        widths[String(size.widthPx)] = build(EXPORT_PLOT_FRAMES[kind]);
+    }
+    const sized = { names, widths };
+    return { page: build(PAGE_PLOT_FRAME), member: { [SIZED_SERIES_MEMBER]: sized } };
+}
+/** The channel of the quick path that a dense figure demands. An absent channel refuses. */
+export function demandedChannel(blockId, chartType, encoding, channel) {
+    const declared = encoding[channel];
+    if (declared === undefined) {
+        return err(chartProblem(blockId, `The ${chartType} chart needs a column for the "${channel}" channel.`));
+    }
+    return ok(declared);
+}
+/**
+ * The plotted value of one channel for each row: the transformed value where the channel declares a
+ * transform, else the number of the cell. The composition reads the same numbers, thus a rule of the figure
+ * and a point of the chart agree.
+ */
+export function plottedValues(rows, channel) {
+    const column = channelColumn(channel);
+    const transform = channelTransform(channel);
+    return transform === undefined ? rows.map((row) => toNumber(row[column])) : transformColumn(rows, column, transform);
+}
+/** The round coefficients of an axis end, in ascending order. */
+const ROUND_COEFFICIENTS = [1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10];
+/**
+ * The smallest round number at or above a positive value: one of the round coefficients times a power of ten.
+ * A value that is not positive gives one.
+ *
+ * A figure ends an axis here. The ladder is fine, thus the end leaves little empty room past the data.
+ */
+export function niceCeiling(value) {
+    if (!(value > 0))
+        return 1;
+    const base = Math.pow(10, Math.floor(Math.log10(value)));
+    const fraction = Number((value / base).toPrecision(12));
+    const coefficient = ROUND_COEFFICIENTS.find((candidate) => candidate >= fraction) ?? 10;
+    return Number((coefficient * base).toPrecision(12));
+}
+/**
+ * The range fields of an axis symmetric around zero, with a tick at each end, at zero, and at each half.
+ *
+ * The runtime picks its own tick step, and a step that does not divide the end leaves the last tick short of
+ * it. The half of the end always divides it, thus the two ends and zero carry a tick.
+ */
+export function symmetricRange(end) {
+    return { min: -end, max: end, interval: end / 2 };
+}
+/** The largest value of a list, or `undefined` for an empty list. The loop keeps a long list off the stack. */
+export function largest(values) {
+    let top;
+    for (const value of values) {
+        if (top === undefined || value > top)
+            top = value;
+    }
+    return top;
+}
+/** The smallest value of a list, or `undefined` for an empty list. */
+export function smallest(values) {
+    let bottom;
+    for (const value of values) {
+        if (bottom === undefined || value < bottom)
+            bottom = value;
+    }
+    return bottom;
+}
+/** The series of an option, as objects. */
+export function seriesOf(option) {
+    const series = option.series;
+    return Array.isArray(series) ? series.filter((entry) => typeof entry === "object" && entry !== null) : [];
+}
+/** The axis of an option as one object. A composition of one grid gives one object for each axis. */
+export function axisOf(option, key) {
+    const axis = option[key];
+    return typeof axis === "object" && axis !== null && !Array.isArray(axis) ? axis : {};
+}
+/** The fields of one layer of points: the fill, the opacity, the symbol size, and the drawing order. */
+export function pointLayer(color, size, opacity, z) {
+    return { itemStyle: { color, opacity }, symbolSize: size, ...(z !== undefined ? { z } : {}) };
+}
+/** The shown text of a count in a legend name: a whole number with a thousands separator. */
+export function countText(count) {
+    return formatNumberCell(count, "compact").text;
+}

package/dist/report-render/figures/dotplot.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The dot plot: a marker dot plot of a single-cell study, or the enrichment dot plot of a gene-set test.
+ *
+ * The canonical marker dot plot is the scanpy `pl.dotplot` and the Seurat `DotPlot`: the clusters down the y
+ * axis, the genes along x, the fraction of expressing cells as the dot size, and the mean expression as the
+ * dot color. The canonical enrichment dot plot is the enrichplot `dotplot`: the terms down the y axis, the gene
+ * ratio along x, the gene count as the dot size, and the adjusted p as the dot color. Each plot shows two
+ * keys: a size legend of three reference circles, and a sequential color scale with its two ends.
+ *
+ * The y axis reads top-down in the order of its channel, thus a table that sorts its terms by their ratio
+ * reads from the first term down. The x axis draws categories where its column holds text, and values where
+ * it holds numbers.
+ *
+ * The dots build through the composition machinery. The figure moves each dot onto the place of its category,
+ * and the page builds no such move, thus the rows stay inline whatever their count.
+ */
+import type { FigureModule } from "./index.js";
+/** The height of one line of a y label, and the gap between two terms, in pixels at the page text size. */
+export declare const DOTPLOT_LINE_PX = 14;
+export declare const DOTPLOT_ROW_GAP_PX = 6;
+/**
+ * One term wrapped at its spaces into lines of 30 characters at most, two lines at most. A term past two lines
+ * ends its second line with an ellipsis, thus two terms never run into each other. A word longer than a line
+ * stays whole.
+ */
+export declare function wrappedTerm(term: string): string;
+/** The dot plot. */
+export declare const DOTPLOT_FIGURE: FigureModule;