@kanzo-tech/ui 0.0.1-alpha

package/dist/charts/id-set-client.js

@@ -0,0 +1,43 @@
+var o = (t) => {
+  throw TypeError(t);
+};
+var n = (t, r, e) => r.has(t) || o("Cannot " + e);
+var i = (t, r, e) => (n(t, r, "read from private field"), e ? e.call(t) : r.get(t)), l = (t, r, e) => r.has(t) ? o("Cannot add the same private member more than once") : r instanceof WeakSet ? r.add(t) : r.set(t, e), u = (t, r, e, c) => (n(t, r, "write to private field"), c ? c.call(t, e) : r.set(t, e), e);
+import { MosaicClient as d, clausePoints as f } from "@uwdata/mosaic-core";
+import { Query as p } from "@uwdata/mosaic-sql";
+import { column as y } from "./arrow.js";
+var h, s, m, a;
+class w extends d {
+  constructor(e) {
+    super(e.filterBy);
+    l(this, h);
+    l(this, s);
+    l(this, m);
+    l(this, a);
+    u(this, h, e.table), u(this, s, e.idField), u(this, m, e.as), u(this, a, e.onSurvivors);
+  }
+  query(e = []) {
+    return p.from(i(this, h)).select({ id: i(this, s) }).where(e);
+  }
+  queryResult(e) {
+    return i(this, a).call(this, y(e, "id")), this;
+  }
+  /** `null` retracts the selection: an empty clause has a null predicate, which the resolver drops. */
+  publish(e) {
+    i(this, m).update(
+      f([i(this, s)], e == null ? void 0 : e.map((c) => [c]), {
+        source: this,
+        // A crossfilter normally exempts a client from its own clause, so a brush can be widened
+        // after it has collapsed the chart under it. A view that FADES an excluded row instead of
+        // removing it does not need the exemption: the row is still on screen and still
+        // selectable. Declining it is what makes the selection visible — the fade is the brush.
+        clients: /* @__PURE__ */ new Set()
+      })
+    );
+  }
+}
+h = new WeakMap(), s = new WeakMap(), m = new WeakMap(), a = new WeakMap();
+export {
+  w as IdSetClient
+};
+//# sourceMappingURL=id-set-client.js.map

package/dist/charts/id-set-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-set-client.js","sources":["../../src/charts/id-set-client.ts"],"sourcesContent":["import { MosaicClient, clausePoints, type Selection } from \"@uwdata/mosaic-core\";\nimport { Query, type FilterExpr } from \"@uwdata/mosaic-sql\";\nimport { column } from \"./arrow.js\";\n\n/**\n * The crossfilter adapter for a view whose positions are not in the database.\n *\n * A `MosaicClient` asks for two things, and this is both:\n *\n *   `query(filter)` — which rows survive the page's filters? The coordinator answers with a column\n *     of ids, and the view fades everything else. The **observable** half.\n *   `publish(ids)` — the user selected these. A points clause, `id IN (…)`, which every other chart\n *     on the page filters by. The **controllable** half.\n *\n * The id list is not a shortcut, it is the only thing such a view can say. A Plot brush publishes\n * `weight BETWEEN …`, an interval in data space, because Plot's `x` IS a column. A GPU simulation's\n * `x` exists nowhere in the database, so no predicate over columns can describe the loop the user\n * drew. Enumerating what was hit is the honest translation — and its cost is the length of the `IN`\n * list, which is the real ceiling on the whole approach.\n *\n * Nothing here knows what draws. It is named for what it exchanges rather than for the renderer it\n * was first written against, because a canvas, a map and an imperative widget all reach the\n * crossfilter through exactly this shape.\n */\n\nexport interface IdSetClientOptions {\n  /** The relation. Its `idField` column is what gets published and matched. */\n  table: string;\n  idField: string;\n  /** What the view fades by. */\n  filterBy: Selection;\n  /** Where the selection publishes. */\n  as: Selection;\n  /** The surviving ids, in relation order, on every filter change. */\n  onSurvivors: (ids: readonly unknown[]) => void;\n}\n\nexport class IdSetClient extends MosaicClient {\n  #table: string;\n  #idField: string;\n  #as: Selection;\n  #emit: (ids: readonly unknown[]) => void;\n\n  constructor(options: IdSetClientOptions) {\n    super(options.filterBy);\n    this.#table = options.table;\n    this.#idField = options.idField;\n    this.#as = options.as;\n    this.#emit = options.onSurvivors;\n  }\n\n  override query(filter: FilterExpr = []) {\n    return Query.from(this.#table).select({ id: this.#idField }).where(filter);\n  }\n\n  override queryResult(data: unknown): this {\n    this.#emit(column(data, \"id\"));\n    return this;\n  }\n\n  /** `null` retracts the selection: an empty clause has a null predicate, which the resolver drops. */\n  publish(ids: readonly unknown[] | null): void {\n    this.#as.update(\n      clausePoints([this.#idField], ids?.map((id) => [id]), {\n        source: this,\n        // A crossfilter normally exempts a client from its own clause, so a brush can be widened\n        // after it has collapsed the chart under it. A view that FADES an excluded row instead of\n        // removing it does not need the exemption: the row is still on screen and still\n        // selectable. Declining it is what makes the selection visible — the fade is the brush.\n        clients: new Set<MosaicClient>(),\n      }),\n    );\n  }\n}\n"],"names":["IdSetClient","MosaicClient","options","__privateAdd","_table","_idField","_as","_emit","__privateSet","filter","Query","__privateGet","data","column","ids","clausePoints","id"],"mappings":";;;;;;;;;AAqCO,MAAMA,UAAoBC,EAAa;AAAA,EAM5C,YAAYC,GAA6B;AACvC,UAAMA,EAAQ,QAAQ;AANxB,IAAAC,EAAA,MAAAC;AACA,IAAAD,EAAA,MAAAE;AACA,IAAAF,EAAA,MAAAG;AACA,IAAAH,EAAA,MAAAI;AAIE,IAAAC,EAAA,MAAKJ,GAASF,EAAQ,QACtBM,EAAA,MAAKH,GAAWH,EAAQ,UACxBM,EAAA,MAAKF,GAAMJ,EAAQ,KACnBM,EAAA,MAAKD,GAAQL,EAAQ;AAAA,EACvB;AAAA,EAES,MAAMO,IAAqB,IAAI;AACtC,WAAOC,EAAM,KAAKC,EAAA,MAAKP,EAAM,EAAE,OAAO,EAAE,IAAIO,EAAA,MAAKN,GAAA,CAAU,EAAE,MAAMI,CAAM;AAAA,EAC3E;AAAA,EAES,YAAYG,GAAqB;AACxC,WAAAD,EAAA,MAAKJ,GAAL,WAAWM,EAAOD,GAAM,IAAI,IACrB;AAAA,EACT;AAAA;AAAA,EAGA,QAAQE,GAAsC;AAC5C,IAAAH,EAAA,MAAKL,GAAI;AAAA,MACPS,EAAa,CAACJ,EAAA,MAAKN,EAAQ,GAAGS,KAAA,gBAAAA,EAAK,IAAI,CAACE,MAAO,CAACA,CAAE,IAAI;AAAA,QACpD,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,QAKR,6BAAa,IAAA;AAAA,MAAkB,CAChC;AAAA,IAAA;AAAA,EAEL;AACF;AAnCEZ,IAAA,eACAC,IAAA,eACAC,IAAA,eACAC,IAAA;"}

