@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/ui/charts/sparklineOption.d.ts

@@ -0,0 +1,19 @@
+import { EChartsCoreOption } from 'echarts/core';
+import { MetricCardData } from '../../analysis/index.js';
+import { FilledNote, ValueLabel } from './family.js';
+import { ChartTheme } from './theme.js';
+/** What a metric card's trend reads besides its points. */
+export interface SparklineContext {
+    label: ValueLabel;
+    /** The date dimension the trend runs along. */
+    x?: string;
+    /** The metric the card headlines. */
+    metric?: string;
+    /** What a point is called in the tooltip: 「趋势」. */
+    name: string;
+    animate: boolean;
+    /** A filled-in bucket as the tooltip says it (`useFilledNote`). */
+    filled?: FilledNote;
+}
+export declare function sparklineOption(trend: NonNullable<MetricCardData['trend']>, { label, x, metric, name, animate, filled }: SparklineContext, theme: ChartTheme): EChartsCoreOption;
+//# sourceMappingURL=sparklineOption.d.ts.map

package/dist/ui/charts/sparklineOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparklineOption.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/sparklineOption.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxD,2DAA2D;AAC3D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,UAAU,CAAC;IAClB,+CAA+C;IAC/C,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,mEAAmE;IACnE,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAWD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,WAAW,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,EAC3C,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,gBAAgB,EAC7D,KAAK,EAAE,UAAU,GAChB,iBAAiB,CAmDnB"}

package/dist/ui/charts/theme.d.ts

