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

package/dist/analysis/timeCharts.d.ts

@@ -0,0 +1,76 @@
+import { AnalysisViewConfig, CalendarSpec, RecordData, ThemeRiverSpec } from '../model/index.js';
+/** One day of a calendar: its bucket, its date in the zone, its number. */
+export interface CalendarDay {
+    /** The bucket key the row carried: what a press drills. */
+    at: unknown;
+    /** The day as the calendar places it, `YYYY-MM-DD` in the bucket's zone. */
+    date: string;
+    value: number;
+}
+export interface CalendarData {
+    type: 'calendar';
+    /** The measured days, earliest first; a day no row holds is no cell. */
+    days: CalendarDay[];
+    /** The years the days fall in, earliest first: one calendar each. */
+    years: number[];
+    /** The smallest and the largest measured number: the colour scale's ends. */
+    low: number;
+    high: number;
+    /**
+     * The period still under way at the axis's end (`unfinishedBucket`): drawn
+     * and marked, and left out of what the chart is read to say. Absent when
+     * every period had ended, or when the question carries no `now`.
+     */
+    unfinished?: {
+        at: unknown;
+    };
+}
+/**
+ * A calendar heatmap's days: each row a day of the one daily dimension, its
+ * date written in the zone its bucket was cut in, earliest first. A day the
+ * rows lack is no cell — a calendar draws "no group" as nothing, as a
+ * heatmap does — so the colour scale's ends are measured days only, never a
+ * 0 written in.
+ */
+export declare function shapeCalendar(spec: CalendarSpec, config: AnalysisViewConfig, rows: readonly RecordData[], timeZone: string): CalendarData;
+/** One stream of a theme river: a split value, or the folded rest. */
+export interface RiverStream {
+    key: string;
+    /** The split value it stands for; left out on the folded 「其他」. */
+    value?: unknown;
+    other?: true;
+}
+export interface ThemeRiverData {
+    type: 'themeRiver';
+    /** The time axis, earliest first and without holes. */
+    times: unknown[];
+    /** Largest first; past the palette the smallest folded into one 「其他」. */
+    streams: RiverStream[];
+    /** `values[time][stream]`: a number at every point, which a river needs. */
+    values: number[][];
+    /**
+     * How many points were written in as 0 with no row to say so and nothing
+     * to say the group was empty — rows cut short, groups kept by 「只保留」.
+     * A river cannot leave a hole, so the drawing says how many it guessed.
+     */
+    uncertain: number;
+    /**
+     * The period still under way at the axis's end (`unfinishedBucket`): drawn
+     * and marked, and left out of what the chart is read to say. Absent when
+     * every period had ended, or when the question carries no `now`.
+     */
+    unfinished?: {
+        at: unknown;
+    };
+}
+/**
+ * A theme river's streams over time: the one date dimension forward and
+ * without holes, a stream per value of the other dimension, each point its
+ * row's number. A point the rows lack is 0 — a stream cannot break — and is
+ * counted as `uncertain` unless the group is known to have had no records
+ * (`absenceReader`). Past the palette the smallest streams are folded into
+ * one grey 「其他」, their numbers added — the metric adds up, or the river
+ * refuses it, and every row of the folded streams is on hand.
+ */
+export declare function shapeThemeRiver(spec: ThemeRiverSpec, config: AnalysisViewConfig, rows: readonly RecordData[], timeZone: string): ThemeRiverData;
+//# sourceMappingURL=timeCharts.d.ts.map

package/dist/analysis/timeCharts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeCharts.d.ts","sourceRoot":"","sources":["../../src/analysis/timeCharts.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAU3B,2EAA2E;AAC3E,MAAM,WAAW,WAAW;IAC1B,2DAA2D;IAC3D,EAAE,EAAE,OAAO,CAAC;IACZ,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,CAAC;IACjB,wEAAwE;IACxE,IAAI,EAAE,WAAW,EAAE,CAAC;IACpB,qEAAqE;IACrE,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,6EAA6E;IAC7E,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,UAAU,CAAC,EAAE;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,CAAC;CAC9B;AAYD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,QAAQ,EAAE,MAAM,GACf,YAAY,CAkBd;AAED,sEAAsE;AACtE,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,IAAI,CAAC;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,YAAY,CAAC;IACnB,uDAAuD;IACvD,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,yEAAyE;IACzE,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,4EAA4E;IAC5E,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,CAAC;CAC9B;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,QAAQ,EAAE,MAAM,GACf,cAAc,CAuDhB"}