package/dist/charts/mosaic-provider.d.ts

@@ -0,0 +1,70 @@
+import { ReactNode } from 'react';
+import { Selection, Coordinator } from '@uwdata/mosaic-core';
+/**
+ * MosaicProvider — the crossfilter context every chart on this subpath reads from.
+ *
+ * **Bring-your-own coordinator**, the way CodeEditor is bring-your-own-language. The package
+ * never instantiates a `Coordinator` and never imports DuckDB-WASM: the consumer builds the
+ * coordinator over their own backend (`wasmConnector()` + `new Coordinator(connector)`, a
+ * socket/REST connector, a shared worker…) and passes it in. That single decision is what keeps
+ * DuckDB-WASM out of the library bundle and out of any React Server Component — the whole boot
+ * lives in the consumer's `"use client"` island.
+ *
+ * The provider does two things: it registers the caller's coordinator as vgplot's active one, so
+ * `vg.plot(...)` marks resolve their queries through it, and it hands every descendant chart a
+ * shared `Selection.crossfilter()` so brushing one chart filters the others.
+ */
+export interface MosaicContextValue {
+    /** The caller-supplied coordinator. Also registered as vgplot's active coordinator. */
+    coordinator: Coordinator;
+    /** The shared crossfilter selection every chart **filters by**. */
+    crossfilter: Selection;
+    /**
+     * Every clause published by any chart on the page, flattened into one plain union — the page-wide
+     * read model, for a filter-chip row or a readout. Relayed into `crossfilter`.
+     *
+     * It is **not** what a chart highlights by: a page-wide selection names columns other charts
+     * group by, and that is a binder error waiting to happen (see `chart-root`). Charts publish into
+     * a selection of their own, which converges here.
+     */
+    selected: Selection;
+    /**
+     * Enrols a selection in `reset()`. With `relay` (what `ChartRoot` does for the selection it owns)
+     * the selection's clauses are also forwarded into `selected`, and from there into `crossfilter`.
+     * Returns the unregister.
+     */
+    registerSelection: (selection: Selection, options?: {
+        relay?: boolean;
+    }) => () => void;
+    /**
+     * Clears every clause on the page — the shared selections **and** every registered chart
+     * selection. `Selection.reset()` travels downstream only, so resetting `crossfilter` alone leaves
+     * each chart holding its own pick; this is the call a "Clear filters" button wants.
+     */
+    reset: () => void;
+}
+export interface MosaicProviderProps {
+    /**
+     * The Mosaic `Coordinator`, constructed by the caller over their own DuckDB / connector.
+     * The package never builds one — see the module note.
+     */
+    coordinator: Coordinator;
+    /**
+     * The crossfilter `Selection` every descendant chart filters by. Defaults to a fresh
+     * `Selection.crossfilter()`. Pass one to share a selection across trees or to seed a predicate;
+     * everything below still works, because the provider relays into it rather than constructing it.
+     */
+    crossfilter?: Selection;
+    children: ReactNode;
+}
+export declare function MosaicProvider({ coordinator, crossfilter, children }: MosaicProviderProps): import("react").JSX.Element;
+/** The Mosaic context — coordinator, shared selections, `registerSelection` and `reset`. */
+export declare function useMosaic(): MosaicContextValue;
+/** The shared crossfilter `Selection` — what a chart's marks filter by. */
+export declare function useCrossfilter(): Selection;
+/**
+ * Every chart clause on the page in one plain union — a read model, not a publish target. To clear
+ * the page use `useMosaic().reset()`: a reset here never reaches the per-chart selections upstream.
+ */
+export declare function useSelected(): Selection;
+//# sourceMappingURL=mosaic-provider.d.ts.map

