@aceshooting/lyra-ui 3.6.0 → 3.8.0

package/dist/components/markdown/katex-loader.js

@@ -0,0 +1,33 @@
+let cached;
+/**
+ * Loads the optional peer dependency `katex`, used by `<lyra-markdown>`'s `math` property to
+ * render `$...$`/`$$...$$` TeX as MathML. Resolves `null` (with a one-time `console.warn`) if the
+ * peer isn't installed -- rendering falls back to the literal, unparsed TeX source in that case,
+ * a fully supported default rather than a degraded mode. Mirrors `dompurify-loader.ts`'s single-
+ * optional-peer shape.
+ */
+export async function loadKatex(importKatex = () => import('katex')) {
+    try {
+        const mod = await importKatex();
+        return ('default' in mod ? mod.default : mod);
+    }
+    catch (error) {
+        console.warn('<lyra-markdown> needs the optional peer dependency `katex` to render math (the `math` property is set) — install it with `pnpm add katex`:', error);
+        return null;
+    }
+}
+/**
+ * Lazily loads `katex` once per page, caching the resolved module (or `null`) across every
+ * `<lyra-markdown>` instance -- mirrors `markdown-loader.ts`'s `loadMarkdownDeps()`/
+ * `getMarkdownDepsIfLoaded()` cached-promise shape for a single optional peer.
+ */
+export function getKatex(importKatex) {
+    if (!cached)
+        cached = loadKatex(importKatex);
+    return cached;
+}
+/** @internal Test-only cache reset. */
+export function clearKatexCache() {
+    cached = undefined;
+}
+//# sourceMappingURL=katex-loader.js.map

package/dist/components/markdown/katex-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"katex-loader.js","sourceRoot":"","sources":["../../../src/components/markdown/katex-loader.ts"],"names":[],"mappings":"AAMA,IAAI,MAA4C,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,WAAW,GAAoD,GAAG,EAAE,CAClE,MAAM,CAAC,OAAO,CAAmC;IAEnD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,WAAW,EAAE,CAAC;QAChC,OAAO,CAAC,SAAS,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAa,CAAC;IAC5D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,IAAI,CACV,4IAA4I,EAC5I,KAAK,CACN,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,WAA6D;IACpF,IAAI,CAAC,MAAM;QAAE,MAAM,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;IAC7C,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,eAAe;IAC7B,MAAM,GAAG,SAAS,CAAC;AACrB,CAAC"}

package/dist/components/markdown/markdown.class.d.ts

@@ -1,6 +1,16 @@
 import { type TemplateResult, type PropertyValues } from 'lit';
 import { LyraElement } from '../../internal/lyra-element.js';