@@ -0,0 +1,179 @@
+/**
+ * The theme a chart is drawn in: its whole look, as concrete values.
+ *
+ * The stylesheet stays the one source of truth (`--chart-1..8`,
+ * `--foreground`, the chart's roles `--_fve-chart-*`, and whatever a host
+ * or a preset sets through `--fve-*` / `--fvp-*`); this is that cascade read
+ * back off the chart's own element (theme-architecture.md 6). The option
+ * handed to the library never holds a `var()`: the library derives a
+ * hovered mark's colour and a label's contrast by parsing the colour it was
+ * given, and a custom property parses as nothing (echarts#16044, #19743).
+ * Nor an `oklch()`, which the theme is written in and the library's parser
+ * does not read — so every colour is converted to `rgb()` here — nor a
+ * `calc()`: every length is the browser's pixels, every number a number.
+ * An option builder reads its look from here and writes no size, width or
+ * corner of its own (`test/chartTheme.test.tsx` walks their source).
+ */
+export interface ChartTheme {
+    /** The eight slots, in the order the stylesheet validated them in. */
+    palette: readonly string[];
+    /** Text written over the plot: a value label, a total. */
+    foreground: string;
+    /**
+     * The quiet grey of what is no series: a pie's "Other", a reference
+     * line, a target band, a gauge's track, the zoom's shade.
+     */
+    muted: string;
+    /** What the chart stands on, drawn around a value label as its halo. */
+    ground: string;
+    /** Gridlines and axis rules: their colour and width (`chart-grid`). */
+    grid: {
+        color: string;
+        width: number;
+    };
+    /**
+     * The quiet text: ticks, axis titles, a scale's ends, the names written
+     * beside the marks (`chart-axis`).
+     */
+    axis: {
+        color: string;
+    };
+    /**
+     * The type: the surface's family, the chart's text size and a value
+     * label's, a step under it (`chart-text-size`, `chart-label-size`).
+     */
+    text: {
+        family: string;
+        size: number;
+        labelSize: number;
+    };
+    /** A line's width, and how opaque an area under it is filled. */
+    line: {
+        width: number;
+        areaOpacity: number;
+    };
+    /**
+     * A bar's end corner and its width's bounds; no `minWidth` is no lower
+     * bound (`chart-bar-*`).
+     */
+    bar: {
+        radius: number;
+        minWidth?: number;
+        maxWidth: number;
+    };
+    /** The seam of the ground between two slices (`chart-slice-border`). */
+    slice: {
+        border: number;
+    };
+    /**
+     * A map's boundaries (`chart-map-edge`): what outlines an area with no
+     * number, an island and a disputed line against the ground.
+     */
+    map: {
+        edge: string;
+    };
+    /**
+     * Patterns over the series' colours, as the host pinned them with
+     * `--fve-chart-patterns: on | off`; `undefined` follows the reader's
+     * system (`usePatterns`, D33 Q57).
+     */
+    patterns?: boolean;
+    /** A colour the spec pinned — a `var(--slot)` or any CSS colour — made concrete. */
+    resolve(color: string): string;
+    /** Equal for two readings of the same theme. */
+    key: string;
+}
+/** The chart's text at its size, the option's `textStyle`. */
+export declare function chartText(theme: ChartTheme): {
+    fontFamily: string;
+    fontSize: number;
+};
+/**
+ * The pin on patterns over a chart's colours: `on`, `off`, or unset to
+ * follow the reader's system (`patternsPinned`), read in the stylesheet's
+ * order — the host's `--fve-chart-patterns` first, then a preset's
+ * `--fvp-chart-patterns` (theme-architecture.md 3, S2). Read off the chart's
+ * element like every colour, so either is set on any ancestor.
+ */
+export declare const PATTERNS_TOKENS: readonly ["--fve-chart-patterns", "--fvp-chart-patterns"];
+/**
+ * Every token a chart reads, the slots first, and the attributes that can
+ * move what they resolve to — both the theme registry's
+ * (`../theme/tokens.ts`), which the README's list of what redraws a chart
+ * is written from too. `ViewSurface` watches the same tokens to tell a
+ * chart that the theme under it moved (`useSurfaceTokens`), and observes
+ * those attributes and nothing else, so what is read and what is watched
+ * cannot part.
+ */
+export { CHART_TOKENS, THEME_ATTRIBUTES } from '../theme/tokens.js';
+/**
+ * The light theme's look, for where nothing can be read: jsdom resolves no
+ * custom property, and a chart outside any stylesheet still has to draw in
+ * something. They are the stylesheet's light tokens and the chart roles'
+ * built-in values, made concrete — a second spelling of `styles.css`, so
+ * `test/chartTheme.test.tsx` reads the light token block and holds every
+ * value here to it. Before that test the first slot had drifted: it was
+ * still the step the palette was tuned away from.
+ */
+export declare const CHART_FALLBACK: {
+    readonly palette: readonly ["rgb(38, 117, 211)", "rgb(235, 104, 52)", "rgb(27, 175, 122)", "rgb(237, 161, 0)", "rgb(232, 123, 164)", "rgb(0, 131, 0)", "rgb(74, 58, 167)", "rgb(227, 73, 72)"];
+    readonly foreground: "rgb(10, 10, 10)";
+    readonly muted: "rgb(115, 115, 115)";
+    readonly ground: "rgb(255, 255, 255)";
+    readonly grid: {
+        readonly color: "rgb(229, 229, 229)";
+        readonly width: 1;
+    };
+    readonly axis: {
+        readonly color: "rgb(115, 115, 115)";
+    };
+    readonly text: {
+        readonly family: "sans-serif";
+        readonly size: 12;
+        readonly labelSize: 11;
+    };
+    readonly line: {
+        readonly width: 2;
+        readonly areaOpacity: 0.2;
+    };
+    readonly bar: {
+        readonly radius: 2;
+        readonly maxWidth: 80;
+    };
+    readonly slice: {
+        readonly border: 1;
+    };
+    readonly map: {
+        readonly edge: "rgb(115, 115, 115)";
+    };
+};
+/** Any CSS colour as `rgb()`/`rgba()`; `undefined` when it is none. */
+export declare function concreteColor(text: string | undefined): string | undefined;
+/**
+ * `color` at `strength` over `ground`, as the one opaque colour the eye gets
+ * there: what painting it at that opacity on that ground shows, worked out
+ * before the library sees it. A scale drawn apart from the marks — a
+ * heatmap's colour bar — then reads the same colours the marks show, on
+ * whatever the ground is; handed the opacity instead, the library drew the
+ * bar's pale end against a ground of its own, bright on a dark page where
+ * the cells were near black (audit P1-9). Mixed in `rgb`, as the opacity
+ * composites. A colour that does not parse is given back as it came.
+ */
+export declare function mixColor(ground: string, color: string, strength: number): string;
+/**
+ * A mark's colour while the pointer is on it: `fill` a step toward the
+ * foreground (`EMPHASIS`), so emphasis reads as more, never as less.
+ */
+export declare function emphasized(theme: ChartTheme, fill: string): string;
+/**
+ * The ink a label written on `fill` wears: the foreground or the ground,
+ * whichever stands further from it (WCAG contrast). A number inside a
+ * stacked bar's segment or on a heatmap's cell sits on the mark rather
+ * than on the page, and one colour for all of them wrote dark digits on
+ * the deep end of the scale, with a halo that only blurred them (2026-09-23
+ * audit). The mark decides, so a label is legible on every shade in either
+ * mode, and needs no halo.
+ */
+export declare function inkOn(theme: ChartTheme, fill: string): string;
+export declare function readChartTheme(element: Element): ChartTheme;
+//# sourceMappingURL=theme.d.ts.map