package/dist/charts/mosaic-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mosaic-provider.d.ts","sourceRoot":"","sources":["../../src/charts/mosaic-provider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAA8C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACnF,OAAO,EAAE,SAAS,EAAuC,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvG;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,kBAAkB;IACjC,uFAAuF;IACvF,WAAW,EAAE,WAAW,CAAC;IACzB,mEAAmE;IACnE,WAAW,EAAE,SAAS,CAAC;IACvB;;;;;;;OAOG;IACH,QAAQ,EAAE,SAAS,CAAC;IACpB;;;;OAIG;IACH,iBAAiB,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,MAAM,IAAI,CAAC;IACvF;;;;OAIG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAID,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,WAAW,EAAE,WAAW,CAAC;IACzB;;;;OAIG;IACH,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,QAAQ,EAAE,SAAS,CAAC;CACrB;AA4BD,wBAAgB,cAAc,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,mBAAmB,+BA4CzF;AAED,4FAA4F;AAC5F,wBAAgB,SAAS,IAAI,kBAAkB,CAI9C;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,IAAI,SAAS,CAE1C;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,SAAS,CAEvC"}

package/dist/charts/mosaic-provider.js

@@ -0,0 +1,53 @@
+"use client";
+import { jsx as M } from "react/jsx-runtime";
+import { createContext as v, useRef as w, useMemo as C, useContext as S } from "react";
+import { coordinator as h, Selection as i } from "@uwdata/mosaic-core";
+const l = v(null);
+function d(e, t) {
+  return e._relay.add(t), () => {
+    e._relay.delete(t);
+  };
+}
+function b({ coordinator: e, crossfilter: t, children: f }) {
+  const n = w(null);
+  n.current ?? (n.current = /* @__PURE__ */ new Set());
+  const m = C(() => {
+    h(e);
+    const o = n.current, s = i.union(), c = t ?? i.crossfilter();
+    return d(s, c), {
+      coordinator: e,
+      crossfilter: c,
+      selected: s,
+      registerSelection(r, u) {
+        if (o.add(r), !(u != null && u.relay)) return () => void o.delete(r);
+        const x = d(r, s);
+        return () => {
+          o.delete(r), r.reset(), x();
+        };
+      },
+      reset() {
+        for (const r of o) r.reset();
+        s.reset(), c.reset();
+      }
+    };
+  }, [e, t]);
+  return /* @__PURE__ */ M(l.Provider, { value: m, children: f });
+}
+function a() {
+  const e = S(l);
+  if (!e) throw new Error("useMosaic must be used within a <MosaicProvider>.");
+  return e;
+}
+function j() {
+  return a().crossfilter;
+}
+function p() {
+  return a().selected;
+}
+export {
+  b as MosaicProvider,
+  j as useCrossfilter,
+  a as useMosaic,
+  p as useSelected
+};
+//# sourceMappingURL=mosaic-provider.js.map

