@aceshooting/lyra-ui 29.0.2 → 29.1.0

package/llms/components/lr-word-cloud.md

@@ -9,7 +9,7 @@
 - **Release history** [CHANGELOG.md](../../CHANGELOG.md)
 - **Deprecations** none
 - **Optional peers** none
-- **Themeable via** 12 parts, 8 custom properties — see this component's own `@csspart`/`@cssprop` list below
+- **Themeable via** 14 parts, 8 custom properties — see this component's own `@csspart`/`@cssprop` list below
 - **Library-wide behavior** (events, form association, `locale`/`strings`, tokens, TS types): `llms/shared.md`
 
 ---
@@ -41,6 +41,10 @@ remain nonnegative; placement budgets, font-size limits, and the omitted-word po
 
 **Properties:**
 
+- `preparedWords: LyraPreparedWordCloud | null = null` (property only) — whole-catalog weighted
+  summary, taking precedence over `words`. Invalid non-null input shows a localized `error`;
+  setting it to `null` restores the current legacy word snapshot without changing the `words`
+  getter. See the prepared-catalog contract below.
 - `words: readonly WordCloudWord[] = []` (attribute: false) — readonly `{ text: string, weight:
 number, color?: string, group?: string }` snapshots; malformed/hostile records are skipped while
   later valid records survive. `weight` is normalized once to a finite nonnegative value used by