package/dist/ui/charts/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/theme.ts"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,UAAU;IACzB,sEAAsE;IACtE,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC;;;OAGG;IACH,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACxB;;;OAGG;IACH,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D,iEAAiE;IACjE,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C;;;OAGG;IACH,GAAG,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7D,wEAAwE;IACxE,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1B;;;OAGG;IACH,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oFAAoF;IACpF,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;CACb;AAED,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU;;;EAE1C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,2DAGlB,CAAC;AAWX;;;;;;;;GAQG;AACH,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEpE;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqB6B,CAAC;AAOzD,uEAAuE;AACvE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAK1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,MAAM,CAKR;AAWD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAS7D;AA2FD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CA6F3D"}

package/dist/ui/charts/timeOption.d.ts

@@ -0,0 +1,54 @@
+import { EChartsCoreOption } from 'echarts/core';
+import { CalendarData, ThemeRiverData } from '../../analysis/index.js';
+import { ChartSpec, RecordData } from '../../model/index.js';
+import { ColumnTitle, SeriesName, ToneOf, ValueLabel } from './family.js';
+import { ChartTheme } from './theme.js';
+/** What a calendar or a theme river reads besides its data. */
+export interface TimeContext {
+    spec?: ChartSpec;
+    label: ValueLabel;
+    column: ColumnTitle;
+    seriesName?: SeriesName;
+    /**
+     * The tone a split value's option gives it (`useToneOf`): a stream of a
+     * toned value wears its tone's colour (`heldTones`), as a split series does.
+     */
+    toneOf?: ToneOf;
+    /** The surface's language: the weekday and month names are its. */
+    locale?: string;
+    animate: boolean;
+    pickable: boolean;
+    /** The group a press set the board's filter to (D22 I): the rest faint. */
+    highlight?: (row: RecordData) => boolean;
+    /** 「其他」, as the chart says the folded rest. */
+    other: string;
+    /**
+     * A period still under way as the chart names it: 「2026年9月（进行中）」
+     * (second review R2-P1-7).
+     */
+    ongoing?: (period: string) => string;
+}
+export declare function calendarOption(data: CalendarData, context: TimeContext, theme: ChartTheme): EChartsCoreOption;
+/** The day a datum is (`d{n}`), by its place in `CalendarData.days`. */
+export declare function dayOf(datum: {
+    id?: unknown;
+} | undefined): number | undefined;
+/** One drawn stream: its key, its name as the legend says it, its colour. */
+export interface DrawnStream {
+    key: string;
+    name: string;
+    color: string;
+    other: boolean;
+}
+/** Every stream of a theme river, as the legend and the tooltip name them. */
+export declare function drawnStreams(data: ThemeRiverData, { spec, label, seriesName, other, toneOf, }: Pick<TimeContext, 'spec' | 'label' | 'seriesName' | 'other' | 'toneOf'>): DrawnStream[];
+/**
+ * A theme river as the library draws it: the time axis along the bottom,
+ * each stream a band as wide as its number at every bucket, stacked round a
+ * centre line so the whole reads as one river and each stream's swell as
+ * its own. The streams are in the kernel's order, largest first, the folded
+ * 「其他」 grey and last. A point is drawn at every bucket (a river cannot
+ * break); the tooltip reads every stream at the bucket under the pointer.
+ */
+export declare function themeRiverOption(data: ThemeRiverData, context: TimeContext, theme: ChartTheme): EChartsCoreOption;
+//# sourceMappingURL=timeOption.d.ts.map