package/dist/charts/mosaic-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mosaic-provider.js","sources":["../../src/charts/mosaic-provider.tsx"],"sourcesContent":["\"use client\";\n\nimport { createContext, useContext, useMemo, useRef, type ReactNode } from \"react\";\nimport { Selection, coordinator as setActiveCoordinator, type Coordinator } from \"@uwdata/mosaic-core\";\n\n/**\n * MosaicProvider — the crossfilter context every chart on this subpath reads from.\n *\n * **Bring-your-own coordinator**, the way CodeEditor is bring-your-own-language. The package\n * never instantiates a `Coordinator` and never imports DuckDB-WASM: the consumer builds the\n * coordinator over their own backend (`wasmConnector()` + `new Coordinator(connector)`, a\n * socket/REST connector, a shared worker…) and passes it in. That single decision is what keeps\n * DuckDB-WASM out of the library bundle and out of any React Server Component — the whole boot\n * lives in the consumer's `\"use client\"` island.\n *\n * The provider does two things: it registers the caller's coordinator as vgplot's active one, so\n * `vg.plot(...)` marks resolve their queries through it, and it hands every descendant chart a\n * shared `Selection.crossfilter()` so brushing one chart filters the others.\n */\n\nexport interface MosaicContextValue {\n  /** The caller-supplied coordinator. Also registered as vgplot's active coordinator. */\n  coordinator: Coordinator;\n  /** The shared crossfilter selection every chart **filters by**. */\n  crossfilter: Selection;\n  /**\n   * Every clause published by any chart on the page, flattened into one plain union — the page-wide\n   * read model, for a filter-chip row or a readout. Relayed into `crossfilter`.\n   *\n   * It is **not** what a chart highlights by: a page-wide selection names columns other charts\n   * group by, and that is a binder error waiting to happen (see `chart-root`). Charts publish into\n   * a selection of their own, which converges here.\n   */\n  selected: Selection;\n  /**\n   * Enrols a selection in `reset()`. With `relay` (what `ChartRoot` does for the selection it owns)\n   * the selection's clauses are also forwarded into `selected`, and from there into `crossfilter`.\n   * Returns the unregister.\n   */\n  registerSelection: (selection: Selection, options?: { relay?: boolean }) => () => void;\n  /**\n   * Clears every clause on the page — the shared selections **and** every registered chart\n   * selection. `Selection.reset()` travels downstream only, so resetting `crossfilter` alone leaves\n   * each chart holding its own pick; this is the call a \"Clear filters\" button wants.\n   */\n  reset: () => void;\n}\n\nconst MosaicContext = createContext<MosaicContextValue | null>(null);\n\nexport interface MosaicProviderProps {\n  /**\n   * The Mosaic `Coordinator`, constructed by the caller over their own DuckDB / connector.\n   * The package never builds one — see the module note.\n   */\n  coordinator: Coordinator;\n  /**\n   * The crossfilter `Selection` every descendant chart filters by. Defaults to a fresh\n   * `Selection.crossfilter()`. Pass one to share a selection across trees or to seed a predicate;\n   * everything below still works, because the provider relays into it rather than constructing it.\n   */\n  crossfilter?: Selection;\n  children: ReactNode;\n}\n\n/**\n * Relay `from`'s clauses into `to`, **after** both already exist.\n *\n * Mosaic exposes relaying only through the constructor's `include` option, and all `include` does\n * is `upstream._relay.add(downstream)`. That is useless to us: a `ChartRoot`'s selection is born\n * when the chart mounts, long after the provider built the crossfilter it has to feed, and a\n * selection handed in as a prop was built by the caller. So we do the `add` ourselves.\n *\n * `_relay` is underscore-prefixed but genuinely public — `Set<Selection>`, no `private` modifier,\n * present in mosaic-core 0.29's emitted `.d.ts` — and it is the single channel every relayed path\n * in `Selection` uses: `update`, `activate` and `reset` all end in `_relay.forEach(...)`. Which is\n * exactly why the obvious alternative is worse: subscribing to `from` and re-publishing into `to`\n * arrives an async tick late, can lose a clause when the dispatch queue coalesces two updates, and\n * cannot forward `reset()` at all — `reset` is a method, it emits no event.\n *\n * Relaying passes the **clause object itself**, so `source` and `clients` survive. That matters:\n * the crossfilter exempts a chart from its own clause by looking at `clause.clients`, and a copy\n * would make every chart filter itself away.\n */\nfunction relay(from: Selection, to: Selection): () => void {\n  from._relay.add(to);\n  return () => {\n    from._relay.delete(to);\n  };\n}\n\nexport function MosaicProvider({ coordinator, crossfilter, children }: MosaicProviderProps) {\n  // Survives the memo below, so a coordinator swap does not lose the charts already mounted.\n  const registry = useRef<Set<Selection> | null>(null);\n  registry.current ??= new Set<Selection>();\n\n  const value = useMemo<MosaicContextValue>(() => {\n    // Register the caller's coordinator as vgplot's active one. `coordinator(instance)` is\n    // mosaic-core's global setter — the same call keasy's boot makes, except the instance\n    // arrives as a prop here instead of being built in the library.\n    setActiveCoordinator(coordinator);\n    const owned = registry.current as Set<Selection>;\n    const selected = Selection.union();\n    const shared = crossfilter ?? Selection.crossfilter();\n    relay(selected, shared);\n\n    return {\n      coordinator,\n      crossfilter: shared,\n      selected,\n      registerSelection(selection, options) {\n        owned.add(selection);\n        if (!options?.relay) return () => void owned.delete(selection);\n        const stop = relay(selection, selected);\n        return () => {\n          owned.delete(selection);\n          // Withdraw before unwiring, or a chart that unmounts (a tab, a conditional) leaves its\n          // clause filtering the page with nothing left on screen to clear it. Only for selections\n          // the root minted — a caller's `as` may well outlive this chart.\n          selection.reset();\n          stop();\n        };\n      },\n      reset() {\n        // Children first: each relays its own removal downstream into `selected` and the\n        // crossfilter. The two shared resets then take whatever was published straight into them —\n        // a `ChartFilter`, a `ChartSearch`, a clause the caller seeded.\n        for (const selection of owned) selection.reset();\n        selected.reset();\n        shared.reset();\n      },\n    };\n  }, [coordinator, crossfilter]);\n\n  return <MosaicContext.Provider value={value}>{children}</MosaicContext.Provider>;\n}\n\n/** The Mosaic context — coordinator, shared selections, `registerSelection` and `reset`. */\nexport function useMosaic(): MosaicContextValue {\n  const ctx = useContext(MosaicContext);\n  if (!ctx) throw new Error(\"useMosaic must be used within a <MosaicProvider>.\");\n  return ctx;\n}\n\n/** The shared crossfilter `Selection` — what a chart's marks filter by. */\nexport function useCrossfilter(): Selection {\n  return useMosaic().crossfilter;\n}\n\n/**\n * Every chart clause on the page in one plain union — a read model, not a publish target. To clear\n * the page use `useMosaic().reset()`: a reset here never reaches the per-chart selections upstream.\n */\nexport function useSelected(): Selection {\n  return useMosaic().selected;\n}\n"],"names":["setActiveCoordinator","coordinator"],"mappings":";;;;AAgDA;AAoCA;AACE;AAEE;AAAqB;AAEzB;AAEO;AAEL;AACA;AAEA;AAIEA;AACA;AAGA;AAEO;AACLC;AACa;AACb;AAGE;AACA;AACA;AACE;AAKA;AACF;AACF;AAKE;AACA;AACO;AACT;AAAA;AAIJ;AACF;AAGO;AACL;AACA;AACA;AACF;AAGO;AACL;AACF;AAMO;AACL;AACF;;;;;;;"}

package/dist/charts/query-client.d.ts

@@ -0,0 +1,22 @@
+import { MosaicClient, Selection } from '@uwdata/mosaic-core';
+import { Query, FilterExpr } from '@uwdata/mosaic-sql';
+export type ChartQueryRow = Record<string, unknown>;
+/**
+ * Bridges React state to the Mosaic client life-cycle: one query in, one row array out.
+ *
+ * `useChartQuery` and `useMosaicInput` had a copy of this each — same two private fields, same
+ * `super(filterBy)`, same `query()`, same `queryResult()`, differing only in the name of the row
+ * alias. Two copies is two places a Mosaic life-cycle bug can hide, and the crossfilter is the one
+ * layer where a bug shows up as a *plausible wrong number* rather than a crash.
+ *
+ * Module-level and not on `/analytics`: subclassing `MosaicClient` yourself is the documented
+ * protocol, and this class adds nothing to it a consumer would want — it is the plumbing under two
+ * hooks, both of which are exported.
+ */
+export declare class ChartQueryClient extends MosaicClient {
+    #private;
+    constructor(filterBy: Selection | undefined, build: (filter: FilterExpr) => Query | null, emit: (rows: readonly ChartQueryRow[]) => void);
+    query(filter?: FilterExpr | null): Query | null;
+    queryResult(data: unknown): this;
+}
+//# sourceMappingURL=query-client.d.ts.map