package/dist/analysis/treemap.d.ts

@@ -0,0 +1,36 @@
+import { RecordData, TreemapSpec } from '../model/index.js';
+/**
+ * One tile: a group value and its number. An outer tile — a value of the
+ * spec's `parent` — holds the tiles of its own rows, and its number is
+ * theirs added up.
+ */
+export interface TreemapTile {
+    /** The group value the tile stands for. */
+    group: unknown;
+    value: number;
+    /** The tiles inside an outer one; left out on the innermost level. */
+    tiles?: TreemapTile[];
+}
+export interface TreemapData {
+    type: 'treemap';
+    /** The outer level, largest first; each holds its tiles, largest first. */
+    tiles: TreemapTile[];
+    /** Whether the tiles nest: two dimensions, `parent` outside `category`. */
+    nested: boolean;
+    /**
+     * How many rows have no area to draw: a number that is not above zero —
+     * a sum that came out negative, a group with nothing — which no tile can
+     * be the size of. They stay in the reading table and in the table, and a
+     * drawing says how many it left out rather than lying about the whole.
+     */
+    omitted: number;
+}
+/**
+ * A treemap's tiles: one per row, sized by its number; with a `parent`,
+ * gathered into one outer tile per parent value in the order the values
+ * first come. Every level is laid out largest first, which is how a tiling
+ * reads (the biggest in the corner the eye starts at) and the order the
+ * reading table lists them in, so the two agree.
+ */
+export declare function shapeTreemap(spec: TreemapSpec, rows: readonly RecordData[]): TreemapData;
+//# sourceMappingURL=treemap.d.ts.map

package/dist/analysis/treemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treemap.d.ts","sourceRoot":"","sources":["../../src/analysis/treemap.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGjE;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,2CAA2C;IAC3C,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,2EAA2E;IAC3E,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,2EAA2E;IAC3E,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,WAAW,CAuCb"}

package/dist/analysis/validate.d.ts

@@ -0,0 +1,19 @@
+import { AnalysisViewConfig, DataViewDefinition, Issue, RuntimeLimits } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+export interface ValidateAnalysisOptions {
+    limits?: RuntimeLimits;
+}
+/**
+ * Admits an analysis config against its definition.
+ *
+ * Every rule here mirrors one the Wow aggregation factories enforce by
+ * throwing. Checking them first turns a crash during compilation into a
+ * fixable issue on the配置.
+ *
+ * This file is the order the rule sets run in; each set lives in its own file
+ * beside it — the skeleton, the tree budget shared by expressions and having,
+ * aliases, the element domain, groups, metrics, having, sort with columns,
+ * and the declared limits.
+ */
+export declare function validateAnalysis(definition: DataViewDefinition, config: AnalysisViewConfig, kinds: FieldKindRegistry, options?: ValidateAnalysisOptions): Issue[];
+//# sourceMappingURL=validate.d.ts.map

package/dist/analysis/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/analysis/validate.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,KAAK,EACV,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAc5B,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,iBAAiB,EACxB,OAAO,GAAE,uBAA4B,GACpC,KAAK,EAAE,CAmCT"}

package/dist/analysis/validateAliases.d.ts

@@ -0,0 +1,16 @@
+import { AnalysisViewConfig, Issue, IssuePath } from '../model/index.js';
+/** The alias sets the having and sort rules address their config by. */
+export declare function aliasesOf(config: AnalysisViewConfig): {
+    groups: Set<string>;
+    metrics: Set<string>;
+    nonAnyMetrics: Set<string>;
+};
+export declare function validateAliases(config: AnalysisViewConfig): Issue[];
+/**
+ * A display name is optional, and given it is a word: a blank one would
+ * head a column with nothing, which reads as a header that failed to load.
+ */
+export declare function displayNameIssues(entry: {
+    label?: unknown;
+}, path: IssuePath): Issue[];
+//# sourceMappingURL=validateAliases.d.ts.map

package/dist/analysis/validateAliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateAliases.d.ts","sourceRoot":"","sources":["../../src/analysis/validateAliases.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,KAAK,EACV,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAgB3B,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,MAAM,EAAE,kBAAkB;;;;EAUnD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,kBAAkB,GAAG,KAAK,EAAE,CAsBnE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,EAC1B,IAAI,EAAE,SAAS,GACd,KAAK,EAAE,CAOT"}

package/dist/analysis/validateChart.d.ts