package/dist/ui/charts/timeOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeOption.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/timeOption.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG/E,OAAO,EAAY,KAAK,UAAU,EAAa,MAAM,YAAY,CAAC;AAGlE,+DAA+D;AAC/D,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,CAAC;IACzC,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACtC;AAkCD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,UAAU,GAChB,iBAAiB,CAsHnB;AAED,wEAAwE;AACxE,wBAAgB,KAAK,CAAC,KAAK,EAAE;IAAE,EAAE,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAI7E;AAED,6EAA6E;AAC7E,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAC1B,IAAI,EAAE,cAAc,EACpB,EACE,IAAI,EACJ,KAAK,EACL,UAAU,EACV,KAAK,EACL,MAAM,GACP,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC,GACzE,WAAW,EAAE,CAef;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,UAAU,GAChB,iBAAiB,CAsFnB"}

package/dist/ui/charts/tooltip.d.ts

@@ -0,0 +1,51 @@
+import { ChartTheme } from './theme.js';
+/** One row of a tooltip: the mark's colour, whose it is, and the number. */
+export interface TooltipRow {
+    color: string;
+    name: string;
+    /** Already text, read as its column reads it — never shortened. */
+    value: string;
+    /**
+     * Said after the number, quieter: how it moved from the period before
+     * (「+12.3%」), which the tooltip's footnote names.
+     */
+    note?: string;
+}
+/**
+ * Text going into the tooltip's HTML. Every name and value here comes from
+ * the data — a category, a split value, a column title an analyst typed —
+ * so none of it is markup.
+ */
+export declare function escapeHtml(text: string): string;
+/**
+ * A tooltip as the registry's chart tooltip draws one — the same box, the
+ * heading, a swatch, the name muted and the number in tabular figures — so
+ * the drawing's tooltip and every other popup on the page read as one
+ * family: on the popups' surface, their corner and their lift, through the
+ * chart tooltip's roles (`chart-tooltip`, `-foreground`, `-shadow`,
+ * theme-architecture.md 6), which fall back to `popover`, its words and
+ * `shadow-md` (the registry's `bg-background shadow-xl` was darker than
+ * the cards round it in the dark). The library renders it inside the
+ * chart's own element, which is inside the surface, so the classes resolve
+ * against the theme's tokens and follow a switch to dark without being
+ * told.
+ */
+export declare function tooltipHtml(heading: string, rows: readonly TooltipRow[], 
+/** A quiet line under the rows: what the rows' notes are measured against. */
+footnote?: string): string;
+/**
+ * The library's own tooltip box, emptied: ours is drawn inside it. It stays
+ * within the chart (`confine`), so a panel's edge does not cut it.
+ */
+export declare function tooltipFrame(theme: ChartTheme): {
+    confine: boolean;
+    backgroundColor: string;
+    borderWidth: number;
+    padding: number;
+    extraCssText: string;
+    textStyle: {
+        fontFamily: string;
+        fontSize: number;
+    };
+};
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/ui/charts/tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/tooltip.ts"],"names":[],"mappings":"AAaA,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAExD,4EAA4E;AAC5E,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ/C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,UAAU,EAAE;AAC3B,8EAA8E;AAC9E,QAAQ,CAAC,EAAE,MAAM,UAmClB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU;;;;;;;;;;EAS7C"}

package/dist/ui/charts/treemapOption.d.ts

