react-cheminfo 0.33.0 → 0.34.0

package/README.md

@@ -112,7 +112,7 @@ through a wildcard subpath exactly as `react-science` serves its own.
 | **Figures**                | `chartScale`, `chartAxisScale`, `chartAxisTitle`, `chartShare`, `chartColumnExtent`, `chartBinCounts`, `chartSeriesColor`, `rowMatrix`, `stackedMatrix`, `emptiestCorner`, `placeOverlayCard`, `overlayMetrics`                                                                                                  | `ChartFrame`, `ChartAxis`, `TrackedLineChart`, `OverlayBar`, `OverlaySelect`, `OverlaySegmented`, `OverlayToggle`, `OverlayNumber`, `OverlayLegend`, `OverlayCaption`, `OverlayReadout`                                                                                                            |
 | **Projections**            | `pcaResult`, `embeddingResult`, `projectionTabs`, `loadingProfiles`, `explainedShares`, `confidenceEllipse`, `projectEllipse`, `pointsInPolygon`, `resolveProjectionGroups`, `resolveProjectionShapes`, `PROJECTION_COPY`                                                                                        | `PcaViewer`, `ProjectionViewer`, `ScatterPlot`, `ScatterMatrix`                                                                                                                                                                                                                                    |
 | **Parallel coordinates**   | `parallelAxisOf`, `parallelAxisLayouts`, `parallelIncludedMask`, `parallelKeptCount`, `parallelNearestRow`, `parallelSegmentAt`, `parallelBandAt`, `parallelRangeOf`, `parallelPalette`, `parallelColorSteps`, `paintParallelLines`                                                                              | `ParallelCoordinates`                                                                                                                                                                                                                                                                              |
-| **Periodic table**         | `PERIODIC_ELEMENTS`, `elementBySymbol`, `elementByAtomicNumber`, `cellOf`, `placedElements`, `elementByArrowKey`, `categorySwatch`, `CATEGORY_LABELS`                                                                                                                                                            | `PeriodicTable`, `ElementCell`, `CategoryLegend`                                                                                                                                                                                                                                                   |
+| **Periodic table**         | `PERIODIC_ELEMENTS`, `elementBySymbol`, `elementByAtomicNumber`, `cellOf`, `placedElements`, `elementByArrowKey`, `EMPTY_BLOCK`, `categorySwatch`, `CATEGORY_LABELS`                                                                                                                                             | `PeriodicTable`, `ElementCell`, `CategoryLegend`                                                                                                                                                                                                                                                   |
 
 Everything in that table is exported from `./core`, `./ui`, `./slides`,
 `./vite` or `./structure` and nothing else is: the sub-components a component is built

package/lib/axis/core/axisMarks.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Where a figure's marks land inside its box, so something else can count them.
+ *
+ * `emptiestCorner` picks the corner a floating card can sit in without covering
+ * the cluster the reader came for, and it needs screen positions to do it. A
+ * chart drawn by a library builds its scales during its own render, where a
+ * caller cannot reach them, so the positions are worked out here from the same
+ * values and the same two transforms the axes use.
+ *
+ * It is an estimate, which is all a corner needs: the plot area is inset from
+ * the box by the margins, and a mark a few pixels from a corner counts for that
+ * corner either way.
+ */
+import type { AxisScale } from './axisScale.ts';
+/** A point of the figure, in the quantities its axes carry. */
+export interface AxisPoint {
+    x: number;
+    y: number;
+}
+/** Pixel positions of every mark, as `emptiestCorner` reads them. */
+export interface AxisMarkPositions {
+    x: Float64Array;
+    y: Float64Array;
+}
+/** What {@link axisMarkPositions} needs beyond the points and the box. */
+export interface AxisMarkPositionsOptions {
+    /**
+     * Width of the linear region of a logarithmic axis — d3's symmetric-log
+     * `constant`. Pass `0` for a true logarithmic axis.
+     * @default 1
+     */
+    constant?: number;
+}
+/**
+ * Place every point in the box the figure is drawn in.
+ * @param points - The points the figure draws.
+ * @param box - Its size, in pixels, normally from `useContainerSize`.
+ * @param box.width - How wide the figure is drawn.
+ * @param box.height - How tall it is drawn.
+ * @param scale - The scale each axis is drawn on, which the positions have to
+ *   follow to land where the marks do.
+ * @param scale.y - How the vertical axis is read.
+ * @param scale.x - How the horizontal axis is read.
+ * @param options - See {@link AxisMarkPositionsOptions}.
+ * @returns One position per point, in the order they were given.
+ */
+export declare function axisMarkPositions(points: readonly AxisPoint[], box: {
+    width: number;
+    height: number;
+}, scale: {
+    x: AxisScale;
+    y: AxisScale;
+}, options?: AxisMarkPositionsOptions): AxisMarkPositions;
+//# sourceMappingURL=axisMarks.d.ts.map