@@ -0,0 +1,60 @@
+import { AnalysisDerivedExpression, AnalysisMetric, AnalysisViewConfig, Issue } from '../model/index.js';
+/**
+ * Metrics the projection may add up across rows: a pie's "other" slice and a
+ * metric card's trend headline are both sums of queried buckets, which only
+ * means something for a metric that adds. AVG, MIN, MAX, DISTINCT_COUNT and a
+ * percentile cannot be re-aggregated from their parts. A funnel's stages are
+ * counts of what entered and remained, so they are these too.
+ */
+export declare function isAdditiveMetric(metric: AnalysisMetric | undefined): boolean;
+/**
+ * Whether a metric's number over any span is read off sums over that span
+ * (D38): one that adds, or a derived metric computed from such metrics and
+ * numbers alone — 客单价 = GMV ÷ 订单数. The source computes a derived metric
+ * from each row's own operands, so a bucket's is its own sums divided and
+ * the whole's the whole's sums divided — which is what a metric card's
+ * trend and its whole need, though the ratios themselves never add.
+ * `metricOf` finds an operand by alias.
+ */
+export declare function readsOffSums(metric: AnalysisMetric | undefined, metricOf: (alias: string) => AnalysisMetric | undefined, through?: ReadonlySet<string>): boolean;
+/** Every metric a derived expression names, left to right. */
+export declare function derivedOperands(expression: AnalysisDerivedExpression): string[];
+/**
+ * Whether a saved colour is one the renderer may pass on. A chart colour
+ * reaches the page as a colour — the drawing is handed it made concrete, the
+ * legend's dot wears it as a style — so a config from a store gets to name a
+ * colour and nothing else. The renderer applies the same predicate and falls
+ * back to the palette, so an unvalidated spec draws in a slot rather than in
+ * whatever it said.
+ *
+ * Two shapes pass. A `var(--slot)` reference, which is how this package's own
+ * palette is written and which no parser resolves; and anything `culori`
+ * parses, which decides validity rather than a character class: a named
+ * colour (case-insensitively, as CSS reads them), `#rgb` through `#rrggbbaa`,
+ * `rgb()`/`rgba()`, `hsl()`/`hsla()`, `lab()`, `lch()`, `oklab()`, `oklch()`
+ * and `color()` over the spaces the registered modes name — `srgb`,
+ * `display-p3` and the rest. A spelling outside that set is refused even
+ * where it would have painted, `currentcolor` among them; the hand-written
+ * regexes this replaced did the opposite, taking `banana`, `rgb(foo)` and
+ * `color(nope)` for colours and leaving the series they named unpainted.
+ */
+export declare function isChartColor(value: unknown): value is string;
+/**
+ * Charts reference aliases, so their rules are about what the query actually
+ * produces. The strictest one is that a chart must consume every group: an
+ * unconsumed dimension leaves several rows per coordinate, and AVG, percentile
+ * and DISTINCT_COUNT cannot be re-aggregated over them in the projection.
+ *
+ * `moments` are the metrics whose value is a moment (`momentMetrics`): a
+ * slot a mark measures refuses one (`chart.metric.moment`), and so does a
+ * card's comparison, target and number format over one. `validateAnalysis`
+ * passes them from the scope; left out, nothing is a moment.
+ *
+ * These are the rules of a chart that is drawn: `validateAnalysis` asks
+ * them only while the layout is the chart and its type can draw the shape
+ * (D20; `chartUnfit`). A finding names a group or a metric by its alias, in
+ * `alias` or `metric`, because an alias is all this layer has; a surface
+ * says it as the column is headed (`analysisIssueNamer` in `/ui`).
+ */
+export declare function validateChart(config: AnalysisViewConfig, moments?: ReadonlySet<string>): Issue[];
+//# sourceMappingURL=validateChart.d.ts.map

package/dist/analysis/validateChart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateChart.d.ts","sourceRoot":"","sources":["../../src/analysis/validateChart.ts"],"names":[],"mappings":"AA0BA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,kBAAkB,EAGvB,KAAK,KAAK,EAEX,MAAM,mBAAmB,CAAC;AAmB3B;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,OAAO,CAI5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,GAAG,SAAS,EAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,EACvD,OAAO,GAAE,WAAW,CAAC,MAAM,CAAa,GACvC,OAAO,CAOT;AAED,8DAA8D;AAC9D,wBAAgB,eAAe,CAC7B,UAAU,EAAE,yBAAyB,GACpC,MAAM,EAAE,CAYV;AAmBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAI5D;AAkBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,GAAE,WAAW,CAAC,MAAM,CAAa,GACvC,KAAK,EAAE,CAqBT"}