package/dist/charts/query-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-client.d.ts","sourceRoot":"","sources":["../../src/charts/query-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE5D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,qBAAa,gBAAiB,SAAQ,YAAY;;gBAK9C,QAAQ,EAAE,SAAS,GAAG,SAAS,EAC/B,KAAK,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,KAAK,GAAG,IAAI,EAC3C,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,aAAa,EAAE,KAAK,IAAI;IAOvC,KAAK,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI;IAI/C,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;CAI1C"}

package/dist/charts/query-client.js

@@ -0,0 +1,26 @@
+var l = (r) => {
+  throw TypeError(r);
+};
+var a = (r, e, t) => e.has(r) || l("Cannot " + t);
+var o = (r, e, t) => (a(r, e, "read from private field"), t ? t.call(r) : e.get(r)), h = (r, e, t) => e.has(r) ? l("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t), n = (r, e, t, u) => (a(r, e, "write to private field"), u ? u.call(r, t) : e.set(r, t), t);
+import { MosaicClient as m } from "@uwdata/mosaic-core";
+var s, i;
+class C extends m {
+  constructor(t, u, c) {
+    super(t);
+    h(this, s);
+    h(this, i);
+    n(this, s, u), n(this, i, c);
+  }
+  query(t) {
+    return o(this, s).call(this, t ?? []);
+  }
+  queryResult(t) {
+    return o(this, i).call(this, Array.from(t)), this;
+  }
+}
+s = new WeakMap(), i = new WeakMap();
+export {
+  C as ChartQueryClient
+};
+//# sourceMappingURL=query-client.js.map

package/dist/charts/query-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-client.js","sources":["../../src/charts/query-client.ts"],"sourcesContent":["import { MosaicClient, type Selection } from \"@uwdata/mosaic-core\";\nimport type { Query, FilterExpr } from \"@uwdata/mosaic-sql\";\n\nexport type ChartQueryRow = Record<string, unknown>;\n\n/**\n * Bridges React state to the Mosaic client life-cycle: one query in, one row array out.\n *\n * `useChartQuery` and `useMosaicInput` had a copy of this each — same two private fields, same\n * `super(filterBy)`, same `query()`, same `queryResult()`, differing only in the name of the row\n * alias. Two copies is two places a Mosaic life-cycle bug can hide, and the crossfilter is the one\n * layer where a bug shows up as a *plausible wrong number* rather than a crash.\n *\n * Module-level and not on `/analytics`: subclassing `MosaicClient` yourself is the documented\n * protocol, and this class adds nothing to it a consumer would want — it is the plumbing under two\n * hooks, both of which are exported.\n */\nexport class ChartQueryClient extends MosaicClient {\n  #build: (filter: FilterExpr) => Query | null;\n  #emit: (rows: readonly ChartQueryRow[]) => void;\n\n  constructor(\n    filterBy: Selection | undefined,\n    build: (filter: FilterExpr) => Query | null,\n    emit: (rows: readonly ChartQueryRow[]) => void,\n  ) {\n    super(filterBy);\n    this.#build = build;\n    this.#emit = emit;\n  }\n\n  override query(filter?: FilterExpr | null): Query | null {\n    return this.#build(filter ?? []);\n  }\n\n  override queryResult(data: unknown): this {\n    this.#emit(Array.from(data as Iterable<ChartQueryRow>));\n    return this;\n  }\n}\n"],"names":["ChartQueryClient","MosaicClient","filterBy","build","emit","__privateAdd","_build","_emit","__privateSet","filter","__privateGet","data"],"mappings":";;;;;;;AAiBO,MAAMA,UAAyBC,EAAa;AAAA,EAIjD,YACEC,GACAC,GACAC,GACA;AACA,UAAMF,CAAQ;AARhB,IAAAG,EAAA,MAAAC;AACA,IAAAD,EAAA,MAAAE;AAQE,IAAAC,EAAA,MAAKF,GAASH,IACdK,EAAA,MAAKD,GAAQH;AAAA,EACf;AAAA,EAES,MAAMK,GAA0C;AACvD,WAAOC,EAAA,MAAKJ,GAAL,WAAYG,KAAU;EAC/B;AAAA,EAES,YAAYE,GAAqB;AACxC,WAAAD,EAAA,MAAKH,GAAL,WAAW,MAAM,KAAKI,CAA+B,IAC9C;AAAA,EACT;AACF;AArBEL,IAAA,eACAC,IAAA;"}

package/dist/charts/tokenized-plot.d.ts

@@ -0,0 +1,26 @@
+export interface TokenizedPlotProps {
+    /**
+     * Builds the vgplot element from the measured container width; return
+     * `vg.plot(..., vg.width(width))`. Re-invoked whenever a `deps` entry, the width or the theme
+     * changes, and the result is mounted via `container.replaceChildren(...)` — the same imperative
+     * mount vgplot needs (it renders an SVG/HTML node, not React).
+     *
+     * `host` is for resolving tokens against the cascade the chart actually sits in —
+     * `resolveTokenColor(host, "--chart-1")`. It is the only colour channel this frame offers,
+     * because a fixed pair of colours is a guess about what the plot paints with.
+     */
+    render: (width: number, host: HTMLDivElement) => Node;
+    /** Inputs that rebuild the plot when they change (table, column, selection, height…). */
+    deps: unknown[];
+    className?: string;
+}
+/**
+ * The frame under `ChartRoot`: measure the container, build the vgplot node, and mount it
+ * imperatively into a token-coloured container.
+ *
+ * `text-foreground` on the host is load-bearing — Observable Plot draws axis ticks and labels
+ * with `currentColor`, so inheriting the foreground token is what keeps the axes legible in both
+ * light and dark without resolving a third colour.
+ */
+export declare function TokenizedPlot({ render, deps, className }: TokenizedPlotProps): import("react").JSX.Element;
+//# sourceMappingURL=tokenized-plot.d.ts.map