@@ -84,13 +88,70 @@ number, color?: string, group?: string }` snapshots; malformed/hostile records a
   derived legend below the cloud; the color key is an accessible list and does not change word
   activation or palette selection.
 
+**Prepared weighted catalogs:** `LyraPreparedWordCloud` supplies `revision`, `counts`
+(`sourceCount`, `validCount`, `invalidCount`), `totalWeight`, `retainedWeight`, and readonly
+`words: readonly LyraWeightedWord[]`. Each `LyraWeightedWord` has readonly `id: string`,
+`text: string` and `weight: number`. IDs represent already aggregated catalog entries and must be
+globally unique; distinct IDs may have the same display text. This input is a weighted catalog,
+not a sequence of raw tokens whose frequencies the component computes.
+
+The component admits at most 150 selected words, with nonblank IDs/text limited to 256 UTF-16
+units each and selected text totaling at most 16,384 units. Labels and IDs remain exact; they are
+not clipped or admitted through the legacy prefix budget. Retained IDs must be unique. Counts
+must be safe nonnegative integers conserving the complete source (`validCount + invalidCount =
+sourceCount`); selected length cannot exceed `validCount`, and a nonempty valid catalog requires
+a selection. Weights and their totals must be finite and nonnegative; `retainedWeight` must equal
+the sum of selected weights in descriptor order. The full total must include each selected
+weight; when every valid word is selected, full and retained totals must agree within bounded
+floating-point accumulation error. Invalid positions do not enlarge that complete-sum allowance.
+Sparse/accessor-backed descriptor arrays, malformed metadata, oversized selections and
+inconsistent totals fail visibly instead of falling back to `words` or silently dropping values.
+The bounded descriptor cannot independently certify global top-K membership or full-source totals.
+
+`part="summary"` reports selected versus full valid word counts, invalid count, and retained versus
+full weight through `wordCloudPreparedSummary`. It remains visible for empty/all-invalid input.
+If placement cannot fit a selected word, the separate existing `limit` reports rendered versus
+selected words; it does not relabel top-K omission or rejected source labels as a layout failure.
+Invalid input uses `part="error"` and `wordCloudPreparedUnavailable`. Numeric values use the
+effective locale; `.strings` overrides apply to visible messages and announcements. Mount,
+reconnect and adoption are quiet; later changed summaries announce politely and invalid-input
+transitions announce assertively through the shared light-DOM sink.
+
+The component captures a bounded immutable snapshot of host-authored metadata. After changing a
+mutable descriptor or its revision, assign `preparedWords` again (the same identity is accepted)
+or call unnamed `requestUpdate()`; a coalesced named update does not suppress that refresh.
+Presentation updates reuse the snapshot. Source storage and preparation remain host-owned; the
+component neither reads an original catalog nor starts or cancels its preparation. Replacing or
+clearing `preparedWords` therefore does not abort a helper call already running in application
+code. Theme, pointer and keyboard interactions use the retained words without a full-source pass.
+
+`prepareLyraWordCloud(input, options?)` from the granular utilities module performs one complete
+chunked catalog scan and retains the global heaviest `maxWords` (default/max 150, minimum 1), with
+equal weights favoring earlier original positions. `input` is a `LyraIndexedInput<LyraWeightedWord>`
+with stable `revision`, safe `count`, and `read(start, count, { signal })` returning exactly that
+range. Preparation reads at most 8,192 positions per chunk (default 2,048), yields between chunks
+and checks revision/cancellation. All valid source weight contributes to `totalWeight`, including
+omitted candidates. Blank/over-256-unit text or IDs and negative/nonfinite weights count as invalid
+observations; the helper does not shorten them. Chosen labels exceeding 16,384 units reject the
+call: lower `maxWords` rather than clipping selected words. Heavy late entries compete before any
+text budget is applied. With bounded memory the helper detects duplicates only among retained
+candidates; global ID uniqueness remains the caller's input contract. Exact frequency aggregation
+of arbitrary raw tokens belongs to the caller's keyed catalog. The result is immutable.
+
 **Methods:** `refreshTheme(): void` — forces a relayout so the `--lr-font` custom property is
 re-read from computed style (font-family affects the canvas text measurement layout depends on).
 The component's theme watcher calls it automatically when inherited theme typography changes; the
 method remains available for a host theme system that needs an explicit synchronous refresh.
 
-**Events:** `lr-word-activate` (frozen readonly `detail: { text, weight, group }`; fires from the
-single SVG pointer surface, or Enter/Space on the current word)
+**Events:** `lr-word-activate` fires from the single SVG pointer surface or Enter/Space on the
+current word. Its frozen readonly detail is typed `{ text: string; weight: number; group?: string;
+id?: string; revision?: LyraSourceRevision }`. With `preparedWords` active, `id` and `revision`
+identify the exact original catalog entry and committed summary; duplicate text never substitutes
+for identity. Actions on the old visible layout retain its revision while a replacement is
+scheduled, and replaced/detached layout objects cannot activate new data. With `preparedWords =
+null`, the existing `{ text, weight, group }` payload is unchanged and has no `id`/`revision` fields.
+`LyraPreparedWordCloud` and `LyraWeightedWord` are type-only exports from the component entry and
+from `@aceshooting/lyra-ui/utilities/data-preparation.js`.
 
 **Slots:** none.
 
@@ -98,8 +159,9 @@ single SVG pointer surface, or Enter/Space on the current word)
 cursor's word), `live-region` (visually-hidden, `aria-hidden` mirror of the latest announcement;
 the actual announcement uses the shared light-DOM polite sink),
 `legend`/`legend-item`/`legend-swatch`/`legend-label` (the optional static color key), and `empty`
-(the no-data placeholder), `limit` (localized rendered/received word count), and `legend-limit`
-(localized rendered/received explicit-legend count)
+(the no-data placeholder), `limit` (localized rendered/received word count; rendered/selected in
+prepared mode), `legend-limit` (localized rendered/received explicit-legend count),
+`summary` (prepared full/retained counts and weights), and `error` (invalid prepared-input message)
 
 **Themeable custom properties:** `--lr-word-cloud-color-1`, `--lr-word-cloud-color-2`,
 `--lr-word-cloud-color-3`, `--lr-word-cloud-color-4`, `--lr-word-cloud-color-5`,
@@ -126,21 +188,75 @@ through the normal cascade), plus shared tokens (`--lr-font`,
 </script>
 ```
 