package/lib/axis/core/axisMarks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axisMarks.d.ts","sourceRoot":"","sources":["../../../src/axis/core/axisMarks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,+DAA+D;AAC/D,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,qEAAqE;AACrE,MAAM,WAAW,iBAAiB;IAChC,CAAC,EAAE,YAAY,CAAC;IAChB,CAAC,EAAE,YAAY,CAAC;CACjB;AAED,0EAA0E;AAC1E,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,GAAG,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACtC,KAAK,EAAE;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,CAAC,EAAE,SAAS,CAAA;CAAE,EACrC,OAAO,GAAE,wBAA6B,GACrC,iBAAiB,CAYnB"}

package/lib/axis/core/axisMarks.js

@@ -0,0 +1,69 @@
+/**
+ * Where a figure's marks land inside its box, so something else can count them.
+ *
+ * `emptiestCorner` picks the corner a floating card can sit in without covering
+ * the cluster the reader came for, and it needs screen positions to do it. A
+ * chart drawn by a library builds its scales during its own render, where a
+ * caller cannot reach them, so the positions are worked out here from the same
+ * values and the same two transforms the axes use.
+ *
+ * It is an estimate, which is all a corner needs: the plot area is inset from
+ * the box by the margins, and a mark a few pixels from a corner counts for that
+ * corner either way.
+ */
+/**
+ * Place every point in the box the figure is drawn in.
+ * @param points - The points the figure draws.
+ * @param box - Its size, in pixels, normally from `useContainerSize`.
+ * @param box.width - How wide the figure is drawn.
+ * @param box.height - How tall it is drawn.
+ * @param scale - The scale each axis is drawn on, which the positions have to
+ *   follow to land where the marks do.
+ * @param scale.y - How the vertical axis is read.
+ * @param scale.x - How the horizontal axis is read.
+ * @param options - See {@link AxisMarkPositionsOptions}.
+ * @returns One position per point, in the order they were given.
+ */
+export function axisMarkPositions(points, box, scale, options = {}) {
+    const { constant = 1 } = options;
+    const x = new Float64Array(points.length);
+    const y = new Float64Array(points.length);
+    place(points, 'x', scale.x === 'log', constant, box.width, x);
+    place(points, 'y', scale.y === 'log', constant, box.height, y);
+    // The vertical axis grows upwards while the box is measured from its top.
+    for (let index = 0; index < y.length; index++) {
+        y[index] = box.height - y[index];
+    }
+    return { x, y };
+}
+function place(points, axis, logarithmic, constant, extent, into) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (let index = 0; index < points.length; index++) {
+        const value = transform(points[index][axis], logarithmic, constant);
+        into[index] = value;
+        if (value < min)
+            min = value;
+        if (value > max)
+            max = value;
+    }
+    const span = max - min;
+    for (let index = 0; index < into.length; index++) {
+        const value = into[index] - min;
+        into[index] = span === 0 ? extent / 2 : (value / span) * extent;
+    }
+}
+/**
+ * d3's symmetric log, which is the one a genuine zero survives.
+ * @param value - The value to place.
+ * @param logarithmic - Whether the axis is read logarithmically at all.
+ * @param constant - Width of its linear region.
+ * @returns The value in the units the axis is spaced in.
+ */
+function transform(value, logarithmic, constant) {
+    if (!logarithmic)
+        return value;
+    const width = constant > 0 ? constant : 1;
+    return Math.sign(value) * Math.log1p(Math.abs(value) / width);
+}
+//# sourceMappingURL=axisMarks.js.map