@@ -0,0 +1,56 @@
+import { EChartsCoreOption } from 'echarts/core';
+import { TreemapData } from '../../analysis/index.js';
+import { ChartSpec, RecordData } from '../../model/index.js';
+import { ColumnTitle, ValueLabel } from './family.js';
+import { ChartTheme } from './theme.js';
+/** What a treemap reads besides its tiles. */
+export interface TreemapContext {
+    spec?: ChartSpec;
+    label: ValueLabel;
+    column: ColumnTitle;
+    locale?: string;
+    animate: boolean;
+    pickable: boolean;
+    /** The group a press set the board's filter to (D22 I): the rest faint. */
+    highlight?: (row: RecordData) => boolean;
+}
+/**
+ * How far the smallest tile of a level fades toward the ground when the
+ * tiles share one hue: shaded by rank, the biggest in the full colour.
+ */
+export declare const PALEST = 0.4;
+/** One drawn tile, as the tooltip, the press and the reading take it. */
+export interface DrawnTile {
+    /** The group values it stands for: its own, and its outer tile's. */
+    row: RecordData;
+    /** Its name, and its outer tile's first where it has one. */
+    name: string;
+    path: string;
+    value: number;
+    /** Its number as its column reads it, whole. */
+    text: string;
+    /** Its share of the whole drawn. */
+    share: string;
+}
+export declare function drawnTiles(data: TreemapData, { spec, label, locale }: Pick<TreemapContext, 'spec' | 'label' | 'locale'>): DrawnTile[];
+/**
+ * The colours of one level's tiles. Up to the palette's size each takes a
+ * slot of its own, in order; past it a slot handed out twice would say two
+ * tiles are one thing, so the level wears the first slot alone, shaded
+ * toward the ground by rank (largest first) — a treemap is how a result of
+ * more categories than colours is read (D33 Q56), and every tile carries
+ * its own name, so the colour need not.
+ */
+export declare function levelColors(theme: ChartTheme, count: number): string[];
+/**
+ * A treemap as the library draws it: the whole cut into tiles by area,
+ * each named on itself with its number under the name, the ground's colour
+ * between them. Two levels nest the inner tiles inside a block per outer
+ * value, headed by that value's name; an inner tile wears its block's
+ * colour, shaded toward the ground by rank within it. The library's own
+ * zoom, pan and breadcrumb are off: a press opens the follow-up menu on
+ * the tile, as a press on a bar does, and the result never moves under
+ * the reader.
+ */
+export declare function treemapOption(data: TreemapData, context: TreemapContext, theme: ChartTheme): EChartsCoreOption;
+//# sourceMappingURL=treemapOption.d.ts.map

package/dist/ui/charts/treemapOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treemapOption.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/treemapOption.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG3D,OAAO,EAIL,KAAK,UAAU,EAEhB,MAAM,YAAY,CAAC;AAGpB,8CAA8C;AAC9C,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,CAAC;CAC1C;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM,MAAM,CAAC;AAE1B,yEAAyE;AACzE,MAAM,WAAW,SAAS;IACxB,qEAAqE;IACrE,GAAG,EAAE,UAAU,CAAC;IAChB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf;AAUD,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EACjB,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC,GACzE,SAAS,EAAE,CA0Bb;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAStE;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,UAAU,GAChB,iBAAiB,CA0InB"}

package/dist/ui/charts/waterfallOption.d.ts