+A complete unique weighted catalog can be prepared without constructing a million-element array.
+The helper's one-time full pass is application work; rendering and interaction consume its bounded
+result. Import the helper directly and cancel obsolete preparation before assigning a result:
+
+```ts
+import '@aceshooting/lyra-ui/components/lr-word-cloud.js';
+import {
+  prepareLyraWordCloud,
+  type LyraIndexedInput,
+  type LyraWeightedWord,
+} from '@aceshooting/lyra-ui/utilities/data-preparation.js';
+
+const cloud = document.querySelector('lr-word-cloud')!;
+let pending: AbortController | undefined;
+
+async function showCatalog(input: LyraIndexedInput<LyraWeightedWord>): Promise<void> {
+  pending?.abort();
+  const request = new AbortController();
+  pending = request;
+  try {
+    const prepared = await prepareLyraWordCloud(input, {
+      signal: request.signal, maxWords: 150, batchSize: 8192,
+    });
+    if (pending === request && !request.signal.aborted) cloud.preparedWords = prepared;
+  } catch (error) {
+    if (!request.signal.aborted) throw error;
+  }
+}
+
+await showCatalog({
+  revision: 'catalog-1',
+  count: 1_000_000,
+  read(start, count) {
+    return Array.from({ length: count }, (_, offset) => {
+      const index = start + offset;
+      return {
+        id: `topic-${index}`,
+        text: `Topic ${index}`,
+        weight: index === 999_999 ? 1_000_000 : 1,
+      };
+    });
+  },
+});
+// On view disposal, call pending?.abort().
+```
+
+The final heavy entry participates in selection, and equal-weight entries retain original-position
+ties. A changed catalog/revision needs a new preparation pass; ordinary view interactions do not.
+
 The focusable SVG is the single semantic owner: `role="application"` plus an accessible name. An
 authored host `aria-label` is forwarded to that SVG and wins by attribute presence; when it is
 absent, the SVG uses an auto-computed localized name such as `"Word cloud of 12 words"` / `"Word
 cloud of 1 word"`, counting only words actually rendered. An authored host `role` remains on the
 host and does not replace the SVG's application role. When records are omitted, the SVG references
-the visible localized `[part="limit"]` rendered/received summary.
+the visible localized `[part="limit"]` rendered/received summary. In prepared mode it also
+references the full-catalog `summary`; host-authored description references remain composed with
+these internal descriptions.
 
 **Known gotchas:**
 
 - capped at 150 words (`MAX_WORDS` in `word-cloud-layout.ts`, mirroring `lr-sparkline`'s
   `MAX_POINTS` input-sample guard) — a one-pass bounded top-K scan retains the **heaviest** 150 and
-  counts the rest without cloning/sorting/spreading the full input. A pathological input can exhaust the
-  spiral search's radius bound and get dropped the same way; blank/whitespace-only `text` is dropped
-  during boundary normalization. Omitted diagnostics retain at most 32 records, while a separate
-  complete count drives one deduplicated `console.warn` and the rendered disclosure — nothing throws.
+  counts the rest without cloning/sorting/spreading the full admitted legacy input. The legacy
+  `words` boundary still inspects at most 10,000 positions and applies its text budgets; use
+  `preparedWords` for a complete-catalog summary. A pathological input can exhaust the spiral
+  search's radius bound and be omitted from either route. Legacy blank text is dropped during
+  boundary normalization; malformed prepared input instead shows `error`. Omitted placement
+  diagnostics retain at most 32 records, while a separate complete count drives one deduplicated
+  `console.warn` and the rendered disclosure.
 - each word's spiral search tests at most 4,096 candidate positions. Together with the 150-word and
   512px font-size caps, this bounds placement work even for dense or adversarial layouts; a word
   that exhausts the search budget is reported through the same skipped-word path.
@@ -148,8 +264,8 @@ the visible localized `[part="limit"]` rendered/received summary.
   `--lr-font-weight-semibold` and `--lr-font` token values. A consumer-only `::part(word)` font
   override can still desynchronize measurement from the painted glyph.
 - rotation (`word-rotation="mixed"`) is genuinely random per layout (`Math.random()`, not seeded), so
-  which words render rotated changes on every re-layout (any `words`/`minFontSize`/`maxFontSize`/
-  `scale`/`wordRotation` change) — don't rely on rotation being stable across renders.
+  which words render rotated changes on every re-layout (a prepared-input refresh or an effective
+  `words`/`minFontSize`/`maxFontSize`/`scale`/`wordRotation` change) — don't rely on rotation being stable across renders.
 - only one word is ever in the page's tab sequence at a time (the roving cursor on `[part="svg"]`) —
   there's no way to Tab directly to the Nth word; arrow-key/Home/End your way there, or click it.
 

package/llms/components/lr-xml-viewer.md

@@ -9,7 +9,7 @@
 - **Release history** [CHANGELOG.md](../../CHANGELOG.md)
 - **Deprecations** none
 - **Optional peers** none
-- **Themeable via** 20 parts, 12 custom properties — see this component's own `@csspart`/`@cssprop` list below
+- **Themeable via** 27 parts, 12 custom properties — see this component's own `@csspart`/`@cssprop` list below
 - **Library-wide behavior** (events, form association, `locale`/`strings`, tokens, TS types): `llms/shared.md`
 
 ---