package/lib/axis/core/axisMarks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"axisMarks.js","sourceRoot":"","sources":["../../../src/axis/core/axisMarks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA0BH;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAA4B,EAC5B,GAAsC,EACtC,KAAqC,EACrC,UAAoC,EAAE;IAEtC,MAAM,EAAE,QAAQ,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC;IACjC,MAAM,CAAC,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,CAAC,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAE1C,KAAK,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,KAAK,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC9D,KAAK,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,KAAK,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAC/D,0EAA0E;IAC1E,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAC9C,CAAC,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,MAAM,GAAI,CAAC,CAAC,KAAK,CAAY,CAAC;IAC/C,CAAC;IACD,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAClB,CAAC;AAED,SAAS,KAAK,CACZ,MAA4B,EAC5B,IAAe,EACf,WAAoB,EACpB,QAAgB,EAChB,MAAc,EACd,IAAkB;IAElB,IAAI,GAAG,GAAG,QAAQ,CAAC;IACnB,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC;IACpB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,MAAM,KAAK,GAAG,SAAS,CACpB,MAAM,CAAC,KAAK,CAAe,CAAC,IAAI,CAAC,EAClC,WAAW,EACX,QAAQ,CACT,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;QACpB,IAAI,KAAK,GAAG,GAAG;YAAE,GAAG,GAAG,KAAK,CAAC;QAC7B,IAAI,KAAK,GAAG,GAAG;YAAE,GAAG,GAAG,KAAK,CAAC;IAC/B,CAAC;IAED,MAAM,IAAI,GAAG,GAAG,GAAG,GAAG,CAAC;IACvB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACjD,MAAM,KAAK,GAAI,IAAI,CAAC,KAAK,CAAY,GAAG,GAAG,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC;IAClE,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,SAAS,CAChB,KAAa,EACb,WAAoB,EACpB,QAAgB;IAEhB,IAAI,CAAC,WAAW;QAAE,OAAO,KAAK,CAAC;IAC/B,MAAM,KAAK,GAAG,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1C,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC;AAChE,CAAC"}

package/lib/axis/core/axisScale.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Which of the two scales a quantity is read on, and who decided.
+ *
+ * Every quantity has a scale it is usually read on — a concentration spanning
+ * ten decades is read logarithmically, a first ionisation energy linearly — and
+ * a reader may overrule it. The two are kept apart rather than collapsed into
+ * one boolean, because a figure that forgets which it is holding gets both of
+ * the following wrong: picking another quantity has to bring that quantity's
+ * own scale rather than carry the last one over, and a link has to stay silent
+ * about a scale nobody chose, so that it keeps opening the way the quantity is
+ * read even after the usual scale is reconsidered.
+ */
+/** The two scales an axis is drawn on. */
+export type AxisScale = 'linear' | 'log';
+/** A reader's choice, or `null` while they have not made one. */
+export type AxisScaleChoice = AxisScale | null;
+/**
+ * The scale an axis is actually drawn on.
+ * @param usual - How the quantity on the axis is normally read.
+ * @param chosen - What the reader asked for, or `null` to leave it to the
+ *   quantity.
+ * @returns The scale to draw.
+ */
+export declare function resolveAxisScale(usual: AxisScale, chosen: AxisScaleChoice): AxisScale;
+/**
+ * Narrow an arbitrary string — one off a query parameter — to a scale.
+ * @param value - Candidate scale.
+ * @returns True when it is one of the two.
+ */
+export declare function isAxisScale(value: string): value is AxisScale;
+//# sourceMappingURL=axisScale.d.ts.map

package/lib/axis/core/axisScale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axisScale.d.ts","sourceRoot":"","sources":["../../../src/axis/core/axisScale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,0CAA0C;AAC1C,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEzC,iEAAiE;AACjE,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,IAAI,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,eAAe,GACtB,SAAS,CAEX;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,SAAS,CAE7D"}