-export interface LyraMarkdownEventMap {
+import { type LyraAnchorTargetEventMap } from '../../internal/anchor-target.js';
+import type { LyraAnchor, LyraAnchorKind } from '../document-viewer/anchors.js';
+import { type ShikiLanguageInput } from '../code-block/code-loader.js';
+/** One entry of `getHeadingTree()`'s document-ordered outline. `level` already reflects
+ *  `heading-offset` -- it always matches the rendered `<h${level}>` tag, not the source `#` count. */
+export interface MarkdownHeadingItem {
+    id: string;
+    label: string;
+    level: number;
+}
+export interface LyraMarkdownEventMap extends LyraAnchorTargetEventMap {
     'lyra-render-error': CustomEvent<{
         error: unknown;
     }>;
@@ -9,6 +19,11 @@ export interface LyraMarkdownEventMap {
         internal: boolean;
     }>;
 }
+declare class LyraMarkdownBase extends LyraElement<LyraMarkdownEventMap> {
+}
+declare const LyraMarkdown_base: typeof LyraMarkdownBase & (new (...args: any[]) => import("../../internal/anchor-target.js").LyraAnchorTarget & {
+    renderAnchorLiveRegion(): unknown;
+});
 /**
  * `<lyra-markdown>` — sanitized Markdown-to-HTML rendering (GFM tables,
  * fenced code blocks, links, blockquotes) built on the optional peer
@@ -44,13 +59,44 @@ export interface LyraMarkdownEventMap {
  * directly into the produced HTML — a single pass, not a second DOM walk
  * after insertion.
  *
+ * Fenced code blocks are syntax-highlighted via the same optional `shiki` peer `<lyra-code-block>`
+ * uses (`highlightCode`, default `true` — a pure upgrade gated by whether `shiki` is installed at
+ * all, not a separate opt-in). `languages`/`languagesOnly` mirror `<lyra-code-block>`'s own
+ * fine-grained bundle-size controls. The very first render of any content is always plain
+ * (identical to today's output); highlighting arrives as an asynchronous upgrade one render later,
+ * once shiki resolves. No highlighting is attempted while `streaming` is `true` — it applies once a
+ * stream settles, so there is no added per-chunk cost while content is still arriving.
+ *
+ * When `heading-anchors` is set, every rendered heading's slug (computed via the shared
+ * GitHub-slugger-style `Slugger`) is stamped as its `id`; `getHeadingTree()` computes that same
+ * outline on every parse regardless of `heading-anchors`, so a host can build a table of contents
+ * even while ids aren't in the DOM yet. `scrollToAnchor()` (from the adopted `DocumentAnchorTarget`
+ * mixin) resolves `fragment` anchors against that outline and `text-quote` anchors via
+ * `internal/text-quote.ts`'s shared scope/resolve helpers; `highlights` re-resolve by quote after
+ * every render (never by node identity), so a highlight painted before a `streaming` update
+ * finishes still finds its quote once the matching text arrives. Highlight painting uses
+ * `internal/text-highlights.ts`'s `acquireHighlightHandle()` -- the CSS Custom Highlight API where
+ * the browser supports it (no DOM mutation at all), a `<mark>`-wrap fallback otherwise.
+ *
+ * `math` renders `$...$`/`$$...$$` TeX as MathML via the optional `katex` peer's
+ * `renderToString(tex, { output: 'mathml' })` -- MathML Core renders natively and accessibly in
+ * evergreen browsers with no extra stylesheet or webfont needing to cross the shadow boundary. A
+ * missing `katex` peer renders the literal, unparsed TeX source (delimiters included) and fires one
+ * `lyra-render-error`.
+ *
  * @customElement lyra-markdown
  * @event lyra-link-click - Fired (and the click prevented) when a rendered
  *   link's `href` starts with `internal-link-prefix`. `detail: { href:
  *   string, internal: true }`. Ordinary external links navigate normally
  *   (in `link-target`) and never fire this event.
  * @event lyra-render-error - Fired whenever rendering falls back to plain
- *   text. `detail: { error: unknown }`.
+ *   text, or `math` is set but the `katex` peer isn't installed. `detail: { error: unknown }`.
+ * @event lyra-highlight-activate - A painted `text-quote` highlight was clicked. `detail: { id }`.
+ * @event lyra-text-select - Fired on selection end inside the rendered content. `detail: { text,
+ *   anchor, rects }`; `anchor` is a `text-quote` `LyraAnchor` scoped to the rendered content, or
+ *   `null` if the selection couldn't be anchored.
+ * @event lyra-anchor-result - Fired after an `anchor` property assignment or a `scrollToAnchor()`
+ *   call is applied. `detail: { found }`.
  * @csspart content - The wrapper around the rendered (or plain-text
  *   fallback) output.
  * @csspart heading - Every rendered `<h1>`–`<h6>` (shifted by
@@ -63,8 +109,9 @@ export interface LyraMarkdownEventMap {
  * @csspart table - Every rendered `<table>`.
  * @csspart blockquote - Every rendered `<blockquote>`.
  * @csspart img - Every rendered `<img>`.
+ * @csspart math - A rendered inline or block math span (`data-display="inline"|"block"`).
  */
-export declare class LyraMarkdown extends LyraElement<LyraMarkdownEventMap> {
+export declare class LyraMarkdown extends LyraMarkdown_base {
     static styles: import("lit").CSSResultGroup[];
     /** The Markdown source to render. */
     content: string;
@@ -121,14 +168,153 @@ export declare class LyraMarkdown extends LyraElement<LyraMarkdownEventMap> {
      *  is not final. Set it back to `false` with the final content update.
      *  Reflects so a consumer can also target `lyra-markdown[streaming]`. */
     streaming: boolean;
+    /** Syntax-highlights fenced code blocks via the same optional `shiki` peer `<lyra-code-block>`
+     *  uses. `true` (the default) upgrades every fenced block from plain `<pre><code>` once the peer
+     *  is available -- a pure upgrade, not a behavior change gated on opt-in, since it's itself gated
+     *  transparently by whether `shiki` is installed at all (an app that never installs it sees
+     *  byte-identical output to today). Set `false` to keep plain output even when `shiki` is
+     *  installed. No effect while `streaming` is `true` -- see that property's own doc. */
+    highlightCode: boolean;
+    /** Same shape and purpose as `<lyra-code-block>`'s own `languages` -- a fine-grained, explicit
+     *  language-grammar bundle scoping shiki's build output to just those grammars instead of its
+     *  full ~200-language bundle. Forwarded verbatim to `loadShikiHighlighterCore()`. Unset uses the
+     *  default full-bundle loader, unchanged from how `<lyra-code-block>` itself defaults. */
+    languages?: Record<string, ShikiLanguageInput>;
+    /** Same purpose as `<lyra-code-block>`'s own `languagesOnly` -- skips the default full-bundle
+     *  loader entirely, so a fenced block whose language isn't in `languages` falls back to plain
+     *  unhighlighted text rather than reaching for the full bundle. No effect unless `languages` is
+     *  also set. */
+    languagesOnly: boolean;
+    /** Stamps a computed slug as `id` on every rendered heading. `getHeadingTree()` computes the
+     *  same slugs regardless of this property -- it only controls whether the `id` attribute is
+     *  emitted into the rendered DOM. `false` (the default) preserves today's exact output.
+     *
+     *  When `sanitize` is also on (the default), a slug whose *value* collides with a real
+     *  `document` property name (e.g. a heading literally titled "Title", "Location", or "Forms"
+     *  slugs to `title`/`location`/`forms`) has its `id` silently stripped by DOMPurify's DOM-
+     *  clobbering protection (`SANITIZE_DOM`) -- `getHeadingTree()` still reports that heading's slug
+     *  either way, but `scrollToAnchor({ kind: 'fragment', id })` still resolves it correctly even
+     *  without a DOM `id` present, via its own position-based fallback lookup. */
+    headingAnchors: boolean;
+    /** Renders `$...$`/`$$...$$` TeX via the optional `katex` peer, as MathML. `false` (the
+     *  default) renders `$...$` literally, unparsed -- today's exact output. */
+    math: boolean;
+    /** Anchor kinds this component resolves via `scrollToAnchor()`. Readonly. */
+    readonly anchorKinds: readonly LyraAnchorKind[];
     private renderedHtml;
     private deps?;
+    /** Document-ordered heading outline computed on every parse (see `getHeadingTree()`), regardless
+     *  of `headingAnchors`. */
+    private headingTree;
+    /** Lazily acquired the first time a highlight needs painting; released on disconnect. */
+    private highlightHandle?;
+    /** The most recently resolved `text-quote` highlight ranges, kept for `onContentClick()`'s
+     *  coordinate hit-test -- the CSS Custom Highlight API paints ranges without creating any DOM
+     *  element to attach a click listener to, so activation is resolved by comparing the click point
+     *  against each range's own `getClientRects()` instead, uniformly across both paint paths. */
+    private resolvedHighlightRanges;
+    /** Guards `lyra-render-error` so a permanently-missing `katex` peer reports once per instance,
+     *  not on every subsequent re-render while `math` stays on. Reset whenever `math` toggles. */
+    private mathFailureReported;
+    /** `(lang, code)` -> already-highlighted HTML, content-addressed (see `PendingHighlight`'s doc).
+     *  Persists across renders of this instance; populated asynchronously by `highlightPending()`.
+     *  Never consulted while `streaming` is `true` or `highlightCode` is `false` -- both gates live
+     *  in the `code()` renderer inside `parseMarkdown()`. Bounded to {@link HIGHLIGHT_CACHE_MAX}
+     *  entries, least-recently-used first out, via `getCachedHighlight()`/`setCachedHighlight()` --
+     *  always go through those instead of the map directly so hits refresh recency. */
+    private highlightCache;
+    /** LRU read: a hit is re-inserted so Map iteration order (insertion order) keeps the first key
+     *  the least recently used one -- the entry `setCachedHighlight()` evicts when full. */
+    private getCachedHighlight;
+    private setCachedHighlight;
+    /** Bumped on every `highlightPending()` call, including ones that end up not actually loading
+     *  anything -- guards against a newer `content`/`streaming` change superseding an older in-flight
+     *  highlight, exactly mirroring `<lyra-code-block>`'s own `highlightToken` field for the identical
+     *  race (an async grammar load resolving after a newer call already produced correct output). */
+    private highlightToken;
+    /** Keys from `PendingHighlight` that failed to highlight -- peer missing, language unrecognized,
+     *  or tokenization threw. Once a key lands here, `code()` stops re-discovering it as pending on
+     *  every future render. Without this, a permanently-unhighlightable block (e.g. an unrecognized
+     *  language) would never get cached, so every `renderMarkdown()` pass -- including the one
+     *  `highlightPending()` itself triggers on completion -- would rediscover it as pending and retry
+     *  it again, forever. Mirrors `code-loader.ts`'s own `unsupportedLanguages` Set, which exists for
+     *  the identical reason one level down (a single unrecognized `language` value on
+     *  `<lyra-code-block>`). */
+    private failedHighlightKeys;
     connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Binds selection -> `lyra-text-select` once, on the stable `[part="content"]` wrapper --
+     *  re-renders only replace that wrapper's children via `unsafeHTML`, never the wrapper itself.
+     *  `bindTextSelection` is `protected` on the mixin's own narrowed return type (deliberately not
+     *  part of `LyraAnchorTarget`'s public surface -- see `anchor-target.ts`'s class doc), so it's
+     *  reached the same way that module's own tests do: through a cast, without declaring a no-op
+     *  passthrough override just to satisfy the type checker. */
+    protected firstUpdated(): void;
     protected willUpdate(changed: PropertyValues): void;
-    protected updated(): void;
+    protected updated(changed: PropertyValues): void;
     private renderMarkdown;
     private applyFallback;
+    /** Kicks off the shared `katex` load the first time `math` needs it and no attempt is already
+     *  in flight (module-scoped, so every `<lyra-markdown>` instance on the page shares one load --
+     *  mirrors `markdown-loader.ts`'s own warm-cache shape). Skipped entirely under
+     *  `__setKatexForTesting()` -- that seam controls math-rendering behavior directly and must never
+     *  race a real, unmocked `import('katex')` settling underneath it. */
+    private maybeLoadKatex;
+    /** Fires `lyra-render-error` once per instance for a permanently-missing `katex` peer. Called
+     *  only once `renderMarkdown()` has confirmed the peer is actually missing (`katexOverride` or
+     *  the resolved module is `null`) -- a math token rendering its literal fallback while the load
+     *  is merely still in flight (the same one-microtask transient window every other optional peer
+     *  in this component has) never reports an error on its own. */
+    private reportMathFailure;
+    /** Kicks off async highlighting for `pendingKeys` (see `highlightPending()`) unless there's
+     *  nothing to do, `highlightCode` is off, or `streaming` is on -- called from both of
+     *  `renderMarkdown()`'s exit points (the `sanitize=false` early return and the normal sanitized
+     *  path), since highlighting is independent of that decision. */
+    private maybeHighlightPending;
+    /** Loads whatever shiki grammars `pendingKeys` need, tokenizes each pending block concurrently,
+     *  populates `highlightCache` with the results, then triggers one more `renderMarkdown()` pass so
+     *  the newly-cached entries actually reach the screen. A pending key whose language fails to load
+     *  is recorded in `failedHighlightKeys` (per `loadShikiLanguage()`'s existing "unrecognized
+     *  grammar" contract -- resolves `false`, never throws) -- it stays uncached, so `code()` keeps
+     *  emitting its plain fallback for it on every future render, and `code()` also stops
+     *  re-discovering it as pending (see `failedHighlightKeys`'s own doc for why that matters: without
+     *  it, the `renderMarkdown()` call at the end of this method would rediscover the same
+     *  permanently-uncacheable key as pending on every pass, forever). Does not block or delay any
+     *  other pending key -- each is tried independently via `Promise.all`. */
+    private highlightPending;
     private parseMarkdown;
+    /** A document-ordered, flattened heading outline -- computed on every parse regardless of
+     *  `headingAnchors` (see that property's own doc). A caller building a table of contents can rely
+     *  on this even while `heading-anchors` is off. */
+    getHeadingTree(): MarkdownHeadingItem[];
+    private contentRoot;
+    protected applyAnchor(anchor: LyraAnchor): Promise<boolean>;
+    private applyFragmentAnchor;
+    /** `headingAnchors` may be off, so a target heading might carry no `id` attribute in the DOM --
+     *  re-derives the same slug order `getHeadingTree()` was built in and matches by position
+     *  instead of by attribute. */
+    private findHeadingByComputedId;
+    private applyTextQuoteAnchor;
+    /** Overrides `DocumentAnchorTarget`'s default (whole render-root) selection scope, matching
+     *  `heading`'s slug computation and `applyTextQuoteAnchor()` above: only `[part="content"]` is a
+     *  meaningful text-quote scope, so a selection that somehow reaches outside it (there is no other
+     *  text in this component's shadow tree today, but the live region could grow one) never leaks
+     *  into a captured anchor. */
+    protected computeSelectionAnchor(range: Range): LyraAnchor | null;
+    private ensureHighlightHandle;
+    /** Re-resolves every `text-quote` highlight against the current rendered content and repaints
+     *  via `acquireHighlightHandle()` -- resolution is always by quote text, never by node identity,
+     *  so a highlight set before its quote exists in `content` yet (e.g. mid-`streaming`) simply
+     *  paints nothing until a later render's text actually contains it. `fragment` highlights aren't
+     *  painted (there is no literal span of text to wrap/underline for a whole section). */
+    private repaintHighlights;
+    /** Hit-tests a click point against every currently-resolved highlight's `getClientRects()`,
+     *  topmost (last-resolved) first. The CSS Custom Highlight API paints ranges without creating any
+     *  DOM element to attach a click listener to, so this is the only activation path that works
+     *  identically on both paint paths -- mirrors `<lyra-pdf-viewer>`'s own coordinate-based
+     *  `onPageClick()` hit-test for the same reason (its own painted highlights sit under a text
+     *  layer that intercepts most pointer events). */
+    private hitTestHighlightAt;
     private onContentClick;
     render(): TemplateResult;
 }
@@ -137,4 +323,5 @@ declare global {
         'lyra-markdown': LyraMarkdown;
     }
 }
+export {};
 //# sourceMappingURL=markdown.class.d.ts.map

package/dist/components/markdown/markdown.class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.class.d.ts","sourceRoot":"","sources":["../../../src/components/markdown/markdown.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGrE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAoC7D,MAAM,WAAW,oBAAoB;IACnC,mBAAmB,EAAE,WAAW,CAAC;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACrD,iBAAiB,EAAE,WAAW,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACrE;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,qBAAa,YAAa,SAAQ,WAAW,CAAC,oBAAoB,CAAC;IACjE,MAAM,CAAC,MAAM,iCAAgC;IAE7C,qCAAqC;IACzB,OAAO,SAAM;IAEzB;;4CAEwC;IACX,QAAQ,UAAQ;IAE7C;;;;;;gCAM4B;IAC2B,UAAU,UAAS;IAE1E,sFAAsF;IACzD,GAAG,UAAQ;IAExC;;;;2EAIuE;IAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAY;IAE7E;;;6CAGyC;IACQ,kBAAkB,SAAM;IAEzE;;;;;;4EAMwE;IACf,aAAa,SAAK;IAE3E;;;;;;;;;;;;6EAYyE;IACnB,SAAS,UAAS;IAExE;;;;6EAIyE;IAC7B,SAAS,UAAS;IAMrD,OAAO,CAAC,YAAY,CAAuB;IAEpD,OAAO,CAAC,IAAI,CAAC,CAAe;IAE5B,iBAAiB,IAAI,IAAI,CA2BxB;IAMD,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAiBlD;IAED,SAAS,CAAC,OAAO,IAAI,IAAI,CAMxB;IAED,OAAO,CAAC,cAAc;IA6CtB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,aAAa;IA+GrB,OAAO,CAAC,cAAc,CAapB;IAEF,MAAM,IAAI,cAAc,CAOvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,eAAe,EAAE,YAAY,CAAC;KAC/B;CACF"}
+{"version":3,"file":"markdown.class.d.ts","sourceRoot":"","sources":["../../../src/components/markdown/markdown.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGrE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAK7D,OAAO,EAAwB,KAAK,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAItG,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAA8C,MAAM,+BAA+B,CAAC;AAE5H,OAAO,EAQL,KAAK,kBAAkB,EACxB,MAAM,8BAA8B,CAAC;AA6CtC;sGACsG;AACtG,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAuHD,MAAM,WAAW,oBAAqB,SAAQ,wBAAwB;IACpE,mBAAmB,EAAE,WAAW,CAAC;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACrD,iBAAiB,EAAE,WAAW,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACrE;AAED,cAAM,gBAAiB,SAAQ,WAAW,CAAC,oBAAoB,CAAC;CAAG;;;;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,qBAAa,YAAa,SAAQ,iBAAsC;IACtE,MAAM,CAAC,MAAM,iCAAwC;IAErD,qCAAqC;IACzB,OAAO,SAAM;IAEzB;;4CAEwC;IACX,QAAQ,UAAQ;IAE7C;;;;;;gCAM4B;IAC2B,UAAU,UAAS;IAE1E,sFAAsF;IACzD,GAAG,UAAQ;IAExC;;;;2EAIuE;IAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAY;IAE7E;;;6CAGyC;IACQ,kBAAkB,SAAM;IAEzE;;;;;;4EAMwE;IACf,aAAa,SAAK;IAE3E;;;;;;;;;;;;6EAYyE;IACnB,SAAS,UAAS;IAExE;;;;6EAIyE;IAC7B,SAAS,UAAS;IAE9D;;;;;2FAKuF;IAC7B,aAAa,UAAQ;IAE/E;;;8FAG0F;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAE/E;;;oBAGgB;IAC0C,aAAa,UAAS;IAEhF;;;;;;;;;kFAS8E;IACnB,cAAc,UAAS;IAElF;gFAC4E;IAC/C,IAAI,UAAS;IAE1C,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,SAAS,cAAc,EAAE,CAA8B;IAMpE,OAAO,CAAC,YAAY,CAAuB;IAEpD,OAAO,CAAC,IAAI,CAAC,CAAe;IAE5B;+BAC2B;IAC3B,OAAO,CAAC,WAAW,CAA6B;IAEhD,yFAAyF;IACzF,OAAO,CAAC,eAAe,CAAC,CAAkB;IAE1C;;;kGAG8F;IAC9F,OAAO,CAAC,uBAAuB,CAAsC;IAErE;kGAC8F;IAC9F,OAAO,CAAC,mBAAmB,CAAS;IAEpC;;;;;uFAKmF;IACnF,OAAO,CAAC,cAAc,CAA6B;IAEnD;4FACwF;IACxF,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,kBAAkB;IAU1B;;;qGAGiG;IACjG,OAAO,CAAC,cAAc,CAAK;IAE3B;;;;;;;gCAO4B;IAC5B,OAAO,CAAC,mBAAmB,CAAqB;IAEhD,iBAAiB,IAAI,IAAI,CA2BxB;IAED,oBAAoB,IAAI,IAAI,CAI3B;IAED;;;;;iEAK6D;IAC7D,SAAS,CAAC,YAAY,IAAI,IAAI,CAI7B;IAMD,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAsBlD;IAED,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAU/C;IAED,OAAO,CAAC,cAAc;IAuEtB,OAAO,CAAC,aAAa;IAKrB;;;;0EAIsE;IACtE,OAAO,CAAC,cAAc;IAUtB;;;;oEAIgE;IAChE,OAAO,CAAC,iBAAiB;IAUzB;;;qEAGiE;IACjE,OAAO,CAAC,qBAAqB;IAK7B;;;;;;;;;8EAS0E;YAC5D,gBAAgB;IAmD9B,OAAO,CAAC,aAAa;IA8JrB;;uDAEmD;IACnD,cAAc,IAAI,mBAAmB,EAAE,CAEtC;IAED,OAAO,CAAC,WAAW;IAMnB,UAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAWhE;IAED,OAAO,CAAC,mBAAmB;IAU3B;;mCAE+B;IAC/B,OAAO,CAAC,uBAAuB;IAO/B,OAAO,CAAC,oBAAoB;IAQ5B;;;;kCAI8B;IAC9B,SAAS,CAAC,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,GAAG,IAAI,CAIhE;IAID,OAAO,CAAC,qBAAqB;IAK7B;;;;4FAIwF;IACxF,OAAO,CAAC,iBAAiB;IA6BzB;;;;;sDAKkD;IAClD,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,cAAc,CAkBpB;IAEF,MAAM,IAAI,cAAc,CAQvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,eAAe,EAAE,YAAY,CAAC;KAC/B;CACF"}