package/dist/analysis/validateElements.d.ts

@@ -0,0 +1,20 @@
+import { AnalysisViewConfig, Issue, RuntimeLimits } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { AnalysisScope } from './capability.js';
+/**
+ * Admits the expansion chain.
+ *
+ * Wow's `elements` is one ordered parent-to-child walk, so a config may only
+ * follow the chain the capability declares, from its first level down, and
+ * stop wherever it likes. Two ways to get it wrong, and they are different
+ * mistakes: a path the chain never mentions, and one it does mention but at
+ * another depth — an inner array expanded without the array that holds it, or
+ * two levels swapped. The second is what a list of sibling arrays used to
+ * look like, and it is the one Wow answers with "requires its declared
+ * element scope" rather than "unknown field".
+ *
+ * The first entry that breaks the chain ends the scope, so nothing below it
+ * is judged against fields the expansion never reached.
+ */
+export declare function validateElements(config: AnalysisViewConfig, scope: AnalysisScope, kinds: FieldKindRegistry, limits: RuntimeLimits): Issue[];
+//# sourceMappingURL=validateElements.d.ts.map

package/dist/analysis/validateElements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateElements.d.ts","sourceRoot":"","sources":["../../src/analysis/validateElements.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,kBAAkB,EAClB,KAAK,EAEL,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAS,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAC;AAGzB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,aAAa,GACpB,KAAK,EAAE,CAkCT"}

package/dist/analysis/validateGroups.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeLimits, AnalysisCapability, AnalysisViewConfig, Issue } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { AnalysisScope } from './capability.js';
+export declare function validateGroups(config: AnalysisViewConfig, scope: AnalysisScope, kinds: FieldKindRegistry, analysis?: Pick<AnalysisCapability, 'dense' | 'expressions' | 'dateDiffUnits'>, limits?: RuntimeLimits): Issue[];
+//# sourceMappingURL=validateGroups.d.ts.map

package/dist/analysis/validateGroups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateGroups.d.ts","sourceRoot":"","sources":["../../src/analysis/validateGroups.ts"],"names":[],"mappings":"AAaA,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,KAAK,EAEX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAS,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKvE,wBAAgB,cAAc,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,iBAAiB,EACxB,QAAQ,CAAC,EAAE,IAAI,CACb,kBAAkB,EAClB,OAAO,GAAG,aAAa,GAAG,eAAe,CAC1C,EACD,MAAM,GAAE,aAAsC,GAC7C,KAAK,EAAE,CAuHT"}

package/dist/analysis/validateHaving.d.ts

@@ -0,0 +1,9 @@
+import { AnalysisViewConfig, DataViewDefinition, Issue, RuntimeLimits } from '../model/index.js';
+export declare function validateHaving(config: AnalysisViewConfig, capability: NonNullable<DataViewDefinition['analysis']>, limits: RuntimeLimits, 
+/**
+ * The metrics that are moments (`momentMetrics`). A having compares a
+ * metric with a number, and the earliest of a date is no number anybody
+ * types, so it is refused as a sample value is.
+ */
+moments?: ReadonlySet<string>): Issue[];
+//# sourceMappingURL=validateHaving.d.ts.map

package/dist/analysis/validateHaving.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateHaving.d.ts","sourceRoot":"","sources":["../../src/analysis/validateHaving.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAEV,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,EAEL,aAAa,EACd,MAAM,mBAAmB,CAAC;AAK3B,wBAAgB,cAAc,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,WAAW,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,EACvD,MAAM,EAAE,aAAa;AACrB;;;;GAIG;AACH,OAAO,GAAE,WAAW,CAAC,MAAM,CAAa,GACvC,KAAK,EAAE,CA8DT"}

package/dist/analysis/validateLevels.d.ts