@@ -0,0 +1,58 @@
+import { EChartsCoreOption } from 'echarts/core';
+import { WaterfallData } from '../../analysis/index.js';
+import { ChartSpec } from '../../model/index.js';
+import { ColumnTitle, ValueLabel } from './family.js';
+import { ChartTheme } from './theme.js';
+/** What a waterfall reads besides its steps. */
+export interface WaterfallContext {
+    spec?: ChartSpec;
+    label: ValueLabel;
+    column: ColumnTitle;
+    animate: boolean;
+    pickable: boolean;
+    /** The words the drawing writes itself, in the surface's language. */
+    words: {
+        total: string;
+        increase: string;
+        decrease: string;
+        running: string;
+    };
+}
+/** One bar as drawn: a step, or the closing total. */
+export interface DrawnBar {
+    /** The name under it: the step's group, or 「合计」. */
+    name: string;
+    /** Where it runs from and to on the value axis. */
+    from: number;
+    to: number;
+    /** A rise, a fall, or the total the steps arrive at. */
+    kind: 'up' | 'down' | 'total';
+    /** Its number as a label writes it: a step signed, the total not. */
+    text: string;
+    /** The same, whole, for the tooltip. */
+    whole: string;
+    /** The running total after it, whole; a step only. */
+    running?: string;
+}
+/**
+ * The bars a waterfall draws, in order: one a step, floating from the
+ * running total before it to the one after, and — unless the spec asked
+ * for none — the total the steps arrive at, standing on zero. A step that
+ * changes nothing is a rise of nothing, drawn as a sliver.
+ */
+export declare function drawnBars(data: WaterfallData, { spec, label, words }: Pick<WaterfallContext, 'spec' | 'label' | 'words'>): DrawnBar[];
+/**
+ * A waterfall as the library draws it: bars stacked on an unseen base, so
+ * each floats where the steps before it left the running total (D33 Q55;
+ * the library's own bars, nothing more to load). A rise wears `--_fve-rise` and
+ * a fall `--_fve-fall` — a direction, whose colours the host's change convention
+ * picks (success and destructive unless `red-up` crosses them, themes.md 2.6) —
+ * and the closing total the palette's first slot, as one series does.
+ *
+ * Its number is written past the bar's end, over a rise and under a fall,
+ * in the foreground ink: on the page rather than on the fill, so it reads
+ * on either colour in either mode. The stack adds whatever the sign
+ * (`stackStrategy: 'all'`), so a step that crosses zero floats across it.
+ */
+export declare function waterfallOption(data: WaterfallData, context: WaterfallContext, theme: ChartTheme): EChartsCoreOption;
+//# sourceMappingURL=waterfallOption.d.ts.map

package/dist/ui/charts/waterfallOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waterfallOption.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/waterfallOption.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAGzD,gDAAgD;AAChD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,sDAAsD;AACtD,MAAM,WAAW,QAAQ;IACvB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,wDAAwD;IACxD,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,OAAO,CAAC;IAC9B,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAOD;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,aAAa,EACnB,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,GACzE,QAAQ,EAAE,CAqBZ;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,UAAU,GAChB,iBAAiB,CA8FnB"}

package/dist/ui/colorMode.d.ts

@@ -0,0 +1,39 @@
+import { ReactNode } from 'react';
+/** The modes a reader may pick: the system's, or one pinned. */
+export type ColorMode = 'system' | 'light' | 'dark';
+/** Who paints the mode: the engine, starting from one of the three, or the host. */
+export type HostColorMode = ColorMode | 'host';
+/** What `useColorMode` hands a host's switch. */
+export interface ColorModeControl {
+    /** The mode in force; `host` where the host paints its own. */
+    mode: HostColorMode;
+    /**
+     * Picks a mode for this reader — kept on this machine where the host asked
+     * (`ViewHost`'s `rememberColorMode`); picking the host's own starting mode
+     * forgets the pick. Does nothing under `host`.
+     */
+    setMode(mode: ColorMode): void;
+}
+export interface ColorModeHostProps {
+    /** Who paints, and from which mode; `system` by default. */
+    colorMode?: HostColorMode;
+    /** Where the reader's pick is kept (a `localStorage` key); not kept when left out. */
+    rememberColorMode?: string;
+    /** Whether this host paints `<html>` at all: only the outermost one does. */
+    paints: boolean;
+    children: ReactNode;
+}
+/**
+ * Paints `<html>` for the mode in force, before the first paint, and again
+ * as the system changes while it follows it; puts `<html>` back as it found
+ * it when it goes.
+ */
+export declare function ColorModeHost({ colorMode, rememberColorMode, paints, children, }: ColorModeHostProps): import('react').JSX.Element;
+/**
+ * The page's mode and a way to pick one, for the host's own switch (a
+ * menu in its top bar): what the `ViewHost` above paints. Under a host
+ * that paints its own (`colorMode="host"`), or with no `ViewHost` above,
+ * the mode is `host` and picking does nothing.
+ */
+export declare function useColorMode(): ColorModeControl;
+//# sourceMappingURL=colorMode.d.ts.map