package/lib/axis/core/axisScale.js

@@ -0,0 +1,31 @@
+/**
+ * Which of the two scales a quantity is read on, and who decided.
+ *
+ * Every quantity has a scale it is usually read on — a concentration spanning
+ * ten decades is read logarithmically, a first ionisation energy linearly — and
+ * a reader may overrule it. The two are kept apart rather than collapsed into
+ * one boolean, because a figure that forgets which it is holding gets both of
+ * the following wrong: picking another quantity has to bring that quantity's
+ * own scale rather than carry the last one over, and a link has to stay silent
+ * about a scale nobody chose, so that it keeps opening the way the quantity is
+ * read even after the usual scale is reconsidered.
+ */
+/**
+ * The scale an axis is actually drawn on.
+ * @param usual - How the quantity on the axis is normally read.
+ * @param chosen - What the reader asked for, or `null` to leave it to the
+ *   quantity.
+ * @returns The scale to draw.
+ */
+export function resolveAxisScale(usual, chosen) {
+    return chosen ?? usual;
+}
+/**
+ * Narrow an arbitrary string — one off a query parameter — to a scale.
+ * @param value - Candidate scale.
+ * @returns True when it is one of the two.
+ */
+export function isAxisScale(value) {
+    return value === 'linear' || value === 'log';
+}
+//# sourceMappingURL=axisScale.js.map

package/lib/axis/core/axisScale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"axisScale.js","sourceRoot":"","sources":["../../../src/axis/core/axisScale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAQH;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAgB,EAChB,MAAuB;IAEvB,OAAO,MAAM,IAAI,KAAK,CAAC;AACzB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,KAAa;IACvC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,KAAK,CAAC;AAC/C,CAAC"}

package/lib/axis/core/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * How an axis is read: linearly or logarithmically, who decided, where it
+ * starts and ends, and where its marks land.
+ *
+ * It is a domain of its own rather than part of any chart, because the library
+ * draws figures with three different renderers and the sites draw more with
+ * libraries of their own — and the two things that go wrong on a logarithmic
+ * axis go wrong the same way in all of them.
+ */
+export type { AxisMarkPositions, AxisMarkPositionsOptions, AxisPoint, } from './axisMarks.ts';
+export { axisMarkPositions } from './axisMarks.ts';
+export type { AxisScale, AxisScaleChoice } from './axisScale.ts';
+export { isAxisScale, resolveAxisScale } from './axisScale.ts';
+export type { LogAxisBounds, LogAxisBoundsOptions } from './logAxisBounds.ts';
+export { logAxisBounds } from './logAxisBounds.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/axis/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/axis/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,YAAY,EACV,iBAAiB,EACjB,wBAAwB,EACxB,SAAS,GACV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC"}

package/lib/axis/core/index.js

@@ -0,0 +1,13 @@
+/**
+ * How an axis is read: linearly or logarithmically, who decided, where it
+ * starts and ends, and where its marks land.
+ *
+ * It is a domain of its own rather than part of any chart, because the library
+ * draws figures with three different renderers and the sites draw more with
+ * libraries of their own — and the two things that go wrong on a logarithmic
+ * axis go wrong the same way in all of them.
+ */
+export { axisMarkPositions } from "./axisMarks.js";
+export { isAxisScale, resolveAxisScale } from "./axisScale.js";
+export { logAxisBounds } from "./logAxisBounds.js";
+//# sourceMappingURL=index.js.map

package/lib/axis/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/axis/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE/D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC"}