@@ -0,0 +1,33 @@
+import { AnalysisViewConfig, Issue } from '../model/index.js';
+import { ChartContext } from './chartRefs.js';
+/**
+ * A candle is four numbers of one field over one period (N1): its one
+ * dimension is a date bucket, and its four slots the opening value, the
+ * highest, the lowest and the closing value of one field under one
+ * condition (`isOhlcSet`), each a quantity the result has.
+ */
+export declare function candlestickIssues(context: ChartContext, config: AnalysisViewConfig): Issue[];
+/**
+ * A map shades regions: its one dimension names them (`TERMS`), a bucket of
+ * a scale names none; its shade a quantity the result has; the map it names,
+ * when it names one, is a name.
+ */
+export declare function mapIssues(context: ChartContext, config: AnalysisViewConfig): Issue[];
+/**
+ * A calendar lays out days: its one dimension is a date bucket by day, and
+ * its shade a quantity the result has.
+ */
+export declare function calendarIssues(context: ChartContext, config: AnalysisViewConfig): Issue[];
+/**
+ * A theme river runs along a date bucket, its streams the values of the
+ * other dimension, their widths a metric that adds up — the streams are
+ * stacked into one river.
+ */
+export declare function themeRiverIssues(context: ChartContext, config: AnalysisViewConfig): Issue[];
+/**
+ * A sunburst, a tree or a sankey: two to `MAX_CHART_LEVELS` levels, each a
+ * dimension the result has, none twice, every dimension one of them; and a
+ * size that adds up — a parent is its parts' sum, a node its bands'.
+ */
+export declare function levelled(context: ChartContext): Issue[];
+//# sourceMappingURL=validateLevels.d.ts.map

package/dist/analysis/validateLevels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateLevels.d.ts","sourceRoot":"","sources":["../../src/analysis/validateLevels.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,KAAK,EAEX,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAA+B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAIhF;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,kBAAkB,GACzB,KAAK,EAAE,CAmBT;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,kBAAkB,GACzB,KAAK,EAAE,CAgBT;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,kBAAkB,GACzB,KAAK,EAAE,CAWT;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,kBAAkB,GACzB,KAAK,EAAE,CA0BT;AAwBD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,KAAK,EAAE,CAyBvD"}

package/dist/analysis/validateLimits.d.ts

@@ -0,0 +1,3 @@
+import { AnalysisViewConfig, DataViewDefinition, Issue, RuntimeLimits } from '../model/index.js';
+export declare function validateLimits(config: AnalysisViewConfig, capability: NonNullable<DataViewDefinition['analysis']>, limits: RuntimeLimits): Issue[];
+//# sourceMappingURL=validateLimits.d.ts.map

package/dist/analysis/validateLimits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateLimits.d.ts","sourceRoot":"","sources":["../../src/analysis/validateLimits.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,EAEL,aAAa,EACd,MAAM,mBAAmB,CAAC;AAI3B,wBAAgB,cAAc,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,WAAW,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,EACvD,MAAM,EAAE,aAAa,GACpB,KAAK,EAAE,CAuDT"}

package/dist/analysis/validateMetrics.d.ts

@@ -0,0 +1,5 @@
+import { AnalysisViewConfig, DataViewDefinition, Issue, RuntimeLimits } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { AnalysisScope } from './capability.js';
+export declare function validateMetrics(config: AnalysisViewConfig, capability: NonNullable<DataViewDefinition['analysis']>, scope: AnalysisScope, kinds: FieldKindRegistry, limits: RuntimeLimits): Issue[];
+//# sourceMappingURL=validateMetrics.d.ts.map

package/dist/analysis/validateMetrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateMetrics.d.ts","sourceRoot":"","sources":["../../src/analysis/validateMetrics.ts"],"names":[],"mappings":"AAaA,OAAO,EAOL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EAEvB,KAAK,KAAK,EAEV,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAC;AAgBzB,wBAAgB,eAAe,CAC7B,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,WAAW,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,EACvD,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,aAAa,GACpB,KAAK,EAAE,CAkOT"}

package/dist/analysis/validateOffers.d.ts

@@ -0,0 +1,12 @@
+import { AnalysisCapability, DataViewDefinition, Issue } from '../model/index.js';
+/**
+ * What each field of an analysis capability offers, held to the fields it
+ * names: a root entry must name a declared field — an aggregation over a
+ * name the definition never declared resolves to nothing — and a field
+ * offering `DATE_PART` must hold time, which a calendar part is read off
+ * (Wow's `AGGREGATE_TEMPORAL`), with only the parts Wow has. An element's
+ * unknown fields are the chain's finding (`validateElementChain`); its date
+ * parts are checked here too.
+ */
+export declare function offerIssues(definition: DataViewDefinition, capability: AnalysisCapability): Issue[];
+//# sourceMappingURL=validateOffers.d.ts.map