package/dist/ui/colorMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorMode.d.ts","sourceRoot":"","sources":["../../src/ui/colorMode.tsx"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AAEH,OAAO,EAML,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAEf,gEAAgE;AAChE,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAEpD,oFAAoF;AACpF,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,MAAM,CAAC;AAE/C,iDAAiD;AACjD,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,IAAI,EAAE,aAAa,CAAC;IACpB;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;CAChC;AAoDD,MAAM,WAAW,kBAAkB;IACjC,4DAA4D;IAC5D,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,sFAAsF;IACtF,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAC5B,SAAoB,EACpB,iBAAiB,EACjB,MAAM,EACN,QAAQ,GACT,EAAE,kBAAkB,+BAiDpB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,gBAAgB,CAE/C"}

package/dist/ui/columns/ColumnRow.d.ts

@@ -0,0 +1,79 @@
+import { SummaryFunction } from '../../model/index.js';
+import { HandleMove } from '../kit/DragHandle.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+import { ColumnSettingRow } from './rows.js';
+/**
+ * What a reader hears once a column has been pinned or let go.
+ *
+ * `aria-pressed` reports the toggle's new state, and a reader hears it the
+ * moment they press — but only as one word ("pressed"), which names neither
+ * the column nor the edge it is now held against. So the panel's one live
+ * region says the sentence as well (`ColumnSettings`), which is also where
+ * the next state is decided, so the wording is written once.
+ */
+export declare function pinAnnouncement(messages: MessageFormatters, field: string, pinned: boolean): string;
+export interface ColumnRowProps {
+    row: ColumnSettingRow;
+    onToggle(): void;
+    onPin(): void;
+    /**
+     * Whether the cap (D17-4) is not drawing this row's pin right now. The
+     * config still holds it and the switch still says so; the row adds that
+     * it is let go, or the screen shows a pin with no edge under it.
+     */
+    released?: boolean;
+    onSummary(fn: SummaryFunction | null): void;
+    /** The column's width in pixels; `undefined` while it sizes itself. */
+    width?: number;
+    /** Sets the width, or `null` back to automatic (`WidthInput`). */
+    onWidth(width: number | null): void;
+    /**
+     * Where the row stands among the columns it can trade places with — its
+     * area's movable ones — and how many there are, for the handle's menu.
+     */
+    place: {
+        index: number;
+        total: number;
+    };
+    /** Moves the row, from the arrow keys on its handle or from its menu. */
+    onMove(move: HandleMove): void;
+    /** True while the library is carrying this row, so the arrows are its. */
+    dragging?: boolean;
+    elementRef?(element: HTMLElement | null): void;
+    handleRef?(element: HTMLElement | null): void;
+}
+/**
+ * One column in the settings: drag handle, visibility, name, summary, pin.
+ *
+ * The one column the definition places — the row key — shows its state and
+ * disables its controls rather than leaving them out: a row that is missing
+ * its pin toggle reads as an oversight, while one that shows a pin it
+ * cannot change says who decides. It carries no sentence about the pin: the
+ * toggle's own name says that it is held, and the area it is listed in says
+ * so again. The host's action column is not a row here at all (D19) — it is
+ * a render slot rather than something a config names.
+ *
+ * Every other reason a control here is refused is written on the row that
+ * owns it. A rule belongs to the thing it governs — collected at the top of
+ * the panel, five of them were a paragraph the reader had to match against
+ * the row in front of them.
+ */
+export declare function ColumnRow({ row, onToggle, onPin, released, onSummary, width, onWidth, place, onMove, dragging, elementRef, handleRef, }: ColumnRowProps): import('react').JSX.Element;
+/**
+ * A column that can be dragged, wired to the library.
+ *
+ * Only movable rows become sortable items, which is how an area keeps its
+ * columns: a fixed row is not a drop target at all, so nothing can be
+ * carried past the key column or behind the actions.
+ *
+ * The optimistic plugin is left out on purpose. It reorders the DOM while
+ * the pointer moves, which makes the indexes this component is rendered
+ * from stale exactly when the drop is read; without it the library still
+ * draws the drag preview, and the committed order is computed from the two
+ * ids the drop reports.
+ */
+export declare function SortableColumnRow(props: ColumnRowProps & {
+    index: number;
+    group: string;
+}): import('react').JSX.Element;
+//# sourceMappingURL=ColumnRow.d.ts.map