package/dist/charts/tokenized-plot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenized-plot.d.ts","sourceRoot":"","sources":["../../src/charts/tokenized-plot.tsx"],"names":[],"mappings":"AAMA,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;OASG;IACH,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IACtD,yFAAyF;IACzF,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAKD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,kBAAkB,+BAyD5E"}

package/dist/charts/tokenized-plot.js

@@ -0,0 +1,41 @@
+"use client";
+import { jsx as R } from "react/jsx-runtime";
+import { useRef as d, useState as w, useEffect as a } from "react";
+import { cn as E } from "../lib/cn.js";
+import { useThemeTick as v } from "../lib/theme-tick.js";
+const S = 140;
+function C({ render: c, deps: m, className: h }) {
+  const r = d(null), s = d(c);
+  s.current = c;
+  const p = v(), [n, o] = w(0);
+  return a(() => {
+    const e = r.current;
+    if (!e || typeof ResizeObserver > "u") {
+      e && o(e.clientWidth);
+      return;
+    }
+    let t = null, u = !0;
+    const f = new ResizeObserver((T) => {
+      var l;
+      const i = Math.round(((l = T[0]) == null ? void 0 : l.contentRect.width) ?? 0);
+      if (!(i <= 0)) {
+        if (u) {
+          u = !1, o(i);
+          return;
+        }
+        t && clearTimeout(t), t = setTimeout(() => o(i), S);
+      }
+    });
+    return f.observe(e), () => {
+      t && clearTimeout(t), f.disconnect();
+    };
+  }, []), a(() => {
+    const e = r.current;
+    if (!(!e || n === 0))
+      return e.replaceChildren(s.current(n, e)), () => e.replaceChildren();
+  }, [p, n, ...m]), /* @__PURE__ */ R("div", { ref: r, "data-slot": "chart", className: E("w-full text-foreground", h) });
+}
+export {
+  C as TokenizedPlot
+};
+//# sourceMappingURL=tokenized-plot.js.map

package/dist/charts/tokenized-plot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenized-plot.js","sources":["../../src/charts/tokenized-plot.tsx"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useRef, useState } from \"react\";\nimport { cn } from \"../lib/cn.js\";\nimport { useThemeTick } from \"../lib/theme-tick.js\";\n\nexport interface TokenizedPlotProps {\n  /**\n   * Builds the vgplot element from the measured container width; return\n   * `vg.plot(..., vg.width(width))`. Re-invoked whenever a `deps` entry, the width or the theme\n   * changes, and the result is mounted via `container.replaceChildren(...)` — the same imperative\n   * mount vgplot needs (it renders an SVG/HTML node, not React).\n   *\n   * `host` is for resolving tokens against the cascade the chart actually sits in —\n   * `resolveTokenColor(host, \"--chart-1\")`. It is the only colour channel this frame offers,\n   * because a fixed pair of colours is a guess about what the plot paints with.\n   */\n  render: (width: number, host: HTMLDivElement) => Node;\n  /** Inputs that rebuild the plot when they change (table, column, selection, height…). */\n  deps: unknown[];\n  className?: string;\n}\n\n/** How long a resize has to be quiet before the plot is rebuilt at the new width. */\nconst RESIZE_SETTLE_MS = 140;\n\n/**\n * The frame under `ChartRoot`: measure the container, build the vgplot node, and mount it\n * imperatively into a token-coloured container.\n *\n * `text-foreground` on the host is load-bearing — Observable Plot draws axis ticks and labels\n * with `currentColor`, so inheriting the foreground token is what keeps the axes legible in both\n * light and dark without resolving a third colour.\n */\nexport function TokenizedPlot({ render, deps, className }: TokenizedPlotProps) {\n  const container = useRef<HTMLDivElement>(null);\n  // Long-lived across rebuilds: read the latest builder without making it a dependency.\n  const renderRef = useRef(render);\n  renderRef.current = render;\n  const tick = useThemeTick();\n  const [width, setWidth] = useState(0);\n\n  // Charts do not mount in a background tab. The cause is `requestAnimationFrame` in\n  // `@uwdata/mosaic-plot/src/plot.js` (`requestAnimationFrame(() => this.render())`), which a\n  // hidden tab never services — not the ResizeObserver below, which is the obvious suspect and\n  // the wrong one. Verified while benchmarking a 20k-node plot.\n  // Size the plot to its container: vgplot needs an explicit width (it defaults to 640), so a\n  // bare mount overflows a narrow column. Re-measure on resize and rebuild at the new width.\n  useEffect(() => {\n    const host = container.current;\n    if (!host || typeof ResizeObserver === \"undefined\") {\n      if (host) setWidth(host.clientWidth);\n      return;\n    }\n    // The width is a plot option, so every value it takes rebuilds the plot — and a rebuilt plot\n    // builds new Mosaic clients, which re-query the database. Committing every ResizeObserver tick\n    // therefore turns one drag of a splitter or window edge into a query per pixel. The first\n    // measurement lands at once (nothing is on screen yet to keep steady); after that the width\n    // waits for the drag to stop.\n    let settle: ReturnType<typeof setTimeout> | null = null;\n    // A local flag, not the `width` state: the observer is created once, so a closure over `width`\n    // would read 0 forever and every tick would commit immediately.\n    let first = true;\n    const ro = new ResizeObserver((entries) => {\n      const w = Math.round(entries[0]?.contentRect.width ?? 0);\n      if (w <= 0) return;\n      if (first) {\n        first = false;\n        setWidth(w);\n        return;\n      }\n      if (settle) clearTimeout(settle);\n      settle = setTimeout(() => setWidth(w), RESIZE_SETTLE_MS);\n    });\n    ro.observe(host);\n    return () => {\n      if (settle) clearTimeout(settle);\n      ro.disconnect();\n    };\n  }, []);\n\n  useEffect(() => {\n    const host = container.current;\n    if (!host || width === 0) return;\n    host.replaceChildren(renderRef.current(width, host));\n    return () => host.replaceChildren();\n    // `render` is read through a ref; `tick` re-runs on theme change, `width`/`deps` on resize/input.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [tick, width, ...deps]);\n\n  return <div ref={container} data-slot=\"chart\" className={cn(\"w-full text-foreground\", className)} />;\n}\n"],"names":[],"mappings":";;;;;AAwBA;AAUO;AACL;AAGA;AACA;AASA;AACE;AACA;AACE;AACA;AAAA;AAOF;AAIA;;AACE;AACA;AACA;AACE;AAEA;AAAA;AAEF;AACuD;AAAA;AAEzD;AAEE;AACG;AACL;AAIA;AACA;AACA;AACkB;AAMtB;;;;"}