package/dist/analysis/validateOffers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateOffers.d.ts","sourceRoot":"","sources":["../../src/analysis/validateOffers.ts"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EAEvB,KAAK,KAAK,EAEX,MAAM,mBAAmB,CAAC;AAG3B;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,UAAU,EAAE,kBAAkB,EAC9B,UAAU,EAAE,kBAAkB,GAC7B,KAAK,EAAE,CA4BT"}

package/dist/analysis/validateReferences.d.ts

@@ -0,0 +1,16 @@
+import { CartesianSpec, Issue, IssuePath } from '../model/index.js';
+/**
+ * What a cartesian chart draws over its marks, checked for shape (D33
+ * batch B): every reference line and band hangs on an axis that has a
+ * series, a line stands at a number or at a statistic of a metric drawn on
+ * its axis, a band runs from a number up to a larger one, and a derived
+ * series is a known kind over a metric drawn, a moving average over a
+ * window of two points or more.
+ *
+ * What depends on the rows — a running total over rows cut short, a
+ * statistic over a split — is no finding here: the config is sound, the
+ * result is not whole, and the kernel leaves the line out and says why
+ * (`derivedGap`, `placeLines`).
+ */
+export declare function referenceIssues(spec: CartesianSpec, path: IssuePath): Issue[];
+//# sourceMappingURL=validateReferences.d.ts.map

package/dist/analysis/validateReferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateReferences.d.ts","sourceRoot":"","sources":["../../src/analysis/validateReferences.ts"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,KAAK,EACV,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAG3B;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,GAAG,KAAK,EAAE,CAqE7E"}

package/dist/analysis/validateShape.d.ts

@@ -0,0 +1,14 @@
+import { AnalysisViewConfig, Issue } from '../model/index.js';
+/**
+ * Whether the config has the skeleton every other rule reads through.
+ *
+ * A config arrives from a store, so any container may be missing or of the
+ * wrong kind — `groups` a string, `chart` absent, an alias a number. The rules
+ * index into them without looking (`groups.map`, `alias.includes`,
+ * `CHART_FAMILY[chart.type]`), so each wrong piece is named here with its
+ * path, and the caller stops before anything walks it. This is the analysis
+ * counterpart of the filter budget: the kernel's contract is an Issue out,
+ * never a TypeError.
+ */
+export declare function validateShape(config: AnalysisViewConfig): Issue[];
+//# sourceMappingURL=validateShape.d.ts.map

package/dist/analysis/validateShape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateShape.d.ts","sourceRoot":"","sources":["../../src/analysis/validateShape.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAa,MAAM,mBAAmB,CAAC;AAO9E;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,kBAAkB,GAAG,KAAK,EAAE,CAiCjE"}

package/dist/analysis/validateSort.d.ts

@@ -0,0 +1,3 @@
+import { AnalysisCapability, AnalysisViewConfig, Issue } from '../model/index.js';
+export declare function validateSortAndColumns(config: AnalysisViewConfig, analysis?: Pick<AnalysisCapability, 'metricSort'>): Issue[];
+//# sourceMappingURL=validateSort.d.ts.map

package/dist/analysis/validateSort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSort.d.ts","sourceRoot":"","sources":["../../src/analysis/validateSort.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,EAEN,MAAM,mBAAmB,CAAC;AAI3B,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC,GAChD,KAAK,EAAE,CA6CT"}

package/dist/analysis/waterfall.d.ts

@@ -0,0 +1,33 @@
+import { AnalysisViewConfig, RecordData, WaterfallSpec } from '../model/index.js';
+/** One step of a waterfall: its group, its change, and where it floats. */
+export interface WaterfallStep {
+    /** The group value the step stands for. */
+    x: unknown;
+    /** The change the step brings, as its row measured it. */
+    value: number;
+    /** The running total before the step. */
+    start: number;
+    /** The running total after it: `start + value`. */
+    end: number;
+}
+export interface WaterfallData {
+    type: 'waterfall';
+    steps: WaterfallStep[];
+    /**
+     * The total the steps arrive at, drawn as the closing bar from zero —
+     * left out when the spec asked for none (`WaterfallSpec.total`). It is
+     * the sum of the steps drawn, so the chart closes on itself; over rows
+     * cut short it is the total of the groups shown, which a drawing says.
+     */
+    total?: number;
+}
+/**
+ * A waterfall's steps, each its row's number and the running total it
+ * starts and ends at, from zero. A step over time runs earliest first, as
+ * every time axis does; any other dimension keeps the rows' order, which is
+ * the view's sort — the steps are read in that order, so it is the
+ * analyst's. A period the rows lack is no step: nothing changed in it that
+ * the rows know of, and a 0 written in would say what the query did not.
+ */
+export declare function shapeWaterfall(spec: WaterfallSpec, config: AnalysisViewConfig, rows: readonly RecordData[]): WaterfallData;
+//# sourceMappingURL=waterfall.d.ts.map