package/dist/ui/columns/ColumnRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColumnRow.d.ts","sourceRoot":"","sources":["../../../src/ui/columns/ColumnRow.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAmBpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAuBlD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,OAAO,GACd,MAAM,CAER;AA4BD,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,gBAAgB,CAAC;IACtB,QAAQ,IAAI,IAAI,CAAC;IACjB,KAAK,IAAI,IAAI,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI,CAAC;IAC5C,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IACpC;;;OAGG;IACH,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,yEAAyE;IACzE,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;IAC/C,SAAS,CAAC,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,EACxB,GAAG,EACH,QAAQ,EACR,KAAK,EACL,QAAgB,EAChB,SAAS,EACT,KAAK,EACL,OAAO,EACP,KAAK,EACL,MAAM,EACN,QAAQ,EACR,UAAU,EACV,SAAS,GACV,EAAE,cAAc,+BA0PhB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,+BAkBzD"}

package/dist/ui/columns/ColumnSettings.d.ts

@@ -0,0 +1,51 @@
+import { ReactElement } from 'react';
+import { FieldDefinition, FieldGroupDefinition } from '../../model/index.js';
+import { RecordTableController } from '../../react/index.js';
+import { ReleasedPins } from '../record/pinCap.js';
+import { DetachedPopover } from '../kit/toolbar.js';
+export interface ColumnSettingsProps {
+    table: RecordTableController;
+    /** The fields the definition offers, in its order. */
+    fields: readonly FieldDefinition[];
+    /**
+     * The picker groups of the definition the fields come from, which the
+     * scrolling area is listed under.
+     */
+    fieldGroups?: readonly FieldGroupDefinition[];
+    /** The field holding each row's identity, when the definition declares one. */
+    rowKey?: string;
+    /** Pins the table's cap is not drawing right now (D17-4); see `ColumnRow`. */
+    released?: ReleasedPins;
+    /**
+     * The control that opens it. Left out, the toolbar's bordered icon button
+     * with the panel's name in its tooltip (D12 Ⅳ).
+     *
+     * The error strip passes a worded button instead, and it passes one
+     * because in the state that strip is read in there is no toolbar to be an
+     * icon in: a config the definition refuses never ran, so there is no
+     * result and so no result block (F-14). The panel is the same panel; only
+     * the way in is different, and an icon alone at the end of a sentence
+     * names nothing.
+     */
+    trigger?: ReactElement<Record<string, unknown>>;
+    /**
+     * Draws one half of it, joined to the other by a handle: the toolbar's
+     * button inside the toolbar, the popup beside it (`DetachedPopover`).
+     * Left out, both halves are drawn here together.
+     */
+    detached?: DetachedPopover;
+}
+/**
+ * Which columns the table shows, in which order, pinned where, summarised
+ * how.
+ *
+ * All four are one question — "what does a row look like" — and they were
+ * three controls in three places before this: a checklist for visibility,
+ * the config for the order, and nothing at all for pinning or summaries. A
+ * column keeps to its area: the row key leads the held one, and everything
+ * else orders freely inside whichever area it is pinned to. The host's
+ * action column is in neither — it is a render slot, always last and always
+ * held against the right edge, and none of that is a setting (D19).
+ */
+export declare function ColumnSettings({ table, fields, fieldGroups, rowKey, released, trigger, detached, }: ColumnSettingsProps): import('react').JSX.Element;
+//# sourceMappingURL=ColumnSettings.d.ts.map

package/dist/ui/columns/ColumnSettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColumnSettings.d.ts","sourceRoot":"","sources":["../../../src/ui/columns/ColumnSettings.tsx"],"names":[],"mappings":"AAaA,OAAO,EAKL,KAAK,YAAY,EAClB,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EAErB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAiBlE,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAmBpE,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AA+BtE,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,qBAAqB,CAAC;IAC7B,sDAAsD;IACtD,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IACnC;;;OAGG;IACH,WAAW,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC9C,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAChD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAqB,EACrB,OAAO,EACP,QAAQ,GACT,EAAE,mBAAmB,+BA0RrB"}