package/lib/axis/core/logAxisBounds.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The ends of a logarithmic axis, and the values it is graduated at.
+ *
+ * Both have to be stated rather than left to the charting library, and for two
+ * separate reasons.
+ *
+ * The ends, because a library that finds them itself may not look at every
+ * value. nivo is the measured case: it sorts and takes a true minimum and
+ * maximum only for a linear axis, and on a log or symmetric-log one `'auto'`
+ * resolves to the first value the data carries and the last — so the domain
+ * comes out in plotting order, upside down whenever the first point outweighs
+ * the last, and cutting off everything past the last point drawn.
+ *
+ * The graduations, because d3 rules a symmetric-log axis at evenly *spaced*
+ * values while placing them logarithmically, so the top of a wide axis collects
+ * every graduation it has into one unreadable line. Ruling it by decade spreads
+ * them evenly, which is also how such a quantity is read.
+ */
+/** What {@link logAxisBounds} answers. */
+export interface LogAxisBounds {
+    /** The low end of the axis. */
+    min: number;
+    /** The high end. */
+    max: number;
+    /**
+     * The values to rule it at, or `undefined` for an axis spanning too few
+     * decades to be worth ruling by them — there the library's own linear
+     * graduations read better, and there is no pile-up to undo.
+     */
+    tickValues?: number[];
+}
+/** What {@link logAxisBounds} needs beyond the values. */
+export interface LogAxisBoundsOptions {
+    /**
+     * Width of the linear region at the bottom of a symmetric-log axis — d3's
+     * `constant`. Everything smaller than it is placed almost on the zero line,
+     * so no graduation is written below it; a graduation there would land on top
+     * of the one before it, which is the pile-up this exists to prevent.
+     *
+     * Pass `0` for a true logarithmic axis, which has no such region — and which
+     * cannot place a zero or a negative at all, so those values are then left out
+     * of the ends rather than dragging them to nothing.
+     * @default 1
+     */
+    constant?: number;
+    /**
+     * Whether the ends are rounded outwards to whole powers of ten. An axis that
+     * ends on its own extreme values reads as though those were round numbers;
+     * one that ends on decades says what it is. Worth it on a true logarithmic
+     * axis, where every graduation is a decade anyway.
+     * @default false — the ends are the data's own
+     */
+    snapToDecades?: boolean;
+    /**
+     * How many decades the axis may span at most, counted down from its top. A
+     * quantity that reaches zero asymptotically has no meaningful bottom, and an
+     * axis given one spends most of its height on values nobody is reading.
+     * Only consulted with `snapToDecades`.
+     * @default Infinity — the axis spans whatever the data does
+     */
+    maxDecades?: number;
+    /**
+     * How many graduations the axis may carry. More than this is a smear however
+     * they are spread, so the decades are stepped over rather than written out.
+     * @default 10
+     */
+    mostTicks?: number;
+}
+/**
+ * Where a logarithmic axis starts and ends, and where it is graduated.
+ * @param values - Every value plotted on the axis. Anything not finite is
+ *   ignored, so a sheet's gaps need not be filtered out first.
+ * @param options - See {@link LogAxisBoundsOptions}.
+ * @returns The ends and the graduations, or `null` when no value can be drawn
+ *   and the caller should leave the axis to its library.
+ */
+export declare function logAxisBounds(values: Iterable<number>, options?: LogAxisBoundsOptions): LogAxisBounds | null;
+//# sourceMappingURL=logAxisBounds.d.ts.map

package/lib/axis/core/logAxisBounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logAxisBounds.d.ts","sourceRoot":"","sources":["../../../src/axis/core/logAxisBounds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC5B,+BAA+B;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,oBAAoB;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,0DAA0D;AAC1D,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAKD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,EACxB,OAAO,GAAE,oBAAyB,GACjC,aAAa,GAAG,IAAI,CAkCtB"}

package/lib/axis/core/logAxisBounds.js