package/dist/analysis/waterfall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waterfall.d.ts","sourceRoot":"","sources":["../../src/analysis/waterfall.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,kBAAkB,EAClB,UAAU,EACV,aAAa,EACd,MAAM,mBAAmB,CAAC;AAI3B,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,CAAC,EAAE,OAAO,CAAC;IACX,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,aAAa,CAgBf"}

package/dist/capabilities/aliases.d.ts

@@ -0,0 +1,36 @@
+import { ViewInstance, DataViewConfig, RecordViewConfig } from '../model/index.js';
+/**
+ * A config with every field it names by an alias renamed to the field's
+ * canonical path (#3519): the source answers, projects and reports under
+ * the canonical path, so a view has to ask by it to read what comes back.
+ * Returns the config itself when it names no alias.
+ *
+ * What is renamed is what names a root field: conditions (their own and a
+ * metric's), the sort, the columns and cards, the summaries, an analysis's
+ * dimensions, metrics and expanded paths. A condition inside an element's
+ * predicate names the element's own fields and is left as it is.
+ */
+export declare function withCanonicalNames<C extends DataViewConfig>(config: C, renamed: Readonly<Record<string, string>>): C;
+/**
+ * A definition's starting record config (`record.defaults`, a partial one)
+ * with every field it names by an alias renamed to the path, as a saved
+ * config is read (`withCanonicalNames`): a view created from it asks by the
+ * path from the start. Returns the defaults themselves when they name no
+ * alias.
+ */
+export declare function withCanonicalDefaults(defaults: Partial<RecordViewConfig>, renamed: Readonly<Record<string, string>>): Partial<RecordViewConfig>;
+/**
+ * A view's draft, applied config and saved baseline under the paths a
+ * narrowing renames aliases to, as a patch; `null` when nothing names an
+ * alias. The baseline moves with them, so the view is not left dirty.
+ */
+export declare function withCanonicalState<C extends DataViewConfig>(state: {
+    draft: C;
+    applied: C;
+    saved: ViewInstance | null;
+}, renamed: Readonly<Record<string, string>>): {
+    draft: C;
+    applied: C;
+    saved?: ViewInstance;
+} | null;
+//# sourceMappingURL=aliases.d.ts.map

package/dist/capabilities/aliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aliases.d.ts","sourceRoot":"","sources":["../../src/capabilities/aliases.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,YAAY,EAIjB,KAAK,cAAc,EAGnB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAG3B;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,cAAc,EACzD,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACxC,CAAC,CAiCH;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,OAAO,CAAC,gBAAgB,CAAC,EACnC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACxC,OAAO,CAAC,gBAAgB,CAAC,CAI3B;AAoHD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,cAAc,EACzD,KAAK,EAAE;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAA;CAAE,EAC3D,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACxC;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,YAAY,CAAA;CAAE,GAAG,IAAI,CAqBvD"}

package/dist/capabilities/analysis.d.ts

@@ -0,0 +1,19 @@
+import { QueryModelDescriptor } from '@ahoo-wang/wow-client';
+import { AnalysisCapability, Issue } from '../model/index.js';
+/**
+ * The analysis capability as the descriptor admits it (capabilities.md
+ * 4.4): each field's groups, date units and functions cut to what its
+ * path and the model feed, a
+ * metric type the model does not offer taken off every field, an element
+ * the model cannot aggregate over taken away, and the aggregation sizes
+ * lowered to the entry's.
+ *
+ * `undefined` when not one metric is left to start from. That is a
+ * deployment offering less, not a definition written wrong — admission's
+ * `definition.analysis.no-metric` is the error for that — so it is a
+ * warning, and the definition runs on without analyses.
+ */
+export declare function narrowAnalysis(capability: AnalysisCapability, descriptor: QueryModelDescriptor, findings: Issue[]): AnalysisCapability | undefined;
+/** Whether an analysis can start from anything: the count, or one metric of one field. */
+export declare function constructible(capability: AnalysisCapability): boolean;
+//# sourceMappingURL=analysis.d.ts.map