package/dist/charts/use-chart-query.d.ts

@@ -0,0 +1,30 @@
+import { Selection } from '@uwdata/mosaic-core';
+import { Query, FilterExpr } from '@uwdata/mosaic-sql';
+import { ChartQueryRow } from './query-client.js';
+/**
+ * Read a relation from the same coordinator the charts use, and follow the same crossfilter.
+ *
+ * A dashboard always has something that is not a plot — a KPI, a readout, a table — and it has to
+ * move with the brush like everything else. Doing that by hand means connecting a `MosaicClient`,
+ * and a widget that instead runs a plain `coordinator.query()` in an effect reports **unfiltered**
+ * totals sitting next to filtered charts, which reads as a bug in the crossfilter.
+ */
+export type { ChartQueryRow };
+export interface ChartQueryOptions {
+    /** Builds the query from the crossfilter predicate; return `null` to ask for nothing. */
+    query: (filter: FilterExpr) => Query | null;
+    /** What to filter by. Defaults to the provider's crossfilter; `null` reads the full relation. */
+    filterBy?: Selection | null;
+    /** Rebuilds the client — and re-runs the query — when an entry changes. */
+    deps?: readonly unknown[];
+}
+export interface ChartQueryResult {
+    /** The rows, or `null` while the first query is in flight. */
+    rows: readonly ChartQueryRow[] | null;
+    /** The first row, for the common single-aggregate case. */
+    row: ChartQueryRow | undefined;
+}
+export declare function useChartQuery(options: ChartQueryOptions): ChartQueryResult;
+/** Re-exported so a caller builds a query without a direct `@uwdata/mosaic-sql` import. */
+export { Query };
+//# sourceMappingURL=use-chart-query.d.ts.map

package/dist/charts/use-chart-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chart-query.d.ts","sourceRoot":"","sources":["../../src/charts/use-chart-query.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAG5D,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEzE;;;;;;;GAOG;AAEH,YAAY,EAAE,aAAa,EAAE,CAAC;AAE9B,MAAM,WAAW,iBAAiB;IAChC,yFAAyF;IACzF,KAAK,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,KAAK,GAAG,IAAI,CAAC;IAC5C,iGAAiG;IACjG,QAAQ,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,2EAA2E;IAC3E,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,8DAA8D;IAC9D,IAAI,EAAE,SAAS,aAAa,EAAE,GAAG,IAAI,CAAC;IACtC,2DAA2D;IAC3D,GAAG,EAAE,aAAa,GAAG,SAAS,CAAC;CAChC;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CAmB1E;AAED,2FAA2F;AAC3F,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/charts/use-chart-query.js

@@ -0,0 +1,19 @@
+"use client";
+import { Query as x } from "@uwdata/mosaic-sql";
+import { useRef as m, useState as a, useEffect as y } from "react";
+import { useMosaic as d } from "./mosaic-provider.js";
+import { ChartQueryClient as p } from "./query-client.js";
+function q(r) {
+  const { filterBy: o, deps: i = [] } = r, { coordinator: t, crossfilter: f } = d(), n = o === void 0 ? f : o, c = m(r.query);
+  c.current = r.query;
+  const [e, u] = a(null);
+  return y(() => {
+    const s = new p(n ?? void 0, (l) => c.current(l), u);
+    return u(null), t.connect(s), () => t.disconnect(s);
+  }, [t, n, ...i]), { rows: e, row: e == null ? void 0 : e[0] };
+}
+export {
+  x as Query,
+  q as useChartQuery
+};
+//# sourceMappingURL=use-chart-query.js.map