@@ -36,11 +36,84 @@ that deferred too can instead import
 same registration lazily and exports `XML_VIEWER_TAG` (`'lr-xml-viewer'`) as a stable reference to
 the tag it eventually registers.
 
+**Complete provider hierarchy:** `treeSource: XmlViewerTreeSource | undefined`
+(attribute: false) takes display precedence over `xml`/`src`. Invalid defined providers fail visibly;
+setting `undefined` restores the current inline XML or normal URL loading. The readonly `source`
+property remains the legacy text-source snapshot described below; it is not the provider input.
+Assigning `xml` still performs synchronous bounded parsing while provider display is active.
+Provider records themselves never enter `DOMParser` or `XMLSerializer`, and provider mode skips
+`src` fetching. Legacy `maxNodes`, `maxRows` and `expandDepth` do not cap the provider's logical
+domain or control its expansion. `maxHeight` constrains the source scroller, whose unset ceiling
+is `var(--lr-size-20rem)`.
+
+```ts
+import type { XmlViewerTreeSource } from
+  "@aceshooting/lyra-ui/components/viewers/xml-viewer/xml-viewer.class.js";
+import type { LyraHierarchySource, LyraHierarchyQuery, LyraInspectionNode } from
+  "@aceshooting/lyra-ui/data-sources.js";
+```
+
+`XmlViewerTreeSource` is `LyraHierarchySource<LyraInspectionNode, LyraHierarchyQuery>`.
+Its immutable `revision` is a nonempty string or finite number. `project(request)` receives
+revision, locale, abort signal, previous opaque `state` (initially `null`),
+`{ search: searchQuery, hiddenKinds: [] }` and reset/toggle/reveal actions. It returns
+`{ state, total, rows, focusIndex? }`, where `total` includes collapsed nodes and `rows.count`
+is the complete visible preorder; both are safe nonnegative integers with `rows.count <= total`.
+The nonempty state token is at most 65,536 UTF-16 units. Rows support indexed
+`itemAt`/`keyAt`/`indexOfKey`, or asynchronous `read` with required `indexOfKey`; no key lookup scans
+the logical hierarchy. Each row supplies unique `key`, `parentKey`, one-based `level`/`position`,
+exact sibling `setSize`, `childCount`, `expanded`, `selected`, and optional
+`disabled`/`selectionState`.
+
+The closed own-data inspection value has string `name`, string `path` equal to the row key,
+optional string `value`, and `kind` from `'object' | 'array' | 'scalar' | 'element' | 'attribute' |
+'text' | 'comment' | 'processing-instruction'`. Keys are nonblank and keys/display fields are each
+at most 65,536 UTF-16 units. Current/staged normalized rows, the retained focused row and projection
+state share 2,000,000 payload units; oversized rows/pages fail without clipping. At most 301 rows
+mount; four 100-row pages plus at most one focused row are cached. Range reads request at most
+100 rows with two physical reads pending; projection calls serialize with only the latest intent
+queued. The provider owns global key uniqueness, immutable snapshots and expansion. Logical ARIA
+depth/sibling counts remain exact while visual indentation clamps at 32 levels.
+
+`revealSourceKey(key: string): Promise<boolean>` opens provider ancestors and focuses the exact
+returned key, resolving `false` for absent, invalid, failed, obsolete or unset-source requests.
+Compact arbitrary keys avoid depth-sized ancestor paths. For shared `node-path` anchors, providers
+must instead expose canonical `JSON.stringify(path)` keys: at most 256 total segments, consisting
+of safe nonnegative numeric segments and an optional terminal nonempty `'@attribute'`, with total key length
+at most 65,536 units. Attribute anchors resolve their exact attribute key. Source highlights paint
+only exact admitted matching keys and preserve bounded highlight/action admission; no global
+highlight scan or fallback to a parent is performed.
+
+Source `search(query)` delegates to optional global `search({ revision, locale, signal, query,
+limit })`, returning `{ hits: [{ key }], total, exhaustive }`. It counts nodes across the complete
+hierarchy, retains at most 10,000 hits/2,000,000 key units, and accepts queries up to 4,096 units.
+`total` is a known global total or `null`; `exhaustive` means every global hit was returned.
+XML search reveals its first returned hit; next/previous reveal retained keys without repeating
+global search. `lr-search-change` retains `{ query, matchCount, matchCountExact, activeIndex }`;
+unavailable, partial, invalid and over-budget results never claim exactness. `search-status`
+discloses unavailable/partial results.
+
+Copy controls require `copyable` and callable provider `copy`. Requests include revision, locale,
+signal, `maxBytes`, and `key`/`scope`: document uses `null`/`'document'`, containers `'subtree'`,
+leaves `'node'`. Complete text must fit normalized `maxBytes` in UTF-8; loaded rows are never
+serialized as a substitute. Provider/byte rejection gives localized feedback without clipboard
+error events; current platform writes retain `lr-copy`, `lr-copy-error` and clipboard-only
+`lr-error` outcomes. Source failures also use the guarded `lr-render-error` contract.
+
+Reassign even the same source, or call a keyless `requestUpdate()`, after revision/state changes.
+Locale, reconnect and adoption refresh provider authority; replacement, query changes and lifecycle
+cancellation revoke older search, reveal, highlight and copy effects. Named presentation updates
+reuse admitted data. Ignored aborts retain physical request permits until settlement. Source-only
+parts are `source-list`, `source-row`, `source-toggle`, `source-label`, `source-status`,
+`source-error` and `search-status`; `tag`, `attribute`, `attribute-name`, `attribute-value`, `text`,
+`comment`, `pi`, `copy-button` and `highlight-action` remain aliases on source content where applicable.
+The following parsed-document/search limits describe the legacy `xml`/`src` route.
+
 **Properties:** `src: string = ''` — URL to fetch and parse; ignored once `xml` is set. `xml?:
 string` (property only) — raw XML text to parse and render; wins over `src`, and setting it parses
 synchronously. Assigning `undefined` relinquishes inline authority and immediately resumes an
 already configured `src`, or exposes idle when none exists. `source: LyraXmlViewerSource` is the