package/dist/capabilities/analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.d.ts","sourceRoot":"","sources":["../../src/capabilities/analysis.ts"],"names":[],"mappings":"AAaA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAKL,KAAK,kBAAkB,EAGvB,KAAK,KAAK,EAEX,MAAM,mBAAmB,CAAC;AAK3B;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,kBAAkB,EAC9B,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,EAAE,GAChB,kBAAkB,GAAG,SAAS,CAsEhC;AAgQD,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAcrE"}

package/dist/capabilities/cache.d.ts

@@ -0,0 +1,69 @@
+import { QueryDescriptorResult, QueryModelDescriptor } from '@ahoo-wang/wow-client';
+/**
+ * Reads one source's descriptor, sending the version already held so an
+ * unchanged one answers `notModified` without a body — the shape of
+ * wow-client's `describeSnapshot` and `describeEventStream`.
+ */
+export type Describe = (previous?: string) => Promise<QueryDescriptorResult>;
+/**
+ * How old a descriptor may be before a trigger checks it again: the
+ * service's own default revalidation interval
+ * (`wow.query.schema.revalidate-interval`), so a check never runs more
+ * often than the answer can change.
+ */
+export declare const DESCRIPTOR_MAX_AGE_MS: number;
+/**
+ * How long the first view over a source waits for its descriptor before it
+ * opens on the definition as declared (capabilities.md 6「取不到时」). A
+ * service that takes the connection and never answers would otherwise hold
+ * the opening for ever; the read goes on, and narrows the view when it lands.
+ */
+export declare const DESCRIBE_DEADLINE_MS: number;
+export interface DescriptorCacheOptions {
+    /** Milliseconds since the epoch; the runtime environment's clock. */
+    now(): number;
+    /**
+     * Told when a source's descriptor is read for the first time and whenever
+     * its version changes — what the views over it run on has changed.
+     */
+    changed?(key: string, descriptor: QueryModelDescriptor): void;
+    /** Told when reading a source's descriptor failed; what was held is kept. */
+    failed?(key: string, error: unknown): void;
+    maxAge?: number;
+}
+/**
+ * One descriptor per source key (capabilities.md 6): a board of ten panels
+ * over one source reads it once, and reads asked for at the same moment
+ * share one request. It is never persisted — a descriptor belongs to the
+ * deployment, not to anyone's saved work — and a read that fails keeps
+ * whatever was held and is tried again at the next trigger past the
+ * maximum age.
+ *
+ * The last answer wins. Replicas may briefly disagree on the version; the
+ * cache does not compare them, and the worst case is one extra narrowing.
+ */
+export declare class DescriptorCache {
+    private readonly options;
+    private readonly entries;
+    constructor(options: DescriptorCacheOptions);
+    /** The descriptor held for a source, or `null` when none has been read. */
+    current(key: string): QueryModelDescriptor | null;
+    /**
+     * The source's descriptor. The first time, it is read and waited for, so
+     * the first query already goes out narrowed; after that the one held is
+     * answered at once, and checked again in the background once it is older
+     * than the maximum age. `null` while none could be read.
+     */
+    load(key: string, describe: Describe): Promise<QueryModelDescriptor | null>;
+    /**
+     * Checks a source's descriptor again when it is older than the maximum
+     * age, or at once when `force`d. A check already in flight is joined,
+     * never doubled.
+     */
+    revalidate(key: string, force?: boolean): Promise<void>;
+    /** Every source whose descriptor is older than the maximum age, checked again. */
+    revalidateStale(): void;
+    private stale;
+    private check;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/capabilities/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/capabilities/cache.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAE/B;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAE7E;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAgB,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,QAAY,CAAC;AAE9C,MAAM,WAAW,sBAAsB;IACrC,qEAAqE;IACrE,GAAG,IAAI,MAAM,CAAC;IACd;;;OAGG;IACH,OAAO,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC9D,6EAA6E;IAC7E,MAAM,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAUD;;;;;;;;;;GAUG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4B;gBAExC,OAAO,EAAE,sBAAsB;IAI3C,2EAA2E;IAC3E,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI;IAIjD;;;;;OAKG;IACG,IAAI,CACR,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAWvC;;;;OAIG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAQrD,kFAAkF;IAClF,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,KAAK;IAMb,OAAO,CAAC,KAAK;CAoBd"}