@@ -0,0 +1,129 @@
+/**
+ * The ends of a logarithmic axis, and the values it is graduated at.
+ *
+ * Both have to be stated rather than left to the charting library, and for two
+ * separate reasons.
+ *
+ * The ends, because a library that finds them itself may not look at every
+ * value. nivo is the measured case: it sorts and takes a true minimum and
+ * maximum only for a linear axis, and on a log or symmetric-log one `'auto'`
+ * resolves to the first value the data carries and the last — so the domain
+ * comes out in plotting order, upside down whenever the first point outweighs
+ * the last, and cutting off everything past the last point drawn.
+ *
+ * The graduations, because d3 rules a symmetric-log axis at evenly *spaced*
+ * values while placing them logarithmically, so the top of a wide axis collects
+ * every graduation it has into one unreadable line. Ruling it by decade spreads
+ * them evenly, which is also how such a quantity is read.
+ */
+/** Under this many decades the library's own graduations read better. */
+const RULE_PAST_DECADES = 3;
+/**
+ * Where a logarithmic axis starts and ends, and where it is graduated.
+ * @param values - Every value plotted on the axis. Anything not finite is
+ *   ignored, so a sheet's gaps need not be filtered out first.
+ * @param options - See {@link LogAxisBoundsOptions}.
+ * @returns The ends and the graduations, or `null` when no value can be drawn
+ *   and the caller should leave the axis to its library.
+ */
+export function logAxisBounds(values, options = {}) {
+    const { constant = 1, snapToDecades = false } = options;
+    const { maxDecades = Infinity, mostTicks = 10 } = options;
+    // A true logarithmic axis has no room for a zero or a negative, so they are
+    // not what its bottom end is taken from.
+    const positiveOnly = constant === 0;
+    let min = Infinity;
+    let max = -Infinity;
+    for (const value of values) {
+        if (!Number.isFinite(value))
+            continue;
+        if (positiveOnly && value <= 0)
+            continue;
+        if (value < min)
+            min = value;
+        if (value > max)
+            max = value;
+    }
+    if (min > max)
+        return null;
+    if (snapToDecades) {
+        const top = Math.ceil(Math.log10(Math.abs(max) || 1));
+        const bottom = Math.max(Math.floor(Math.log10(Math.abs(min) || 1)), top - maxDecades);
+        return withTicks(decade(bottom), decade(top), constant, mostTicks);
+    }
+    // A lone value, or a column of identical ones, spans nothing: reach to the
+    // origin so it is read against a zero rather than filling the axis.
+    if (min === max) {
+        if (min === 0)
+            return { min: -1, max: 1 };
+        return { min: Math.min(min, 0), max: Math.max(max, 0) };
+    }
+    return withTicks(min, max, constant, mostTicks);
+}
+/**
+ * The ends, with the graduations when they are worth writing.
+ * @param min
+ * @param max
+ * @param constant
+ * @param mostTicks
+ */
+function withTicks(min, max, constant, mostTicks) {
+    const ticks = decadesBetween(min, max, constant, mostTicks);
+    return ticks === undefined ? { min, max } : { min, max, tickValues: ticks };
+}
+/**
+ * Zero, and the powers of ten the axis both reaches and can separate.
+ * @param min - The low end of the axis.
+ * @param max - Its high end.
+ * @param constant - Width of the linear region; see the options.
+ * @param mostTicks - How many graduations the axis may carry.
+ * @returns The values to rule it at, or nothing to leave it to the library.
+ */
+function decadesBetween(min, max, constant, mostTicks) {
+    const largest = Math.max(Math.abs(min), Math.abs(max));
+    if (largest === 0)
+        return undefined;
+    // Below the linear region every decade lands on the same pixel, so the axis
+    // is ruled from there up rather than from its smallest value.
+    const floor = constant > 0 ? Math.log10(constant) : smallestDecade(min, max);
+    const bottom = Math.ceil(floor);
+    const top = Math.floor(Math.log10(largest));
+    // Under a few decades the library's own graduations read better — but only
+    // where it has linear ones to offer. On a true logarithmic axis every
+    // graduation is a decade, so a short one is still ruled by decade.
+    if (constant > 0 && top - bottom + 1 < RULE_PAST_DECADES)
+        return undefined;
+    const step = Math.ceil((top - bottom + 1) / mostTicks);
+    const ticks = min <= 0 && max >= 0 ? [0] : [];
+    for (let power = bottom; power <= top; power += step) {
+        const tick = decade(power);
+        if (tick >= min && tick <= max)
+            ticks.push(tick);
+    }
+    if (constant === 0)
+        return ticks;
+    return ticks.length < RULE_PAST_DECADES ? undefined : ticks;
+}
+/**
+ * A whole power of ten.
+ * @param power - The exponent, a whole number.
+ * @returns Ten to that power, the same bits on every engine.
+ */
+function decade(power) {
+    // Read as a decimal rather than computed: `10 ** power` goes through pow,
+    // which is not bit-exact across V8 versions — node 22 answers
+    // 0.00009999999999999999 for -4 and 1.0000000000000001e-20 for -20 — while a
+    // decimal literal is the correctly-rounded double everywhere.
+    return Number(`1e${power}`);
+}
+/**
+ * The decade of the smaller end, for an axis with no linear region.
+ * @param min - The low end of the axis.
+ * @param max - Its high end.
+ * @returns The base-ten logarithm of the smaller end that is not zero.
+ */
+function smallestDecade(min, max) {
+    const ends = [Math.abs(min), Math.abs(max)].filter((end) => end > 0);
+    return Math.log10(Math.min(...ends));
+}
+//# sourceMappingURL=logAxisBounds.js.map

