reke-ui 0.4.0 → 0.4.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +6 -0
- package/custom-elements.json +477 -5
- package/dist/components/reke-table/reke-table.d.ts +201 -3
- package/dist/components/reke-table/reke-table.d.ts.map +1 -1
- package/dist/components/reke-table/reke-table.js +238 -64
- package/dist/components/reke-table/reke-table.styles.d.ts.map +1 -1
- package/dist/components/reke-table/reke-table.styles.js +29 -0
- package/dist/shared/tailwind.js +1 -1
- package/package.json +2 -1
|
@@ -28,6 +28,15 @@ export type GetRowKey = (row: TableRow, index: number) => RowKey;
|
|
|
28
28
|
* @tag reke-table
|
|
29
29
|
* @summary A data table with custom cell rendering, framework-agnostic expandable rows, and toolbar/footer slots.
|
|
30
30
|
*
|
|
31
|
+
* Virtualization: opt-in via `virtualized`, off by default. When on, only the
|
|
32
|
+
* rows intersecting the viewport are rendered and spacer rows carry the scroll
|
|
33
|
+
* height of the rest. Requires `rowHeight` and `maxHeight`. Expandable rows are
|
|
34
|
+
* supported: their height is measured with a ResizeObserver and folded into the
|
|
35
|
+
* row offsets, which is affordable because only a handful of rows are ever open
|
|
36
|
+
* at once. Rows are never recycled across keys — a row key keeps its host
|
|
37
|
+
* element and its cleanup contract even while scrolled out of the window.
|
|
38
|
+
* See README-DOC.md.
|
|
39
|
+
*
|
|
31
40
|
* @slot toolbar - Toolbar area above the table (search, filters, title).
|
|
32
41
|
* @slot footer - Footer area below the table (pagination, record count).
|
|
33
42
|
* @slot empty - Custom empty state content (replaces default "No data").
|
|
@@ -106,6 +115,43 @@ export declare class RekeTable extends RekeElement {
|
|
|
106
115
|
* toggle).
|
|
107
116
|
*/
|
|
108
117
|
expandOnRowClick: boolean;
|
|
118
|
+
/**
|
|
119
|
+
* Opt-in row windowing: only the rows intersecting the viewport are rendered,
|
|
120
|
+
* with spacer rows standing in for the rest.
|
|
121
|
+
*
|
|
122
|
+
* This is NOT a transparent optimization — it changes the layout contract.
|
|
123
|
+
* A virtualized table needs a bounded scroll container, so `maxHeight` and
|
|
124
|
+
* `rowHeight` are both REQUIRED when this is `true` (dev error otherwise), and
|
|
125
|
+
* the table switches to `table-layout: fixed` so column widths stop depending
|
|
126
|
+
* on whichever rows happen to be rendered. That is also why this is a prop and
|
|
127
|
+
* not an automatic row-count threshold: silently changing a consumer's layout
|
|
128
|
+
* because their dataset grew past some boundary is worse than being slow.
|
|
129
|
+
*
|
|
130
|
+
* Not yet compatible with `expandedRowElement` — see the class JSDoc.
|
|
131
|
+
*/
|
|
132
|
+
virtualized: boolean;
|
|
133
|
+
/**
|
|
134
|
+
* Height in px of a single COLLAPSED row, declared by the consumer. Required
|
|
135
|
+
* when `virtualized` is `true`.
|
|
136
|
+
*
|
|
137
|
+
* Declared rather than measured on purpose: it makes row offsets pure
|
|
138
|
+
* arithmetic (`index * rowHeight`) available on the very first frame, with no
|
|
139
|
+
* measure-then-render pass. The tradeoff is yours to honor — if your cell
|
|
140
|
+
* content is taller than this, rows will overlap. Keep it in sync with the
|
|
141
|
+
* `dense` modifier if you use it.
|
|
142
|
+
*/
|
|
143
|
+
rowHeight: number;
|
|
144
|
+
/**
|
|
145
|
+
* CSS length capping the scroll container height (e.g. `'600px'`, `'70vh'`).
|
|
146
|
+
* Required when `virtualized` is `true` — without a bounded height there is
|
|
147
|
+
* no viewport to window against.
|
|
148
|
+
*/
|
|
149
|
+
maxHeight: string;
|
|
150
|
+
/**
|
|
151
|
+
* Extra rows rendered above and below the viewport, absorbing fast scrolls
|
|
152
|
+
* before blank space can appear. Higher costs more per frame.
|
|
153
|
+
*/
|
|
154
|
+
overscan: number;
|
|
109
155
|
sortKey: string;
|
|
110
156
|
sortDirection: 'asc' | 'desc';
|
|
111
157
|
/**
|
|
@@ -145,7 +191,13 @@ export declare class RekeTable extends RekeElement {
|
|
|
145
191
|
private _warnedNumericTarget;
|
|
146
192
|
/** Track which keys are currently mounted in the DOM, to honor the contract that mount happens after `updated()` reconciles. */
|
|
147
193
|
private _mountedKeys;
|
|
148
|
-
/**
|
|
194
|
+
/**
|
|
195
|
+
* Keys currently animating their collapse. The row stays rendered while the
|
|
196
|
+
* key is here; teardown runs when the collapse settles (see
|
|
197
|
+
* `_scheduleCollapseTeardown`). A key is NEVER in both this set and
|
|
198
|
+
* `expandedRows` — collapse removes it from `expandedRows` immediately, which
|
|
199
|
+
* is what makes a re-entrant toggle read as a genuine re-expand.
|
|
200
|
+
*/
|
|
149
201
|
private _collapsingKeys;
|
|
150
202
|
/**
|
|
151
203
|
* Keys newly expanded this tick. They render collapsed (0fr) for the first
|
|
@@ -154,14 +206,140 @@ export declare class RekeTable extends RekeElement {
|
|
|
154
206
|
* expand row starts at 1fr and pops open with no animation.
|
|
155
207
|
*/
|
|
156
208
|
private _enteringKeys;
|
|
157
|
-
/**
|
|
158
|
-
|
|
209
|
+
/**
|
|
210
|
+
* Generation token per collapsing key. A pending settle only tears the key
|
|
211
|
+
* down when its token is still the current one, so cancelling a collapse
|
|
212
|
+
* (re-expand, row removal, disconnect) is a single map delete.
|
|
213
|
+
*/
|
|
214
|
+
private _collapseTokens;
|
|
215
|
+
private _collapseSeq;
|
|
159
216
|
/** Latest resolved row map: key → row. Filled during render so callbacks can look up rows. */
|
|
160
217
|
private _keyToRow;
|
|
218
|
+
/** Latest resolved index map: key → absolute index into `rows`. */
|
|
219
|
+
private _keyToIndex;
|
|
220
|
+
/**
|
|
221
|
+
* Measured height in px of each rendered expand row, keyed by row key.
|
|
222
|
+
*
|
|
223
|
+
* This is the whole reason expand and virtualization can coexist. A collapsed
|
|
224
|
+
* row's height is declared (`rowHeight`); an expanded row's is not knowable in
|
|
225
|
+
* advance, because the consumer mounts arbitrary content into the host. So we
|
|
226
|
+
* measure it — and that is affordable precisely because the set is tiny: no
|
|
227
|
+
* one has ten thousand rows open at once. Offsets stay
|
|
228
|
+
* `index * rowHeight + sum(extra heights of expanded rows above)`.
|
|
229
|
+
*
|
|
230
|
+
* Entries survive an expanded row scrolling out of the window (the height is
|
|
231
|
+
* still needed for the math) and are dropped only on teardown.
|
|
232
|
+
*/
|
|
233
|
+
private _expandedHeights;
|
|
234
|
+
private _expandRowElements;
|
|
235
|
+
private _expandRowKeys;
|
|
236
|
+
private _expandRowRefs;
|
|
237
|
+
private _expandObserver;
|
|
238
|
+
/** Window rendered on the last pass, for scroll anchoring and focus rescue. */
|
|
239
|
+
private _windowStart;
|
|
240
|
+
private _windowEnd;
|
|
241
|
+
private _previousWindowStart;
|
|
242
|
+
private _previousWindowEnd;
|
|
243
|
+
/**
|
|
244
|
+
* Which record focus was last placed on, as an `aria-rowindex`. Scrolling a
|
|
245
|
+
* virtualized table does not usually destroy the focused control — Lit reuses
|
|
246
|
+
* the row's DOM positionally and rebinds it to a different record — so the
|
|
247
|
+
* thing to detect is not "focus disappeared" but "focus is now on a different
|
|
248
|
+
* row than the user put it on".
|
|
249
|
+
*/
|
|
250
|
+
private _focusInsideRows;
|
|
251
|
+
private _focusedRowIndex;
|
|
252
|
+
private _onRowsFocusIn;
|
|
253
|
+
/** The `aria-rowindex` of the row containing a node, if any. */
|
|
254
|
+
private _rowIndexOf;
|
|
255
|
+
private _clearRowFocusTracking;
|
|
161
256
|
/** Stable ref callback per row key. One closure per key, reused across renders. */
|
|
162
257
|
private _refCallbacks;
|
|
163
258
|
private _hasToolbar;
|
|
164
259
|
private _hasFooter;
|
|
260
|
+
/** Live scroll offset of the scroll container, in px. Virtualized mode only. */
|
|
261
|
+
private _scrollTop;
|
|
262
|
+
/** Measured height of the scroll container, in px. Virtualized mode only. */
|
|
263
|
+
private _viewportHeight;
|
|
264
|
+
private _scrollContainer;
|
|
265
|
+
private _viewportObserver;
|
|
266
|
+
private _scrollFrame;
|
|
267
|
+
/**
|
|
268
|
+
* Coalesce scroll into one update per frame. A trackpad fires scroll events
|
|
269
|
+
* far faster than the browser paints, and each one would otherwise queue a
|
|
270
|
+
* full window recompute.
|
|
271
|
+
*/
|
|
272
|
+
private _onScroll;
|
|
273
|
+
/**
|
|
274
|
+
* Bind the scroll container. Called by lit's `ref` on every render, so it must
|
|
275
|
+
* be cheap and idempotent — it rebinds only when the element actually changes.
|
|
276
|
+
*/
|
|
277
|
+
private _bindScrollContainer;
|
|
278
|
+
/**
|
|
279
|
+
* Expanded rows that add height, as `{ index, extra }` sorted by index.
|
|
280
|
+
* Small by construction — this is the set of rows the user has open.
|
|
281
|
+
*/
|
|
282
|
+
private _extraHeights;
|
|
283
|
+
/** Distance in px from the top of the dataset to the top of row `index`. */
|
|
284
|
+
private _offsetOf;
|
|
285
|
+
/**
|
|
286
|
+
* Inverse of `_offsetOf`: the row index sitting at a given scroll offset.
|
|
287
|
+
* Walks the (short) list of expanded rows to find which linear segment the
|
|
288
|
+
* offset falls in, then divides within that segment.
|
|
289
|
+
*/
|
|
290
|
+
private _indexAtOffset;
|
|
291
|
+
/**
|
|
292
|
+
* The slice of `rows` to render plus the spacer heights standing in for the
|
|
293
|
+
* rows outside it. `end` is exclusive.
|
|
294
|
+
*
|
|
295
|
+
* Expanded rows INSIDE the window render at their real height, so their extra
|
|
296
|
+
* height is deliberately excluded from the spacers — only rows above and below
|
|
297
|
+
* the window contribute.
|
|
298
|
+
*/
|
|
299
|
+
private _computeWindow;
|
|
300
|
+
/**
|
|
301
|
+
* Observe an expand row so its height feeds the window math. Measuring is what
|
|
302
|
+
* lets expanded rows coexist with windowing; the observer also fires
|
|
303
|
+
* continuously while the row animates open, so the offsets track the
|
|
304
|
+
* transition instead of jumping at the end.
|
|
305
|
+
*/
|
|
306
|
+
private _expandRowRef;
|
|
307
|
+
/**
|
|
308
|
+
* Hand focus back to the scroll container when a window change moved it off
|
|
309
|
+
* the record the user chose.
|
|
310
|
+
*
|
|
311
|
+
* Two things can happen when the window slides under a focused control. Lit
|
|
312
|
+
* usually reuses the row's DOM and rebinds it, so focus silently ends up on a
|
|
313
|
+
* DIFFERENT record with nothing announced — the user believes they are on row
|
|
314
|
+
* 5 while they are on row 505. Less often the node is destroyed outright and
|
|
315
|
+
* focus falls to the document body, after which arrow keys scroll the page
|
|
316
|
+
* instead of the table. Both are resolved by parking focus on the scroll
|
|
317
|
+
* container, which is a place the user can reason about.
|
|
318
|
+
*
|
|
319
|
+
* Guarded so a normal Tab-away or an unrelated re-render is never hijacked:
|
|
320
|
+
* it acts only when the window actually moved and focus is still inside this
|
|
321
|
+
* component.
|
|
322
|
+
*/
|
|
323
|
+
private _rescueFocusAfterWindowChange;
|
|
324
|
+
/**
|
|
325
|
+
* Keep the tracked scroll offset in agreement with the container after the
|
|
326
|
+
* dataset changes size.
|
|
327
|
+
*
|
|
328
|
+
* Filtering 10.000 rows down to 10 while parked near the bottom leaves the
|
|
329
|
+
* offset past the end of the new content. The browser silently clamps its own
|
|
330
|
+
* `scrollTop` when that happens but emits no scroll event, so `_scrollTop`
|
|
331
|
+
* would keep describing a position that no longer exists and the window math
|
|
332
|
+
* would render a slice of nothing. Clamp explicitly, then resync either way.
|
|
333
|
+
*/
|
|
334
|
+
private _clampScrollToContent;
|
|
335
|
+
private _ensureExpandObserver;
|
|
336
|
+
/**
|
|
337
|
+
* A zero-content row standing in for the rows outside the window, holding the
|
|
338
|
+
* scroll height they would have occupied. `<tr>` height is honored as a
|
|
339
|
+
* minimum, and the cell is stripped of padding and borders so it contributes
|
|
340
|
+
* nothing beyond `height`.
|
|
341
|
+
*/
|
|
342
|
+
private _renderSpacerRow;
|
|
165
343
|
private _resolveKey;
|
|
166
344
|
private handleHeaderClick;
|
|
167
345
|
private handleRowClick;
|
|
@@ -200,7 +378,27 @@ export declare class RekeTable extends RekeElement {
|
|
|
200
378
|
private _renderRow;
|
|
201
379
|
willUpdate(_changed: PropertyValues): void;
|
|
202
380
|
private _warnedLegacyApi;
|
|
381
|
+
private _warnedVirtualConfig;
|
|
203
382
|
updated(_changed: PropertyValues): void;
|
|
383
|
+
/**
|
|
384
|
+
* Wait for a collapsing row to finish animating, then tear it down.
|
|
385
|
+
*
|
|
386
|
+
* The wait resolves off `getAnimations()`, not `transitionend`: that event is
|
|
387
|
+
* never guaranteed (reduced motion, `display: none`, a backgrounded tab, a
|
|
388
|
+
* zero-duration override, the row being unmounted mid-flight), and when it
|
|
389
|
+
* failed to arrive the key stayed in `_collapsingKeys` forever, which in turn
|
|
390
|
+
* disabled the purge in `updated()`. If there is no animation at all,
|
|
391
|
+
* `Promise.allSettled([])` settles on the next microtask and teardown is
|
|
392
|
+
* immediate. `COLLAPSE_TEARDOWN_FALLBACK_MS` is the last resort for an
|
|
393
|
+
* animation that never finishes.
|
|
394
|
+
*/
|
|
395
|
+
private _scheduleCollapseTeardown;
|
|
396
|
+
/**
|
|
397
|
+
* Release every resource held for a row key. Idempotent and safe to call at
|
|
398
|
+
* any point in the lifecycle — each step is a delete, and `_safeCleanup`
|
|
399
|
+
* drops its entry after running.
|
|
400
|
+
*/
|
|
401
|
+
private _teardownKey;
|
|
204
402
|
/**
|
|
205
403
|
* Invoke the cached cleanup for a key, swallowing consumer errors so our own state
|
|
206
404
|
* mutation (`expandedRows`, host/cleanup/ref maps) and `emit` stay consistent even if
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"reke-table.d.ts","sourceRoot":"","sources":["../../../src/components/reke-table/reke-table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;
|
|
1
|
+
{"version":3,"file":"reke-table.d.ts","sourceRoot":"","sources":["../../../src/components/reke-table/reke-table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAK9E,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAG3D,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpC,qEAAqE;IACrE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,sFAAsF;IACtF,MAAM,CAAC,EAAE,CACP,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,MAAM,KACV,cAAc,GAAG,MAAM,GAAG,WAAW,GAAG,IAAI,CAAC;CACnD;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE/C,mCAAmC;AACnC,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAErC,yDAAyD;AACzD,MAAM,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC;AAEjC;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAAC;AAEnG,yEAAyE;AACzE,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AA8CjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBACa,SAAU,SAAQ,WAAW;IAExC,OAAgB,iBAAiB,EAAE,cAAc,CAG/C;IAEF,OAAgB,MAAM,4BAAU;IAGhC,OAAO,EAAE,WAAW,EAAE,CAAM;IAG5B,IAAI,EAAE,QAAQ,EAAE,CAAM;IAGtB,OAAO,UAAS;IAGhB,KAAK,UAAS;IAGd,SAAS,UAAS;IAGlB,QAAQ,UAAS;IAGjB,UAAU,UAAS;IAEnB;;;;;;;;OAQG;IAEH,UAAU,UAAS;IAEnB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IAEH,gBAAgB,UAAS;IAEzB;;;;;;;;;;;;;OAaG;IAEH,WAAW,UAAS;IAEpB;;;;;;;;;OASG;IAEH,SAAS,SAAK;IAEd;;;;OAIG;IAEH,SAAS,SAAM;IAEf;;;OAGG;IAEH,QAAQ,SAAK;IAGb,OAAO,SAAM;IAGb,aAAa,EAAE,KAAK,GAAG,MAAM,CAAS;IAEtC;;;;;;;;;;;;;;;;;OAiBG;IAEH,kBAAkB,EAAE,kBAAkB,GAAG,IAAI,CAAQ;IAErD;;;;OAIG;IAEH,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB,0CAA0C;IAE1C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAEtC,sEAAsE;IACtE,OAAO,CAAC,UAAU,CAAkC;IAEpD,+FAA+F;IAC/F,OAAO,CAAC,WAAW,CAA8B;IAEjD,yFAAyF;IACzF,OAAO,CAAC,cAAc,CAAqB;IAE3C,8EAA8E;IAC9E,OAAO,CAAC,oBAAoB,CAAS;IAErC,gIAAgI;IAChI,OAAO,CAAC,YAAY,CAAqB;IAEzC;;;;;;OAMG;IACH,OAAO,CAAC,eAAe,CAAqB;IAE5C;;;;;OAKG;IACH,OAAO,CAAC,aAAa,CAAqB;IAE1C;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAA6B;IAEpD,OAAO,CAAC,YAAY,CAAK;IAEzB,8FAA8F;IAC9F,OAAO,CAAC,SAAS,CAA+B;IAEhD,mEAAmE;IACnE,OAAO,CAAC,WAAW,CAA6B;IAEhD;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,gBAAgB,CAA6B;IAErD,OAAO,CAAC,kBAAkB,CAAkC;IAC5D,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,cAAc,CAAwD;IAC9E,OAAO,CAAC,eAAe,CAA+B;IAEtD,+EAA+E;IAC/E,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,kBAAkB,CAAK;IAE/B;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,gBAAgB,CAAuB;IAE/C,OAAO,CAAC,cAAc,CAGpB;IAEF,gEAAgE;IAChE,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,sBAAsB;IAK9B,mFAAmF;IACnF,OAAO,CAAC,aAAa,CAAwD;IAEpE,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAS;IAEpC,gFAAgF;IACvE,OAAO,CAAC,UAAU,CAAK;IAEhC,6EAA6E;IACpE,OAAO,CAAC,eAAe,CAAK;IAErC,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,CAAC,iBAAiB,CAA+B;IACxD,OAAO,CAAC,YAAY,CAAuB;IAE3C;;;;OAIG;IACH,OAAO,CAAC,SAAS,CAQf;IAEF;;;OAGG;IACH,OAAO,CAAC,oBAAoB,CAwB1B;IAEF;;;OAGG;IACH,OAAO,CAAC,aAAa;IAWrB,4EAA4E;IAC5E,OAAO,CAAC,SAAS;IASjB;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAwCtB;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAmBrB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,6BAA6B;IAyBrC;;;;;;;;;OASG;IACH,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,qBAAqB;IAsC7B;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,cAAc;IAgBtB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAK3B;;;;;;;;OAQG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IA8D3C,oEAAoE;IACpE,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAInC,OAAO,CAAC,oBAAoB;IAK5B,OAAO,CAAC,mBAAmB;IAK3B,OAAO,CAAC,gBAAgB;IAUxB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,UAAU;IAkFT,UAAU,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAsDnD,OAAO,CAAC,gBAAgB,CAAS;IAEjC,OAAO,CAAC,oBAAoB,CAAS;IAE5B,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IA2FhD;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,yBAAyB;IAuCjC;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAmBpB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,uBAAuB;IA0BtB,oBAAoB;IAgBpB,MAAM;CAmJhB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,YAAY,EAAE,SAAS,CAAC;KACzB;CACF"}
|