-readonly discriminated effective authority (`{ kind: 'inline', value }`, `{ kind: 'url', url }`, or
+readonly discriminated legacy text authority (`{ kind: 'inline', value }`, `{ kind: 'url', url }`, or
 `null`). `name: string = ''` — accessible label. `expandDepth?: number` (attribute
 `expand-depth`) — elements at or beyond this nesting depth (root = 0) start collapsed, so only the
 levels above it start expanded; unset, nothing auto-collapses. `copyable:
@@ -51,7 +124,23 @@ contract) — each numeric path segment is the 0-based index within the parent's
 and an optional trailing string segment `'@attrName'` addresses one existing, nonempty-named
 attribute. Invalid CSS `max-height` values, declaration breaks, and `url()` are ignored.
 
-**Methods:** `search(query)` resolves the match count via a case-insensitive substring search over
+Configurable limits:
+
+- `maxNodes: number = 50000` (attribute `max-nodes`) — parsed document nodes;
+  effective range 1–500,000.
+- `maxRows: number = 5000` (attribute `max-rows`) — displayed tree rows;
+  effective range 1–50,000.
+- `maxBytes: number = 26214400` (attribute `max-bytes`) — UTF-8 XML input bytes, default 25 MiB;
+  effective range 1–262,144,000 bytes (250 MiB).
+
+Limits truncate finite fractions and clamp to their effective ranges; non-finite inputs use the
+stated defaults. Inline and fetched XML pass byte/node/depth preflight before `DOMParser`, then
+parsed-document node/depth validation. The depth ceiling remains 256. Changing `maxNodes` or
+`maxBytes` revalidates the effective source; changing `maxRows` changes the rendered window.
+An inline `xml` assignment parses synchronously. Fetched XML yields between preflight and parsing,
+with source-generation checks after the yield; the parse itself remains synchronous.
+
+**Legacy search methods:** `search(query)` resolves the match count via a case-insensitive substring search over
 every element's tag name, attribute names/values, and own text (empty/whitespace query behaves like
 `clearSearch()`), accepting at most 4,096 query code units and scanning at most 4,000,000 code
 units while retaining 10,000 matches; `searchNext()`/`searchPrevious()` advance/step back through matches (wrapping);
@@ -107,6 +196,12 @@ only while the viewer and its composed ancestors are exposed to the accessibilit
 The spinner always includes visible localized loading text alongside its decorative ring; the text
 remains understandable without CSS or animation and the ring stops under reduced motion.
 
+With `treeSource` set, additional CSS parts are `source-list` (bounded provider virtual viewport), `source-row` (flat
+logical tree item and focus owner), `source-label` (row content), `source-toggle` (expand/collapse
+or retry button), `source-status` (loading, full-source count or empty text), and `source-error`
+(localized projection or row failure).
+`search-status` discloses unavailable or partial global provider search.
+
 **Themeable custom properties:** `--lr-xml-viewer-max-height` (default `none`) — maximum block size
 of the scrollable body; also settable via the `max-height` property.
 `--lr-xml-viewer-active-match-color` (default `var(--lr-color-warning)`) — the solid outline on the
@@ -154,9 +249,11 @@ viewer.copyable = true;
 await viewer.search(query);
 ```
 
-Node cap: 50,000 — exceeding it renders the localized `xmlViewerTooManyNodes` error instead of the
-tree. A collapsed element's child count includes element, text, comment, CDATA, and processing-
-instruction children rather than only element descendants. Expanded rendering stops after 5,000
-rows and shows a localized `limit` notice; collapse state and the parsed document remain intact.
-Search still counts the complete parsed document, while a `node-path` outside the rendered window
-reports `found: false` until it can be rendered.
+By default, the node cap is 50,000 and expanded rendering stops after 5,000 rows; configure these
+with `maxNodes` and `maxRows`. Node/byte/depth rejection displays a localized error and emits
+`lr-render-error` instead of rendering the tree. A collapsed element's child count includes element,
+text, comment, CDATA, and processing-instruction children rather than only element descendants.
+Reaching the rendered-row budget shows the existing localized `limit` notice; collapse state and
+the parsed document remain intact. Search still visits the complete admitted document within its
+separate search budgets, while a `node-path` outside the rendered window reports `found: false`
+until it can be rendered.

package/llms/index.md

@@ -250,7 +250,7 @@ Optional peers: `llms/peers.md`. Safe `wa-*`/`sl-*` migration: `llms/migration.m
 - `lr-highlight-layer` · lr-highlight-layer.js · `stable` since `4.0.0` — a presentational overlay that paints highlight rectangles (percent-of-box coordinates) over positioned content and owns their activation,...
 - `lr-page-rail` · lr-page-rail.js · `stable` since `4.0.0` — a virtualized vertical thumbnail rail for page-addressed documents, with per-page highlight heat markers.
 - `lr-notebook-viewer` · lr-notebook-viewer.js · `stable` since `4.0.0` — read-only Jupyter notebook (nbformat 4.x) renderer, composing existing components per cell.
-- `lr-xml-viewer` · lr-xml-viewer.js · `stable` since `4.0.0` — collapsible, copyable, `DOMParser`-based tree view for XML documents, mirroring `lr-json-viewer`'s UX (`expand-depth`, `copyable`, struct...
+- `lr-xml-viewer` · lr-xml-viewer.js · `stable` since `4.0.0` — Property-only treeSource takes display precedence over xml/src without parsing provider records.
 - `lr-document-compare` · lr-document-compare.js · `stable` since `4.1.0` — side-by-side or inline comparison of two document versions, composed entirely from two existing primitives rather than reimplementing eit...
 - `lr-geojson-viewer` · lr-geojson-viewer.js · `stable` since `9.0.0` — document-registry bridge rendering a fetched GeoJSON file through `<lr-map>`'s `dataLayers`.
 

package/llms/peers.md

@@ -39,7 +39,7 @@ for the page.
 |---|---|---|
 | `@aceshooting/lyra-flags` | `^2.3.0` | _(loaded by a shared internal module)_ |
 | `@aceshooting/lyra-map` | `^1.1.0` | `lr-geojson-viewer`, `lr-map` |
-| `@aceshooting/lyra-translations` | `^29.0.2` | _(not referenced by any component)_ |
+| `@aceshooting/lyra-translations` | `^29.1.0` | _(not referenced by any component)_ |
 | `@aiden0z/pptx-renderer` | `^1.3.0` | `lr-pptx-viewer` |
 | `@sgratzl/chartjs-chart-boxplot` | `^4.0.0` | `lr-box-plot` |
 | `chart.js` | `^4.0.1` | `lr-bar-chart`, `lr-box-plot`, `lr-bubble-chart`, `lr-chart`, `lr-doughnut-chart`, `lr-histogram`, `lr-line-chart`, `lr-pie-chart`, `lr-polar-area-chart`, `lr-radar-chart`, `lr-scatter-chart` |