package/dist/charts/use-chart-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chart-query.js","sources":["../../src/charts/use-chart-query.ts"],"sourcesContent":["\"use client\";\n\nimport type { Selection } from \"@uwdata/mosaic-core\";\nimport { Query, type FilterExpr } from \"@uwdata/mosaic-sql\";\nimport { useEffect, useRef, useState } from \"react\";\nimport { useMosaic } from \"./mosaic-provider.js\";\nimport { ChartQueryClient, type ChartQueryRow } from \"./query-client.js\";\n\n/**\n * Read a relation from the same coordinator the charts use, and follow the same crossfilter.\n *\n * A dashboard always has something that is not a plot — a KPI, a readout, a table — and it has to\n * move with the brush like everything else. Doing that by hand means connecting a `MosaicClient`,\n * and a widget that instead runs a plain `coordinator.query()` in an effect reports **unfiltered**\n * totals sitting next to filtered charts, which reads as a bug in the crossfilter.\n */\n\nexport type { ChartQueryRow };\n\nexport interface ChartQueryOptions {\n  /** Builds the query from the crossfilter predicate; return `null` to ask for nothing. */\n  query: (filter: FilterExpr) => Query | null;\n  /** What to filter by. Defaults to the provider's crossfilter; `null` reads the full relation. */\n  filterBy?: Selection | null;\n  /** Rebuilds the client — and re-runs the query — when an entry changes. */\n  deps?: readonly unknown[];\n}\n\nexport interface ChartQueryResult {\n  /** The rows, or `null` while the first query is in flight. */\n  rows: readonly ChartQueryRow[] | null;\n  /** The first row, for the common single-aggregate case. */\n  row: ChartQueryRow | undefined;\n}\n\nexport function useChartQuery(options: ChartQueryOptions): ChartQueryResult {\n  const { filterBy, deps = [] } = options;\n  const { coordinator, crossfilter } = useMosaic();\n  const source = filterBy === undefined ? crossfilter : filterBy;\n  // Read the latest builder without making it a dependency: an inline arrow would reconnect the\n  // client on every render, and reconnecting re-runs the query.\n  const latest = useRef(options.query);\n  latest.current = options.query;\n  const [rows, setRows] = useState<readonly ChartQueryRow[] | null>(null);\n\n  useEffect(() => {\n    const client = new ChartQueryClient(source ?? undefined, (filter) => latest.current(filter), setRows);\n    setRows(null);\n    coordinator.connect(client);\n    return () => coordinator.disconnect(client);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [coordinator, source, ...deps]);\n\n  return { rows, row: rows?.[0] };\n}\n\n/** Re-exported so a caller builds a query without a direct `@uwdata/mosaic-sql` import. */\nexport { Query };\n"],"names":[],"mappings":";;;;;AAmCO;AACL;AAMA;AACA;AAEA;AACE;AACA;AAE0C;AAK9C;;;;;"}

package/dist/composites/CodeEditor.d.ts

@@ -0,0 +1,64 @@
+import { Extension } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { HighlightStyle } from '@codemirror/language';
+/**
+ * Kanzo syntax theme — maps Lezer highlight tags to the design tokens, so a consumer's language
+ * extension is coloured by whichever palette document is on the page. Exported so a
+ * bring-your-own editor can wire the same palette. Inert until the caller injects a language
+ * (there is no tree to tag).
+ *
+ * **Seven of these are `--syntax-*` and the rest are tokens that already existed**, which is the
+ * shape the palette layer settled on: `comment` is `--faint` (the quietest legible ink — a gutter
+ * number, a field's placeholder and a code comment are one decision), `punctuation` is
+ * `--muted-foreground`, `operator` is `--foreground`, and `invalid` is the destructive family.
+ * There were thirteen `--syntax-*` tokens; six of them were duplicating a tint the ramp
+ * already publishes.
+ *
+ * The seven that remain are derived per tenant and graded against `--editor-active-line`, so a
+ * palette finally repaints keywords: Dracula's pink, Nord's purple, Catppuccin's mauve. Every
+ * document used to declare Kanzo's.
+ */
+export declare const kanzoHighlightStyle: HighlightStyle;
+/** The Kanzo highlight style as a ready-to-drop extension. */
+export declare const kanzoHighlighting: Extension;
+export interface CodeEditorProps {
+    value: string;
+    onChange?: (value: string) => void;
+    /** The language brain — CodeMirror extensions injected by the consumer (LSP,
+     *  StreamParser, autocomplete, linting…). Reconfigured live when it changes. */
+    extensions?: Extension;
+    readOnly?: boolean;
+    lineNumbers?: boolean;
+    invalid?: boolean;
+    placeholder?: string;
+    minHeight?: string;
+    maxHeight?: string;
+    /** Include the built-in batteries (history + default keymap + line wrapping +
+     *  the Kanzo token theme). Default true. Set false when the caller's `extensions`
+     *  own all behaviour and theming. */
+    basics?: boolean;
+    /**
+     * Wrap long lines, or scroll sideways. Default true, which is what `basics` always did.
+     *
+     * Wrapping is right where the editor is a reading surface in a narrow pane; it is wrong where
+     * the document has structure a reader tracks by column — a Turtle predicate list read against
+     * its indentation stops being a list once every third line reflows. There is no third option:
+     * `EditorView.lineWrapping` is on or it is not.
+     *
+     * Read once, when the view is built — like `basics`, and for the same reason. Changing it after
+     * mount does nothing.
+     */
+    wrap?: boolean;
+    /**
+     * Wrap the editor in the styled focus-ring chrome (Box + inset ring + surface background).
+     * Default true. Set false for a bare surface.
+     */
+    chrome?: boolean;
+    /** Class applied to the editor host (only meaningful when `chrome={false}`). */
+    className?: string;
+    /** Receives the `EditorView` on mount and `null` on unmount — for side-wiring
+     *  (e.g. pushing LSP notifications). */
+    onView?: (view: EditorView | null) => void;
+}
+export declare function CodeEditor(p: CodeEditorProps): import("react").JSX.Element;
+//# sourceMappingURL=CodeEditor.d.ts.map

package/dist/composites/CodeEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeEditor.d.ts","sourceRoot":"","sources":["../../src/composites/CodeEditor.tsx"],"names":[],"mappings":"AAOA,OAAO,EAAwC,KAAK,SAAS,EAAY,MAAM,mBAAmB,CAAC;AACnG,OAAO,EAGL,UAAU,EAaX,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,cAAc,EAMf,MAAM,sBAAsB,CAAC;AAuB9B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,gBAiC9B,CAAC;AAEH,8DAA8D;AAC9D,eAAO,MAAM,iBAAiB,EAAE,SAAuE,CAAC;AAyXxG,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC;oFACgF;IAChF,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;yCAEqC;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;4CACwC;IACxC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,KAAK,IAAI,CAAC;CAC5C;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,eAAe,+BAiN5C"}