package/lib/axis/core/logAxisBounds.js.map

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

package/lib/axis/ui/AxisScaleControl.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The control that moves one axis between its two scales.
+ *
+ * It belongs on the figure rather than in the page around it: the scale is not
+ * a property of the page but of the picture, a reader decides to change it
+ * while looking at the picture, and a figure handed out on its own — embedded
+ * in a course page, pasted into a deck — takes its controls with it. So it is
+ * written as a control of an `OverlayBar`, floating in whichever corner the
+ * marks leave emptiest.
+ *
+ * Its two segments are named here rather than by each site, because `Linear`
+ * and `Log` are chrome: one translation reaches every figure in the family.
+ */
+import type { ReactElement } from 'react';
+import type { HelpContent } from '../../help/ui/HelpBody.tsx';
+import type { AxisScale } from '../core/axisScale.ts';
+/** Which axis a control belongs to, which is how it names itself. */
+export type AxisScaleAxis = 'x' | 'y';
+/** What {@link AxisScaleControl} needs. */
+export interface AxisScaleControlProps {
+    /** The scale in force — what `resolveAxisScale` answered, not the choice. */
+    value: AxisScale;
+    /** Called with the scale the reader picked. */
+    onChange: (scale: AxisScale) => void;
+    /**
+     * Which axis it sets, which names it `X scale` or `Y scale`. Leave it out on
+     * a figure where only one axis offers the choice: the control is then simply
+     * `Scale`, because naming the axis is only worth the width when there are two
+     * of them to tell apart.
+     * @default undefined — the control is named `Scale`
+     */
+    axis?: AxisScaleAxis;
+    /**
+     * What it is called, overriding both of the above. For a figure whose axis
+     * has a name the reader already knows it by.
+     * @default the chrome's own word, in the language of the page
+     */
+    label?: string;
+    /**
+     * What the two scales do, in a sentence.
+     * @default the chrome's own explanation
+     */
+    help?: HelpContent;
+    /**
+     * Whether the name is announced but not written.
+     * @default false
+     */
+    hideLabel?: boolean;
+    /**
+     * Whether the control is greyed and unreachable.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Value of the `data-testid` attribute.
+     * @default undefined
+     */
+    testId?: string;
+}
+/**
+ * The two scales, the one in force pressed.
+ * @param props - See {@link AxisScaleControlProps}.
+ * @returns The named pair of segments.
+ */
+export declare function AxisScaleControl(props: AxisScaleControlProps): ReactElement;
+//# sourceMappingURL=AxisScaleControl.d.ts.map

package/lib/axis/ui/AxisScaleControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AxisScaleControl.d.ts","sourceRoot":"","sources":["../../../src/axis/ui/AxisScaleControl.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAE1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAI9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,qEAAqE;AACrE,MAAM,MAAM,aAAa,GAAG,GAAG,GAAG,GAAG,CAAC;AAEtC,2CAA2C;AAC3C,MAAM,WAAW,qBAAqB;IACpC,6EAA6E;IAC7E,KAAK,EAAE,SAAS,CAAC;IACjB,+CAA+C;IAC/C,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IACrC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,YAAY,CAsB3E"}

package/lib/axis/ui/AxisScaleControl.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useChromeT } from "../../i18n/ui/useT.js";
+import { OverlaySegmented } from "../../overlay/ui/OverlaySegmented.js";
+/**
+ * The two scales, the one in force pressed.
+ * @param props - See {@link AxisScaleControlProps}.
+ * @returns The named pair of segments.
+ */
+export function AxisScaleControl(props) {
+    const { value, onChange, axis, label, help, testId } = props;
+    const { hideLabel = false, disabled = false } = props;
+    const t = useChromeT();
+    const options = [
+        { value: 'linear', label: t('axis.linear') },
+        { value: 'log', label: t('axis.logarithmic') },
+    ];
+    return (_jsx(OverlaySegmented, { label: label ?? t(nameOf(axis)), help: help ?? { title: t('axis.scale'), body: t('axis.scaleHelp') }, hideLabel: hideLabel, disabled: disabled, value: value, options: options, onChange: onChange, testId: testId }));
+}
+function nameOf(axis) {
+    if (axis === 'x')
+        return 'axis.xScale';
+    if (axis === 'y')
+        return 'axis.yScale';
+    return 'axis.scale';
+}
+//# sourceMappingURL=AxisScaleControl.js.map

package/lib/axis/ui/AxisScaleControl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AxisScaleControl.js","sourceRoot":"","sources":["../../../src/axis/ui/AxisScaleControl.tsx"],"names":[],"mappings":";AAiBA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAuC,CAAC;AAgDzE;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAA4B;IAC3D,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAC7D,MAAM,EAAE,SAAS,GAAG,KAAK,EAAE,QAAQ,GAAG,KAAK,EAAE,GAAG,KAAK,CAAC;IACtD,MAAM,CAAC,GAAG,UAAU,EAAE,CAAC;IAEvB,MAAM,OAAO,GAA4C;QACvD,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,aAAa,CAAC,EAAE;QAC5C,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,kBAAkB,CAAC,EAAE;KAC/C,CAAC;IAEF,OAAO,CACL,KAAC,gBAAgB,IACf,KAAK,EAAE,KAAK,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAC/B,IAAI,EAAE,IAAI,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,gBAAgB,CAAC,EAAE,EACnE,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,GACd,CACH,CAAC;AACJ,CAAC;AAED,SAAS,MAAM,CACb,IAA+B;IAE/B,IAAI,IAAI,KAAK,GAAG;QAAE,OAAO,aAAa,CAAC;IACvC,IAAI,IAAI,KAAK,GAAG;QAAE,OAAO,aAAa,CAAC;IACvC,OAAO,YAAY,CAAC;AACtB,CAAC"}

package/lib/axis/ui/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The controls that say how an axis is read.
+ */
+export type { AxisScaleAxis, AxisScaleControlProps, } from './AxisScaleControl.tsx';
+export { AxisScaleControl } from './AxisScaleControl.tsx';
+//# sourceMappingURL=index.d.ts.map

package/lib/axis/ui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/axis/ui/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EACV,aAAa,EACb,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

package/lib/axis/ui/index.js

@@ -0,0 +1,5 @@
+/**
+ * The controls that say how an axis is read.
+ */
+export { AxisScaleControl } from "./AxisScaleControl.js";
+//# sourceMappingURL=index.js.map

package/lib/axis/ui/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/axis/ui/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAwB,CAAC"}

package/lib/core.d.ts

@@ -1,4 +1,5 @@
 export * from './about/core/index.ts';
+export * from './axis/core/index.ts';
 export * from './build/core/index.ts';
 export * from './chart/core/index.ts';
 export * from './citation/core/index.ts';

package/lib/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}

package/lib/core.js

@@ -1,4 +1,5 @@
 export * from "./about/core/index.js";
+export * from "./axis/core/index.js";
 export * from "./build/core/index.js";
 export * from "./chart/core/index.js";
 export * from "./citation/core/index.js";

package/lib/core.js.map

@@ -1 +1 @@
-{"version":3,"file":"core.js","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,+EAA+E;AAC/E,2EAA2E;AAC3E,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,0EAA0E;AAC1E,8EAA8E;AAC9E,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,+EAA+E;AAC/E,2EAA2E;AAC3E,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,0EAA0E;AAC1E,8EAA8E;AAC9E,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}